Fix bugs

Author: ChaseSunstrom

CMakeLists.txt

@@ -120,13 +120,6 @@ target_link_libraries(${PROJECT_NAME} PUBLIC
     tomlplusplus::tomlplusplus
 )
 
-# Definitions for config 'Debug'
-if(CMAKE_BUILD_TYPE STREQUAL "Debug")
-  target_compile_definitions(${PROJECT_NAME} PUBLIC DEBUG=1)
-  target_compile_definitions(${PROJECT_NAME} PUBLIC FMT_HEADER_ONLY=ON)
-  target_compile_definitions(${PROJECT_NAME} PUBLIC FMT_UNICODE=0)
-endif()
-
 # Link libraries
 target_link_libraries(${PROJECT_NAME} PUBLIC
 )
@@ -169,7 +162,7 @@ endif()
 
 # CPack configuration
 set(CPACK_PACKAGE_NAME "${PROJECT_NAME}")
-set(CPACK_PACKAGE_VENDOR "Chase Sunstrom")
+set(CPACK_PACKAGE_VENDOR "Unknown")
 set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "A C/C++ build tool with dependency management")
 set(CPACK_PACKAGE_VERSION "2.3.0")
 set(CPACK_PACKAGE_INSTALL_DIRECTORY "${PROJECT_NAME}")

cforge.hash

@@ -3,8 +3,8 @@
 # Do not commit to version control.
 
 [metadata]
-generated = "2025-12-08T23:58:51Z"
+generated = "2025-12-09T00:30:37Z"
 
 [config]
-hash = "192a6443b869e18e"
+hash = "7f2b48ac9f98c592"
 

include/core/lockfile.hpp

@@ -11,6 +11,7 @@
 #include "cforge/log.hpp"
 #include "core/constants.h"
 #include "core/git_utils.hpp"
+#include "core/registry.hpp"
 #include "core/toml_reader.hpp"
 
 #include <chrono>
@@ -514,4 +515,118 @@ inline bool verify_lockfile(const std::filesystem::path &project_dir,
   return all_match;
 }
 
+/**
+ * @brief Generate lock file from cforge.toml configuration (for FetchContent mode)
+ *
+ * @param project_dir Project directory
+ * @param config Project configuration
+ * @param verbose Verbose output
+ * @return true if lock file was generated successfully
+ */
+inline bool generate_lockfile_from_config(const std::filesystem::path &project_dir,
+                                          const toml_reader &config,
+                                          bool verbose = false) {
+  registry reg;
+  std::filesystem::path lock_path = project_dir / LOCK_FILE;
+  std::ofstream lock_file(lock_path);
+
+  if (!lock_file.is_open()) {
+    if (verbose) {
+      logger::print_warning("Failed to create lock file: " + lock_path.string());
+    }
+    return false;
+  }
+
+  // Write lock file header
+  lock_file << "# cforge.lock - Dependency lock file for reproducible builds\n";
+  lock_file << "# Generated by cforge - DO NOT EDIT MANUALLY\n";
+  lock_file << "# Mode: FetchContent\n\n";
+
+  // Get index dependencies from cforge.toml
+  auto dep_keys = config.get_table_keys("dependencies");
+  bool has_deps = false;
+
+  for (const auto &key : dep_keys) {
+    // Skip config keys
+    if (key == "fetch_content" || key == "directory" || key == "git" || key == "vcpkg") {
+      continue;
+    }
+
+    std::string version = config.get_string("dependencies." + key, "*");
+
+    // Try to get package info from registry
+    auto pkg_info = reg.get_package(key);
+    std::string resolved_version = version;
+    std::string repository;
+    std::string git_tag;
+
+    if (pkg_info) {
+      repository = pkg_info->repository;
+      // Resolve version
+      resolved_version = reg.resolve_version(key, version);
+      if (resolved_version.empty()) {
+        resolved_version = version;
+      }
+      // Get git tag for the version
+      for (const auto &ver : pkg_info->versions) {
+        if (ver.version == resolved_version) {
+          git_tag = ver.tag;
+          break;
+        }
+      }
+      // If no explicit tag, use tag pattern
+      if (git_tag.empty() && !pkg_info->tags.pattern.empty()) {
+        git_tag = pkg_info->tags.pattern;
+        size_t pos = git_tag.find("{version}");
+        if (pos != std::string::npos) {
+          git_tag.replace(pos, 9, resolved_version);
+        }
+      }
+    }
+
+    lock_file << "[dependency." << key << "]\n";
+    lock_file << "source_type = \"index\"\n";
+    lock_file << "version = \"" << resolved_version << "\"\n";
+    if (!repository.empty()) {
+      lock_file << "url = \"" << repository << "\"\n";
+    }
+    if (!git_tag.empty()) {
+      lock_file << "resolved = \"" << git_tag << "\"\n";
+    }
+    lock_file << "\n";
+    has_deps = true;
+
+    if (verbose) {
+      logger::print_verbose("Locked " + key + " @ " + resolved_version);
+    }
+  }
+
+  // Also handle git dependencies
+  for (const auto &key : config.get_table_keys("dependencies.git")) {
+    std::string url = config.get_string("dependencies.git." + key + ".url", "");
+    std::string tag = config.get_string("dependencies.git." + key + ".tag", "");
+    std::string branch = config.get_string("dependencies.git." + key + ".branch", "");
+    std::string commit = config.get_string("dependencies.git." + key + ".commit", "");
+
+    lock_file << "[dependency." << key << "]\n";
+    lock_file << "source_type = \"git\"\n";
+    if (!url.empty()) lock_file << "url = \"" << url << "\"\n";
+    if (!tag.empty()) lock_file << "version = \"" << tag << "\"\n";
+    if (!branch.empty()) lock_file << "branch = \"" << branch << "\"\n";
+    if (!commit.empty()) lock_file << "resolved = \"" << commit << "\"\n";
+    lock_file << "\n";
+    has_deps = true;
+  }
+
+  lock_file.close();
+
+  if (!has_deps) {
+    // No dependencies, remove empty lock file
+    std::filesystem::remove(lock_path);
+    return true;
+  }
+
+  return true;
+}
+
 } // namespace cforge

src/core/command_add.cpp

@@ -322,18 +322,26 @@ static bool add_dependency_to_section(const std::filesystem::path &config_file,
   int section_end = -1;
 
   // Read all lines and find the section
+  std::string section_header = "[" + section + "]";
   while (std::getline(file, line)) {
     lines.push_back(line);
 
-    // Check if this is our section
-    if (line.find("[" + section + "]") != std::string::npos) {
+    // Trim whitespace for comparison
+    std::string trimmed = line;
+    size_t start = trimmed.find_first_not_of(" \t");
+    if (start != std::string::npos) {
+      trimmed = trimmed.substr(start);
+    }
+
+    // Check if this is exactly our section (not a subsection like [dependencies.git])
+    if (trimmed == section_header) {
       in_section = true;
       section_found = true;
       continue;
     }
 
     // Check if we're leaving the section (new section starts)
-    if (in_section && !line.empty() && line[0] == '[') {
+    if (in_section && !trimmed.empty() && trimmed[0] == '[') {
       section_end = lines.size() - 1;
       in_section = false;
     }
@@ -345,8 +353,11 @@ static bool add_dependency_to_section(const std::filesystem::path &config_file,
     if (verbose) {
       logger::print_verbose("Creating new section: [" + section + "]");
     }
-    lines.push_back(""); // Add blank line before new section
-    lines.push_back("[" + section + "]");
+    // Add blank line before new section if file doesn't end with blank line
+    if (!lines.empty() && !lines.back().empty()) {
+      lines.push_back("");
+    }
+    lines.push_back(section_header);
     section_end = lines.size();
   }
 

src/core/command_build.cpp

@@ -660,13 +660,8 @@ static bool run_cmake_configure(const std::vector<std::string> &cmake_args,
       formatted_errors = format_build_errors(pr.stdout_output);
     }
     if (!formatted_errors.empty()) {
-      std::istringstream iss(formatted_errors);
-      std::string line;
-      while (std::getline(iss, line)) {
-        if (!line.empty()) {
-          logger::print_error(line);
-        }
-      }
+      // Print formatted errors directly (they already contain "error" prefix from Rust-style formatting)
+      fmt::print("{}", formatted_errors);
     } else {
       // Fallback: print raw outputs
       if (!pr.stderr_output.empty()) {
@@ -824,10 +819,16 @@ static bool build_project(const std::filesystem::path &project_dir,
 
     // Generate/update lock file after dependencies are resolved
     {
+      bool use_fetch_content = project_config.get_bool("dependencies.fetch_content", true);
       std::string deps_dir_str =
           project_config.get_string("dependencies.directory", "deps");
       std::filesystem::path deps_path = project_dir / deps_dir_str;
-      if (std::filesystem::exists(deps_path)) {
+
+      if (use_fetch_content) {
+        // FetchContent mode: generate lock file from cforge.toml + registry
+        generate_lockfile_from_config(project_dir, project_config, verbose);
+      } else if (std::filesystem::exists(deps_path)) {
+        // Clone mode: scan deps directory
         update_lockfile(project_dir, deps_path, verbose);
       }
     }

src/core/command_lock.cpp

@@ -12,11 +12,13 @@
 #include "core/commands.hpp"
 #include "core/constants.h"
 #include "core/lockfile.hpp"
+#include "core/registry.hpp"
 #include "core/toml_reader.hpp"
 #include "core/workspace.hpp"
 
 #include <cstring>
 #include <filesystem>
+#include <fstream>
 #include <string>
 
 using namespace cforge;
@@ -108,9 +110,9 @@ cforge_int_t cforge_cmd_lock(const cforge_context_t *ctx) {
     return 1;
   }
 
-  // Get dependencies directory
+  // Get dependencies directory (default: deps)
   std::string deps_dir_str =
-      config.get_string("dependencies.directory", "vendor");
+      config.get_string("dependencies.directory", "deps");
   std::filesystem::path deps_dir = current_dir / deps_dir_str;
 
   // Handle --verify option
@@ -153,6 +155,116 @@ cforge_int_t cforge_cmd_lock(const cforge_context_t *ctx) {
   // Generate/update lock file
   logger::print_action("Generating", "lock file");
 
+  // Check if using FetchContent mode
+  bool use_fetch_content = config.get_bool("dependencies.fetch_content", true);
+
+  if (use_fetch_content) {
+    // FetchContent mode: generate lock file from cforge.toml + registry
+    registry reg;
+    std::filesystem::path lock_path = current_dir / LOCK_FILE;
+    std::ofstream lock_file(lock_path);
+
+    if (!lock_file.is_open()) {
+      logger::print_error("Failed to create lock file: " + lock_path.string());
+      return 1;
+    }
+
+    // Write lock file header
+    lock_file << "# cforge.lock - Dependency lock file for reproducible builds\n";
+    lock_file << "# Generated by cforge - DO NOT EDIT MANUALLY\n";
+    lock_file << "# Mode: FetchContent\n\n";
+
+    // Get index dependencies from cforge.toml
+    auto dep_keys = config.get_table_keys("dependencies");
+    bool has_deps = false;
+
+    for (const auto &key : dep_keys) {
+      // Skip config keys
+      if (key == "fetch_content" || key == "directory" || key == "git" || key == "vcpkg") {
+        continue;
+      }
+
+      std::string version = config.get_string("dependencies." + key, "*");
+
+      // Try to get package info from registry
+      auto pkg_info = reg.get_package(key);
+      std::string resolved_version = version;
+      std::string repository;
+      std::string git_tag;
+
+      if (pkg_info) {
+        repository = pkg_info->repository;
+        // Resolve version
+        resolved_version = reg.resolve_version(key, version);
+        if (resolved_version.empty()) {
+          resolved_version = version;
+        }
+        // Get git tag for the version
+        for (const auto &ver : pkg_info->versions) {
+          if (ver.version == resolved_version) {
+            git_tag = ver.tag;
+            break;
+          }
+        }
+        // If no explicit tag, use tag pattern
+        if (git_tag.empty() && !pkg_info->tags.pattern.empty()) {
+          git_tag = pkg_info->tags.pattern;
+          size_t pos = git_tag.find("{version}");
+          if (pos != std::string::npos) {
+            git_tag.replace(pos, 9, resolved_version);
+          }
+        }
+      }
+
+      lock_file << "[dependency." << key << "]\n";
+      lock_file << "source_type = \"index\"\n";
+      lock_file << "version = \"" << resolved_version << "\"\n";
+      if (!repository.empty()) {
+        lock_file << "url = \"" << repository << "\"\n";
+      }
+      if (!git_tag.empty()) {
+        lock_file << "resolved = \"" << git_tag << "\"\n";
+      }
+      lock_file << "\n";
+      has_deps = true;
+
+      if (verbose) {
+        logger::print_verbose("Locked " + key + " @ " + resolved_version);
+      }
+    }
+
+    // Also handle git dependencies
+    for (const auto &key : config.get_table_keys("dependencies.git")) {
+      std::string url = config.get_string("dependencies.git." + key + ".url", "");
+      std::string tag = config.get_string("dependencies.git." + key + ".tag", "");
+      std::string branch = config.get_string("dependencies.git." + key + ".branch", "");
+      std::string commit = config.get_string("dependencies.git." + key + ".commit", "");
+
+      lock_file << "[dependency." << key << "]\n";
+      lock_file << "source_type = \"git\"\n";
+      if (!url.empty()) lock_file << "url = \"" << url << "\"\n";
+      if (!tag.empty()) lock_file << "version = \"" << tag << "\"\n";
+      if (!branch.empty()) lock_file << "branch = \"" << branch << "\"\n";
+      if (!commit.empty()) lock_file << "resolved = \"" << commit << "\"\n";
+      lock_file << "\n";
+      has_deps = true;
+    }
+
+    lock_file.close();
+
+    if (!has_deps) {
+      logger::print_warning("No dependencies found to lock");
+      std::filesystem::remove(lock_path);
+      return 0;
+    }
+
+    logger::generated(std::string(LOCK_FILE));
+    logger::print_action(
+        "Note", "commit this file to version control for reproducible builds");
+    return 0;
+  }
+
+  // Non-FetchContent mode: scan deps directory
   if (!std::filesystem::exists(deps_dir)) {
     logger::print_warning("Dependencies directory not found: " +
                           deps_dir.string());