@parseme/cli 0.0.3 → 0.0.5

package/dist/{analyzers → core/analyzers}/project-analyzer.js

@@ -1,9 +1,12 @@
 import { readFile, access, readdir, stat } from 'fs/promises';
 import { join, basename } from 'path';
+import { FileCollector } from '../../utils/file-collector.js';
 export class ProjectAnalyzer {
     config;
+    fileCollector;
     constructor(config) {
         this.config = config;
+        this.fileCollector = new FileCollector(config);
     }
     async analyze(rootDir) {
         const packageJsonPath = join(rootDir, 'package.json');
@@ -30,7 +33,7 @@ export class ProjectAnalyzer {
                 name: basename(rootDir),
                 type: await this.detectProjectType(rootDir),
                 category: 'unknown',
-                packageManager: 'npm',
+                packageManager: 'unknown',
                 dependencies: {},
                 devDependencies: {},
                 scripts: {},
@@ -41,7 +44,7 @@ export class ProjectAnalyzer {
     }
     async detectProjectType(rootDir) {
         try {
-            const files = await this.getFilesRecursive(rootDir, 2); // Only check 2 levels deep
+            const files = await this.getFilesRecursive(rootDir, rootDir, 2); // Only check 2 levels deep
             const tsFiles = files.filter((f) => f.endsWith('.ts') && !f.endsWith('.d.ts'));
             const jsFiles = files.filter((f) => f.endsWith('.js'));
             if (tsFiles.length > 0 && jsFiles.length > 0) {
@@ -74,7 +77,7 @@ export class ProjectAnalyzer {
         }
         return 'npm';
     }
-    async getFilesRecursive(dir, maxDepth) {
+    async getFilesRecursive(dir, rootDir, maxDepth) {
         if (maxDepth <= 0) {
             return [];
         }
@@ -88,7 +91,7 @@ export class ProjectAnalyzer {
                     files.push(fullPath);
                 }
                 else if (stats.isDirectory() && !entry.startsWith('.') && entry !== 'node_modules') {
-                    files.push(...(await this.getFilesRecursive(fullPath, maxDepth - 1)));
+                    files.push(...(await this.getFilesRecursive(fullPath, rootDir, maxDepth - 1)));
                 }
             }
             return files;
@@ -132,11 +135,7 @@ export class ProjectAnalyzer {
             return 'frontend-web';
         }
         // Check for backend frameworks
-        if (deps['express'] ||
-            deps['fastify'] ||
-            deps['@nestjs/core'] ||
-            deps['koa'] ||
-            deps['@hapi/hapi']) {
+        if (deps['express'] || deps['fastify'] || deps['@nestjs/core']) {
             return 'backend-api';
         }
         // Check if it's a library (has main/module/exports but no app dependencies)
@@ -202,4 +201,8 @@ export class ProjectAnalyzer {
         ];
         return appIndicators.some((indicator) => deps[indicator]);
     }
+    async getAllProjectFiles(rootDir) {
+        const result = await this.fileCollector.getAllProjectFiles(rootDir);
+        return result.files;
+    }
 }

package/dist/core/config.d.ts

@@ -0,0 +1,19 @@
+import type { ParsemeConfigFile } from './types.js';
+export declare class ParsemeConfig {
+    private readonly config;
+    private readonly userConfig;
+    constructor(config?: Partial<ParsemeConfigFile>);
+    static fromFileWithOptions(configPath?: string, cliOptions?: Partial<ParsemeConfigFile>, options?: {
+        showWarnings?: boolean;
+    }): Promise<ParsemeConfig>;
+    static fromFile(configPath?: string, options?: {
+        showWarnings?: boolean;
+        throwOnNotFound?: boolean;
+    }): Promise<ParsemeConfig>;
+    private mergeWithDefaults;
+    get(): ParsemeConfigFile;
+    save(path?: string): Promise<void>;
+    private generateJSConfig;
+    private generateTSConfig;
+    private mergeExcludePatterns;
+}

package/dist/{config.js → core/config.js}

@@ -1,30 +1,37 @@
-import { readFileSync, existsSync } from 'fs';
+import { existsSync } from 'fs';
 import { readFile, writeFile } from 'fs/promises';
 import { join, extname } from 'path';
 export class ParsemeConfig {
     config;
+    userConfig;
     constructor(config = {}) {
+        this.userConfig = { ...config }; // Store original user config
         this.config = this.mergeWithDefaults(config);
     }
-    static async fromFileWithOptions(configPath, cliOptions = {}) {
-        const configFromFile = await ParsemeConfig.fromFile(configPath);
+    static async fromFileWithOptions(configPath, cliOptions = {}, options = { showWarnings: true }) {
+        const configFromFile = await ParsemeConfig.fromFile(configPath, options);
         const mergedConfig = {
             ...configFromFile.get(),
             ...cliOptions, // CLI options take priority
         };
         return new ParsemeConfig(mergedConfig);
     }
-    static async fromFile(configPath) {
+    static async fromFile(configPath, options = {
+        showWarnings: true,
+        throwOnNotFound: false,
+    }) {
         const defaultPaths = [
-            'parseme.config.ts',
-            'parseme.config.js',
             'parseme.config.json',
-            '.parsemerc.ts',
-            '.parsemerc.js',
             '.parsemerc.json',
             '.parsemerc',
+            'parseme.config.ts',
+            '.parsemerc.ts',
+            'parseme.config.js',
+            '.parsemerc.js',
         ];
         const paths = configPath ? [configPath] : defaultPaths;
+        let tsWarning = null;
+        let configLoadError = null;
         for (const path of paths) {
             try {
                 const ext = extname(path);
@@ -32,17 +39,18 @@ export class ParsemeConfig {
                     // Dynamic import for JS/TS config files
                     const fullPath = path.startsWith('/') ? path : join(process.cwd(), path);
                     if (ext === '.ts') {
-                        // For TypeScript files, try to import directly first
-                        // This works if the user has transpiled their TS config to JS or is using tsx/ts-node
-                        try {
-                            const module = await import(fullPath);
-                            const config = module.default || module;
-                            return new ParsemeConfig(config);
-                        }
-                        catch {
-                            // If direct import fails, suggest using .js instead
-                            console.warn(`Could not load TypeScript config file: ${path}`);
-                            console.warn(`Consider using a .js config file or ensure tsx/ts-node is available`);
+                        // For TypeScript files, check if file exists first
+                        if (existsSync(fullPath)) {
+                            try {
+                                const module = await import(fullPath);
+                                const config = module.default || module;
+                                return new ParsemeConfig(config);
+                            }
+                            catch (error) {
+                                // File exists but can't be loaded - save warning
+                                tsWarning = path;
+                                configLoadError = { path, error: error };
+                            }
                         }
                     }
                     else {
@@ -54,20 +62,56 @@ export class ParsemeConfig {
                 }
                 else {
                     // JSON config files
-                    const content = await readFile(path, 'utf-8');
+                    const fullPath = path.startsWith('/') ? path : join(process.cwd(), path);
+                    const content = await readFile(fullPath, 'utf-8');
                     const config = JSON.parse(content);
                     return new ParsemeConfig(config);
                 }
             }
-            catch {
+            catch (error) {
+                // If file exists, save the error
+                const fullPath = path.startsWith('/') ? path : join(process.cwd(), path);
+                if (existsSync(fullPath)) {
+                    configLoadError = { path, error: error };
+                }
                 // Continue to next path
             }
         }
+        // Handle case when config file was found but couldn't be loaded
+        if (configLoadError) {
+            const { path, error } = configLoadError;
+            if (options.throwOnNotFound) {
+                throw new Error(`Configuration file "${path}" found but failed to load: ${error.message}`);
+            }
+            if (options.showWarnings) {
+                console.warn(`Configuration file "${path}" found but failed to load: ${error.message}`);
+            }
+        }
+        else {
+            // Handle case when no config found at all
+            if (options.throwOnNotFound) {
+                throw new Error('No configuration file found. Run "parseme init" to create one.');
+            }
+            if (options.showWarnings) {
+                console.warn('No configuration file found. Run "parseme init" to create one.');
+            }
+        }
+        if (tsWarning && !configLoadError && options.showWarnings) {
+            console.warn(`Could not load TypeScript config file: ${tsWarning}`);
+            console.warn(`Consider using a .js config file or ensure tsx/ts-node is available`);
+        }
         // Return default config if no file found
         return new ParsemeConfig();
     }
     mergeWithDefaults(config) {
         const rootDir = config.rootDir || process.cwd();
+        const supportedFileTypes = ['ts', 'tsx', 'js', 'jsx'];
+        // Validate analyzeFileTypes
+        const fileTypes = config.analyzeFileTypes || ['ts', 'tsx', 'js', 'jsx'];
+        const invalidTypes = fileTypes.filter((type) => !supportedFileTypes.includes(type));
+        if (invalidTypes.length > 0) {
+            throw new Error(`Invalid file types: ${invalidTypes.join(', ')}. Supported types are: ${supportedFileTypes.join(', ')}`);
+        }
         return {
             // Output
             outputPath: config.outputPath || 'PARSEME.md',
@@ -76,19 +120,10 @@ export class ParsemeConfig {
             rootDir,
             maxDepth: config.maxDepth || 10,
             excludePatterns: this.mergeExcludePatterns(config.excludePatterns, rootDir),
-            includePatterns: config.includePatterns || [
-                'src/**/*.ts',
-                'src/**/*.js',
-                'src/**/*.tsx',
-                'src/**/*.jsx',
-                'lib/**/*.ts',
-                'lib/**/*.js',
-                'package.json',
-                'tsconfig.json',
-                'README.md',
-            ],
+            analyzeFileTypes: fileTypes,
             // Git
             includeGitInfo: config.includeGitInfo ?? true,
+            useGitForFiles: config.useGitForFiles ?? true,
             // Sections
             sections: {
                 overview: true,
@@ -109,10 +144,7 @@ export class ParsemeConfig {
             },
             // Size limits
             limits: {
-                maxLinesPerFile: config.limits?.maxLinesPerFile ?? 1000,
-                maxCharsPerFile: config.limits?.maxCharsPerFile ?? 50000, // ~15k tokens
-                maxFilesPerContext: config.limits?.maxFilesPerContext ?? 20,
-                truncateStrategy: config.limits?.truncateStrategy ?? 'truncate',
+                maxFilesPerContext: config.limits?.maxFilesPerContext ?? 5000,
             },
         };
     }
@@ -132,73 +164,29 @@ export class ParsemeConfig {
             await writeFile(path, configContent);
         }
         else {
-            // Generate JSON config file
-            await writeFile(path, JSON.stringify(this.config, null, 2));
+            // Generate JSON config file - only save user config, not defaults
+            await writeFile(path, JSON.stringify(this.userConfig, null, 2));
         }
     }
     generateJSConfig() {
+        // Only export user-specified config, not defaults
         return `/** @type {import('parseme').ParsemeConfigFile} */
-export default ${JSON.stringify(this.config, null, 2)};
+const config = ${JSON.stringify(this.userConfig, null, 2)};
+
+export default config;
 `;
     }
     generateTSConfig() {
+        // Only export user-specified config, not defaults
         return `import type { ParsemeConfigFile } from 'parseme';
 
-const config: ParsemeConfigFile = ${JSON.stringify(this.config, null, 2)};
+const config: ParsemeConfigFile = ${JSON.stringify(this.userConfig, null, 2)};
 
 export default config;
 `;
     }
-    mergeExcludePatterns(configPatterns, rootDir) {
-        const defaultPatterns = [
-            'node_modules/**',
-            'dist/**',
-            'build/**',
-            'coverage/**',
-            '.git/**',
-            '**/*.log',
-            '**/*.tmp',
-            '**/.DS_Store',
-            '**/.*',
-        ];
-        // Priority: Config patterns > .gitignore patterns > Default patterns
-        if (configPatterns) {
-            return configPatterns;
-        }
-        // Try to read .gitignore patterns
-        const gitignorePatterns = this.readGitignorePatterns(rootDir);
-        if (gitignorePatterns.length > 0) {
-            // Merge gitignore patterns with critical defaults
-            const criticalDefaults = ['node_modules/**', '.git/**'];
-            return [...new Set([...criticalDefaults, ...gitignorePatterns])];
-        }
-        return defaultPatterns;
-    }
-    readGitignorePatterns(rootDir) {
-        try {
-            const gitignorePath = join(rootDir, '.gitignore');
-            if (!existsSync(gitignorePath)) {
-                return [];
-            }
-            const gitignoreContent = readFileSync(gitignorePath, 'utf-8');
-            return gitignoreContent
-                .split('\n')
-                .map((line) => line.trim())
-                .filter((line) => line && !line.startsWith('#'))
-                .map((pattern) => {
-                // Convert gitignore patterns to glob patterns
-                if (pattern.endsWith('/')) {
-                    return pattern + '**';
-                }
-                if (!pattern.includes('/') && !pattern.includes('*')) {
-                    // Convert simple names to match directory patterns
-                    return pattern + '/**';
-                }
-                return pattern;
-            });
-        }
-        catch {
-            return [];
-        }
+    mergeExcludePatterns(configPatterns, _rootDir) {
+        // Only use config patterns - git ignore is now handled by FileFilterService
+        return configPatterns || [];
     }
 }

package/dist/{builders → core}/context-builder.d.ts

@@ -1,8 +1,9 @@
-import type { ParsemeConfig } from '../config.js';
-import type { ContextOutput, ProjectInfo, FileAnalysis, GitInfo, GeneratorOptions } from '../types.js';
+import type { ParsemeConfig } from './config.js';
+import type { ContextOutput, ProjectInfo, FileAnalysis, GitInfo, GeneratorOptions } from './types.js';
 interface BuildContext {
     projectInfo: ProjectInfo;
     fileAnalyses: FileAnalysis[];
+    allFiles: string[];
     gitInfo?: GitInfo | null;
     options: GeneratorOptions;
     contextDir?: string;
@@ -11,20 +12,12 @@ interface BuildContext {
 export declare class ContextBuilder {
     private readonly config;
     constructor(config: ParsemeConfig);
-    private truncateContent;
-    private splitContentByLines;
-    private splitContentByChars;
     build(context: BuildContext): ContextOutput;
     private buildMultiFile;
     private buildHeader;
     private buildProjectOverview;
-    private buildFrameworkSection;
-    private buildArchitectureSection;
-    private buildRoutesSection;
-    private buildFileStructureSection;
-    private buildDependenciesSection;
+    private formatFrameworksList;
     private buildGitSection;
-    private buildFooter;
     private buildSummarySection;
     private buildFilesList;
     private buildDetailedStructure;

package/dist/core/context-builder.js

@@ -0,0 +1,225 @@
+import { relative, dirname } from 'path';
+export class ContextBuilder {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    build(context) {
+        return this.buildMultiFile(context);
+    }
+    buildMultiFile(context) {
+        const { projectInfo, fileAnalyses, gitInfo, contextDir, outputPath } = context;
+        // 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) {
+            const outputDir = dirname(outputPath);
+            if (contextDir.startsWith('/')) {
+                // Absolute path: calculate relative path from output file to context dir
+                linkPath = relative(outputDir, contextDir);
+            }
+            else {
+                // Relative path: use as-is since it's relative to the output file's directory
+                linkPath = contextDir;
+            }
+        }
+        else if (contextDir) {
+            // Fallback: use contextDir as-is if no outputPath provided
+            linkPath = contextDir;
+        }
+        // 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(linkPath, hasRoutes) +
+            '\n\n\n' +
+            (gitInfo ? this.buildGitSection(gitInfo) : '');
+        const contextFiles = {
+            structure: '',
+        };
+        // Files list (markdown) - all files in project, not just analyzed ones
+        contextFiles.files = this.buildFilesList(context.allFiles);
+        // Detailed structure (JSON with AST)
+        contextFiles.structure = this.buildDetailedStructure(fileAnalyses, hasRoutes);
+        // Routes documentation (only if routes exist)
+        if (hasRoutes) {
+            contextFiles.routes = this.buildDetailedRoutes(routes);
+        }
+        // Git information
+        if (gitInfo?.diffStat?.length && gitInfo.diffStat.length > 0) {
+            contextFiles.gitDiff = this.buildDetailedGit(gitInfo);
+        }
+        return {
+            parseme: mainContent,
+            context: contextFiles,
+        };
+    }
+    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](${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
+
+**Project:** ${projectInfo.name}${projectInfo.version ? ` v${projectInfo.version}` : ''}
+**Description:** ${projectInfo.description || 'No description available.'}
+**Type:** ${projectInfo.type} project
+**Package Manager:** ${projectInfo.packageManager}
+**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]}`;
+        }
+        content += '\n';
+        // Add dependencies
+        const deps = Object.keys(projectInfo.dependencies);
+        if (deps.length > 0) {
+            content += '\n\n### Dependencies\n';
+            deps.forEach((dep) => {
+                content += `- ${dep}\n`;
+            });
+        }
+        // Add available scripts
+        if (projectInfo.scripts && Object.keys(projectInfo.scripts).length > 0) {
+            content += '\n### Available Scripts\n';
+            Object.entries(projectInfo.scripts).forEach(([name, script]) => {
+                content += `- **${name}**: \`${script}\`\n`;
+            });
+        }
+        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) {
+        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`;
+        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](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(linkPath, hasRoutes) {
+        let content = `## Project Files
+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](${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`;
+        allFiles.forEach((file) => {
+            content += `- ${file}\n`;
+        });
+        return content;
+    }
+    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) {
+        return JSON.stringify(routes, null, 2);
+    }
+    buildDetailedDependencies(projectInfo) {
+        const jsonContent = JSON.stringify({
+            dependencies: projectInfo.dependencies,
+            packageManager: projectInfo.packageManager,
+            version: projectInfo.version,
+        }, null, 2);
+        return jsonContent;
+    }
+    buildDetailedFramework(frameworks) {
+        if (!frameworks || frameworks.length === 0) {
+            return '';
+        }
+        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
+`;
+        content += gitInfo.diffStat;
+        return content;
+    }
+}

package/dist/{generator.d.ts → core/generator.d.ts}

@@ -1,4 +1,3 @@
-import { type ParsemeConfigFile } from './config.js';
 import type { ContextOutput, GeneratorOptions } from './types.js';
 export declare class ParsemeGenerator {
     private readonly config;
@@ -8,8 +7,6 @@ export declare class ParsemeGenerator {
     private readonly gitAnalyzer;
     private readonly contextBuilder;
     constructor(options?: GeneratorOptions);
-    static fromConfig(configPath?: string): Promise<ParsemeGenerator>;
-    static fromConfigWithOptions(configPath?: string, cliOptions?: Partial<ParsemeConfigFile>): Promise<ParsemeGenerator>;
     generate(outputPath?: string): Promise<ContextOutput>;
     generateToFile(outputPath?: string, contextDir?: string): Promise<void>;
 }