@parseme/cli 0.0.2 → 0.0.4

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

@@ -3,28 +3,35 @@ 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,17 +120,7 @@ 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,
             // Sections
@@ -132,47 +166,36 @@ 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
+        // Always 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])];
+        // Merge gitignore patterns with config patterns, they are added to gitignore patterns, not replacing them
+        const excludePatterns = [...gitignorePatterns];
+        if (configPatterns) {
+            excludePatterns.push(...configPatterns);
         }
-        return defaultPatterns;
+        return excludePatterns;
     }
     readGitignorePatterns(rootDir) {
         try {
@@ -184,17 +207,7 @@ export default config;
             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('*')) {
-                    return '**/' + pattern;
-                }
-                return pattern;
-            });
+                .filter((line) => line && !line.startsWith('#'));
         }
         catch {
             return [];

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

@@ -1,9 +1,10 @@
-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[];
-    gitInfo?: GitInfo;
+    allFiles: string[];
+    gitInfo?: GitInfo | null;
     options: GeneratorOptions;
     contextDir?: string;
     outputPath?: string;
@@ -18,14 +19,9 @@ export declare class ContextBuilder {
     private buildMultiFile;
     private buildHeader;
     private buildProjectOverview;
-    private buildFrameworkSection;
-    private buildArchitectureSection;
-    private buildRoutesSection;
-    private buildFileStructureSection;
-    private buildDependenciesSection;
     private buildGitSection;
-    private buildFooter;
     private buildSummarySection;
+    private buildFilesList;
     private buildDetailedStructure;
     private buildDetailedRoutes;
     private buildDetailedDependencies;

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

@@ -76,21 +76,39 @@ export class ContextBuilder {
         return this.buildMultiFile(context);
     }
     buildMultiFile(context) {
-        const { projectInfo, fileAnalyses, gitInfo } = 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;
-        const mainContent = this.buildHeader(projectInfo) +
-            '\n\n' +
+        // 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;
+        }
+        const mainContent = this.buildHeader(linkPath) +
+            '\n\n\n' +
             this.buildProjectOverview(projectInfo) +
-            '\n\n' +
-            this.buildSummarySection(context);
+            '\n\n\n' +
+            this.buildSummarySection(context, linkPath) +
+            '\n\n\n' +
+            (gitInfo ? this.buildGitSection(gitInfo) : '');
         const contextFiles = {
             structure: '',
             routes: '',
-            dependencies: '',
         };
         // Helper function to merge split files into contextFiles
         const mergeSplitFiles = (result, baseName) => {
@@ -104,150 +122,107 @@ export class ContextBuilder {
                 });
             }
         };
-        // Detailed structure
+        // 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, 'routes');
-        }
-        // Dependencies
-        const dependenciesResult = this.buildDetailedDependencies(projectInfo);
-        mergeSplitFiles(dependenciesResult, 'dependencies');
-        // Framework details
-        if (projectInfo.framework &&
-            projectInfo.framework.name &&
-            projectInfo.framework.name !== 'unknown') {
-            contextFiles.framework = this.buildDetailedFramework(projectInfo.framework);
+            mergeSplitFiles(routesResult, 'api-endpoints');
         }
         // Git information
         if (gitInfo) {
-            const gitResult = this.buildDetailedGit(gitInfo);
-            mergeSplitFiles(gitResult, 'git');
+            contextFiles.gitDiff = this.buildDetailedGit(gitInfo);
         }
         return {
             parseme: mainContent,
             context: contextFiles,
         };
     }
-    buildHeader(projectInfo) {
-        return `# ${projectInfo.name}
+    buildHeader(linkPath) {
+        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.
 
-*AI-Generated Project Context*
-
-${projectInfo.description || 'No description available.'}`;
+**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.`;
     }
     buildProjectOverview(projectInfo) {
-        return `## Project Overview
+        let content = `## Basic Project Information
 
-- **Type**: ${projectInfo.type} project
-- **Package Manager**: ${projectInfo.packageManager}
-- **Framework**: ${projectInfo.framework?.name || 'None detected'}
-- **Version**: ${projectInfo.version || 'Not specified'}`;
-    }
-    buildFrameworkSection(framework) {
-        if (!framework) {
-            return '';
+**Project:** ${projectInfo.name}${projectInfo.version ? ` v${projectInfo.version}` : ''}
+**Description:** ${projectInfo.description || 'No description available.'}
+**Type:** ${projectInfo.type} project
+**Package Manager:** ${projectInfo.packageManager}
+**Framework:** ${projectInfo.framework?.name || 'None detected'}`;
+        // Add main entry point if available
+        if (projectInfo.entryPoints && projectInfo.entryPoints.length > 0) {
+            content += `\n**Main Entry Point:** ${projectInfo.entryPoints[0]}`;
         }
-        const features = framework.features.length > 0 ? `\n- **Features**: ${framework.features.join(', ')}` : '';
-        return `## Framework: ${framework.name}
-
-- **Version**: ${framework.version || 'Unknown'}${features}`;
-    }
-    buildArchitectureSection(fileAnalyses) {
-        const typeGroups = fileAnalyses.reduce((acc, file) => {
-            if (!acc[file.type]) {
-                acc[file.type] = [];
-            }
-            acc[file.type].push(file);
-            return acc;
-        }, {});
-        const archLines = Object.entries(typeGroups)
-            .map(([type, files]) => `- **${type}**: ${files.length} files`)
-            .join('\n');
-        return `## Architecture Overview
-
-${archLines}`;
-    }
-    buildRoutesSection(routes, _fileAnalyses) {
-        const routesByMethod = routes.reduce((acc, route) => {
-            if (!acc[route.method]) {
-                acc[route.method] = [];
-            }
-            acc[route.method].push(route);
-            return acc;
-        }, {});
-        const routeLines = Object.entries(routesByMethod)
-            .map(([method, methodRoutes]) => {
-            const routeList = methodRoutes
-                .map((route) => `  - \`${route.path}\` → ${route.handler}`)
-                .join('\n');
-            return `- **${method}**:\n${routeList}`;
-        })
-            .join('\n');
-        return `## API Endpoints
-
-${routeLines}`;
-    }
-    buildFileStructureSection(fileAnalyses) {
-        const structure = fileAnalyses.map((file) => `- \`${file.path}\` (${file.type})`).join('\n');
-        return `## File Structure
-
-${structure}`;
-    }
-    buildDependenciesSection(projectInfo) {
+        content += '\n';
+        // Add dependencies
         const deps = Object.keys(projectInfo.dependencies);
-        const devDeps = Object.keys(projectInfo.devDependencies);
-        let content = '## Dependencies\n\n';
         if (deps.length > 0) {
-            content += `**Production**: ${deps.join(', ')}\n\n`;
+            content += '\n\n### Dependencies\n';
+            deps.forEach((dep) => {
+                content += `- ${dep}\n`;
+            });
         }
-        if (devDeps.length > 0) {
-            content += `**Development**: ${devDeps.join(', ')}`;
+        // 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;
     }
     buildGitSection(gitInfo) {
         return `## Git Information
 
-- **Branch**: ${gitInfo.branch}
-- **Status**: ${gitInfo.status}
-- **Last Commit**: ${gitInfo.lastCommit}
-${gitInfo.changedFiles.length > 0 ? `- **Changed Files**: ${gitInfo.changedFiles.join(', ')}` : ''}`;
-    }
-    buildFooter() {
-        return `---
+**State when PARSEME.md and all linked files were automatically generated:**
 
-*Generated by PARSEME v1.0.0 on ${new Date().toISOString().split('T')[0]}*`;
+- **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\`.
+
+**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.`;
     }
-    buildSummarySection(context) {
-        const { fileAnalyses, contextDir, outputPath } = context;
-        const totalFiles = fileAnalyses.length;
+    buildSummarySection(context, linkPath) {
+        const { fileAnalyses } = context;
         const routes = fileAnalyses.flatMap((f) => f.routes || []).length;
-        // 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;
-        }
-        return `## Summary
+        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.
 
-This project contains ${totalFiles} analyzed files${routes > 0 ? ` with ${routes} API endpoints` : ''}.
 
-For detailed information, see the files in the \`${linkPath}/\` directory.`;
+## 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).`;
+        }
+        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`;
+        allFiles.forEach((file) => {
+            content += `- ${file}\n`;
+        });
+        return content;
     }
     buildDetailedStructure(fileAnalyses) {
         const structureData = fileAnalyses.map((file) => ({
@@ -317,16 +292,18 @@ For detailed information, see the files in the \`${linkPath}/\` directory.`;
         return content;
     }
     buildDetailedGit(gitInfo) {
-        const jsonContent = JSON.stringify(gitInfo, 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[`git${suffix}`] = part;
-            });
-            return splitFiles;
+        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;
         }
-        return result;
+        else {
+            content += 'No changes detected at time of generation.';
+        }
+        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>;
 }

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

@@ -4,8 +4,8 @@ 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 { ContextBuilder } from './builders/context-builder.js';
 import { ParsemeConfig } from './config.js';
+import { ContextBuilder } from './context-builder.js';
 export class ParsemeGenerator {
     config;
     projectAnalyzer;
@@ -17,18 +17,10 @@ export class ParsemeGenerator {
         this.config = new ParsemeConfig(options);
         this.projectAnalyzer = new ProjectAnalyzer(this.config);
         this.astAnalyzer = new ASTAnalyzer(this.config);
-        this.frameworkDetector = new FrameworkDetector(this.config);
-        this.gitAnalyzer = new GitAnalyzer(this.config);
+        this.frameworkDetector = new FrameworkDetector();
+        this.gitAnalyzer = new GitAnalyzer();
         this.contextBuilder = new ContextBuilder(this.config);
     }
-    static async fromConfig(configPath) {
-        const config = await ParsemeConfig.fromFile(configPath);
-        return new ParsemeGenerator(config.get());
-    }
-    static async fromConfigWithOptions(configPath, cliOptions = {}) {
-        const config = await ParsemeConfig.fromFileWithOptions(configPath, cliOptions);
-        return new ParsemeGenerator(config.get());
-    }
     async generate(outputPath) {
         const configData = this.config.get();
         // Step 1: Analyze the project structure and metadata
@@ -37,16 +29,19 @@ export class ParsemeGenerator {
         projectInfo.framework = await this.frameworkDetector.detect(projectInfo);
         // Step 3: Analyze all relevant files with AST
         const fileAnalyses = await this.astAnalyzer.analyzeProject(configData.rootDir);
-        // Step 4: Get git information if enabled
+        // 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
         const gitInfo = configData.includeGitInfo
             ? await this.gitAnalyzer.analyze(configData.rootDir)
-            : undefined;
+            : null;
         // Calculate final output path for link generation
         const finalOutputPath = outputPath || configData.outputPath || join(configData.rootDir, 'PARSEME.md');
-        // Step 5: Build the context output
+        // Step 6: Build the context output
         return this.contextBuilder.build({
             projectInfo,
             fileAnalyses,
+            allFiles,
             gitInfo,
             options: configData,
             contextDir: configData.contextDir,
@@ -81,7 +76,9 @@ export class ParsemeGenerator {
         await writeFile(finalOutputPath, context.parseme);
         if (context.context) {
             for (const [filename, content] of Object.entries(context.context)) {
-                await writeFile(join(parsemeDir, `${filename}.json`), content);
+                // Use .md extension for markdown files, .json for others
+                const extension = filename === 'gitDiff' || filename === 'files' ? '.md' : '.json';
+                await writeFile(join(parsemeDir, `${filename}${extension}`), content);
             }
         }
     }