combicode 1.5.3 → 1.7.1

package/CHANGELOG.md

@@ -1,5 +1,33 @@
 # Changelog
 
+## [1.7.1](https://github.com/aaurelions/combicode/compare/combicode-js-v1.7.0...combicode-js-v1.7.1) (2025-01-XX)
+
+### Bug Fixes
+
+- **ci:** restore NPM_TOKEN for npm publishing to fix authentication issues
+
+## [1.7.0](https://github.com/aaurelions/combicode/compare/combicode-js-v1.6.0...combicode-js-v1.7.0) (2025-01-XX)
+
+### Maintenance
+
+- **ci:** migrate to npm trusted publishing (OIDC), remove NPM_TOKEN requirement
+
+## [1.6.0](https://github.com/aaurelions/combicode/compare/combicode-js-v1.5.4...combicode-js-v1.6.0) (2025-01-XX)
+
+### Features
+
+- **skip-content:** add `--skip-content` option to include files in tree but omit their content (useful for large test files)
+
+## [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.
 
@@ -80,6 +81,20 @@ Use the `--exclude` or `-e` flag with comma-separated glob patterns.
 npx combicode -e "**/*_test.py,docs/**"
 ```
 
+### Skip content for specific files
+
+Use the `--skip-content` flag to include files in the tree structure but omit their content. This is useful for large files (like test files) that you want visible in the project overview but don't need their full content.
+
+```bash
+# Include .test.ts files in tree but skip their content
+npx combicode --skip-content "**/*.test.ts"
+
+# Skip content for multiple patterns
+npx combicode --skip-content "**/*.test.ts,**/*.spec.ts,**/tests/**"
+```
+
+Files with skipped content will be marked with `(content omitted)` in the file tree and will show a placeholder in the content section.
+
 ### Generating Context for `llms.txt`
 
 The `--llms.txt` or `-l` flag is designed for projects that use an [`llms.txt`](https://llmstxt.org/) file to specify important documentation. When this flag is used, Combicode inserts a specialized system prompt telling the LLM that the provided context is the project's definitive documentation for a specific version. This helps the LLM provide more accurate answers and avoid using deprecated functions.
@@ -97,6 +112,7 @@ npx combicode -l -i .md -o llms.txt
 | `--dry-run`      | `-d`  | Preview files without creating the output file.                                | `false`         |
 | `--include-ext`  | `-i`  | Comma-separated list of extensions to exclusively include.                     | (include all)   |
 | `--exclude`      | `-e`  | Comma-separated list of additional glob patterns to exclude.                   | (none)          |
+| `--skip-content` |       | Comma-separated glob patterns for files to include in tree but omit content.   | (none)          |
 | `--llms-txt`     | `-l`  | Use a specialized system prompt for context generated from an `llms.txt` file. | `false`         |
 | `--no-gitignore` |       | Do not use patterns from the project's `.gitignore` file.                      | `false`         |
 | `--no-header`    |       | Omit the introductory prompt and file tree from the output.                    | `false`         |

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,18 +50,137 @@ function formatBytes(bytes, decimals = 1) {
   return parseFloat((bytes / Math.pow(k, i)).toFixed(dm)) + "" + sizes[i];
 }
 
-function generateFileTree(filesWithSize, root) {
+/**
+ * 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, skipContentSet = null) {
   let tree = `${path.basename(root)}/\n`;
   const structure = {};
 
-  // Build the structure
   filesWithSize.forEach(({ relativePath, formattedSize }) => {
     const parts = relativePath.split(path.sep);
     let currentLevel = structure;
     parts.forEach((part, index) => {
       const isFile = index === parts.length - 1;
       if (isFile) {
-        currentLevel[part] = formattedSize;
+        const shouldSkipContent = skipContentSet && skipContentSet.has(relativePath);
+        currentLevel[part] = { size: formattedSize, skipContent: shouldSkipContent };
       } else {
         if (!currentLevel[part]) {
           currentLevel[part] = {};
@@ -88,12 +195,12 @@ function generateFileTree(filesWithSize, root) {
     entries.forEach((entry, index) => {
       const isLast = index === entries.length - 1;
       const value = level[entry];
-      const isFile = typeof value === "string";
-
+      const isFile = typeof value === "object" && value.size !== undefined;
       const connector = isLast ? "└── " : "├── ";
 
       if (isFile) {
-        tree += `${prefix}${connector}[${value}] ${entry}\n`;
+        const marker = value.skipContent ? " (content omitted)" : "";
+        tree += `${prefix}${connector}[${value.size}] ${entry}${marker}\n`;
       } else {
         tree += `${prefix}${connector}${entry}\n`;
         buildTree(value, `${prefix}${isLast ? "    " : "│   "}`);
@@ -112,7 +219,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]")
@@ -154,43 +260,36 @@ async function main() {
       type: "boolean",
       default: false,
     })
+    .option("skip-content", {
+      describe: "Comma-separated glob patterns for files to include in tree but omit content",
+      type: "string",
+    })
     .version(version)
     .alias("v", "version")
     .help()
     .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);
+  // Create skip-content manager
+  const skipContentManager = ignore();
+  if (argv.skipContent) {
+    skipContentManager.add(argv.skipContent.split(","));
+  }
 
-  let allFiles = await glob("**/*", {
-    cwd: projectRoot,
-    dot: true,
-    ignore: ignorePatterns,
-    absolute: true,
-    stats: true,
-  });
+  const absoluteOutputPath = path.resolve(projectRoot, argv.output);
 
   const allowedExtensions = argv.includeExt
     ? new Set(
@@ -200,73 +299,121 @@ 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));
+  // Determine which files should have content skipped
+  const skipContentSet = new Set();
+  if (argv.skipContent) {
+    includedFiles.forEach((file) => {
+      const relativePath = file.relativePath.replace(/\\/g, "/");
+      if (skipContentManager.ignores(relativePath)) {
+        skipContentSet.add(file.relativePath);
+      }
+    });
+  }
+
+  // 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);
   }
 
   if (argv.dryRun) {
     console.log("\n📋 Files to be included (Dry Run):\n");
-    const tree = generateFileTree(includedFiles, projectRoot);
+    const tree = generateFileTree(includedFiles, projectRoot, skipContentSet);
     console.log(tree);
-    console.log(`\nTotal: ${includedFiles.length} files.`);
+    console.log("\n📊 Summary (Dry Run):");
+    console.log(
+      `   • Included: ${includedFiles.length} files (${formatBytes(
+        totalSizeBytes
+      )})`
+    );
+    if (skipContentSet.size > 0) {
+      console.log(`   • Content omitted: ${skipContentSet.size} files`);
+    }
+    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);
+    const tree = generateFileTree(includedFiles, projectRoot, skipContentSet);
     outputStream.write(tree);
     outputStream.write("```\n\n");
     outputStream.write("---\n\n");
+
+    totalLines += tree.split("\n").length + 5;
   }
 
   for (const fileObj of includedFiles) {
     const relativePath = fileObj.relativePath.replace(/\\/g, "/");
+    const shouldSkipContent = skipContentSet.has(fileObj.relativePath);
+    
     outputStream.write(`### **FILE:** \`${relativePath}\`\n`);
     outputStream.write("```\n");
-    try {
-      const content = fs.readFileSync(fileObj.path, "utf8");
-      outputStream.write(content);
-    } catch (e) {
-      outputStream.write(`... (error reading file: ${e.message}) ...`);
+    if (shouldSkipContent) {
+      outputStream.write(`(Content omitted - file size: ${fileObj.formattedSize})\n`);
+      totalLines += 1;
+    } else {
+      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
+    )})`
   );
+  if (skipContentSet.size > 0) {
+    console.log(`   • Content omitted: ${skipContentSet.size} files`);
+  }
+  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.7.1",
   "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,177 @@ 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:** `combicode.txt`"),
+      "Output file included itself"
+    );
+
+    // --- Scenario 5: Skip Content Feature ---
+    console.log("   [5/5] Checking Skip Content Feature...");
+    teardown();
+    fs.mkdirSync(TEST_DIR);
+
+    createStructure(TEST_DIR, {
+      "main.js": "console.log('main');",
+      "test.js": "describe('test', () => { it('works', () => {}); });",
+      "large.test.ts": "const data = " + '"x'.repeat(1000) + '";',
+      subdir: {
+        "spec.ts": "describe('spec', () => {});",
+        "utils.js": "export function util() {}",
+      },
+    });
+
+    execSync(`node ${CLI_PATH} -o combicode.txt --skip-content "**/*test.ts,**/*spec.ts"`, {
+      cwd: TEST_DIR,
+      stdio: "inherit",
+    });
+    content = fs.readFileSync(OUTPUT_FILE, "utf8");
+
+    // Files should appear in tree with (content omitted) marker
     assert.ok(
-      content.includes("### **FILE:** `subdir/beta.txt`"),
-      "New header format missing for beta.txt"
+      content.includes("large.test.ts (content omitted)"),
+      "Tree should show (content omitted) marker for large.test.ts"
     );
+    // Check for spec.ts - it might be in subdir/spec.ts path
+    assert.ok(
+      content.includes("spec.ts (content omitted)") || content.includes("subdir/spec.ts (content omitted)"),
+      "Tree should show (content omitted) marker for spec.ts"
+    );
+
+    // Files should have FILE headers
+    assert.ok(content.includes("### **FILE:** `large.test.ts`"), "File header should exist");
+    assert.ok(content.includes("### **FILE:** `subdir/spec.ts`"), "File header should exist");
+
+    // Content should be omitted (placeholder instead)
+    const largeTestMatch = content.match(/### \*\*FILE:\*\* `large\.test\.ts`[\s\S]*?```([\s\S]*?)```/);
+    assert.ok(largeTestMatch, "Should find large.test.ts content section");
+    assert.ok(
+      largeTestMatch[1].includes("Content omitted"),
+      "Content should be replaced with placeholder"
+    );
+    assert.ok(
+      largeTestMatch[1].includes("file size:"),
+      "Placeholder should include file size"
+    );
+
+    // Regular files should have full content
+    assert.ok(content.includes("console.log('main');"), "main.js should have full content");
+    assert.ok(content.includes("export function util() {}"), "utils.js should have full content");
+
+    // Dry run should show content omitted count
+    const skipContentDryRunOutput = execSync(`node ${CLI_PATH} --dry-run --skip-content "**/*.test.ts"`, {
+      cwd: TEST_DIR,
+    }).toString();
+    assert.match(skipContentDryRunOutput, /Content omitted:/, "Dry run should show content omitted count");
 
     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"
-]