@parseme/cli 0.0.3 → 0.0.5

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

@@ -2,10 +2,10 @@ import { mkdir, writeFile } from 'fs/promises';
 import { join } from 'path';
 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';
+import { GitAnalyzer } from '../utils/git.js';
 export class ParsemeGenerator {
     config;
     projectAnalyzer;
@@ -17,36 +17,31 @@ 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
         const projectInfo = await this.projectAnalyzer.analyze(configData.rootDir);
-        // Step 2: Detect framework and analyze specific patterns
-        projectInfo.framework = await this.frameworkDetector.detect(projectInfo);
-        // Step 3: Analyze all relevant files with AST
+        // Step 2: Analyze all relevant files with AST
         const fileAnalyses = await this.astAnalyzer.analyzeProject(configData.rootDir);
-        // Step 4: Get git information if enabled
+        // Step 3: Detect frameworks from dependencies
+        projectInfo.frameworks = await this.frameworkDetector.detect(projectInfo);
+        // 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)
             : 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,

package/dist/core/types/analyzer-types.d.ts

@@ -0,0 +1,38 @@
+import type { ServiceInfo, ModelInfo, ConfigInfo, MiddlewareInfo, UtilityInfo, EndpointInfo } from '../analyzers/pattern-detector.js';
+export type { ServiceInfo, ModelInfo, ConfigInfo, MiddlewareInfo, UtilityInfo, EndpointInfo };
+export interface FileAnalysis {
+    path: string;
+    type: 'route' | 'middleware' | 'model' | 'service' | 'utility' | 'config' | 'test' | 'component';
+    exports: string[];
+    imports: string[];
+    functions: string[];
+    classes: string[];
+    routes?: EndpointInfo[];
+    components?: ComponentInfo[];
+    services?: ServiceInfo[];
+    models?: ModelInfo[];
+    configs?: ConfigInfo[];
+    middleware?: MiddlewareInfo[];
+    utilities?: UtilityInfo[];
+}
+export interface RouteInfo {
+    method: string;
+    path: string;
+    handler: string;
+    middleware?: string[];
+    file: string;
+    line: number;
+}
+export interface ComponentInfo {
+    name: string;
+    file: string;
+    line: number;
+}
+export interface GitInfo {
+    branch: string;
+    lastCommit: string;
+    changedFiles: string[];
+    status: 'clean' | 'dirty';
+    origin?: string;
+    diffStat?: string;
+}

package/dist/core/types/analyzer-types.js

@@ -0,0 +1,2 @@
+// Types related to file analysis and AST parsing
+export {};

package/dist/core/types/config-types.d.ts

@@ -0,0 +1,36 @@
+export interface GeneratorOptions {
+    rootDir?: string;
+    includeGitInfo?: boolean;
+    useGitForFiles?: boolean;
+    maxDepth?: number;
+    excludePatterns?: string[];
+    analyzeFileTypes?: string[];
+}
+export interface ParsemeConfigFile extends GeneratorOptions {
+    outputPath?: string;
+    contextDir?: string;
+    rootDir?: string;
+    analyzeFileTypes?: string[];
+    excludePatterns?: string[];
+    maxDepth?: number;
+    includeGitInfo?: boolean;
+    useGitForFiles?: boolean;
+    readmeSuggestion?: boolean;
+    sections?: {
+        overview?: boolean;
+        architecture?: boolean;
+        routes?: boolean;
+        dependencies?: boolean;
+        git?: boolean;
+        fileStructure?: boolean;
+    };
+    style?: {
+        includeLineNumbers?: boolean;
+        includeFileStats?: boolean;
+        groupByType?: boolean;
+        sortOrder?: 'alphabetical' | 'type' | 'size';
+    };
+    limits?: {
+        maxFilesPerContext?: number;
+    };
+}

package/dist/core/types/config-types.js

@@ -0,0 +1,2 @@
+// Types related to configuration and generator options
+export {};

package/dist/core/types/generator-types.d.ts

@@ -0,0 +1,6 @@
+export interface ContextOutput {
+    parseme: string;
+    context?: {
+        [key: string]: string;
+    };
+}

package/dist/core/types/generator-types.js

@@ -0,0 +1,2 @@
+// Types related to generator output and context building
+export {};

package/dist/core/types/index.d.ts

@@ -0,0 +1,4 @@
+export * from './analyzer-types.js';
+export * from './config-types.js';
+export * from './generator-types.js';
+export * from './project-types.js';

package/dist/core/types/index.js

@@ -0,0 +1,5 @@
+// Main types index - re-exports all domain-specific types
+export * from './analyzer-types.js';
+export * from './config-types.js';
+export * from './generator-types.js';
+export * from './project-types.js';

package/dist/core/types/project-types.d.ts

@@ -0,0 +1,30 @@
+import type { RouteInfo, ComponentInfo } from './analyzer-types.js';
+export interface ProjectInfo {
+    name: string;
+    version?: string;
+    description?: string;
+    type: 'typescript' | 'javascript' | 'mixed';
+    category: ProjectCategory;
+    packageManager: 'unknown' | 'npm' | 'yarn' | 'pnpm' | 'bun';
+    frameworks?: FrameworkInfo[];
+    buildTool?: BuildToolInfo;
+    dependencies: Record<string, string>;
+    devDependencies: Record<string, string>;
+    scripts?: Record<string, string>;
+    entryPoints?: string[];
+    outputTargets?: string[];
+}
+export type ProjectCategory = 'backend-api' | 'frontend-web' | 'frontend-mobile' | 'npm-package' | 'monorepo' | 'cli-tool' | 'desktop-app' | 'fullstack' | 'unknown';
+export interface FrameworkInfo {
+    name: string;
+    version?: string;
+    features: string[];
+    routes?: RouteInfo[];
+    components?: ComponentInfo[];
+}
+export interface BuildToolInfo {
+    name: string;
+    version?: string;
+    configFiles: string[];
+    features: string[];
+}

package/dist/core/types/project-types.js

@@ -0,0 +1,2 @@
+// Types related to project information and framework detection
+export {};

package/dist/core/types.d.ts

@@ -0,0 +1 @@
+export * from './types/index.js';

package/dist/core/types.js

@@ -0,0 +1,2 @@
+// Core types for the parseme package - re-exports from organized type modules
+export * from './types/index.js';

package/dist/index.d.ts

@@ -1,4 +1,3 @@
-export { ParsemeGenerator } from './generator.js';
-export { ParsemeConfig } from './config.js';
-export type { GeneratorOptions, ContextOutput, ProjectInfo, FrameworkInfo, RouteInfo, FileAnalysis, GitInfo, } from './types.js';
-export type { ParsemeConfigFile } from './config.js';
+export { ParsemeGenerator } from './core/generator.js';
+export { ParsemeConfig } from './core/config.js';
+export type { GeneratorOptions, ContextOutput, ProjectInfo, FrameworkInfo, RouteInfo, FileAnalysis, GitInfo, ParsemeConfigFile, } from './core/types.js';

package/dist/index.js

@@ -1,3 +1,3 @@
 // Main exports for the parseme package
-export { ParsemeGenerator } from './generator.js';
-export { ParsemeConfig } from './config.js';
+export { ParsemeGenerator } from './core/generator.js';
+export { ParsemeConfig } from './core/config.js';

package/dist/utils/file-collector.d.ts

@@ -0,0 +1,23 @@
+import type { ParsemeConfig } from '../core/config.js';
+export interface FileCollectionOptions {
+    fileTypes?: string[];
+}
+export interface FileCollectionResult {
+    files: string[];
+    totalFound: number;
+    excluded: number;
+}
+export declare class FileCollector {
+    private readonly fileFilter;
+    private readonly config;
+    constructor(config: ParsemeConfig);
+    getFiles(rootDir: string, options?: FileCollectionOptions): Promise<FileCollectionResult>;
+    /**
+     * Get all project files (no file type filtering, for files.md)
+     */
+    getAllProjectFiles(rootDir: string): Promise<FileCollectionResult>;
+    /**
+     * Get code files for AST analysis (filtered by file types, for structure.json)
+     */
+    getCodeFiles(rootDir: string, fileTypes?: string[]): Promise<FileCollectionResult>;
+}

package/dist/utils/file-collector.js

@@ -0,0 +1,61 @@
+import { FileFilterService } from './file-filter.js';
+export class FileCollector {
+    fileFilter;
+    config;
+    constructor(config) {
+        this.config = config;
+        const configData = this.config.get();
+        this.fileFilter = new FileFilterService(configData.excludePatterns, configData.useGitForFiles ?? true);
+    }
+    async getFiles(rootDir, options = {}) {
+        const configData = this.config.get();
+        const { fileTypes } = options;
+        // Get all filtered files (respects git ignore + custom excludePatterns)
+        const allFiles = await this.fileFilter.getFilteredFiles(rootDir);
+        // Filter by file types if specified
+        let filteredFiles = allFiles;
+        if (fileTypes && fileTypes.length > 0) {
+            const extensionSet = new Set(fileTypes.map((ext) => (ext.startsWith('.') ? ext : `.${ext}`)));
+            filteredFiles = allFiles.filter((file) => {
+                const ext = file.substring(file.lastIndexOf('.'));
+                return extensionSet.has(ext);
+            });
+        }
+        // Apply limits
+        let finalFiles = filteredFiles;
+        let excluded = 0;
+        if (configData.limits?.maxFilesPerContext) {
+            const limit = configData.limits.maxFilesPerContext;
+            if (filteredFiles.length > limit) {
+                finalFiles = filteredFiles.slice(0, limit);
+                excluded = filteredFiles.length - limit;
+                // Show warning when files are excluded
+                const fileTypeDesc = fileTypes ? `${fileTypes.join(', ')} files` : 'files';
+                console.warn(`⚠️  File limit reached: ${excluded} ${fileTypeDesc} excluded.`);
+                console.warn(`   Processed: ${limit}/${filteredFiles.length} files`);
+                console.warn(`   To process more files, increase 'limits.maxFilesPerContext' in your config file.`);
+            }
+        }
+        return {
+            files: finalFiles,
+            totalFound: filteredFiles.length,
+            excluded,
+        };
+    }
+    /**
+     * Get all project files (no file type filtering, for files.md)
+     */
+    async getAllProjectFiles(rootDir) {
+        return this.getFiles(rootDir);
+    }
+    /**
+     * Get code files for AST analysis (filtered by file types, for structure.json)
+     */
+    async getCodeFiles(rootDir, fileTypes) {
+        const configData = this.config.get();
+        const defaultFileTypes = configData.analyzeFileTypes || ['ts', 'tsx', 'js', 'jsx'];
+        return this.getFiles(rootDir, {
+            fileTypes: fileTypes || defaultFileTypes,
+        });
+    }
+}

package/dist/utils/file-filter.d.ts

@@ -0,0 +1,30 @@
+export declare class FileFilterService {
+    private readonly excludePatterns;
+    private readonly useGitForFiles;
+    private readonly ig;
+    constructor(excludePatterns?: string[], useGitForFiles?: boolean);
+    /**
+     * Get all files that should be analyzed, respecting:
+     * 1. Git-tracked files (respects all .gitignore files automatically)
+     * 2. All files (if non-git repo) - respects only custom excludePatterns
+     * 3. Custom excludePatterns from config (always applied)
+     */
+    getFilteredFiles(rootDir: string, fileExtensions?: string[]): Promise<string[]>;
+    /**
+     * Check if the directory is a git repository
+     */
+    private isGitRepository;
+    /**
+     * Get all tracked files from git
+     * This respects all .gitignore files in the repository (parent, current, and child dirs)
+     */
+    private getGitTrackedFiles;
+    /**
+     * Get all files recursively (fallback for non-git repos)
+     */
+    private getAllFilesRecursive;
+    /**
+     * Check if a specific file should be filtered out
+     */
+    shouldIgnore(filePath: string): boolean;
+}

package/dist/utils/file-filter.js

@@ -0,0 +1,99 @@
+import { exec } from 'child_process';
+import { readdir, stat } from 'fs/promises';
+import { join, relative } from 'path';
+import { promisify } from 'util';
+import ignore from 'ignore';
+const execAsync = promisify(exec);
+export class FileFilterService {
+    excludePatterns;
+    useGitForFiles;
+    ig;
+    constructor(excludePatterns = [], useGitForFiles = true) {
+        this.excludePatterns = excludePatterns;
+        this.useGitForFiles = useGitForFiles;
+        this.ig = ignore();
+        this.ig.add(excludePatterns);
+    }
+    /**
+     * Get all files that should be analyzed, respecting:
+     * 1. Git-tracked files (respects all .gitignore files automatically)
+     * 2. All files (if non-git repo) - respects only custom excludePatterns
+     * 3. Custom excludePatterns from config (always applied)
+     */
+    async getFilteredFiles(rootDir, fileExtensions) {
+        try {
+            let files;
+            // Try to get git-tracked files first (only if useGitForFiles is enabled)
+            const isGitRepo = this.useGitForFiles && (await this.isGitRepository(rootDir));
+            if (isGitRepo) {
+                files = await this.getGitTrackedFiles(rootDir);
+            }
+            else {
+                // Fallback: get all files recursively
+                files = await this.getAllFilesRecursive(rootDir, rootDir);
+            }
+            // Apply custom exclude patterns
+            const filteredFiles = files.filter((file) => !this.ig.ignores(file));
+            // Optionally filter by file extensions
+            if (fileExtensions && fileExtensions.length > 0) {
+                const extensionSet = new Set(fileExtensions.map((ext) => (ext.startsWith('.') ? ext : `.${ext}`)));
+                return filteredFiles.filter((file) => {
+                    const ext = file.substring(file.lastIndexOf('.'));
+                    return extensionSet.has(ext);
+                });
+            }
+            return filteredFiles;
+        }
+        catch (error) {
+            throw new Error(`Failed to get filtered files: ${error.message}`);
+        }
+    }
+    /**
+     * Check if the directory is a git repository
+     */
+    async isGitRepository(rootDir) {
+        try {
+            await execAsync('git rev-parse --git-dir', { cwd: rootDir });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Get all tracked files from git
+     * This respects all .gitignore files in the repository (parent, current, and child dirs)
+     */
+    async getGitTrackedFiles(rootDir) {
+        const { stdout } = await execAsync('git ls-files', { cwd: rootDir });
+        return stdout
+            .split('\n')
+            .map((line) => line.trim())
+            .filter((line) => line);
+    }
+    /**
+     * Get all files recursively (fallback for non-git repos)
+     */
+    async getAllFilesRecursive(dir, rootDir) {
+        const entries = await readdir(dir);
+        const files = [];
+        for (const entry of entries) {
+            const fullPath = join(dir, entry);
+            const relativePath = relative(rootDir, fullPath);
+            const stats = await stat(fullPath);
+            if (stats.isFile()) {
+                files.push(relativePath);
+            }
+            else if (stats.isDirectory() && !entry.startsWith('.')) {
+                files.push(...(await this.getAllFilesRecursive(fullPath, rootDir)));
+            }
+        }
+        return files;
+    }
+    /**
+     * Check if a specific file should be filtered out
+     */
+    shouldIgnore(filePath) {
+        return this.ig.ignores(filePath);
+    }
+}

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

@@ -1,8 +1,5 @@
-import type { ParsemeConfig } from '../config.js';
-import type { GitInfo } from '../types.js';
+import type { GitInfo } from '../core/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/git-analyzer.js → utils/git.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/{prompt.d.ts → utils/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 → utils/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/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@parseme/cli",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "description": "Adds a PARSEME.md file—a README.md for AI agents—to your project, providing context and structure for automated tools.",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "bin": {
-    "parseme": "dist/cli.js"
+    "parseme": "dist/cli/cli.js"
   },
   "files": [
     "dist",
@@ -24,12 +24,16 @@
     "format:check": "prettier . --ignore-unknown --check",
     "lint": "eslint --config ./eslint.config.js --fix",
     "lint:check": "eslint --config ./eslint.config.js --no-fix --max-warnings 0",
-    "test": "node --test --experimental-test-coverage tests/**/*.test.ts",
-    "test:unit": "node --test tests/unit/**/*.test.ts",
-    "test:integration": "node --test tests/integration/**/*.test.ts",
-    "test:watch": "node --test --watch tests/**/*.test.ts",
-    "test:coverage": "node --test --experimental-test-coverage tests/**/*.test.ts",
-    "prepare": "npm run build",
+    "test": "node --test --experimental-test-coverage 'tests/**/*.test.ts'",
+    "pretest:unit": "npm run build",
+    "test:unit": "node --test 'tests/unit/**/*.test.ts'",
+    "pretest:integration": "npm run build",
+    "test:integration": "node --test 'tests/integration/**/*.test.ts'",
+    "test:watch": "node --test --watch 'tests/**/*.test.ts'",
+    "pretest:coverage": "npm run build",
+    "test:coverage": "node --test --experimental-test-coverage 'tests/unit/**/*.test.ts' 'tests/integration/**/*.test.ts'",
+    "test:setup:e2e": "npm run -C ../e2e setup",
+    "test:e2e": "npm run -C ../e2e test",
     "clean": "rm -rf dist"
   },
   "keywords": [

package/dist/analyzers/framework-detector.d.ts

@@ -1,12 +0,0 @@
-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;
-    private detectNestJS;
-    private detectKoa;
-    private detectHapi;
-}