combicode 1.5.4 → 1.7.2

package/CHANGELOG.md

@@ -1,6 +1,29 @@
 # Changelog
 
-# Changelog
+## [1.7.2](https://github.com/aaurelions/combicode/compare/combicode-js-v1.7.1...combicode-js-v1.7.2) (2025-01-XX)
+
+### Bug Fixes
+
+- **skip-content:** fix total size calculation to exclude files with skipped content
+- **skip-content:** remove extra blank line after placeholder text in output
+
+## [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)
 

package/README.md

@@ -81,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.
@@ -98,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

@@ -169,7 +169,7 @@ function walkDirectory(
   return results;
 }
 
-function generateFileTree(filesWithSize, root) {
+function generateFileTree(filesWithSize, root, skipContentSet = null) {
   let tree = `${path.basename(root)}/\n`;
   const structure = {};
 
@@ -179,7 +179,8 @@ function generateFileTree(filesWithSize, root) {
     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] = {};
@@ -194,11 +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 ? "    " : "│   "}`);
@@ -258,6 +260,10 @@ 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()
@@ -277,6 +283,12 @@ async function main() {
     rootIgnoreManager.add(argv.exclude.split(","));
   }
 
+  // Create skip-content manager
+  const skipContentManager = ignore();
+  if (argv.skipContent) {
+    skipContentManager.add(argv.skipContent.split(","));
+  }
+
   const absoluteOutputPath = path.resolve(projectRoot, argv.output);
 
   const allowedExtensions = argv.includeExt
@@ -306,9 +318,26 @@ async function main() {
 
   includedFiles.sort((a, b) => a.path.localeCompare(b.path));
 
-  // Calculate total size of included files
+  // 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 (excluding files with skipped content)
   const totalSizeBytes = includedFiles.reduce(
-    (acc, file) => acc + file.size,
+    (acc, file) => {
+      // Don't count files with skipped content in the total size
+      if (skipContentSet.has(file.relativePath)) {
+        return acc;
+      }
+      return acc + file.size;
+    },
     0
   );
 
@@ -321,7 +350,7 @@ async function main() {
 
   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("\n📊 Summary (Dry Run):");
     console.log(
@@ -329,6 +358,9 @@ async function main() {
         totalSizeBytes
       )})`
     );
+    if (skipContentSet.size > 0) {
+      console.log(`   • Content omitted: ${skipContentSet.size} files`);
+    }
     console.log(`   • Ignored:  ${stats.ignored} files/dirs`);
     return;
   }
@@ -345,7 +377,7 @@ async function main() {
 
     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");
@@ -355,14 +387,21 @@ async function main() {
 
   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);
-      totalLines += content.split("\n").length;
-    } catch (e) {
-      outputStream.write(`... (error reading file: ${e.message}) ...`);
+    if (shouldSkipContent) {
+      outputStream.write(`(Content omitted - file size: ${fileObj.formattedSize})`);
+      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
@@ -375,6 +414,9 @@ async function main() {
       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!`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "combicode",
-  "version": "1.5.4",
+  "version": "1.7.2",
   "description": "A CLI tool to combine a project's codebase into a single file for LLM context.",
   "main": "index.js",
   "bin": {

package/test/test.js

@@ -141,6 +141,64 @@ function runTest() {
       "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("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);