@parseme/cli 0.0.3 → 0.0.5

package/dist/cli/cli.js

@@ -0,0 +1,144 @@
+#!/usr/bin/env node
+import { join } from 'path';
+import { Command } from 'commander';
+import { ParsemeConfig } from '../core/config.js';
+import { ParsemeGenerator } from '../core/generator.js';
+import { prompt } from '../utils/prompt.js';
+const program = new Command();
+async function promptForMissingConfig(config) {
+    return { ...config };
+}
+program.name('parseme').description('AI Project Context Generator').version('0.1.0');
+// Generate command
+program
+    .command('generate')
+    .alias('g')
+    .description('Generate project context using config file')
+    .option('-c, --config <path>', 'Config file path')
+    .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('--file-types <types...>', 'File types to analyze (e.g., ts tsx js jsx)')
+    .option('--exclude <patterns...>', 'Exclude patterns (glob)')
+    .option('--no-git', 'Disable git integration (info and file discovery)')
+    .option('--max-depth <number>', 'Maximum directory depth', parseInt)
+    .action(async (options) => {
+    try {
+        // Convert CLI options to config format
+        const cliOptions = {
+            ...(options.output && { outputPath: options.output }),
+            ...(options.root && { rootDir: options.root }),
+            ...(options.contextDir && { contextDir: options.contextDir }),
+            ...(options.fileTypes && { analyzeFileTypes: options.fileTypes }),
+            ...(options.exclude && { excludePatterns: options.exclude }),
+            ...(options.git === false && { includeGitInfo: false, useGitForFiles: false }),
+            ...(options.maxDepth && { maxDepth: options.maxDepth }),
+        };
+        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,
+            ...cliOptions,
+        };
+        const config = new ParsemeConfig(finalConfig);
+        const generator = new ParsemeGenerator(config.get());
+        await generator.generateToFile();
+        console.log('Context generated successfully');
+    }
+    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);
+    }
+});
+// Init command
+program
+    .command('init')
+    .alias('i')
+    .description('Initialize parseme configuration')
+    .option('-f, --force', 'Overwrite existing config')
+    .option('--format <format>', 'Config format: json, ts, or js', 'json')
+    .action(async (options) => {
+    try {
+        // Validate format
+        if (!['js', 'ts', 'json'].includes(options.format)) {
+            console.error('Invalid format. Use js, ts, or json');
+            process.exit(1);
+        }
+        const configPath = join(process.cwd(), `parseme.config.${options.format}`);
+        // Check if config already exists
+        if (!options.force) {
+            try {
+                const fs = await import('fs/promises');
+                await fs.access(configPath);
+                console.log('Configuration file already exists. Use --force to overwrite.');
+                process.exit(1);
+            }
+            catch {
+                // File doesn't exist, continue
+            }
+        }
+        // Build config with only user-specified values
+        const userConfig = {};
+        // Set defaults that would normally be prompted for
+        const defaultExcludePatterns = ['node_modules/**', 'dist/**', '.git/**'];
+        userConfig.contextDir = 'parseme-context';
+        userConfig.excludePatterns = defaultExcludePatterns;
+        // 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 excludePatternsAnswer = await prompt({
+                message: 'Exclude patterns (comma-separated glob patterns - in git repositories, additional to git-tracked files)',
+                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('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);
+        process.exit(1);
+    }
+});
+// If no command provided, show error and available commands
+if (process.argv.length <= 2) {
+    console.error('No command specified.\n');
+    console.error('Available commands:');
+    console.error('  parseme generate (or parseme g) - Generate project context');
+    console.error('  parseme init (or parseme i)     - Initialize parseme configuration');
+    console.error('\nUse "parseme --help" for more information');
+    process.exit(1);
+}
+program.parse();

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

@@ -2,7 +2,7 @@ import type { ParsemeConfig } from '../config.js';
 import type { FileAnalysis } from '../types.js';
 export declare class ASTAnalyzer {
     private readonly config;
-    private readonly ig;
+    private readonly fileCollector;
     private readonly patternDetector;
     constructor(config: ParsemeConfig);
     analyzeProject(rootDir: string): Promise<FileAnalysis[]>;

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

@@ -1,45 +1,32 @@
 import { readFile } from 'fs/promises';
-import { relative, extname } from 'path';
+import { join, extname } from 'path';
 import { parse } from '@babel/parser';
 import traverse from '@babel/traverse';
 import * as t from '@babel/types';
-import { glob } from 'glob';
-import ignore from 'ignore';
 import { PatternDetector } from './pattern-detector.js';
+import { FileCollector } from '../../utils/file-collector.js';
 export class ASTAnalyzer {
     config;
-    ig;
+    fileCollector;
     patternDetector;
     constructor(config) {
         this.config = config;
-        this.ig = ignore();
-        const configData = this.config.get();
-        this.ig.add(configData.excludePatterns || []);
-        this.patternDetector = new PatternDetector(config);
+        this.fileCollector = new FileCollector(config);
+        this.patternDetector = new PatternDetector();
     }
     async analyzeProject(rootDir) {
-        const configData = this.config.get();
-        const patterns = configData.includePatterns || ['**/*.ts', '**/*.js'];
-        const files = await glob(patterns, {
-            cwd: rootDir,
-            absolute: true,
-            ignore: configData.excludePatterns,
-        });
+        const result = await this.fileCollector.getCodeFiles(rootDir);
         const analyses = [];
-        for (const file of files) {
-            const relativePath = relative(rootDir, file);
-            // Skip if ignored
-            if (this.ig.ignores(relativePath)) {
-                continue;
-            }
+        for (const file of result.files) {
+            const filePath = join(rootDir, file);
             try {
-                const analysis = await this.analyzeFile(file, relativePath);
+                const analysis = await this.analyzeFile(filePath, file);
                 if (analysis) {
                     analyses.push(analysis);
                 }
             }
             catch (error) {
-                console.warn(`Failed to analyze ${relativePath}:`, error);
+                console.warn(`Failed to analyze ${file}:`, error);
                 // Continue with other files
             }
         }
@@ -58,7 +45,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 +103,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 +131,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/core/analyzers/framework-detector.d.ts

@@ -0,0 +1,7 @@
+import type { ProjectInfo, FrameworkInfo } from '../types.js';
+export declare class FrameworkDetector {
+    private readonly frameworks;
+    detect(projectInfo: ProjectInfo): Promise<FrameworkInfo[]>;
+    private shouldDetect;
+    private buildFrameworkInfo;
+}

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

@@ -0,0 +1,165 @@
+export class FrameworkDetector {
+    frameworks = [
+        // Backend frameworks
+        {
+            name: 'nestjs',
+            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;
+    }
+    shouldDetect(config, deps) {
+        if (typeof config.detectionKeys === 'function') {
+            return config.detectionKeys(deps);
+        }
+        return config.detectionKeys.some((key) => deps[key]);
+    }
+    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: config.name,
+            version: deps[config.versionKey],
+            features,
+        };
+    }
+}

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[];
@@ -11,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 {
@@ -51,8 +48,8 @@ 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;
+    private extractNextJSRoutePath;
+    private extractNuxtRoutePath;
 }

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: [],
@@ -15,27 +11,8 @@ export class PatternDetector {
             middleware: [],
             utilities: [],
         };
-        // Use a single traverse call to detect all patterns
+        // Analyze patterns in the AST
         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;
@@ -54,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,
                                     });
                                 }
@@ -63,6 +39,107 @@ export class PatternDetector {
                     });
                 }
             },
+            // 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)) {
+                    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];
+                        // 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) => {
+                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 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;
@@ -141,34 +218,42 @@ 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;
     }
     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/{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 fileCollector;
     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[]>;
 }