@parseme/cli 0.0.4 → 0.0.5

package/dist/core/analyzers/framework-detector.js

@@ -1,175 +1,164 @@
 export class FrameworkDetector {
-    async detect(projectInfo) {
-        const deps = { ...projectInfo.dependencies, ...projectInfo.devDependencies };
-        // Check for frameworks in dependencies
-        if (deps['@nestjs/core'] || deps['@nestjs/common']) {
-            return this.detectNestJS(deps);
-        }
-        if (deps['fastify']) {
-            return this.detectFastify(deps);
-        }
-        if (deps['express']) {
-            return this.detectExpress(deps);
-        }
-        if (deps['koa']) {
-            return this.detectKoa(deps);
-        }
-        if (deps['@hapi/hapi']) {
-            return this.detectHapi(deps);
-        }
-        return {
-            name: 'unknown',
-            features: [],
-        };
-    }
-    detectExpress(deps) {
-        const features = [];
-        // Detect common Express features
-        if (deps['express-session']) {
-            features.push('sessions');
-        }
-        if (deps['passport']) {
-            features.push('authentication');
-        }
-        if (deps['express-rate-limit']) {
-            features.push('rate-limiting');
-        }
-        if (deps['helmet']) {
-            features.push('security');
-        }
-        if (deps['cors']) {
-            features.push('cors');
-        }
-        if (deps['body-parser']) {
-            features.push('body-parsing');
-        }
-        if (deps['express-validator']) {
-            features.push('validation');
-        }
-        if (deps['multer']) {
-            features.push('file-upload');
-        }
-        if (deps['express-static']) {
-            features.push('static-files');
-        }
-        return {
-            name: 'express',
-            version: deps['express'],
-            features,
-        };
-    }
-    detectFastify(deps) {
-        const features = [];
-        if (deps['@fastify/cors']) {
-            features.push('cors');
-        }
-        if (deps['@fastify/helmet']) {
-            features.push('security');
-        }
-        if (deps['@fastify/rate-limit']) {
-            features.push('rate-limiting');
-        }
-        if (deps['@fastify/multipart']) {
-            features.push('file-upload');
-        }
-        if (deps['@fastify/static']) {
-            features.push('static-files');
-        }
-        if (deps['@fastify/jwt']) {
-            features.push('jwt');
-        }
-        if (deps['@fastify/session']) {
-            features.push('sessions');
-        }
-        return {
-            name: 'fastify',
-            version: deps['fastify'],
-            features,
-        };
-    }
-    detectNestJS(deps) {
-        const features = [];
-        if (deps['@nestjs/typeorm'] || deps['@nestjs/mongoose']) {
-            features.push('orm');
-        }
-        if (deps['@nestjs/passport']) {
-            features.push('authentication');
-        }
-        if (deps['@nestjs/jwt']) {
-            features.push('jwt');
-        }
-        if (deps['@nestjs/swagger']) {
-            features.push('swagger');
-        }
-        if (deps['@nestjs/graphql']) {
-            features.push('graphql');
-        }
-        if (deps['@nestjs/websockets']) {
-            features.push('websockets');
-        }
-        if (deps['@nestjs/microservices']) {
-            features.push('microservices');
-        }
-        if (deps['@nestjs/testing']) {
-            features.push('testing');
-        }
-        // NestJS uses decorators by default
-        features.push('decorators', 'dependency-injection', 'modules');
-        return {
+    frameworks = [
+        // Backend frameworks
+        {
             name: 'nestjs',
-            version: deps['@nestjs/core'],
-            features,
-        };
+            detectionKeys: ['@nestjs/core', '@nestjs/common'],
+            versionKey: '@nestjs/core',
+            builtInFeatures: ['decorators', 'dependency-injection', 'modules'],
+            featureMap: {
+                '@nestjs/typeorm': 'orm',
+                '@nestjs/mongoose': 'orm',
+                '@nestjs/passport': 'authentication',
+                '@nestjs/jwt': 'jwt',
+                '@nestjs/swagger': 'swagger',
+                '@nestjs/graphql': 'graphql',
+                '@nestjs/websockets': 'websockets',
+                '@nestjs/microservices': 'microservices',
+                '@nestjs/testing': 'testing',
+            },
+        },
+        {
+            name: 'fastify',
+            detectionKeys: ['fastify'],
+            versionKey: 'fastify',
+            featureMap: {
+                '@fastify/cors': 'cors',
+                '@fastify/helmet': 'security',
+                '@fastify/rate-limit': 'rate-limiting',
+                '@fastify/multipart': 'file-upload',
+                '@fastify/static': 'static-files',
+                '@fastify/jwt': 'jwt',
+                '@fastify/session': 'sessions',
+            },
+        },
+        {
+            name: 'express',
+            detectionKeys: ['express'],
+            versionKey: 'express',
+            featureMap: {
+                'express-session': 'sessions',
+                passport: 'authentication',
+                'express-rate-limit': 'rate-limiting',
+                helmet: 'security',
+                cors: 'cors',
+                'body-parser': 'body-parsing',
+                'express-validator': 'validation',
+                multer: 'file-upload',
+                'express-static': 'static-files',
+            },
+        },
+        // Fullstack frameworks
+        {
+            name: 'next.js',
+            detectionKeys: ['next'],
+            versionKey: 'next',
+            builtInFeatures: ['ssr', 'routing', 'api-routes', 'file-based-routing'],
+            featureMap: {
+                'next-auth': 'authentication',
+                '@vercel/analytics': 'analytics',
+            },
+        },
+        {
+            name: 'nuxt.js',
+            detectionKeys: ['nuxt'],
+            versionKey: 'nuxt',
+            builtInFeatures: ['ssr', 'routing', 'api-routes', 'file-based-routing', 'auto-imports'],
+            featureMap: {
+                '@nuxt/content': 'content-management',
+                '@nuxtjs/auth': 'authentication',
+                '@nuxtjs/auth-next': 'authentication',
+                '@pinia/nuxt': 'state-management-pinia',
+                '@nuxt/image': 'image-optimization',
+                '@nuxtjs/tailwindcss': 'tailwind',
+            },
+        },
+        // Frontend frameworks
+        {
+            name: 'react',
+            detectionKeys: ['react', 'react-dom'],
+            versionKey: 'react',
+            featureMap: {
+                'react-router': 'routing',
+                'react-router-dom': 'routing',
+                redux: 'state-management-redux',
+                '@reduxjs/toolkit': 'state-management-redux',
+                zustand: 'state-management-zustand',
+                'react-query': 'data-fetching',
+                '@tanstack/react-query': 'data-fetching',
+                '@testing-library/react': 'testing',
+            },
+        },
+        {
+            name: 'vue',
+            detectionKeys: (deps) => !!deps['vue'] || Object.keys(deps).some((dep) => dep.startsWith('@vue/')),
+            versionKey: 'vue',
+            featureMap: {
+                'vue-router': 'routing',
+                pinia: 'state-management-pinia',
+                vuex: 'state-management-vuex',
+                '@vue/test-utils': 'testing',
+            },
+        },
+        {
+            name: 'angular',
+            detectionKeys: ['@angular/core'],
+            versionKey: '@angular/core',
+            builtInFeatures: ['decorators', 'dependency-injection', 'typescript'],
+            featureMap: {
+                '@angular/router': 'routing',
+                '@angular/forms': 'forms',
+                '@angular/common/http': 'http-client',
+                '@angular/common': 'http-client',
+                '@ngrx/store': 'state-management-ngrx',
+                '@angular/material': 'material-design',
+                '@angular/animations': 'animations',
+            },
+        },
+        {
+            name: 'svelte',
+            detectionKeys: (deps) => !!deps['svelte'] || Object.keys(deps).some((dep) => dep.startsWith('@sveltejs/')),
+            versionKey: 'svelte',
+            featureMap: {
+                '@sveltejs/kit': 'sveltekit',
+                '@sveltejs/adapter-auto': 'sveltekit',
+                'svelte-routing': 'routing',
+                '@testing-library/svelte': 'testing',
+            },
+        },
+    ];
+    async detect(projectInfo) {
+        // Only check dependencies (not devDependencies) for framework detection
+        // This prevents false positives from libraries that have frameworks in devDependencies for testing
+        const deps = projectInfo.dependencies || {};
+        const detectedFrameworks = [];
+        for (const config of this.frameworks) {
+            if (this.shouldDetect(config, deps)) {
+                detectedFrameworks.push(this.buildFrameworkInfo(config, deps));
+            }
+        }
+        return detectedFrameworks;
     }
-    detectKoa(deps) {
-        const features = [];
-        if (deps['@koa/cors']) {
-            features.push('cors');
-        }
-        if (deps['koa-helmet']) {
-            features.push('security');
-        }
-        if (deps['koa-ratelimit']) {
-            features.push('rate-limiting');
-        }
-        if (deps['koa-multer']) {
-            features.push('file-upload');
-        }
-        if (deps['koa-static']) {
-            features.push('static-files');
-        }
-        if (deps['koa-session']) {
-            features.push('sessions');
-        }
-        if (deps['koa-bodyparser']) {
-            features.push('body-parsing');
+    shouldDetect(config, deps) {
+        if (typeof config.detectionKeys === 'function') {
+            return config.detectionKeys(deps);
         }
-        return {
-            name: 'koa',
-            version: deps['koa'],
-            features,
-        };
+        return config.detectionKeys.some((key) => deps[key]);
     }
-    detectHapi(deps) {
-        const features = [];
-        if (deps['@hapi/cookie']) {
-            features.push('sessions');
-        }
-        if (deps['@hapi/jwt']) {
-            features.push('jwt');
-        }
-        if (deps['@hapi/inert']) {
-            features.push('static-files');
-        }
-        if (deps['@hapi/vision']) {
-            features.push('templates');
-        }
-        if (deps['@hapi/boom']) {
-            features.push('error-handling');
+    buildFrameworkInfo(config, deps) {
+        const features = [...(config.builtInFeatures || [])];
+        // Detect features based on feature map
+        for (const [depKey, feature] of Object.entries(config.featureMap)) {
+            if (deps[depKey]) {
+                // Avoid duplicates
+                if (!features.includes(feature)) {
+                    features.push(feature);
+                }
+            }
         }
         return {
-            name: 'hapi',
-            version: deps['@hapi/hapi'],
+            name: config.name,
+            version: deps[config.versionKey],
             features,
         };
     }

package/dist/core/analyzers/pattern-detector.d.ts

@@ -10,8 +10,6 @@ export interface PatternAnalysis {
     utilities: UtilityInfo[];
 }
 export interface EndpointInfo extends RouteInfo {
-    type: 'rest' | 'graphql' | 'websocket' | 'rpc' | 'unknown';
-    framework?: string;
     decorator?: string;
 }
 export interface ServiceInfo {
@@ -52,4 +50,6 @@ export interface UtilityInfo {
 export declare class PatternDetector {
     analyzePatterns(ast: t.File, filePath: string, _content: string): PatternAnalysis;
     private hasJSXReturn;
+    private extractNextJSRoutePath;
+    private extractNuxtRoutePath;
 }

package/dist/core/analyzers/pattern-detector.js

@@ -11,7 +11,7 @@ export class PatternDetector {
             middleware: [],
             utilities: [],
         };
-        // Use a single traverse call to detect all patterns
+        // Analyze patterns in the AST
         traverse.default(ast, {
             // Detect decorator-based routes: @Get(), @Post(), etc.
             ClassMethod: (path) => {
@@ -31,7 +31,6 @@ export class PatternDetector {
                                         handler: t.isIdentifier(path.node.key) ? path.node.key.name : 'anonymous',
                                         file: filePath,
                                         line: path.node.loc?.start.line || 0,
-                                        type: 'rest',
                                         decorator: callee.name,
                                     });
                                 }
@@ -40,7 +39,7 @@ export class PatternDetector {
                     });
                 }
             },
-            // Detect Express/Router-style routes: app.get(), router.post(), etc.
+            // Detect Express/Fastify-style routes: app.get(), router.post(), fastify.get(), etc.
             CallExpression: (path) => {
                 const { callee, arguments: args } = path.node;
                 if (t.isMemberExpression(callee) && t.isIdentifier(callee.property)) {
@@ -48,19 +47,47 @@ export class PatternDetector {
                     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',
-                            });
+                        // Only detect if:
+                        // 1. First argument is a string literal (route path)
+                        // 2. Object is a known route handler name
+                        if (t.isStringLiteral(routePath) && t.isIdentifier(callee.object)) {
+                            const objectName = callee.object.name;
+                            const routeObjectNames = [
+                                'app',
+                                'router',
+                                'server',
+                                'fastify',
+                                'express',
+                                'route',
+                                'api',
+                            ];
+                            // Only detect if it's a common route object name
+                            // This filters out axios.get(), client.get(), etc.
+                            if (routeObjectNames.includes(objectName.toLowerCase())) {
+                                analysis.endpoints.push({
+                                    method: methodName.toUpperCase(),
+                                    path: routePath.value,
+                                    handler: 'anonymous',
+                                    file: filePath,
+                                    line: path.node.loc?.start.line || 0,
+                                });
+                            }
                         }
                     }
                 }
+                // Detect Nuxt.js server routes: defineEventHandler()
+                if (t.isIdentifier(callee) && callee.name === 'defineEventHandler') {
+                    // Extract route path from file path
+                    // Nuxt server routes are in server/api/ or server/routes/
+                    const routePath = this.extractNuxtRoutePath(filePath);
+                    analysis.endpoints.push({
+                        method: 'GET/POST',
+                        path: routePath,
+                        handler: 'defineEventHandler',
+                        file: filePath,
+                        line: path.node.loc?.start.line || 0,
+                    });
+                }
             },
             // Detect TypeScript interfaces and type aliases
             TSInterfaceDeclaration: (path) => {
@@ -92,6 +119,27 @@ export class PatternDetector {
                     type: 'type',
                 });
             },
+            // Detect Next.js API route handlers: export function GET/POST/etc.
+            ExportNamedDeclaration: (path) => {
+                const declaration = path.node.declaration;
+                if (t.isFunctionDeclaration(declaration) && declaration.id) {
+                    const functionName = declaration.id.name;
+                    const httpMethods = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'OPTIONS', 'HEAD'];
+                    // Only detect if it's an HTTP method name and in an api directory
+                    if (httpMethods.includes(functionName) && /\/api\//.test(filePath)) {
+                        // Extract route path from file path
+                        // Next.js API routes are in app/api/ or pages/api/
+                        const routePath = this.extractNextJSRoutePath(filePath);
+                        analysis.endpoints.push({
+                            method: functionName,
+                            path: routePath,
+                            handler: functionName,
+                            file: filePath,
+                            line: declaration.loc?.start.line || 0,
+                        });
+                    }
+                }
+            },
             // Detect React components
             FunctionDeclaration: (path) => {
                 const functionName = path.node.id?.name;
@@ -176,4 +224,36 @@ export class PatternDetector {
     hasJSXReturn(body) {
         return body.body.some((stmt) => t.isReturnStatement(stmt) && stmt.argument && t.isJSXElement(stmt.argument));
     }
+    extractNextJSRoutePath(filePath) {
+        // Next.js API routes can be in:
+        // - app/api/[route]/route.ts (App Router)
+        // - pages/api/[route].ts (Pages Router)
+        // Try App Router pattern first
+        let match = filePath.match(/\/app\/api\/(.+)\/route\.[jt]sx?$/);
+        if (match) {
+            return `/api/${match[1]}`;
+        }
+        // Try Pages Router pattern
+        match = filePath.match(/\/pages\/api\/(.+)\.[jt]sx?$/);
+        if (match) {
+            return `/api/${match[1]}`;
+        }
+        // Fallback
+        return '/api/unknown';
+    }
+    extractNuxtRoutePath(filePath) {
+        // Nuxt.js server routes can be in:
+        // - server/api/[route].ts
+        // - server/routes/[route].ts
+        let match = filePath.match(/\/server\/api\/(.+)\.[jt]s$/);
+        if (match) {
+            return `/api/${match[1]}`;
+        }
+        match = filePath.match(/\/server\/routes\/(.+)\.[jt]s$/);
+        if (match) {
+            return `/${match[1]}`;
+        }
+        // Fallback
+        return '/api/unknown';
+    }
 }

package/dist/core/analyzers/project-analyzer.d.ts

@@ -2,7 +2,7 @@ import type { ParsemeConfig } from '../config.js';
 import type { ProjectInfo } from '../types.js';
 export declare class ProjectAnalyzer {
     private readonly config;
-    private readonly ig;
+    private readonly fileCollector;
     constructor(config: ParsemeConfig);
     analyze(rootDir: string): Promise<ProjectInfo>;
     private detectProjectType;

package/dist/core/analyzers/project-analyzer.js

@@ -1,14 +1,12 @@
 import { readFile, access, readdir, stat } from 'fs/promises';
-import { join, basename, relative } from 'path';
-import ignore from 'ignore';
+import { join, basename } from 'path';
+import { FileCollector } from '../../utils/file-collector.js';
 export class ProjectAnalyzer {
     config;
-    ig;
+    fileCollector;
     constructor(config) {
         this.config = config;
-        this.ig = ignore();
-        const configData = this.config.get();
-        this.ig.add(configData.excludePatterns || []);
+        this.fileCollector = new FileCollector(config);
     }
     async analyze(rootDir) {
         const packageJsonPath = join(rootDir, 'package.json');
@@ -88,11 +86,6 @@ 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);
@@ -142,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)
@@ -213,7 +202,7 @@ 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));
+        const result = await this.fileCollector.getAllProjectFiles(rootDir);
+        return result.files;
     }
 }

package/dist/core/config.d.ts

@@ -16,5 +16,4 @@ export declare class ParsemeConfig {
     private generateJSConfig;
     private generateTSConfig;
     private mergeExcludePatterns;
-    private readGitignorePatterns;
 }

package/dist/core/config.js

@@ -1,4 +1,4 @@
-import { readFileSync, existsSync } from 'fs';
+import { existsSync } from 'fs';
 import { readFile, writeFile } from 'fs/promises';
 import { join, extname } from 'path';
 export class ParsemeConfig {
@@ -123,6 +123,7 @@ export class ParsemeConfig {
             analyzeFileTypes: fileTypes,
             // Git
             includeGitInfo: config.includeGitInfo ?? true,
+            useGitForFiles: config.useGitForFiles ?? true,
             // Sections
             sections: {
                 overview: true,
@@ -143,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,
             },
         };
     }
@@ -187,30 +185,8 @@ const config: ParsemeConfigFile = ${JSON.stringify(this.userConfig, null, 2)};
 export default config;
 `;
     }
-    mergeExcludePatterns(configPatterns, rootDir) {
-        // Always read .gitignore patterns
-        const gitignorePatterns = this.readGitignorePatterns(rootDir);
-        // Merge gitignore patterns with config patterns, they are added to gitignore patterns, not replacing them
-        const excludePatterns = [...gitignorePatterns];
-        if (configPatterns) {
-            excludePatterns.push(...configPatterns);
-        }
-        return excludePatterns;
-    }
-    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('#'));
-        }
-        catch {
-            return [];
-        }
+    mergeExcludePatterns(configPatterns, _rootDir) {
+        // Only use config patterns - git ignore is now handled by FileFilterService
+        return configPatterns || [];
     }
 }

package/dist/core/context-builder.d.ts

@@ -12,13 +12,11 @@ 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 formatFrameworksList;
     private buildGitSection;
     private buildSummarySection;
     private buildFilesList;