@parseme/cli 0.0.4 → 0.0.6

package/dist/core/context-builder.js

@@ -4,84 +4,12 @@ export class ContextBuilder {
     constructor(config) {
         this.config = config;
     }
-    truncateContent(content, type = 'chars') {
-        const limits = this.config.get().limits;
-        if (!limits) {
-            return content;
-        }
-        const strategy = limits.truncateStrategy || 'truncate';
-        if (type === 'lines') {
-            const lines = content.split('\n');
-            const maxLines = limits.maxLinesPerFile || 1000;
-            if (lines.length > maxLines) {
-                if (strategy === 'split') {
-                    return this.splitContentByLines(lines, maxLines);
-                }
-                else {
-                    const truncated = lines.slice(0, maxLines).join('\n');
-                    return truncated + '\n\n[... truncated for AI compatibility ...]';
-                }
-            }
-        }
-        else {
-            const maxChars = limits.maxCharsPerFile || 50000;
-            if (content.length > maxChars) {
-                if (strategy === 'split') {
-                    return this.splitContentByChars(content, maxChars);
-                }
-                else {
-                    const truncated = content.substring(0, maxChars - 100);
-                    return truncated + '\n\n[... truncated for AI compatibility ...]';
-                }
-            }
-        }
-        return content;
-    }
-    splitContentByLines(lines, maxLines) {
-        const parts = [];
-        const safeMaxLines = maxLines - 5; // Reserve space for split indicators
-        for (let i = 0; i < lines.length; i += safeMaxLines) {
-            const chunk = lines.slice(i, i + safeMaxLines);
-            const partNumber = Math.floor(i / safeMaxLines) + 1;
-            const totalParts = Math.ceil(lines.length / safeMaxLines);
-            let partContent = chunk.join('\n');
-            partContent += `\n\n[... part ${partNumber} of ${totalParts} ...]`;
-            parts.push(partContent);
-        }
-        return parts;
-    }
-    splitContentByChars(content, maxChars) {
-        const parts = [];
-        const safeMaxChars = maxChars - 200; // Reserve space for split indicators
-        for (let i = 0; i < content.length; i += safeMaxChars) {
-            let chunk = content.substring(i, i + safeMaxChars);
-            const partNumber = Math.floor(i / safeMaxChars) + 1;
-            const totalParts = Math.ceil(content.length / safeMaxChars);
-            // Try to break at a reasonable place (newline or word boundary)
-            if (i + safeMaxChars < content.length) {
-                const lastNewline = chunk.lastIndexOf('\n');
-                const lastSpace = chunk.lastIndexOf(' ');
-                const breakPoint = lastNewline > -1 ? lastNewline : lastSpace > -1 ? lastSpace : chunk.length;
-                if (breakPoint > safeMaxChars * 0.8) {
-                    // Only break if we're not losing too much content
-                    chunk = chunk.substring(0, breakPoint);
-                }
-            }
-            chunk += `\n\n[... part ${partNumber} of ${totalParts} ...]`;
-            parts.push(chunk);
-        }
-        return parts;
-    }
     build(context) {
         return this.buildMultiFile(context);
     }
     buildMultiFile(context) {
         const { projectInfo, fileAnalyses, gitInfo, contextDir, outputPath } = context;
-        const limits = this.config.get().limits;
-        // Limit number of files analyzed if specified
-        const limitedFileAnalyses = limits?.maxFilesPerContext
-            ? fileAnalyses.slice(0, limits.maxFilesPerContext)
-            : fileAnalyses;
+        // Files are now pre-limited in their respective analyzers, so no need to limit here
         // Calculate the relative path for the link in markdown
         let linkPath = 'parseme-context';
         if (contextDir && outputPath) {
@@ -99,42 +27,36 @@ export class ContextBuilder {
             // Fallback: use contextDir as-is if no outputPath provided
             linkPath = contextDir;
         }
-        const mainContent = this.buildHeader(linkPath) +
+        // Check if routes exist before building main content
+        // Extract all actual route objects (filter out reference objects)
+        const routes = fileAnalyses.flatMap((f) => {
+            const fileRoutes = f.routes || [];
+            // Only include if it's an array of actual routes, not a reference object
+            return Array.isArray(fileRoutes) && fileRoutes.length > 0 && !('$ref' in fileRoutes[0])
+                ? fileRoutes
+                : [];
+        });
+        const hasRoutes = routes.length > 0;
+        const mainContent = this.buildHeader(linkPath, hasRoutes) +
             '\n\n\n' +
             this.buildProjectOverview(projectInfo) +
             '\n\n\n' +
-            this.buildSummarySection(context, linkPath) +
+            this.buildSummarySection(linkPath, hasRoutes) +
             '\n\n\n' +
             (gitInfo ? this.buildGitSection(gitInfo) : '');
         const contextFiles = {
             structure: '',
-            routes: '',
-        };
-        // Helper function to merge split files into contextFiles
-        const mergeSplitFiles = (result, baseName) => {
-            if (typeof result === 'string') {
-                contextFiles[baseName] = result;
-            }
-            else {
-                // Merge split files into contextFiles
-                Object.entries(result).forEach(([key, value]) => {
-                    contextFiles[key] = value;
-                });
-            }
         };
         // Files list (markdown) - all files in project, not just analyzed ones
         contextFiles.files = this.buildFilesList(context.allFiles);
         // Detailed structure (JSON with AST)
-        const structureResult = this.buildDetailedStructure(limitedFileAnalyses);
-        mergeSplitFiles(structureResult, 'structure');
-        // Routes documentation
-        const routes = limitedFileAnalyses.flatMap((f) => f.routes || []);
-        if (routes.length > 0) {
-            const routesResult = this.buildDetailedRoutes(routes, limitedFileAnalyses);
-            mergeSplitFiles(routesResult, 'api-endpoints');
+        contextFiles.structure = this.buildDetailedStructure(fileAnalyses, hasRoutes);
+        // Routes documentation (only if routes exist)
+        if (hasRoutes) {
+            contextFiles.routes = this.buildDetailedRoutes(routes);
         }
         // Git information
-        if (gitInfo) {
+        if (gitInfo?.diffStat?.length && gitInfo.diffStat.length > 0) {
             contextFiles.gitDiff = this.buildDetailedGit(gitInfo);
         }
         return {
@@ -142,17 +64,23 @@ export class ContextBuilder {
             context: contextFiles,
         };
     }
-    buildHeader(linkPath) {
-        return `## PARSEME - AI Agent Context 
+    buildHeader(linkPath, hasRoutes) {
+        const routesInstructions = hasRoutes
+            ? `   - Files with routes will reference [${linkPath}/routes.json](${linkPath}/routes.json) using a $ref pattern for token efficiency
+5. For API route details, see [${linkPath}/routes.json](${linkPath}/routes.json) which contains all discovered endpoints
+6. For git tracked projects follow the instructions in the "Git Information" section of this file to validate the actuality of the provided information.
+7. Only dive deeper into specific files after reviewing this summary, that replaces the need for initial project exploration and significantly reduces token usage for project comprehension.`
+            : `5. For git tracked projects, follow the instructions in the "Git Information" section of this file to validate the actuality of the provided information.
+6. Only dive deeper into specific files after reviewing this summary, that replaces the need for initial project exploration and significantly reduces token usage for project comprehension.`;
+        return `## PARSEME - AI Agent Context
 Auto-generated project summary optimized for AI coding agents. This file provides complete project context without requiring full codebase traversal, designed for token efficiency.
 
 **Usage Instructions for AI Agents:**
 1. Read this PARSEME.md file completely first before accessing individual project files
 2. Basic project information, script availability and dependency information provides basic understanding of code base and tech stack without checking package.json
-3. Use the provided file list (${linkPath}/files.md) to see all tracked files in the project
-4. Utilize the structure and AST data (${linkPath}/structure.json) for code analysis without manual parsing
-5. Follow the instruction in the "Git Information" section of this file to validate the actuality of the provided information.
-6. Only dive deeper into specific files after reviewing this summary, that replaces the need for initial project exploration and significantly reduces token usage for project comprehension.`;
+3. Use the provided file list [${linkPath}/files.md](${linkPath}/files.md) to see all tracked files in the project
+4. Utilize the structure and AST data [${linkPath}/structure.json](${linkPath}/structure.json) for code analysis without manual parsing
+${routesInstructions}`;
     }
     buildProjectOverview(projectInfo) {
         let content = `## Basic Project Information
@@ -161,7 +89,7 @@ Auto-generated project summary optimized for AI coding agents. This file provide
 **Description:** ${projectInfo.description || 'No description available.'}
 **Type:** ${projectInfo.type} project
 **Package Manager:** ${projectInfo.packageManager}
-**Framework:** ${projectInfo.framework?.name || 'None detected'}`;
+**Framework:** ${this.formatFrameworksList(projectInfo.frameworks)}`;
         // Add main entry point if available
         if (projectInfo.entryPoints && projectInfo.entryPoints.length > 0) {
             content += `\n**Main Entry Point:** ${projectInfo.entryPoints[0]}`;
@@ -184,81 +112,81 @@ Auto-generated project summary optimized for AI coding agents. This file provide
         }
         return content;
     }
+    formatFrameworksList(frameworks) {
+        if (!frameworks || frameworks.length === 0) {
+            return 'unknown';
+        }
+        if (frameworks.length === 1) {
+            return frameworks[0].name;
+        }
+        // Multiple frameworks - return comma-separated list
+        return frameworks.map((f) => f.name).join(', ');
+    }
     buildGitSection(gitInfo) {
-        return `## Git Information
+        const base = `## Git Information
 
 **State when PARSEME.md and all linked files were automatically generated:**
 
 - **Branch:** ${gitInfo.branch}
 - **Commit:** ${gitInfo.lastCommit}${gitInfo.origin ? `\n- **Origin:** ${gitInfo.origin}` : ''}
 
-### Git Diff Statistics
-Git diff statistics from the time of generation are available at \`parseme-context/gitDiff.md\`.
+### Git Diff Statistics`;
+        const info = gitInfo.diffStat && gitInfo.diffStat.length > 0
+            ? `Git diff statistics from the time of generation are available at [parseme-context/gitDiff.md](parseme-context/gitDiff.md) (relative to the commit mentioned above).
 
 **AI Agent Command:** To check for changes since generation, run:
 \`\`\`bash
 git diff --stat
 \`\`\`
-Compare the output with the baseline in \`parseme-context/gitDiff.md\` to detect any modifications.`;
+Compare the output with the baseline in [parseme-context/gitDiff.md](parseme-context/gitDiff.md) to detect any modifications.`
+            : `Git diff statistics showed no changes at the time of generation relative to the commit mentioned above.`;
+        return base + '\n\n' + info;
     }
-    buildSummarySection(context, linkPath) {
-        const { fileAnalyses } = context;
-        const routes = fileAnalyses.flatMap((f) => f.routes || []).length;
+    buildSummarySection(linkPath, hasRoutes) {
         let content = `## Project Files
-A complete list of all tracked files in the project is available at \`${linkPath}/files.md\`. This list excludes files ignored by git and provides a quick overview of the project structure.
+A complete list of all git-tracked files in the project (excluding files matching additional exclude patterns) is available at [${linkPath}/files.md](${linkPath}/files.md). This provides a quick overview of the project structure.
 
 
 ## Project Structure & AST
-Detailed structure and Abstract Syntax Tree data for all tracked files is available at \`${linkPath}/structure.json\`. This includes file paths, types, imports, exports, functions, classes, interfaces, and routes for comprehensive code analysis without manual parsing.`;
-        if (routes > 0) {
-            content += `\n\n\n## API Endpoints
-A comprehensive list of all discovered API endpoints is available at \`${linkPath}/api-endpoints.json\`. This includes HTTP methods, paths, handler names, and source file locations for backend routes (Express, NestJS, and decorator-based routing).`;
+Detailed structure and Abstract Syntax Tree data for all tracked files is available at [${linkPath}/structure.json](${linkPath}/structure.json). This includes file paths, types, imports, exports, functions, classes, interfaces, and routes for comprehensive code analysis without manual parsing.`;
+        if (hasRoutes) {
+            content += `\n\n\n## API Routes
+A comprehensive list of all discovered API routes is available at [${linkPath}/routes.json](${linkPath}/routes.json). This includes HTTP methods, paths, handler names, and source file locations for backend routes (Express, NestJS, and decorator-based routing).`;
         }
         return content;
     }
     buildFilesList(allFiles) {
-        let content = `# Project Files\n\n`;
-        content += `This is a complete list of all files in the project (excluding files matching exclude patterns).\n\n`;
+        let content = `# Project Files\n`;
         allFiles.forEach((file) => {
             content += `- ${file}\n`;
         });
         return content;
     }
-    buildDetailedStructure(fileAnalyses) {
-        const structureData = fileAnalyses.map((file) => ({
-            path: file.path,
-            type: file.type,
-            exports: file.exports,
-            imports: file.imports,
-            functions: file.functions,
-            classes: file.classes,
-            routes: file.routes || [],
-        }));
-        const jsonContent = JSON.stringify(structureData, null, 2);
-        const result = this.truncateContent(jsonContent);
-        if (Array.isArray(result)) {
-            // Return split files as a record with numbered keys
-            const splitFiles = {};
-            result.forEach((part, index) => {
-                const suffix = index === 0 ? '' : `_part${index + 1}`;
-                splitFiles[`structure${suffix}`] = part;
-            });
-            return splitFiles;
-        }
-        return result;
+    buildDetailedStructure(fileAnalyses, hasRoutes) {
+        const structureData = fileAnalyses.map((file) => {
+            const routes = file.routes || [];
+            // If file has routes and routes exist in the project, replace with reference instead of full route objects
+            const routesData = routes.length > 0 && hasRoutes
+                ? {
+                    $ref: './routes.json',
+                    filter: { file: file.path },
+                    count: routes.length,
+                }
+                : [];
+            return {
+                path: file.path,
+                type: file.type,
+                exports: file.exports,
+                imports: file.imports,
+                functions: file.functions,
+                classes: file.classes,
+                routes: routesData,
+            };
+        });
+        return JSON.stringify(structureData, null, 2);
     }
-    buildDetailedRoutes(routes, _fileAnalyses) {
-        const jsonContent = JSON.stringify(routes, null, 2);
-        const result = this.truncateContent(jsonContent);
-        if (Array.isArray(result)) {
-            const splitFiles = {};
-            result.forEach((part, index) => {
-                const suffix = index === 0 ? '' : `_part${index + 1}`;
-                splitFiles[`routes${suffix}`] = part;
-            });
-            return splitFiles;
-        }
-        return result;
+    buildDetailedRoutes(routes) {
+        return JSON.stringify(routes, null, 2);
     }
     buildDetailedDependencies(projectInfo) {
         const jsonContent = JSON.stringify({
@@ -266,44 +194,32 @@ A comprehensive list of all discovered API endpoints is available at \`${linkPat
             packageManager: projectInfo.packageManager,
             version: projectInfo.version,
         }, null, 2);
-        const result = this.truncateContent(jsonContent);
-        if (Array.isArray(result)) {
-            const splitFiles = {};
-            result.forEach((part, index) => {
-                const suffix = index === 0 ? '' : `_part${index + 1}`;
-                splitFiles[`dependencies${suffix}`] = part;
-            });
-            return splitFiles;
-        }
-        return result;
+        return jsonContent;
     }
-    buildDetailedFramework(framework) {
-        if (!framework) {
+    buildDetailedFramework(frameworks) {
+        if (!frameworks || frameworks.length === 0) {
             return '';
         }
-        let content = `# Framework: ${framework.name}\n\n`;
-        content += `**Version**: ${framework.version || 'Unknown'}\n\n`;
-        if (framework.features.length > 0) {
-            content += '## Features Detected\n\n';
-            framework.features.forEach((feature) => {
-                content += `- ${feature}\n`;
-            });
-        }
+        let content = '';
+        frameworks.forEach((framework, index) => {
+            if (index > 0) {
+                content += '\n\n';
+            }
+            content += `# Framework: ${framework.name}\n\n`;
+            content += `**Version**: ${framework.version || 'Unknown'}\n\n`;
+            if (framework.features.length > 0) {
+                content += '## Features Detected\n\n';
+                framework.features.forEach((feature) => {
+                    content += `- ${feature}\n`;
+                });
+            }
+        });
         return content;
     }
     buildDetailedGit(gitInfo) {
         let content = `# Git Diff Statistics
-# Generated at time of PARSEME.md creation
-# To check for changes since then, run: git diff --stat
-# Compare the output with the content below
-
 `;
-        if (gitInfo.diffStat && gitInfo.diffStat.length > 0) {
-            content += gitInfo.diffStat;
-        }
-        else {
-            content += 'No changes detected at time of generation.';
-        }
+        content += gitInfo.diffStat;
         return content;
     }
 }

package/dist/core/generator.js

@@ -1,11 +1,11 @@
-import { mkdir, writeFile } from 'fs/promises';
+import { mkdir, writeFile, rm } from 'fs/promises';
 import { join } from 'path';
 import { ASTAnalyzer } from './analyzers/ast-analyzer.js';
 import { FrameworkDetector } from './analyzers/framework-detector.js';
-import { GitAnalyzer } from './analyzers/git-analyzer.js';
 import { ProjectAnalyzer } from './analyzers/project-analyzer.js';
 import { ParsemeConfig } from './config.js';
 import { ContextBuilder } from './context-builder.js';
+import { GitAnalyzer } from '../utils/git.js';
 export class ParsemeGenerator {
     config;
     projectAnalyzer;
@@ -25,10 +25,10 @@ export class ParsemeGenerator {
         const configData = this.config.get();
         // Step 1: Analyze the project structure and metadata
         const projectInfo = await this.projectAnalyzer.analyze(configData.rootDir);
-        // Step 2: Detect framework and analyze specific patterns
-        projectInfo.framework = await this.frameworkDetector.detect(projectInfo);
-        // Step 3: Analyze all relevant files with AST
+        // Step 2: Analyze all relevant files with AST
         const fileAnalyses = await this.astAnalyzer.analyzeProject(configData.rootDir);
+        // Step 3: Detect frameworks from dependencies
+        projectInfo.frameworks = await this.frameworkDetector.detect(projectInfo);
         // Step 4: Get all project files (for file list output)
         const allFiles = await this.projectAnalyzer.getAllProjectFiles(configData.rootDir);
         // Step 5: Get git information if enabled
@@ -72,6 +72,8 @@ export class ParsemeGenerator {
         const parsemeDir = finalContextDir.startsWith('/')
             ? finalContextDir // Absolute path
             : join(baseDir, finalContextDir); // Relative path
+        // Clear the directory if it exists, then recreate it
+        await rm(parsemeDir, { recursive: true, force: true });
         await mkdir(parsemeDir, { recursive: true });
         await writeFile(finalOutputPath, context.parseme);
         if (context.context) {

package/dist/core/types/analyzer-types.d.ts

@@ -1,14 +1,13 @@
-import type { ServiceInfo, ModelInfo, ConfigInfo, MiddlewareInfo, UtilityInfo } from '../analyzers/pattern-detector.js';
-export type { ServiceInfo, ModelInfo, ConfigInfo, MiddlewareInfo, UtilityInfo };
+import type { ServiceInfo, ModelInfo, ConfigInfo, MiddlewareInfo, UtilityInfo, EndpointInfo } from '../analyzers/pattern-detector.js';
+export type { ServiceInfo, ModelInfo, ConfigInfo, MiddlewareInfo, UtilityInfo, EndpointInfo };
 export interface FileAnalysis {
     path: string;
     type: 'route' | 'middleware' | 'model' | 'service' | 'utility' | 'config' | 'test' | 'component';
-    framework?: string;
     exports: string[];
     imports: string[];
     functions: string[];
     classes: string[];
-    routes?: RouteInfo[];
+    routes?: EndpointInfo[];
     components?: ComponentInfo[];
     services?: ServiceInfo[];
     models?: ModelInfo[];

package/dist/core/types/config-types.d.ts

@@ -1,6 +1,7 @@
 export interface GeneratorOptions {
     rootDir?: string;
     includeGitInfo?: boolean;
+    useGitForFiles?: boolean;
     maxDepth?: number;
     excludePatterns?: string[];
     analyzeFileTypes?: string[];
@@ -13,6 +14,7 @@ export interface ParsemeConfigFile extends GeneratorOptions {
     excludePatterns?: string[];
     maxDepth?: number;
     includeGitInfo?: boolean;
+    useGitForFiles?: boolean;
     readmeSuggestion?: boolean;
     sections?: {
         overview?: boolean;
@@ -29,9 +31,6 @@ export interface ParsemeConfigFile extends GeneratorOptions {
         sortOrder?: 'alphabetical' | 'type' | 'size';
     };
     limits?: {
-        maxLinesPerFile?: number;
-        maxCharsPerFile?: number;
         maxFilesPerContext?: number;
-        truncateStrategy?: 'truncate' | 'split' | 'summarize';
     };
 }

package/dist/core/types/generator-types.d.ts

@@ -1,8 +1,6 @@
 export interface ContextOutput {
     parseme: string;
     context?: {
-        structure: string;
-        routes: string;
         [key: string]: string;
     };
 }

package/dist/core/types/project-types.d.ts

@@ -6,7 +6,7 @@ export interface ProjectInfo {
     type: 'typescript' | 'javascript' | 'mixed';
     category: ProjectCategory;
     packageManager: 'unknown' | 'npm' | 'yarn' | 'pnpm' | 'bun';
-    framework?: FrameworkInfo;
+    frameworks?: FrameworkInfo[];
     buildTool?: BuildToolInfo;
     dependencies: Record<string, string>;
     devDependencies: Record<string, string>;

package/dist/utils/file-collector.d.ts

@@ -0,0 +1,23 @@
+import type { ParsemeConfig } from '../core/config.js';
+export interface FileCollectionOptions {
+    fileTypes?: string[];
+}
+export interface FileCollectionResult {
+    files: string[];
+    totalFound: number;
+    excluded: number;
+}
+export declare class FileCollector {
+    private readonly fileFilter;
+    private readonly config;
+    constructor(config: ParsemeConfig);
+    getFiles(rootDir: string, options?: FileCollectionOptions): Promise<FileCollectionResult>;
+    /**
+     * Get all project files (no file type filtering, for files.md)
+     */
+    getAllProjectFiles(rootDir: string): Promise<FileCollectionResult>;
+    /**
+     * Get code files for AST analysis (filtered by file types, for structure.json)
+     */
+    getCodeFiles(rootDir: string, fileTypes?: string[]): Promise<FileCollectionResult>;
+}

package/dist/utils/file-collector.js

@@ -0,0 +1,61 @@
+import { FileFilterService } from './file-filter.js';
+export class FileCollector {
+    fileFilter;
+    config;
+    constructor(config) {
+        this.config = config;
+        const configData = this.config.get();
+        this.fileFilter = new FileFilterService(configData.excludePatterns, configData.useGitForFiles ?? true);
+    }
+    async getFiles(rootDir, options = {}) {
+        const configData = this.config.get();
+        const { fileTypes } = options;
+        // Get all filtered files (respects git ignore + custom excludePatterns)
+        const allFiles = await this.fileFilter.getFilteredFiles(rootDir);
+        // Filter by file types if specified
+        let filteredFiles = allFiles;
+        if (fileTypes && fileTypes.length > 0) {
+            const extensionSet = new Set(fileTypes.map((ext) => (ext.startsWith('.') ? ext : `.${ext}`)));
+            filteredFiles = allFiles.filter((file) => {
+                const ext = file.substring(file.lastIndexOf('.'));
+                return extensionSet.has(ext);
+            });
+        }
+        // Apply limits
+        let finalFiles = filteredFiles;
+        let excluded = 0;
+        if (configData.limits?.maxFilesPerContext) {
+            const limit = configData.limits.maxFilesPerContext;
+            if (filteredFiles.length > limit) {
+                finalFiles = filteredFiles.slice(0, limit);
+                excluded = filteredFiles.length - limit;
+                // Show warning when files are excluded
+                const fileTypeDesc = fileTypes ? `${fileTypes.join(', ')} files` : 'files';
+                console.warn(`⚠️  File limit reached: ${excluded} ${fileTypeDesc} excluded.`);
+                console.warn(`   Processed: ${limit}/${filteredFiles.length} files`);
+                console.warn(`   To process more files, increase 'limits.maxFilesPerContext' in your config file.`);
+            }
+        }
+        return {
+            files: finalFiles,
+            totalFound: filteredFiles.length,
+            excluded,
+        };
+    }
+    /**
+     * Get all project files (no file type filtering, for files.md)
+     */
+    async getAllProjectFiles(rootDir) {
+        return this.getFiles(rootDir);
+    }
+    /**
+     * Get code files for AST analysis (filtered by file types, for structure.json)
+     */
+    async getCodeFiles(rootDir, fileTypes) {
+        const configData = this.config.get();
+        const defaultFileTypes = configData.analyzeFileTypes || ['ts', 'tsx', 'js', 'jsx'];
+        return this.getFiles(rootDir, {
+            fileTypes: fileTypes || defaultFileTypes,
+        });
+    }
+}

package/dist/utils/file-filter.d.ts

@@ -0,0 +1,30 @@
+export declare class FileFilterService {
+    private readonly excludePatterns;
+    private readonly useGitForFiles;
+    private readonly ig;
+    constructor(excludePatterns?: string[], useGitForFiles?: boolean);
+    /**
+     * Get all files that should be analyzed, respecting:
+     * 1. Git-tracked files (respects all .gitignore files automatically)
+     * 2. All files (if non-git repo) - respects only custom excludePatterns
+     * 3. Custom excludePatterns from config (always applied)
+     */
+    getFilteredFiles(rootDir: string, fileExtensions?: string[]): Promise<string[]>;
+    /**
+     * Check if the directory is a git repository
+     */
+    private isGitRepository;
+    /**
+     * Get all tracked files from git
+     * This respects all .gitignore files in the repository (parent, current, and child dirs)
+     */
+    private getGitTrackedFiles;
+    /**
+     * Get all files recursively (fallback for non-git repos)
+     */
+    private getAllFilesRecursive;
+    /**
+     * Check if a specific file should be filtered out
+     */
+    shouldIgnore(filePath: string): boolean;
+}