@parseme/cli 0.0.3 → 0.0.4

package/dist/{cli.js → cli/cli.js}

@@ -1,22 +1,12 @@
 #!/usr/bin/env node
 import { join } from 'path';
 import { Command } from 'commander';
-import { ParsemeConfig } from './config.js';
-import { ParsemeGenerator } from './generator.js';
-import { confirmPrompt } from './prompt.js';
+import { prompt } from './prompt.js';
+import { ParsemeConfig } from '../core/config.js';
+import { ParsemeGenerator } from '../core/generator.js';
 const program = new Command();
-async function promptForMissingConfig(config, cliOptions) {
-    const finalConfig = { ...config };
-    // Only prompt if running interactively (stdin is a TTY) and not in CI
-    if (!process.stdin.isTTY || process.env.CI) {
-        return finalConfig;
-    }
-    // Prompt for README suggestion if not set via CLI or config
-    if (cliOptions.readmeSuggestion === undefined && config.readmeSuggestion === undefined) {
-        const wantReadmeSuggestion = await confirmPrompt('Show README.md section suggestion for AI agents?', true);
-        finalConfig.readmeSuggestion = wantReadmeSuggestion;
-    }
-    return finalConfig;
+async function promptForMissingConfig(config) {
+    return { ...config };
 }
 program.name('parseme').description('AI Project Context Generator').version('0.1.0');
 // Main command - just run parseme
@@ -26,11 +16,10 @@ program
     .option('-o, --output <path>', 'Output file path')
     .option('-r, --root <path>', 'Root directory to analyze')
     .option('--context-dir <path>', 'Context directory path (default: parseme-context)')
-    .option('--include <patterns...>', 'Include patterns (glob)')
+    .option('--file-types <types...>', 'File types to analyze (e.g., ts tsx js jsx)')
     .option('--exclude <patterns...>', 'Exclude patterns (glob)')
     .option('--no-git', 'Disable git information')
     .option('--max-depth <number>', 'Maximum directory depth', parseInt)
-    .option('--no-readme-suggestion', 'Disable README.md section suggestion')
     .action(async (options) => {
     try {
         // Convert CLI options to config format
@@ -38,14 +27,16 @@ program
             ...(options.output && { outputPath: options.output }),
             ...(options.root && { rootDir: options.root }),
             ...(options.contextDir && { contextDir: options.contextDir }),
-            ...(options.include && { includePatterns: options.include }),
+            ...(options.fileTypes && { analyzeFileTypes: options.fileTypes }),
             ...(options.exclude && { excludePatterns: options.exclude }),
             ...(options.git === false && { includeGitInfo: false }),
             ...(options.maxDepth && { maxDepth: options.maxDepth }),
-            ...(options.readmeSuggestion === false && { readmeSuggestion: false }),
         };
-        const configFromFile = await ParsemeConfig.fromFile(options.config);
-        const interactiveConfig = await promptForMissingConfig(configFromFile.get(), cliOptions);
+        const configFromFile = await ParsemeConfig.fromFile(options.config, {
+            showWarnings: true,
+            throwOnNotFound: true,
+        });
+        const interactiveConfig = await promptForMissingConfig(configFromFile.get());
         // Merge: CLI options > interactive prompts > config file > defaults
         const finalConfig = {
             ...interactiveConfig,
@@ -55,19 +46,12 @@ program
         const generator = new ParsemeGenerator(config.get());
         await generator.generateToFile();
         console.log('Context generated successfully');
-        console.log('Tip: Add parseme as a git hook to keep context auto-updated! See README for setup instructions.');
-        const shouldShowReadmeSuggestion = finalConfig.readmeSuggestion !== false;
-        if (shouldShowReadmeSuggestion) {
-            console.log('Tip: Add this section to your README.md to help AI agents find the context:');
-            console.log('');
-            console.log('## For AI Assistants');
-            console.log('This project includes AI-optimized documentation:');
-            console.log('- `PARSEME.md` - Main project context and overview');
-            console.log('- `parseme-context/` - Detailed JSON files with code structure, dependencies, and git info');
-            console.log('');
-        }
     }
     catch (error) {
+        if (error instanceof Error && error.message.includes('No configuration file found')) {
+            console.error(error.message);
+            process.exit(1);
+        }
         console.error('Failed to generate context:', error);
         process.exit(1);
     }
@@ -76,7 +60,7 @@ program
     .command('init')
     .description('Initialize parseme configuration')
     .option('-f, --force', 'Overwrite existing config')
-    .option('--format <format>', 'Config format: js, ts, or json', 'js')
+    .option('--format <format>', 'Config format: json, ts, or js', 'json')
     .action(async (options) => {
     try {
         // Validate format
@@ -85,7 +69,6 @@ program
             process.exit(1);
         }
         const configPath = join(process.cwd(), `parseme.config.${options.format}`);
-        const config = new ParsemeConfig();
         // Check if config already exists
         if (!options.force) {
             try {
@@ -98,12 +81,44 @@ program
                 // File doesn't exist, continue
             }
         }
+        // Build config with only user-specified values
+        const userConfig = {};
+        // Only prompt if interactive (TTY) and not in CI
+        if (process.stdin.isTTY && !process.env.CI) {
+            // Ask about context directory path
+            // Set context directory to what user entered (or default if they pressed enter)
+            userConfig.contextDir = await prompt({
+                message: 'Context directory path',
+                defaultValue: 'parseme-context',
+            });
+            // Ask about exclude patterns
+            const defaultExcludePatterns = ['node_modules/**', 'dist/**', '.git/**'];
+            const excludePatternsAnswer = await prompt({
+                message: 'Exclude patterns (comma-separated glob patterns, patterns from .gitignore will be ignored by default as well)',
+                defaultValue: defaultExcludePatterns.join(', '),
+            });
+            // Always set exclude patterns to what user entered (or defaults if they pressed enter)
+            userConfig.excludePatterns = excludePatternsAnswer
+                .split(',')
+                .map((p) => p.trim())
+                .filter((p) => p.length > 0);
+        }
+        const config = new ParsemeConfig(userConfig);
         await config.save(configPath);
         console.log(`Configuration file created at ${configPath}`);
         if (options.format === 'ts') {
             console.log('For TypeScript configs, ensure tsx or ts-node is available to load .ts files');
         }
-        console.log('Add "parseme": "parseme" to your package.json scripts');
+        console.log('Tip: Add "parseme": "parseme" to your package.json scripts for easier manual execution or hook integration');
+        console.log('Tip: Add parseme as a git hook to keep context auto-updated! See README for setup instructions.');
+        console.log('');
+        console.log('Tip: Add this section to your README.md to help AI agents find the context:');
+        console.log('');
+        console.log('## Instructions For AI Agents');
+        console.log('This project includes AI-optimized documentation for efficient context providing:');
+        console.log('- `PARSEME.md` - Project overview with links to detailed context files');
+        console.log('- `parseme-context/` - Structured data files (AST analysis, dependencies, routes, git info)');
+        console.log('');
     }
     catch (error) {
         console.error('Failed to create configuration:', error);
@@ -115,27 +130,22 @@ if (process.argv.length <= 2) {
     // Run the default action
     (async () => {
         try {
-            const configFromFile = await ParsemeConfig.fromFile();
-            const interactiveConfig = await promptForMissingConfig(configFromFile.get(), {});
+            const configFromFile = await ParsemeConfig.fromFile(undefined, {
+                showWarnings: true,
+                throwOnNotFound: true,
+            });
+            const interactiveConfig = await promptForMissingConfig(configFromFile.get());
             const config = new ParsemeConfig(interactiveConfig);
             const generator = new ParsemeGenerator(config.get());
             await generator.generateToFile();
             console.log('Context generated successfully');
-            console.log('Tip: Add parseme as a git hook to keep context auto-updated! See README for setup instructions.');
-            const shouldShowReadmeSuggestion = interactiveConfig.readmeSuggestion !== false;
-            if (shouldShowReadmeSuggestion) {
-                console.log('Tip: Add this section to your README.md to help AI agents find the context:');
-                console.log('');
-                console.log('## For AI Assistants');
-                console.log('This project includes AI-optimized documentation:');
-                console.log('- `PARSEME.md` - Main project context and overview');
-                console.log('- `parseme-context/` - Detailed JSON files with code structure, dependencies, and git info');
-                console.log('');
-            }
         }
         catch (error) {
+            if (error instanceof Error && error.message.includes('No configuration file found')) {
+                console.error(error.message);
+                process.exit(1);
+            }
             console.error('Failed to generate context:', error);
-            console.log('Run "parseme init" to create a configuration file');
             process.exit(1);
         }
     })();

package/dist/{prompt.d.ts → cli/prompt.d.ts}

@@ -4,5 +4,4 @@ interface PromptOptions {
     choices?: string[];
 }
 export declare function prompt(options: PromptOptions): Promise<string>;
-export declare function confirmPrompt(message: string, defaultValue?: boolean): Promise<boolean>;
 export {};

package/dist/{prompt.js → cli/prompt.js}

@@ -31,12 +31,3 @@ export async function prompt(options) {
         });
     });
 }
-export async function confirmPrompt(message, defaultValue = true) {
-    const answer = await prompt({
-        message,
-        defaultValue: defaultValue ? 'y' : 'n',
-        choices: ['y', 'n', 'yes', 'no'],
-    });
-    const normalized = answer.toLowerCase();
-    return normalized === 'y' || normalized === 'yes';
-}

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

@@ -15,11 +15,12 @@ export class ASTAnalyzer {
         this.ig = ignore();
         const configData = this.config.get();
         this.ig.add(configData.excludePatterns || []);
-        this.patternDetector = new PatternDetector(config);
+        this.patternDetector = new PatternDetector();
     }
     async analyzeProject(rootDir) {
         const configData = this.config.get();
-        const patterns = configData.includePatterns || ['**/*.ts', '**/*.js'];
+        const fileTypes = configData.analyzeFileTypes || ['ts', 'tsx', 'js', 'jsx'];
+        const patterns = fileTypes.map((type) => `**/*.${type}`);
         const files = await glob(patterns, {
             cwd: rootDir,
             absolute: true,
@@ -58,7 +59,7 @@ export class ASTAnalyzer {
             const patterns = this.patternDetector.analyzePatterns(ast, relativePath, content);
             const analysis = {
                 path: relativePath,
-                type: this.determineFileType(relativePath, content, patterns),
+                type: this.determineFileType(relativePath, patterns),
                 exports: [],
                 imports: [],
                 functions: [],
@@ -116,8 +117,8 @@ export class ASTAnalyzer {
             });
             return analysis;
         }
-        catch (error) {
-            console.warn(`Failed to parse ${relativePath}:`, error);
+        catch {
+            console.warn(`Failed to parse ${relativePath}`);
             return null;
         }
     }
@@ -144,7 +145,7 @@ export class ASTAnalyzer {
             ],
         });
     }
-    determineFileType(relativePath, content, patterns) {
+    determineFileType(relativePath, patterns) {
         // Use pattern analysis to determine file type dynamically
         if (patterns.endpoints.length > 0) {
             return 'route';

package/dist/{analyzers → core/analyzers}/framework-detector.d.ts

@@ -1,8 +1,5 @@
-import type { ParsemeConfig } from '../config.js';
 import type { ProjectInfo, FrameworkInfo } from '../types.js';
 export declare class FrameworkDetector {
-    private readonly config;
-    constructor(config: ParsemeConfig);
     detect(projectInfo: ProjectInfo): Promise<FrameworkInfo>;
     private detectExpress;
     private detectFastify;

package/dist/{analyzers → core/analyzers}/framework-detector.js

@@ -1,8 +1,4 @@
 export class FrameworkDetector {
-    config;
-    constructor(config) {
-        this.config = config;
-    }
     async detect(projectInfo) {
         const deps = { ...projectInfo.dependencies, ...projectInfo.devDependencies };
         // Check for frameworks in dependencies

package/dist/{analyzers → core/analyzers}/git-analyzer.d.ts

@@ -1,8 +1,5 @@
-import type { ParsemeConfig } from '../config.js';
 import type { GitInfo } from '../types.js';
 export declare class GitAnalyzer {
-    private readonly config;
-    constructor(config: ParsemeConfig);
     analyze(rootDir: string): Promise<GitInfo | null>;
     private getCurrentBranch;
     private getLastCommit;

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

@@ -2,10 +2,6 @@ import { exec } from 'child_process';
 import { promisify } from 'util';
 const execAsync = promisify(exec);
 export class GitAnalyzer {
-    config;
-    constructor(config) {
-        this.config = config;
-    }
     async analyze(rootDir) {
         try {
             // Check if this is a git repository

package/dist/{analyzers → core/analyzers}/pattern-detector.d.ts

@@ -1,5 +1,4 @@
 import * as t from '@babel/types';
-import type { ParsemeConfig } from '../config.js';
 import type { ComponentInfo, RouteInfo } from '../types.js';
 export interface PatternAnalysis {
     endpoints: EndpointInfo[];
@@ -51,8 +50,6 @@ export interface UtilityInfo {
     type: 'helper' | 'lib' | 'hook' | 'composable';
 }
 export declare class PatternDetector {
-    private readonly config;
-    constructor(config: ParsemeConfig);
     analyzePatterns(ast: t.File, filePath: string, _content: string): PatternAnalysis;
     private hasJSXReturn;
 }

package/dist/{analyzers → core/analyzers}/pattern-detector.js

@@ -1,10 +1,6 @@
 import traverse from '@babel/traverse';
 import * as t from '@babel/types';
 export class PatternDetector {
-    config;
-    constructor(config) {
-        this.config = config;
-    }
     analyzePatterns(ast, filePath, _content) {
         const analysis = {
             endpoints: [],
@@ -17,25 +13,6 @@ export class PatternDetector {
         };
         // Use a single traverse call to detect all patterns
         traverse.default(ast, {
-            // Detect Express-style routes: app.get(), router.post(), etc.
-            CallExpression: (path) => {
-                if (t.isMemberExpression(path.node.callee) && t.isIdentifier(path.node.callee.property)) {
-                    const methodName = path.node.callee.property.name;
-                    const httpMethods = ['get', 'post', 'put', 'delete', 'patch', 'options', 'head', 'all'];
-                    if (httpMethods.includes(methodName)) {
-                        const routeArg = path.node.arguments[0];
-                        const routePath = t.isStringLiteral(routeArg) ? routeArg.value : '/';
-                        analysis.endpoints.push({
-                            method: methodName.toUpperCase(),
-                            path: routePath,
-                            handler: 'callback',
-                            file: filePath,
-                            line: path.node.loc?.start.line || 0,
-                            type: 'rest',
-                        });
-                    }
-                }
-            },
             // Detect decorator-based routes: @Get(), @Post(), etc.
             ClassMethod: (path) => {
                 const decorators = path.node.decorators;
@@ -63,6 +40,58 @@ export class PatternDetector {
                     });
                 }
             },
+            // Detect Express/Router-style routes: app.get(), router.post(), etc.
+            CallExpression: (path) => {
+                const { callee, arguments: args } = path.node;
+                if (t.isMemberExpression(callee) && t.isIdentifier(callee.property)) {
+                    const httpMethods = ['get', 'post', 'put', 'delete', 'patch', 'options', 'head'];
+                    const methodName = callee.property.name;
+                    if (httpMethods.includes(methodName) && args.length >= 2) {
+                        const routePath = args[0];
+                        if (t.isStringLiteral(routePath)) {
+                            analysis.endpoints.push({
+                                method: methodName.toUpperCase(),
+                                path: routePath.value,
+                                handler: 'anonymous',
+                                file: filePath,
+                                line: path.node.loc?.start.line || 0,
+                                type: 'rest',
+                                framework: 'express',
+                            });
+                        }
+                    }
+                }
+            },
+            // Detect TypeScript interfaces and type aliases
+            TSInterfaceDeclaration: (path) => {
+                const interfaceName = path.node.id.name;
+                const fields = path.node.body.body
+                    .filter((member) => t.isTSPropertySignature(member))
+                    .map((member) => {
+                    if (t.isIdentifier(member.key)) {
+                        return member.key.name;
+                    }
+                    return '';
+                })
+                    .filter((name) => name !== '');
+                analysis.models.push({
+                    name: interfaceName,
+                    file: filePath,
+                    line: path.node.loc?.start.line || 0,
+                    fields,
+                    type: 'interface',
+                });
+            },
+            TSTypeAliasDeclaration: (path) => {
+                const typeName = path.node.id.name;
+                analysis.models.push({
+                    name: typeName,
+                    file: filePath,
+                    line: path.node.loc?.start.line || 0,
+                    fields: [],
+                    type: 'type',
+                });
+            },
             // Detect React components
             FunctionDeclaration: (path) => {
                 const functionName = path.node.id?.name;
@@ -141,30 +170,6 @@ export class PatternDetector {
                     });
                 }
             },
-            // Detect TypeScript interfaces
-            TSInterfaceDeclaration: (path) => {
-                const interfaceName = path.node.id.name;
-                const fields = path.node.body.body
-                    .filter((member) => t.isTSPropertySignature(member) && t.isIdentifier(member.key))
-                    .map((member) => member.key.name);
-                analysis.models.push({
-                    name: interfaceName,
-                    file: filePath,
-                    line: path.node.loc?.start.line || 0,
-                    fields,
-                    type: 'interface',
-                });
-            },
-            // Detect type aliases
-            TSTypeAliasDeclaration: (path) => {
-                analysis.models.push({
-                    name: path.node.id.name,
-                    file: filePath,
-                    line: path.node.loc?.start.line || 0,
-                    fields: [],
-                    type: 'type',
-                });
-            },
         });
         return analysis;
     }

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

@@ -2,6 +2,7 @@ import type { ParsemeConfig } from '../config.js';
 import type { ProjectInfo } from '../types.js';
 export declare class ProjectAnalyzer {
     private readonly config;
+    private readonly ig;
     constructor(config: ParsemeConfig);
     analyze(rootDir: string): Promise<ProjectInfo>;
     private detectProjectType;
@@ -11,4 +12,5 @@ export declare class ProjectAnalyzer {
     private detectEntryPoints;
     private detectOutputTargets;
     private hasAppDependencies;
+    getAllProjectFiles(rootDir: string): Promise<string[]>;
 }

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

@@ -1,9 +1,14 @@
 import { readFile, access, readdir, stat } from 'fs/promises';
-import { join, basename } from 'path';
+import { join, basename, relative } from 'path';
+import ignore from 'ignore';
 export class ProjectAnalyzer {
     config;
+    ig;
     constructor(config) {
         this.config = config;
+        this.ig = ignore();
+        const configData = this.config.get();
+        this.ig.add(configData.excludePatterns || []);
     }
     async analyze(rootDir) {
         const packageJsonPath = join(rootDir, 'package.json');
@@ -30,7 +35,7 @@ export class ProjectAnalyzer {
                 name: basename(rootDir),
                 type: await this.detectProjectType(rootDir),
                 category: 'unknown',
-                packageManager: 'npm',
+                packageManager: 'unknown',
                 dependencies: {},
                 devDependencies: {},
                 scripts: {},
@@ -41,7 +46,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 +79,7 @@ export class ProjectAnalyzer {
         }
         return 'npm';
     }
-    async getFilesRecursive(dir, maxDepth) {
+    async getFilesRecursive(dir, rootDir, maxDepth) {
         if (maxDepth <= 0) {
             return [];
         }
@@ -83,12 +88,17 @@ export class ProjectAnalyzer {
             const files = [];
             for (const entry of entries) {
                 const fullPath = join(dir, entry);
+                const relativePath = relative(rootDir, fullPath);
+                // Skip if ignored by exclude patterns
+                if (this.ig.ignores(relativePath)) {
+                    continue;
+                }
                 const stats = await stat(fullPath);
                 if (stats.isFile()) {
                     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;
@@ -202,4 +212,8 @@ export class ProjectAnalyzer {
         ];
         return appIndicators.some((indicator) => deps[indicator]);
     }
+    async getAllProjectFiles(rootDir) {
+        const allFiles = await this.getFilesRecursive(rootDir, rootDir, Infinity);
+        return allFiles.map((file) => relative(rootDir, file));
+    }
 }

package/dist/core/config.d.ts

@@ -0,0 +1,20 @@
+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;
+    private readGitignorePatterns;
+}