ctxman 3.0.0 → 3.1.1

package/lib/formatters/gitingest-formatter.js

@@ -1,10 +1,10 @@
 import fs from 'fs';
 import path from 'path';
 import MethodAnalyzer from '../analyzers/method-analyzer.js';
-import MethodFilterParser from '../parsers/method-filter-parser.js';
 import ConfigUtils from '../utils/config-utils.js';
 import TokenUtils from '../utils/token-utils.js';
 import FileUtils from '../utils/file-utils.js';
+import { redactSecrets } from '../utils/secret-redactor.js';
 
 /**
  * GitIngest-style Digest Formatter
@@ -18,729 +18,764 @@ import FileUtils from '../utils/file-utils.js';
  * - Chunk metadata and navigation
  */
 class GitIngestFormatter {
-    constructor(projectRoot, stats, analysisResults, options = {}) {
-        this.projectRoot = projectRoot;
-        this.stats = stats;
-        this.analysisResults = analysisResults;
-        this.options = options;
-
-        // Chunking configuration (v2.3.3: Enhanced)
-        this.chunking = {
-            enabled: options.chunking?.enabled || false,
-            strategy: options.chunking?.strategy || 'smart',
-            maxTokensPerChunk: options.chunking?.maxTokensPerChunk || 100000,
-            overlap: options.chunking?.overlap || 500,
-            preserveContext: options.chunking?.preserveContext !== false,
-            includeMetadata: options.chunking?.includeMetadata !== false, // v2.3.3
-            crossReferences: options.chunking?.crossReferences !== false // v2.3.3
-        };
-
-        // Auto-detect method filtering configuration
-        this.methodFilterEnabled = this.detectMethodFilters();
-        if (this.methodFilterEnabled) {
-            this.methodAnalyzer = new MethodAnalyzer();
-            this.methodFilter = this.initMethodFilter();
-        }
+  constructor(projectRoot, stats, analysisResults, options = {}) {
+    this.projectRoot = projectRoot;
+    this.stats = stats;
+    this.analysisResults = analysisResults;
+    this.options = options;
+
+    // Chunking configuration (v2.3.3: Enhanced)
+    this.chunking = {
+      enabled: options.chunking?.enabled || false,
+      strategy: options.chunking?.strategy || 'smart',
+      maxTokensPerChunk: options.chunking?.maxTokensPerChunk || 100000,
+      overlap: options.chunking?.overlap || 500,
+      preserveContext: options.chunking?.preserveContext !== false,
+      includeMetadata: options.chunking?.includeMetadata !== false, // v2.3.3
+      crossReferences: options.chunking?.crossReferences !== false, // v2.3.3
+    };
+
+    // Mask API keys, tokens and private keys in file contents (on unless redactSecrets: false)
+    this.redactSecrets = options.redactSecrets !== false;
+    this.redactions = {};
+
+    // Auto-detect method filtering configuration
+    this.methodFilterEnabled = this.detectMethodFilters();
+    if (this.methodFilterEnabled) {
+      this.methodAnalyzer = new MethodAnalyzer();
+      this.methodFilter = this.initMethodFilter();
     }
-
-    detectMethodFilters() {
-        return ConfigUtils.detectMethodFilters(this.projectRoot);
+  }
+
+  detectMethodFilters() {
+    return ConfigUtils.detectMethodFilters(this.projectRoot);
+  }
+
+  /**
+   * Apply secret redaction to file content and record what was masked
+   * @param {string} text - File content
+   * @returns {string}
+   */
+  redact(text) {
+    if (!this.redactSecrets) return text;
+
+    const { text: redacted, findings } = redactSecrets(text);
+    for (const type of findings) {
+      this.redactions[type] = (this.redactions[type] || 0) + 1;
     }
+    return redacted;
+  }
+
+  initMethodFilter() {
+    return ConfigUtils.initMethodFilter(this.projectRoot);
+  }
 
-    initMethodFilter() {
-        return ConfigUtils.initMethodFilter(this.projectRoot);
+  generateDigest() {
+    this.redactions = {};
+
+    // Check if chunking is enabled
+    if (this.chunking.enabled) {
+      return this.generateChunkedDigest();
     }
 
-    generateDigest() {
-        // Check if chunking is enabled
-        if (this.chunking.enabled) {
-            return this.generateChunkedDigest();
-        }
+    let digest = '';
 
-        let digest = '';
+    // Header with project info
+    digest += this.generateSummary();
+    digest += '\n';
 
-        // Header with project info
-        digest += this.generateSummary();
-        digest += '\n';
+    // Directory tree structure
+    digest += this.generateTree();
+    digest += '\n';
 
-        // Directory tree structure
-        digest += this.generateTree();
-        digest += '\n';
+    // File contents
+    digest += this.generateFileContents();
 
-        // File contents
-        digest += this.generateFileContents();
+    return digest;
+  }
 
-        return digest;
+  /**
+   * Generate chunked digest for large repositories
+   * Returns array of chunk objects with metadata
+   * v2.3.3: Enhanced with overlap and cross-references
+   */
+  generateChunkedDigest() {
+    const chunks = this.createChunks();
+    const chunkData = [];
+
+    // Add overlap between chunks (v2.3.3)
+    if (this.chunking.overlap > 0) {
+      this.addChunkOverlap(chunks);
     }
 
-    /**
-     * Generate chunked digest for large repositories
-     * Returns array of chunk objects with metadata
-     * v2.3.3: Enhanced with overlap and cross-references
-     */
-    generateChunkedDigest() {
-        const chunks = this.createChunks();
-        const chunkData = [];
+    for (let i = 0; i < chunks.length; i++) {
+      const chunk = chunks[i];
+      const chunkId = `chunk-${i + 1}`;
 
-        // Add overlap between chunks (v2.3.3)
-        if (this.chunking.overlap > 0) {
-            this.addChunkOverlap(chunks);
-        }
+      let digest = '';
 
-        for (let i = 0; i < chunks.length; i++) {
-            const chunk = chunks[i];
-            const chunkId = `chunk-${i + 1}`;
-
-            let digest = '';
-
-            // Chunk header
-            digest += this.generateChunkHeader(i + 1, chunks.length, chunk);
-            digest += '\n';
-
-            // Summary for this chunk
-            digest += this.generateChunkSummary(chunk);
-            digest += '\n';
-
-            // Directory tree for files in this chunk
-            digest += this.generateChunkTree(chunk);
-            digest += '\n';
-
-            // Chunk metadata (v2.3.3)
-            if (this.chunking.includeMetadata) {
-                digest += this.generateChunkMetadata(chunk, i, chunks);
-                digest += '\n';
-            }
-
-            // File contents
-            digest += this.generateChunkFileContents(chunk);
-
-            // Navigation info
-            digest += '\n';
-            digest += this.generateNavigationInfo(i, chunks.length);
-
-            chunkData.push({
-                id: chunkId,
-                index: i + 1,
-                total: chunks.length,
-                content: digest,
-                files: chunk.files.map(f => f.relativePath),
-                tokens: chunk.tokens,
-                metadata: chunk.metadata || {},
-                hasOverlap: chunk.hasOverlap || false, // v2.3.3
-                overlapFiles: chunk.overlapFiles || [] // v2.3.3
-            });
-        }
+      // Chunk header
+      digest += this.generateChunkHeader(i + 1, chunks.length, chunk);
+      digest += '\n';
 
-        return chunkData;
-    }
+      // Summary for this chunk
+      digest += this.generateChunkSummary(chunk);
+      digest += '\n';
 
-    /**
-     * Add overlap between chunks
-     * v2.3.3: Ensures context continuity
-     */
-    addChunkOverlap(chunks) {
-        for (let i = 0; i < chunks.length - 1; i++) {
-            const currentChunk = chunks[i];
-            const nextChunk = chunks[i + 1];
+      // Directory tree for files in this chunk
+      digest += this.generateChunkTree(chunk);
+      digest += '\n';
 
-            // Get last N tokens worth of files from current chunk
-            const overlapFiles = this.getOverlapFiles(currentChunk, this.chunking.overlap);
+      // Chunk metadata (v2.3.3)
+      if (this.chunking.includeMetadata) {
+        digest += this.generateChunkMetadata(chunk, i, chunks);
+        digest += '\n';
+      }
+
+      // File contents
+      digest += this.generateChunkFileContents(chunk);
+
+      // Navigation info
+      digest += '\n';
+      digest += this.generateNavigationInfo(i, chunks.length);
+
+      chunkData.push({
+        id: chunkId,
+        index: i + 1,
+        total: chunks.length,
+        content: digest,
+        files: chunk.files.map((f) => f.relativePath),
+        tokens: chunk.tokens,
+        metadata: chunk.metadata || {},
+        hasOverlap: chunk.hasOverlap || false, // v2.3.3
+        overlapFiles: chunk.overlapFiles || [], // v2.3.3
+      });
+    }
 
-            if (overlapFiles.length > 0) {
-                // Prepend to next chunk
-                nextChunk.files = [...overlapFiles, ...nextChunk.files];
-                nextChunk.hasOverlap = true;
-                nextChunk.overlapFiles = overlapFiles.map(f => f.relativePath);
+    return chunkData;
+  }
+
+  /**
+   * Add overlap between chunks
+   * v2.3.3: Ensures context continuity
+   */
+  addChunkOverlap(chunks) {
+    for (let i = 0; i < chunks.length - 1; i++) {
+      const currentChunk = chunks[i];
+      const nextChunk = chunks[i + 1];
+
+      // Get last N tokens worth of files from current chunk
+      const overlapFiles = this.getOverlapFiles(currentChunk, this.chunking.overlap);
+
+      if (overlapFiles.length > 0) {
+        // Prepend to next chunk
+        nextChunk.files = [...overlapFiles, ...nextChunk.files];
+        nextChunk.hasOverlap = true;
+        nextChunk.overlapFiles = overlapFiles.map((f) => f.relativePath);
+
+        // Update token count
+        const overlapTokens = overlapFiles.reduce((sum, f) => sum + f.tokens, 0);
+        nextChunk.tokens += overlapTokens;
+      }
+    }
+  }
+
+  /**
+   * Get files for overlap based on token count
+   * v2.3.3
+   */
+  getOverlapFiles(chunk, targetOverlapTokens) {
+    const files = [...chunk.files].reverse(); // Start from end
+    const overlapFiles = [];
+    let tokenCount = 0;
+
+    for (const file of files) {
+      if (tokenCount >= targetOverlapTokens) {
+        break;
+      }
+      overlapFiles.unshift(file);
+      tokenCount += file.tokens;
+    }
 
-                // Update token count
-                const overlapTokens = overlapFiles.reduce((sum, f) => sum + f.tokens, 0);
-                nextChunk.tokens += overlapTokens;
-            }
-        }
+    return overlapFiles;
+  }
+
+  /**
+   * Generate chunk metadata
+   * v2.3.3: Language distribution, file types, etc.
+   */
+  generateChunkMetadata(chunk, index, allChunks) {
+    let metadata = '\n';
+    metadata += 'CHUNK METADATA\n';
+    metadata += '='.repeat(60) + '\n';
+
+    // Language distribution
+    const languages = {};
+    for (const file of chunk.files) {
+      const ext = path.extname(file.relativePath) || 'no-ext';
+      languages[ext] = (languages[ext] || 0) + 1;
     }
 
-    /**
-     * Get files for overlap based on token count
-     * v2.3.3
-     */
-    getOverlapFiles(chunk, targetOverlapTokens) {
-        const files = [...chunk.files].reverse(); // Start from end
-        const overlapFiles = [];
-        let tokenCount = 0;
-
-        for (const file of files) {
-            if (tokenCount >= targetOverlapTokens) {
-                break;
-            }
-            overlapFiles.unshift(file);
-            tokenCount += file.tokens;
-        }
+    metadata += 'Languages:\n';
+    for (const [ext, count] of Object.entries(languages).sort((a, b) => b[1] - a[1])) {
+      metadata += `  ${ext}: ${count} files\n`;
+    }
 
-        return overlapFiles;
+    // Directories covered
+    const dirs = new Set(chunk.files.map((f) => path.dirname(f.relativePath)));
+    metadata += `\nDirectories: ${dirs.size}\n`;
+
+    // Cross-references (v2.3.3)
+    if (this.chunking.crossReferences && index > 0) {
+      const prevChunk = allChunks[index - 1];
+      const sharedDirs = this.getSharedDirectories(chunk, prevChunk);
+      if (sharedDirs.length > 0) {
+        metadata += `\nShared with previous chunk: ${sharedDirs.join(', ')}\n`;
+      }
     }
 
-    /**
-     * Generate chunk metadata
-     * v2.3.3: Language distribution, file types, etc.
-     */
-    generateChunkMetadata(chunk, index, allChunks) {
-        let metadata = '\n';
-        metadata += 'CHUNK METADATA\n';
-        metadata += '='.repeat(60) + '\n';
+    return metadata;
+  }
 
-        // Language distribution
-        const languages = {};
-        for (const file of chunk.files) {
-            const ext = path.extname(file.relativePath) || 'no-ext';
-            languages[ext] = (languages[ext] || 0) + 1;
-        }
+  /**
+   * Get shared directories between chunks
+   * v2.3.3
+   */
+  getSharedDirectories(chunk1, chunk2) {
+    const dirs1 = new Set(chunk1.files.map((f) => path.dirname(f.relativePath)));
+    const dirs2 = new Set(chunk2.files.map((f) => path.dirname(f.relativePath)));
 
-        metadata += 'Languages:\n';
-        for (const [ext, count] of Object.entries(languages).sort((a, b) => b[1] - a[1])) {
-            metadata += `  ${ext}: ${count} files\n`;
-        }
+    return [...dirs1].filter((dir) => dirs2.has(dir));
+  }
 
-        // Directories covered
-        const dirs = new Set(chunk.files.map(f => path.dirname(f.relativePath)));
-        metadata += `\nDirectories: ${dirs.size}\n`;
-
-        // Cross-references (v2.3.3)
-        if (this.chunking.crossReferences && index > 0) {
-            const prevChunk = allChunks[index - 1];
-            const sharedDirs = this.getSharedDirectories(chunk, prevChunk);
-            if (sharedDirs.length > 0) {
-                metadata += `\nShared with previous chunk: ${sharedDirs.join(', ')}\n`;
-            }
-        }
+  /**
+   * Create chunks based on selected strategy
+   */
+  createChunks() {
+    const strategy = this.chunking.strategy;
 
-        return metadata;
-    }
-
-    /**
-     * Get shared directories between chunks
-     * v2.3.3
-     */
-    getSharedDirectories(chunk1, chunk2) {
-        const dirs1 = new Set(chunk1.files.map(f => path.dirname(f.relativePath)));
-        const dirs2 = new Set(chunk2.files.map(f => path.dirname(f.relativePath)));
-
-        return [...dirs1].filter(dir => dirs2.has(dir));
-    }
-
-    /**
-     * Create chunks based on selected strategy
-     */
-    createChunks() {
-        const strategy = this.chunking.strategy;
-
-        switch (strategy) {
-            case 'smart':
-                return this.createSmartChunks();
-            case 'size':
-                return this.createSizeBasedChunks();
-            case 'file':
-                return this.createFileBasedChunks();
-            case 'directory':
-                return this.createDirectoryBasedChunks();
-            case 'dependency':
-                return this.createDependencyBasedChunks();
-            default:
-                return this.createSizeBasedChunks();
-        }
+    switch (strategy) {
+      case 'smart':
+        return this.createSmartChunks();
+      case 'size':
+        return this.createSizeBasedChunks();
+      case 'file':
+        return this.createFileBasedChunks();
+      case 'directory':
+        return this.createDirectoryBasedChunks();
+      case 'dependency':
+        return this.createDependencyBasedChunks();
+      default:
+        return this.createSizeBasedChunks();
     }
-
-    /**
-     * Smart chunking - AI-based semantic grouping
-     * Groups related files together based on directory and imports
-     */
-    createSmartChunks() {
-        const chunks = [];
-        const maxTokens = this.chunking.maxTokensPerChunk;
-
-        // Sort files by directory and then by token count
-        const sortedFiles = [...this.analysisResults].sort((a, b) => {
-            const dirA = path.dirname(a.relativePath);
-            const dirB = path.dirname(b.relativePath);
-            if (dirA !== dirB) {
-                return dirA.localeCompare(dirB);
-            }
-            return b.tokens - a.tokens;
-        });
-
-        let currentChunk = { files: [], tokens: 0, directories: new Set() };
-
-        for (const file of sortedFiles) {
-            const fileDir = path.dirname(file.relativePath);
-            const wouldExceedLimit = currentChunk.tokens + file.tokens > maxTokens;
-
-            // Start new chunk if:
-            // 1. Would exceed token limit
-            // 2. Different directory and chunk already has content
-            if (wouldExceedLimit ||
-                (currentChunk.files.length > 0 &&
-                 !currentChunk.directories.has(fileDir) &&
-                 currentChunk.tokens > maxTokens * 0.7)) {
-
-                if (currentChunk.files.length > 0) {
-                    chunks.push(currentChunk);
-                }
-                currentChunk = { files: [], tokens: 0, directories: new Set() };
-            }
-
-            currentChunk.files.push(file);
-            currentChunk.tokens += file.tokens;
-            currentChunk.directories.add(fileDir);
-        }
-
-        // Add last chunk
+  }
+
+  /**
+   * Smart chunking - AI-based semantic grouping
+   * Groups related files together based on directory and imports
+   */
+  createSmartChunks() {
+    const chunks = [];
+    const maxTokens = this.chunking.maxTokensPerChunk;
+
+    // Sort files by directory and then by token count
+    const sortedFiles = [...this.analysisResults].sort((a, b) => {
+      const dirA = path.dirname(a.relativePath);
+      const dirB = path.dirname(b.relativePath);
+      if (dirA !== dirB) {
+        return dirA.localeCompare(dirB);
+      }
+      return b.tokens - a.tokens;
+    });
+
+    let currentChunk = { files: [], tokens: 0, directories: new Set() };
+
+    for (const file of sortedFiles) {
+      const fileDir = path.dirname(file.relativePath);
+      const wouldExceedLimit = currentChunk.tokens + file.tokens > maxTokens;
+
+      // Start new chunk if:
+      // 1. Would exceed token limit
+      // 2. Different directory and chunk already has content
+      if (
+        wouldExceedLimit ||
+        (currentChunk.files.length > 0 &&
+          !currentChunk.directories.has(fileDir) &&
+          currentChunk.tokens > maxTokens * 0.7)
+      ) {
         if (currentChunk.files.length > 0) {
-            chunks.push(currentChunk);
+          chunks.push(currentChunk);
         }
+        currentChunk = { files: [], tokens: 0, directories: new Set() };
+      }
 
-        return chunks;
+      currentChunk.files.push(file);
+      currentChunk.tokens += file.tokens;
+      currentChunk.directories.add(fileDir);
     }
 
-    /**
-     * Size-based chunking - Fixed token size chunks
-     */
-    createSizeBasedChunks() {
-        const chunks = [];
-        const maxTokens = this.chunking.maxTokensPerChunk;
+    // Add last chunk
+    if (currentChunk.files.length > 0) {
+      chunks.push(currentChunk);
+    }
 
-        // Sort files by token count (largest first)
-        const sortedFiles = [...this.analysisResults].sort((a, b) => b.tokens - a.tokens);
+    return chunks;
+  }
 
-        let currentChunk = { files: [], tokens: 0 };
+  /**
+   * Size-based chunking - Fixed token size chunks
+   */
+  createSizeBasedChunks() {
+    const chunks = [];
+    const maxTokens = this.chunking.maxTokensPerChunk;
 
-        for (const file of sortedFiles) {
-            if (currentChunk.tokens + file.tokens > maxTokens && currentChunk.files.length > 0) {
-                chunks.push(currentChunk);
-                currentChunk = { files: [], tokens: 0 };
-            }
+    // Sort files by token count (largest first)
+    const sortedFiles = [...this.analysisResults].sort((a, b) => b.tokens - a.tokens);
 
-            currentChunk.files.push(file);
-            currentChunk.tokens += file.tokens;
-        }
+    let currentChunk = { files: [], tokens: 0 };
 
-        if (currentChunk.files.length > 0) {
-            chunks.push(currentChunk);
-        }
+    for (const file of sortedFiles) {
+      if (currentChunk.tokens + file.tokens > maxTokens && currentChunk.files.length > 0) {
+        chunks.push(currentChunk);
+        currentChunk = { files: [], tokens: 0 };
+      }
 
-        return chunks;
+      currentChunk.files.push(file);
+      currentChunk.tokens += file.tokens;
     }
 
-    /**
-     * File-based chunking - One file per chunk (with directory context)
-     */
-    createFileBasedChunks() {
-        const chunks = [];
-
-        for (const file of this.analysisResults) {
-            chunks.push({
-                files: [file],
-                tokens: file.tokens,
-                metadata: {
-                    directory: path.dirname(file.relativePath)
-                }
-            });
-        }
-
-        return chunks;
+    if (currentChunk.files.length > 0) {
+      chunks.push(currentChunk);
     }
 
-    /**
-     * Directory-based chunking - One directory per chunk
-     */
-    createDirectoryBasedChunks() {
-        const chunks = [];
-        const filesByDirectory = new Map();
-
-        // Group files by directory
-        for (const file of this.analysisResults) {
-            const dir = path.dirname(file.relativePath);
-            if (!filesByDirectory.has(dir)) {
-                filesByDirectory.set(dir, []);
-            }
-            filesByDirectory.get(dir).push(file);
-        }
-
-        // Create chunks from directories
-        for (const [dir, files] of filesByDirectory) {
-            const tokens = files.reduce((sum, f) => sum + f.tokens, 0);
-            chunks.push({
-                files,
-                tokens,
-                metadata: { directory: dir }
-            });
-        }
-
-        return chunks;
+    return chunks;
+  }
+
+  /**
+   * File-based chunking - One file per chunk (with directory context)
+   */
+  createFileBasedChunks() {
+    const chunks = [];
+
+    for (const file of this.analysisResults) {
+      chunks.push({
+        files: [file],
+        tokens: file.tokens,
+        metadata: {
+          directory: path.dirname(file.relativePath),
+        },
+      });
     }
 
-    /**
-     * Dependency-based chunking - Group by import/dependency graph
-     * Placeholder for future implementation with AST analysis
-     */
-    createDependencyBasedChunks() {
-        // For now, fall back to smart chunking
-        // In Phase 2, we'll implement proper dependency analysis
-        return this.createSmartChunks();
+    return chunks;
+  }
+
+  /**
+   * Directory-based chunking - One directory per chunk
+   */
+  createDirectoryBasedChunks() {
+    const chunks = [];
+    const filesByDirectory = new Map();
+
+    // Group files by directory
+    for (const file of this.analysisResults) {
+      const dir = path.dirname(file.relativePath);
+      if (!filesByDirectory.has(dir)) {
+        filesByDirectory.set(dir, []);
+      }
+      filesByDirectory.get(dir).push(file);
     }
 
-    /**
-     * Generate chunk header
-     */
-    generateChunkHeader(index, total, chunk) {
-        let header = '='.repeat(60) + '\n';
-        header += `CHUNK ${index} of ${total}\n`;
-        header += '='.repeat(60);
-        return header;
+    // Create chunks from directories
+    for (const [dir, files] of filesByDirectory) {
+      const tokens = files.reduce((sum, f) => sum + f.tokens, 0);
+      chunks.push({
+        files,
+        tokens,
+        metadata: { directory: dir },
+      });
     }
 
-    /**
-     * Generate summary for a chunk
-     */
-    generateChunkSummary(chunk) {
-        let summary = `Files in this chunk: ${chunk.files.length}\n`;
-        summary += `Estimated tokens: ${this.formatTokenCount(chunk.tokens)}`;
-
-        if (chunk.metadata?.directory) {
-            summary += `\nDirectory: ${chunk.metadata.directory}`;
-        }
+    return chunks;
+  }
+
+  /**
+   * Dependency-based chunking - Group by import/dependency graph
+   * Placeholder for future implementation with AST analysis
+   */
+  createDependencyBasedChunks() {
+    // For now, fall back to smart chunking
+    // In Phase 2, we'll implement proper dependency analysis
+    return this.createSmartChunks();
+  }
+
+  /**
+   * Generate chunk header
+   */
+  generateChunkHeader(index, total, _chunk) {
+    let header = '='.repeat(60) + '\n';
+    header += `CHUNK ${index} of ${total}\n`;
+    header += '='.repeat(60);
+    return header;
+  }
+
+  /**
+   * Generate summary for a chunk
+   */
+  generateChunkSummary(chunk) {
+    let summary = `Files in this chunk: ${chunk.files.length}\n`;
+    summary += `Estimated tokens: ${this.formatTokenCount(chunk.tokens)}`;
+
+    if (chunk.metadata?.directory) {
+      summary += `\nDirectory: ${chunk.metadata.directory}`;
+    }
 
-        return summary;
-    }
-
-    /**
-     * Generate directory tree for chunk
-     */
-    generateChunkTree(chunk) {
-        let tree = 'Directory structure:\n';
-
-        // Build tree structure from chunk files
-        const fileTree = this.buildFileTreeFromFiles(chunk.files);
-        tree += this.formatTreeNode(fileTree, '', true);
-
-        return tree;
-    }
-
-    /**
-     * Build file tree from specific files
-     */
-    buildFileTreeFromFiles(files) {
-        const root = {
-            name: path.basename(this.projectRoot),
-            type: 'directory',
-            children: {}
-        };
-
-        const sortedFiles = [...files].sort((a, b) =>
-            a.relativePath.localeCompare(b.relativePath)
-        );
-
-        for (const fileInfo of sortedFiles) {
-            const parts = fileInfo.relativePath.split('/');
-            let current = root.children;
-
-            for (let i = 0; i < parts.length; i++) {
-                const part = parts[i];
-                const isLastPart = i === parts.length - 1;
-
-                if (isLastPart) {
-                    current[part] = {
-                        name: part,
-                        type: 'file',
-                        fileInfo: fileInfo
-                    };
-                } else {
-                    if (!current[part]) {
-                        current[part] = {
-                            name: part,
-                            type: 'directory',
-                            children: {}
-                        };
-                    }
-                    current = current[part].children;
-                }
-            }
+    return summary;
+  }
+
+  /**
+   * Generate directory tree for chunk
+   */
+  generateChunkTree(chunk) {
+    let tree = 'Directory structure:\n';
+
+    // Build tree structure from chunk files
+    const fileTree = this.buildFileTreeFromFiles(chunk.files);
+    tree += this.formatTreeNode(fileTree, '', true);
+
+    return tree;
+  }
+
+  /**
+   * Build file tree from specific files
+   */
+  buildFileTreeFromFiles(files) {
+    const root = {
+      name: path.basename(this.projectRoot),
+      type: 'directory',
+      children: {},
+    };
+
+    const sortedFiles = [...files].sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+
+    for (const fileInfo of sortedFiles) {
+      const parts = fileInfo.relativePath.split('/');
+      let current = root.children;
+
+      for (let i = 0; i < parts.length; i++) {
+        const part = parts[i];
+        const isLastPart = i === parts.length - 1;
+
+        if (isLastPart) {
+          current[part] = {
+            name: part,
+            type: 'file',
+            fileInfo: fileInfo,
+          };
+        } else {
+          if (!current[part]) {
+            current[part] = {
+              name: part,
+              type: 'directory',
+              children: {},
+            };
+          }
+          current = current[part].children;
         }
-
-        return root;
+      }
     }
 
-    /**
-     * Generate file contents for chunk
-     */
-    generateChunkFileContents(chunk) {
-        let content = '';
+    return root;
+  }
 
-        // Sort files by token count (largest first)
-        const sortedFiles = [...chunk.files].sort((a, b) => b.tokens - a.tokens);
+  /**
+   * Generate file contents for chunk
+   */
+  generateChunkFileContents(chunk) {
+    let content = '';
 
-        for (const fileInfo of sortedFiles) {
-            if (fileInfo.error) continue;
+    // Sort files by token count (largest first)
+    const sortedFiles = [...chunk.files].sort((a, b) => b.tokens - a.tokens);
 
-            content += '\n';
-            content += '='.repeat(48) + '\n';
-            content += `FILE: ${fileInfo.relativePath}\n`;
-            content += '='.repeat(48) + '\n';
+    for (const fileInfo of sortedFiles) {
+      if (fileInfo.error) continue;
 
-            try {
-                const fileContent = fs.readFileSync(fileInfo.path, 'utf8');
+      content += '\n';
+      content += '='.repeat(48) + '\n';
+      content += `FILE: ${fileInfo.relativePath}\n`;
+      content += '='.repeat(48) + '\n';
 
-                if (this.methodFilterEnabled && this.isCodeFile(fileInfo.path)) {
-                    const filteredContent = this.generateFilteredFileContent(fileContent, fileInfo.path);
-                    content += filteredContent;
-                } else {
-                    content += fileContent;
-                }
+      try {
+        const fileContent = fs.readFileSync(fileInfo.path, 'utf8');
 
-                if (!content.endsWith('\n')) {
-                    content += '\n';
-                }
-            } catch (error) {
-                content += `Error reading file: ${error.message}\n`;
-            }
+        if (this.methodFilterEnabled && this.isCodeFile(fileInfo.path)) {
+          const filteredContent = this.generateFilteredFileContent(fileContent, fileInfo.path);
+          content += this.redact(filteredContent);
+        } else {
+          content += this.redact(fileContent);
         }
 
-        return content;
+        if (!content.endsWith('\n')) {
+          content += '\n';
+        }
+      } catch (error) {
+        content += `Error reading file: ${error.message}\n`;
+      }
     }
 
-    /**
-     * Generate navigation info between chunks
-     */
-    generateNavigationInfo(currentIndex, totalChunks) {
-        let nav = '\n';
-        nav += '='.repeat(60) + '\n';
-        nav += 'NAVIGATION\n';
-        nav += '='.repeat(60) + '\n';
-
-        if (currentIndex > 0) {
-            nav += `Previous: chunk-${currentIndex}.txt\n`;
-        }
-        if (currentIndex < totalChunks - 1) {
-            nav += `Next: chunk-${currentIndex + 2}.txt\n`;
-        }
+    return content;
+  }
 
-        nav += `\nTotal Chunks: ${totalChunks}\n`;
-        nav += `Current Position: ${currentIndex + 1} / ${totalChunks}`;
+  /**
+   * Generate navigation info between chunks
+   */
+  generateNavigationInfo(currentIndex, totalChunks) {
+    let nav = '\n';
+    nav += '='.repeat(60) + '\n';
+    nav += 'NAVIGATION\n';
+    nav += '='.repeat(60) + '\n';
 
-        return nav;
+    if (currentIndex > 0) {
+      nav += `Previous: chunk-${currentIndex}.txt\n`;
+    }
+    if (currentIndex < totalChunks - 1) {
+      nav += `Next: chunk-${currentIndex + 2}.txt\n`;
     }
 
-    generateSummary() {
-        const projectName = path.basename(this.projectRoot);
-        let summary = `Directory: ${projectName}\n`;
-        summary += `Files analyzed: ${this.stats.totalFiles}\n`;
+    nav += `\nTotal Chunks: ${totalChunks}\n`;
+    nav += `Current Position: ${currentIndex + 1} / ${totalChunks}`;
 
-        if (this.methodFilterEnabled) {
-            const mode = this.methodFilter.hasIncludeFile ? 'INCLUDE' : 'EXCLUDE';
-            summary += `Method filtering: ${mode} mode active\n`;
-        }
+    return nav;
+  }
 
-        if (this.stats.totalTokens > 0) {
-            const tokenStr = this.formatTokenCount(this.stats.totalTokens);
-            summary += `\nEstimated tokens: ${tokenStr}`;
-        }
+  generateSummary() {
+    const projectName = path.basename(this.projectRoot);
+    let summary = `Directory: ${projectName}\n`;
+    summary += `Files analyzed: ${this.stats.totalFiles}\n`;
 
-        return summary;
-    }
-
-    formatTokenCount(tokens) {
-        return TokenUtils.format(tokens);
-    }
-
-    generateTree() {
-        let tree = 'Directory structure:\n';
-
-        // Build tree structure from analysis results
-        const fileTree = this.buildFileTree();
-        tree += this.formatTreeNode(fileTree, '', true);
-
-        return tree;
-    }
-
-    buildFileTree() {
-        const root = {
-            name: path.basename(this.projectRoot),
-            type: 'directory',
-            children: {}
-        };
-
-        // Sort files by path for consistent tree structure
-        const sortedFiles = [...this.analysisResults].sort((a, b) =>
-            a.relativePath.localeCompare(b.relativePath)
-        );
-
-        for (const fileInfo of sortedFiles) {
-            const parts = fileInfo.relativePath.split('/');
-            let current = root.children;
-
-            for (let i = 0; i < parts.length; i++) {
-                const part = parts[i];
-                const isLastPart = i === parts.length - 1;
-
-                if (isLastPart) {
-                    // It's a file
-                    current[part] = {
-                        name: part,
-                        type: 'file',
-                        fileInfo: fileInfo
-                    };
-                } else {
-                    // It's a directory
-                    if (!current[part]) {
-                        current[part] = {
-                            name: part,
-                            type: 'directory',
-                            children: {}
-                        };
-                    }
-                    current = current[part].children;
-                }
-            }
-        }
-
-        return root;
+    if (this.methodFilterEnabled) {
+      const mode = this.methodFilter.hasIncludeFile ? 'INCLUDE' : 'EXCLUDE';
+      summary += `Method filtering: ${mode} mode active\n`;
     }
 
-    formatTreeNode(node, prefix = '', isLast = true) {
-        let result = '';
+    if (this.stats.totalTokens > 0) {
+      const tokenStr = this.formatTokenCount(this.stats.totalTokens);
+      summary += `\nEstimated tokens: ${tokenStr}`;
+    }
 
-        if (node.name) {
-            const connector = isLast ? '└── ' : '├── ';
-            const displayName = node.type === 'directory' ? `${node.name}/` : node.name;
-            result += `${prefix}${connector}${displayName}\n`;
+    return summary;
+  }
+
+  formatTokenCount(tokens) {
+    return TokenUtils.format(tokens);
+  }
+
+  generateTree() {
+    let tree = 'Directory structure:\n';
+
+    // Build tree structure from analysis results
+    const fileTree = this.buildFileTree();
+    tree += this.formatTreeNode(fileTree, '', true);
+
+    return tree;
+  }
+
+  buildFileTree() {
+    const root = {
+      name: path.basename(this.projectRoot),
+      type: 'directory',
+      children: {},
+    };
+
+    // Sort files by path for consistent tree structure
+    const sortedFiles = [...this.analysisResults].sort((a, b) =>
+      a.relativePath.localeCompare(b.relativePath)
+    );
+
+    for (const fileInfo of sortedFiles) {
+      const parts = fileInfo.relativePath.split('/');
+      let current = root.children;
+
+      for (let i = 0; i < parts.length; i++) {
+        const part = parts[i];
+        const isLastPart = i === parts.length - 1;
+
+        if (isLastPart) {
+          // It's a file
+          current[part] = {
+            name: part,
+            type: 'file',
+            fileInfo: fileInfo,
+          };
+        } else {
+          // It's a directory
+          if (!current[part]) {
+            current[part] = {
+              name: part,
+              type: 'directory',
+              children: {},
+            };
+          }
+          current = current[part].children;
         }
+      }
+    }
 
-        if (node.type === 'directory' && node.children) {
-            const newPrefix = node.name ? (prefix + (isLast ? '    ' : '│   ')) : '';
-            const childKeys = Object.keys(node.children).sort();
+    return root;
+  }
 
-            childKeys.forEach((key, index) => {
-                const child = node.children[key];
-                const childIsLast = index === childKeys.length - 1;
-                result += this.formatTreeNode(child, newPrefix, childIsLast);
-            });
-        }
+  formatTreeNode(node, prefix = '', isLast = true) {
+    let result = '';
 
-        return result;
+    if (node.name) {
+      const connector = isLast ? '└── ' : '├── ';
+      const displayName = node.type === 'directory' ? `${node.name}/` : node.name;
+      result += `${prefix}${connector}${displayName}\n`;
     }
 
-    generateFileContents() {
-        let content = '';
+    if (node.type === 'directory' && node.children) {
+      const newPrefix = node.name ? prefix + (isLast ? '    ' : '│   ') : '';
+      const childKeys = Object.keys(node.children).sort();
 
-        // Sort files by token count (largest first)
-        const sortedFiles = [...this.analysisResults].sort((a, b) =>
-            b.tokens - a.tokens
-        );
+      childKeys.forEach((key, index) => {
+        const child = node.children[key];
+        const childIsLast = index === childKeys.length - 1;
+        result += this.formatTreeNode(child, newPrefix, childIsLast);
+      });
+    }
+
+    return result;
+  }
 
-        for (const fileInfo of sortedFiles) {
-            if (fileInfo.error) continue;
+  generateFileContents() {
+    let content = '';
 
-            content += '\n';
-            content += '='.repeat(48) + '\n';
-            content += `FILE: ${fileInfo.relativePath}\n`;
-            content += '='.repeat(48) + '\n';
+    // Sort files by token count (largest first)
+    const sortedFiles = [...this.analysisResults].sort((a, b) => b.tokens - a.tokens);
 
-            try {
-                const fileContent = fs.readFileSync(fileInfo.path, 'utf8');
+    for (const fileInfo of sortedFiles) {
+      if (fileInfo.error) continue;
 
-                // Apply method-level filtering if enabled and file is a code file
-                if (this.methodFilterEnabled && this.isCodeFile(fileInfo.path)) {
-                    const filteredContent = this.generateFilteredFileContent(fileContent, fileInfo.path);
-                    content += filteredContent;
-                } else {
-                    // Include full file content
-                    content += fileContent;
-                }
+      content += '\n';
+      content += '='.repeat(48) + '\n';
+      content += `FILE: ${fileInfo.relativePath}\n`;
+      content += '='.repeat(48) + '\n';
 
-                if (!content.endsWith('\n')) {
-                    content += '\n';
-                }
-            } catch (error) {
-                content += `Error reading file: ${error.message}\n`;
-            }
+      try {
+        const fileContent = fs.readFileSync(fileInfo.path, 'utf8');
+
+        // Apply method-level filtering if enabled and file is a code file
+        if (this.methodFilterEnabled && this.isCodeFile(fileInfo.path)) {
+          const filteredContent = this.generateFilteredFileContent(fileContent, fileInfo.path);
+          content += this.redact(filteredContent);
+        } else {
+          // Include full file content
+          content += this.redact(fileContent);
         }
 
-        return content;
+        if (!content.endsWith('\n')) {
+          content += '\n';
+        }
+      } catch (error) {
+        content += `Error reading file: ${error.message}\n`;
+      }
     }
 
-    isCodeFile(filePath) {
-        return FileUtils.isCode(filePath);
-    }
+    return content;
+  }
 
-    generateFilteredFileContent(content, filePath) {
-        // Extract all methods from the file
-        const methods = this.methodAnalyzer.extractMethods(content, filePath);
-        const fileName = path.basename(filePath, path.extname(filePath));
+  isCodeFile(filePath) {
+    return FileUtils.isCode(filePath);
+  }
 
-        // Filter methods
-        const filteredMethods = methods.filter(method =>
-            this.methodFilter.shouldIncludeMethod(method.name, fileName)
-        );
+  generateFilteredFileContent(content, filePath) {
+    // Extract all methods from the file
+    const methods = this.methodAnalyzer.extractMethods(content, filePath);
+    const fileName = path.basename(filePath, path.extname(filePath));
 
-        if (filteredMethods.length === 0) {
-            // No methods pass the filter, return a note
-            return `// No methods matched the filter criteria for this file\n`;
-        }
+    // Filter methods
+    const filteredMethods = methods.filter((method) =>
+      this.methodFilter.shouldIncludeMethod(method.name, fileName)
+    );
 
-        // Build filtered content with only included methods
-        let filteredContent = `// File contains ${methods.length} methods, showing ${filteredMethods.length} filtered methods\n\n`;
+    if (filteredMethods.length === 0) {
+      // No methods pass the filter, return a note
+      return `// No methods matched the filter criteria for this file\n`;
+    }
 
-        const lines = content.split('\n');
+    // Build filtered content with only included methods
+    let filteredContent = `// File contains ${methods.length} methods, showing ${filteredMethods.length} filtered methods\n\n`;
 
-        for (const method of filteredMethods) {
-            // Extract method content using a simple approach
-            // Find the method start and try to get its content
-            const methodContent = this.extractMethodBlock(lines, method.line - 1);
+    const lines = content.split('\n');
 
-            filteredContent += `// Method: ${method.name} (line ${method.line})\n`;
-            filteredContent += methodContent + '\n\n';
-        }
+    for (const method of filteredMethods) {
+      // Extract method content using a simple approach
+      // Find the method start and try to get its content
+      const methodContent = this.extractMethodBlock(lines, method.line - 1);
 
-        return filteredContent;
-    }
-
-    extractMethodBlock(lines, startLine) {
-        // Simple method extraction: get the method and its body
-        let braceCount = 0;
-        let inMethod = false;
-        let methodLines = [];
-
-        for (let i = startLine; i < lines.length; i++) {
-            const line = lines[i];
-            methodLines.push(line);
-
-            // Count braces to find method end
-            for (const char of line) {
-                if (char === '{') {
-                    braceCount++;
-                    inMethod = true;
-                } else if (char === '}') {
-                    braceCount--;
-                    if (inMethod && braceCount === 0) {
-                        return methodLines.join('\n');
-                    }
-                }
-            }
-
-            // Safety: limit to 100 lines per method
-            if (methodLines.length > 100) {
-                methodLines.push('// ... (method too long, truncated)');
-                break;
-            }
+      filteredContent += `// Method: ${method.name} (line ${method.line})\n`;
+      filteredContent += methodContent + '\n\n';
+    }
+
+    return filteredContent;
+  }
+
+  extractMethodBlock(lines, startLine) {
+    // Simple method extraction: get the method and its body
+    let braceCount = 0;
+    let inMethod = false;
+    let methodLines = [];
+
+    for (let i = startLine; i < lines.length; i++) {
+      const line = lines[i];
+      methodLines.push(line);
+
+      // Count braces to find method end
+      for (const char of line) {
+        if (char === '{') {
+          braceCount++;
+          inMethod = true;
+        } else if (char === '}') {
+          braceCount--;
+          if (inMethod && braceCount === 0) {
+            return methodLines.join('\n');
+          }
         }
+      }
 
-        return methodLines.join('\n');
+      // Safety: limit to 100 lines per method
+      if (methodLines.length > 100) {
+        methodLines.push('// ... (method too long, truncated)');
+        break;
+      }
     }
 
-    saveToFile(outputPath) {
-        const digest = this.generateDigest();
-        fs.writeFileSync(outputPath, digest, 'utf8');
-        return digest.length;
+    return methodLines.join('\n');
+  }
+
+  /**
+   * Write the digest; a chunked digest becomes one file per chunk next to outputPath
+   * (digest-chunk-1-of-3.txt, ...), listed in this.chunkFiles
+   * @param {string} outputPath
+   * @returns {number} Characters written
+   */
+  saveToFile(outputPath) {
+    const digest = this.generateDigest();
+    this.chunkFiles = [];
+
+    if (Array.isArray(digest)) {
+      const { dir, name, ext } = path.parse(outputPath);
+      for (const chunk of digest) {
+        const chunkPath = path.join(dir, `${name}-chunk-${chunk.index}-of-${chunk.total}${ext}`);
+        fs.writeFileSync(chunkPath, chunk.content, 'utf8');
+        this.chunkFiles.push(chunkPath);
+      }
+      return digest.reduce((size, chunk) => size + chunk.content.length, 0);
     }
-}
 
+    fs.writeFileSync(outputPath, digest, 'utf8');
+    return digest.length;
+  }
+}
 
 export default GitIngestFormatter;