combicode 1.5.3 → 1.5.4

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+# Changelog
+
+## [1.5.4](https://github.com/aaurelions/combicode/compare/combicode-js-v1.5.3...combicode-js-v1.5.4) (2025-12-03)
+
+### Features
+
+- **ignore:** implement full support for nested `.gitignore` files, ensuring exclusion rules are applied correctly within subdirectories
+
+### Bug Fixes
+
+- **deps:** replace `fast-glob` with `ignore` and recursive directory walking for accurate git-like pattern matching
+
 ## [1.5.3](https://github.com/aaurelions/combicode/compare/combicode-js-v1.5.2...combicode-js-v1.5.3) (2025-11-30)
 
 ### Bug Fixes

package/README.md

@@ -16,6 +16,7 @@ The generated file starts with a system prompt and a file tree overview, priming
 - **Intelligent Priming:** Starts the output with a system prompt and a file tree, directing the LLM to analyze the entire codebase before responding.
 - **Intelligent Ignoring:** Automatically skips `node_modules`, `.venv`, `dist`, `.git`, binary files, and other common junk.
 - **`.gitignore` Aware:** Respects your project's existing `.gitignore` rules out of the box.
+- **Nested Ignore Support:** Correctly handles `.gitignore` files located in subdirectories, ensuring local exclusion rules are respected.
 - **Zero-Install Usage:** Run it directly with `npx` or `pipx` without polluting your environment.
 - **Customizable:** Easily filter by file extension or add custom ignore patterns.
 

package/index.js

@@ -4,7 +4,7 @@ const fs = require("fs");
 const path = require("path");
 const yargs = require("yargs/yargs");
 const { hideBin } = require("yargs/helpers");
-const glob = require("fast-glob");
+const ignore = require("ignore");
 
 const { version } = require("./package.json");
 
@@ -24,26 +24,14 @@ When answering questions or writing code, adhere strictly to the functions, vari
 A file tree of the documentation source is provided below for a high-level overview. The subsequent sections contain the full content of each file, clearly marked with a file header.
 `;
 
-function loadDefaultIgnorePatterns() {
-  const configPath = path.resolve(__dirname, "config", "ignore.json");
-  try {
-    const rawConfig = fs.readFileSync(configPath, "utf8");
-    return JSON.parse(rawConfig);
-  } catch (err) {
-    console.error(
-      `❌ Critical: Could not read or parse bundled ignore config at ${configPath}`
-    );
-    process.exit(1);
-  }
-}
-
-const DEFAULT_IGNORE_PATTERNS = loadDefaultIgnorePatterns();
+// Minimal safety ignores that should always apply
+const SAFETY_IGNORES = [".git", ".DS_Store"];
 
-function isLikelyBinary(file) {
+function isLikelyBinary(filePath) {
   const buffer = Buffer.alloc(512);
   let fd;
   try {
-    fd = fs.openSync(file, "r");
+    fd = fs.openSync(filePath, "r");
     const bytesRead = fs.readSync(fd, buffer, 0, 512, 0);
     return buffer.slice(0, bytesRead).includes(0);
   } catch (e) {
@@ -62,11 +50,129 @@ function formatBytes(bytes, decimals = 1) {
   return parseFloat((bytes / Math.pow(k, i)).toFixed(dm)) + "" + sizes[i];
 }
 
+/**
+ * Recursively walks directories, respecting .gitignore files at each level.
+ */
+function walkDirectory(
+  currentDir,
+  rootDir,
+  ignoreChain,
+  allowedExts,
+  absoluteOutputPath,
+  useGitIgnore,
+  stats // { scanned: 0, ignored: 0 }
+) {
+  let results = [];
+  let currentIgnoreManager = null;
+
+  // 1. Check for local .gitignore and add to chain for this scope
+  if (useGitIgnore) {
+    const gitignorePath = path.join(currentDir, ".gitignore");
+    if (fs.existsSync(gitignorePath)) {
+      try {
+        const content = fs.readFileSync(gitignorePath, "utf8");
+        const ig = ignore().add(content);
+        currentIgnoreManager = { manager: ig, root: currentDir };
+      } catch (e) {
+        // Warning could go here
+      }
+    }
+  }
+
+  // Create a new chain for this directory and its children
+  const nextIgnoreChain = currentIgnoreManager
+    ? [...ignoreChain, currentIgnoreManager]
+    : ignoreChain;
+
+  let entries;
+  try {
+    entries = fs.readdirSync(currentDir, { withFileTypes: true });
+  } catch (e) {
+    return [];
+  }
+
+  for (const entry of entries) {
+    const fullPath = path.join(currentDir, entry.name);
+
+    // SKIP CHECK: Output file
+    if (path.resolve(fullPath) === absoluteOutputPath) continue;
+
+    // SKIP CHECK: Ignore Chain
+    let shouldIgnore = false;
+    for (const item of nextIgnoreChain) {
+      // Calculate path relative to the specific ignore manager's root
+      // IMPORTANT: Normalize to POSIX slashes for 'ignore' package compatibility
+      let relToIgnoreRoot = path.relative(item.root, fullPath);
+
+      if (path.sep === "\\") {
+        relToIgnoreRoot = relToIgnoreRoot.replace(/\\/g, "/");
+      }
+
+      // If checking a directory, ensure trailing slash for proper 'ignore' directory matching
+      if (entry.isDirectory() && !relToIgnoreRoot.endsWith("/")) {
+        relToIgnoreRoot += "/";
+      }
+
+      if (item.manager.ignores(relToIgnoreRoot)) {
+        shouldIgnore = true;
+        break;
+      }
+    }
+
+    if (shouldIgnore) {
+      stats.ignored++;
+      continue;
+    }
+
+    if (entry.isDirectory()) {
+      // Recurse
+      results = results.concat(
+        walkDirectory(
+          fullPath,
+          rootDir,
+          nextIgnoreChain,
+          allowedExts,
+          absoluteOutputPath,
+          useGitIgnore,
+          stats
+        )
+      );
+    } else if (entry.isFile()) {
+      // SKIP CHECK: Binary
+      if (isLikelyBinary(fullPath)) {
+        stats.ignored++;
+        continue;
+      }
+
+      // SKIP CHECK: Extensions
+      if (allowedExts && !allowedExts.has(path.extname(entry.name))) {
+        stats.ignored++;
+        continue;
+      }
+
+      try {
+        const fileStats = fs.statSync(fullPath);
+        const relativeToRoot = path.relative(rootDir, fullPath);
+        stats.scanned++;
+        results.push({
+          path: fullPath,
+          relativePath: relativeToRoot,
+          size: fileStats.size,
+          formattedSize: formatBytes(fileStats.size),
+        });
+      } catch (e) {
+        // Skip inaccessible files
+      }
+    }
+  }
+
+  return results;
+}
+
 function generateFileTree(filesWithSize, root) {
   let tree = `${path.basename(root)}/\n`;
   const structure = {};
 
-  // Build the structure
   filesWithSize.forEach(({ relativePath, formattedSize }) => {
     const parts = relativePath.split(path.sep);
     let currentLevel = structure;
@@ -89,7 +195,6 @@ function generateFileTree(filesWithSize, root) {
       const isLast = index === entries.length - 1;
       const value = level[entry];
       const isFile = typeof value === "string";
-
       const connector = isLast ? "└── " : "├── ";
 
       if (isFile) {
@@ -112,7 +217,6 @@ async function main() {
     process.exit(0);
   }
 
-  // Yargs singleton usage works correctly with arguments passed here
   const argv = yargs(rawArgv)
     .scriptName("combicode")
     .usage("$0 [options]")
@@ -160,38 +264,21 @@ async function main() {
     .alias("h", "help").argv;
 
   const projectRoot = process.cwd();
-  console.log(`✨ Running Combicode in: ${projectRoot}`);
+  console.log(`\n✨ Combicode v${version}`);
+  console.log(`📂 Root: ${projectRoot}`);
 
-  const ignorePatterns = [...DEFAULT_IGNORE_PATTERNS];
+  const rootIgnoreManager = ignore();
 
-  if (!argv.noGitignore) {
-    const gitignorePath = path.join(projectRoot, ".gitignore");
-    if (fs.existsSync(gitignorePath)) {
-      console.log("🔎 Found and using .gitignore");
-      const gitignoreContent = fs.readFileSync(gitignorePath, "utf8");
-      ignorePatterns.push(
-        ...gitignoreContent
-          .split(/\r?\n/)
-          .filter((line) => line && !line.startsWith("#"))
-      );
-    }
-  }
+  // Only add minimal safety ignores + CLI excludes.
+  // No external JSON config is loaded.
+  rootIgnoreManager.add(SAFETY_IGNORES);
 
   if (argv.exclude) {
-    ignorePatterns.push(...argv.exclude.split(","));
+    rootIgnoreManager.add(argv.exclude.split(","));
   }
 
-  // Calculate the absolute path of the output file to prevent self-inclusion
   const absoluteOutputPath = path.resolve(projectRoot, argv.output);
 
-  let allFiles = await glob("**/*", {
-    cwd: projectRoot,
-    dot: true,
-    ignore: ignorePatterns,
-    absolute: true,
-    stats: true,
-  });
-
   const allowedExtensions = argv.includeExt
     ? new Set(
         argv.includeExt
@@ -200,30 +287,35 @@ async function main() {
       )
     : null;
 
-  const includedFiles = allFiles
-    .filter((fileObj) => {
-      const file = fileObj.path;
+  // Initialize the ignore chain with the root manager
+  const ignoreChain = [{ manager: rootIgnoreManager, root: projectRoot }];
+
+  // Statistics container
+  const stats = { scanned: 0, ignored: 0 };
+
+  // Perform Recursive Walk
+  const includedFiles = walkDirectory(
+    projectRoot,
+    projectRoot,
+    ignoreChain,
+    allowedExtensions,
+    absoluteOutputPath,
+    !argv.noGitignore,
+    stats
+  );
 
-      // Prevent the output file from being included in the list
-      // We use path.normalize to handle potential differences in separators (e.g., / vs \)
-      if (path.normalize(file) === absoluteOutputPath) return false;
+  includedFiles.sort((a, b) => a.path.localeCompare(b.path));
 
-      if (!fileObj.stats || fileObj.stats.isDirectory()) return false;
-      if (isLikelyBinary(file)) return false;
-      if (allowedExtensions && !allowedExtensions.has(path.extname(file)))
-        return false;
-      return true;
-    })
-    .map((fileObj) => ({
-      path: fileObj.path,
-      relativePath: path.relative(projectRoot, fileObj.path),
-      size: fileObj.stats.size,
-      formattedSize: formatBytes(fileObj.stats.size),
-    }))
-    .sort((a, b) => a.path.localeCompare(b.path));
+  // Calculate total size of included files
+  const totalSizeBytes = includedFiles.reduce(
+    (acc, file) => acc + file.size,
+    0
+  );
 
   if (includedFiles.length === 0) {
-    console.error("❌ No files to include. Check your path or filters.");
+    console.error(
+      "\n❌ No files to include. Check your path, .gitignore, or filters."
+    );
     process.exit(1);
   }
 
@@ -231,23 +323,34 @@ async function main() {
     console.log("\n📋 Files to be included (Dry Run):\n");
     const tree = generateFileTree(includedFiles, projectRoot);
     console.log(tree);
-    console.log(`\nTotal: ${includedFiles.length} files.`);
+    console.log("\n📊 Summary (Dry Run):");
+    console.log(
+      `   • Included: ${includedFiles.length} files (${formatBytes(
+        totalSizeBytes
+      )})`
+    );
+    console.log(`   • Ignored:  ${stats.ignored} files/dirs`);
     return;
   }
 
   const outputStream = fs.createWriteStream(argv.output);
+  let totalLines = 0;
 
   if (!argv.noHeader) {
     const systemPrompt = argv.llmsTxt
       ? LLMS_TXT_SYSTEM_PROMPT
       : DEFAULT_SYSTEM_PROMPT;
     outputStream.write(systemPrompt + "\n");
+    totalLines += systemPrompt.split("\n").length;
+
     outputStream.write("## Project File Tree\n\n");
     outputStream.write("```\n");
     const tree = generateFileTree(includedFiles, projectRoot);
     outputStream.write(tree);
     outputStream.write("```\n\n");
     outputStream.write("---\n\n");
+
+    totalLines += tree.split("\n").length + 5;
   }
 
   for (const fileObj of includedFiles) {
@@ -257,16 +360,24 @@ async function main() {
     try {
       const content = fs.readFileSync(fileObj.path, "utf8");
       outputStream.write(content);
+      totalLines += content.split("\n").length;
     } catch (e) {
       outputStream.write(`... (error reading file: ${e.message}) ...`);
     }
     outputStream.write("\n```\n\n");
+    totalLines += 4; // Headers/footers lines
   }
   outputStream.end();
 
+  console.log(`\n📊 Summary:`);
   console.log(
-    `\n✅ Success! Combined ${includedFiles.length} files into '${argv.output}'.`
+    `   • Included: ${includedFiles.length} files (${formatBytes(
+      totalSizeBytes
+    )})`
   );
+  console.log(`   • Ignored:  ${stats.ignored} files/dirs`);
+  console.log(`   • Output:   ${argv.output} (~${totalLines} lines)`);
+  console.log(`\n✅ Done!`);
 }
 
 main().catch((err) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "combicode",
-  "version": "1.5.3",
+  "version": "1.5.4",
   "description": "A CLI tool to combine a project's codebase into a single file for LLM context.",
   "main": "index.js",
   "bin": {
@@ -10,8 +10,6 @@
     "access": "public"
   },
   "scripts": {
-    "prepack": "mkdir -p config && cp ../configs/ignore.json config/ignore.json",
-    "pretest": "mkdir -p config && cp ../configs/ignore.json config/ignore.json",
     "test": "node test/test.js"
   },
   "repository": {
@@ -34,7 +32,7 @@
   "author": "A. Aurelions",
   "license": "MIT",
   "dependencies": {
-    "fast-glob": "^3.3.3",
+    "ignore": "^5.3.0",
     "yargs": "^17.7.2"
   }
 }

package/test/test.js

@@ -7,20 +7,17 @@ const CLI_PATH = path.resolve(__dirname, "../index.js");
 const TEST_DIR = path.resolve(__dirname, "temp_env");
 const OUTPUT_FILE = path.join(TEST_DIR, "combicode.txt");
 
-// Setup: Create a temp directory with dummy files
-function setup() {
-  if (fs.existsSync(TEST_DIR)) {
-    fs.rmSync(TEST_DIR, { recursive: true, force: true });
-  }
-  fs.mkdirSync(TEST_DIR);
-
-  // Create a dummy JS file
-  fs.writeFileSync(path.join(TEST_DIR, "alpha.js"), "console.log('alpha');");
-
-  // Create a dummy text file in a subdir
-  const subDir = path.join(TEST_DIR, "subdir");
-  fs.mkdirSync(subDir);
-  fs.writeFileSync(path.join(subDir, "beta.txt"), "Hello World");
+// Helper to create directory structure
+function createStructure(base, structure) {
+  Object.entries(structure).forEach(([name, content]) => {
+    const fullPath = path.join(base, name);
+    if (typeof content === "object") {
+      fs.mkdirSync(fullPath);
+      createStructure(fullPath, content);
+    } else {
+      fs.writeFileSync(fullPath, content);
+    }
+  });
 }
 
 // Teardown: Cleanup temp directory
@@ -34,53 +31,119 @@ function runTest() {
   console.log("🧪 Starting Node.js Integration Tests...");
 
   try {
-    setup();
+    // Clean start
+    teardown();
+    fs.mkdirSync(TEST_DIR);
 
-    // 1. Test Version Flag
-    console.log("   Checking --version...");
+    // --- Scenario 1: Basic Functionality ---
+    console.log("   [1/4] Checking Basic Functionality & Version...");
     const versionOutput = execSync(`node ${CLI_PATH} --version`).toString();
     assert.match(versionOutput, /Combicode \(JavaScript\), version/);
 
-    // 2. Test Dry Run
-    console.log("   Checking --dry-run...");
+    createStructure(TEST_DIR, {
+      "alpha.js": "console.log('alpha');",
+      subdir: {
+        "beta.txt": "Hello World",
+      },
+    });
+
+    // Capture dry-run output to verify structure
     const dryRunOutput = execSync(`node ${CLI_PATH} --dry-run`, {
       cwd: TEST_DIR,
     }).toString();
     assert.match(dryRunOutput, /Files to be included \(Dry Run\)/);
-    // Check for file size format in tree (e.g., [21B])
-    assert.match(dryRunOutput, /\[\d+(\.\d+)?[KM]?B\]/);
+    assert.match(dryRunOutput, /\[\d+(\.\d+)?[KM]?B\]/); // Size check
 
-    // 3. Test Actual Generation
-    console.log("   Checking file generation...");
-    execSync(`node ${CLI_PATH} --output combicode.txt`, { cwd: TEST_DIR });
+    // Run generation
+    execSync(`node ${CLI_PATH} --output combicode.txt`, {
+      cwd: TEST_DIR,
+      stdio: "inherit",
+    });
 
     assert.ok(fs.existsSync(OUTPUT_FILE), "Output file should exist");
+    let content = fs.readFileSync(OUTPUT_FILE, "utf8");
+    assert.ok(content.includes("### **FILE:** `alpha.js`"));
+    assert.ok(content.includes("### **FILE:** `subdir/beta.txt`"));
 
-    const content = fs.readFileSync(OUTPUT_FILE, "utf8");
+    // --- Scenario 2: Nested .gitignore Support ---
+    console.log("   [2/4] Checking Nested .gitignore Support...");
+    teardown();
+    fs.mkdirSync(TEST_DIR);
+
+    createStructure(TEST_DIR, {
+      "root.js": "root",
+      "ignore_me_root.log": "log",
+      ".gitignore": "*.log",
+      nested: {
+        "child.js": "child",
+        "ignore_me_child.tmp": "tmp",
+        ".gitignore": "*.tmp",
+        deep: {
+          "deep.js": "deep",
+          "ignore_local.txt": "txt",
+          ".gitignore": "ignore_local.txt",
+        },
+      },
+    });
+
+    execSync(`node ${CLI_PATH} -o combicode.txt`, {
+      cwd: TEST_DIR,
+      stdio: "inherit",
+    });
+    content = fs.readFileSync(OUTPUT_FILE, "utf8");
 
-    // Check for System Prompt
+    // Should include:
+    assert.ok(content.includes("### **FILE:** `root.js`"), "root.js missing");
     assert.ok(
-      content.includes("You are an expert software architect"),
-      "System prompt missing"
+      content.includes("### **FILE:** `nested/child.js`"),
+      "child.js missing"
+    );
+    assert.ok(
+      content.includes("### **FILE:** `nested/deep/deep.js`"),
+      "deep.js missing"
     );
 
-    // Check for Tree structure
-    assert.ok(content.includes("subdir"), "Tree should show subdirectory");
+    // Should exclude (Checking Headers, not content):
+    assert.ok(
+      !content.includes("### **FILE:** `ignore_me_root.log`"),
+      "Root gitignore failed (*.log)"
+    );
+    assert.ok(
+      !content.includes("### **FILE:** `nested/ignore_me_child.tmp`"),
+      "Nested gitignore failed (*.tmp)"
+    );
+    assert.ok(
+      !content.includes("### **FILE:** `nested/deep/ignore_local.txt`"),
+      "Deep nested gitignore failed (specific file)"
+    );
 
-    // Check for new Header format
+    // --- Scenario 3: CLI Exclude Override ---
+    console.log("   [3/4] Checking CLI Exclude Flags...");
+    execSync(`node ${CLI_PATH} -o combicode.txt -e "**/deep.js"`, {
+      cwd: TEST_DIR,
+      stdio: "inherit",
+    });
+    content = fs.readFileSync(OUTPUT_FILE, "utf8");
     assert.ok(
-      content.includes("### **FILE:** `alpha.js`"),
-      "New header format missing for alpha.js"
+      !content.includes("### **FILE:** `nested/deep/deep.js`"),
+      "CLI exclude flag failed"
     );
+
+    // --- Scenario 4: Output File Self-Exclusion ---
+    console.log("   [4/4] Checking Output File Self-Exclusion...");
+    execSync(`node ${CLI_PATH} -o combicode.txt`, {
+      cwd: TEST_DIR,
+      stdio: "inherit",
+    });
+    content = fs.readFileSync(OUTPUT_FILE, "utf8");
     assert.ok(
-      content.includes("### **FILE:** `subdir/beta.txt`"),
-      "New header format missing for beta.txt"
+      !content.includes("### **FILE:** `combicode.txt`"),
+      "Output file included itself"
     );
 
     console.log("✅ All Node.js tests passed!");
   } catch (error) {
     console.error("❌ Test Failed:", error.message);
-    if (error.stdout) console.log(error.stdout.toString());
     process.exit(1);
   } finally {
     teardown();

package/config/ignore.json

@@ -1,53 +0,0 @@
-[
-  "**/node_modules/**",
-  "**/.git/**",
-  "**/.vscode/**",
-  "**/.idea/**",
-  "**/*.log",
-  "**/.env",
-  "**/*.lock",
-  "**/.venv/**",
-  "**/venv/**",
-  "**/env/**",
-  "**/__pycache__/**",
-  "**/*.pyc",
-  "**/*.egg-info/**",
-  "**/build/**",
-  "**/dist/**",
-  "**/.pytest_cache/**",
-  "**/.npm/**",
-  "**/pnpm-lock.yaml",
-  "**/package-lock.json",
-  "**/.next/**",
-  "**/.DS_Store",
-  "**/Thumbs.db",
-  "**/*.png",
-  "**/*.jpg",
-  "**/*.jpeg",
-  "**/*.gif",
-  "**/*.ico",
-  "**/*.svg",
-  "**/*.webp",
-  "**/*.mp3",
-  "**/*.wav",
-  "**/*.flac",
-  "**/*.mp4",
-  "**/*.mov",
-  "**/*.avi",
-  "**/*.zip",
-  "**/*.tar.gz",
-  "**/*.rar",
-  "**/*.pdf",
-  "**/*.doc",
-  "**/*.docx",
-  "**/*.xls",
-  "**/*.xlsx",
-  "**/*.dll",
-  "**/*.exe",
-  "**/*.so",
-  "**/*.a",
-  "**/*.lib",
-  "**/*.o",
-  "**/*.bin",
-  "**/*.iso"
-]