readme-gen-analyzer 1.0.0

package/.turbo/turbo-build.log

@@ -0,0 +1,4 @@
+
+> @readme-gen/analyzer@1.0.0 build G:\Web_Develpoment\main_Projects\readme-gen\packages\analyzer
+> tsc
+

package/README.md

@@ -0,0 +1,77 @@
+# 🧬 @readme-gen/analyzer
+
+**The shared repository analysis engine and semantic README pipeline for the readme-gen platform.**
+
+---
+
+## 📖 Overview
+
+The `analyzer` package is the core grounding layer for all `readme-gen` generation. It extracts project evidence and provides a multi-stage semantic pipeline to ensure generated documentation is tied to concrete code data instead of generic model guesses.
+
+### Key Responsibilities
+- **Repository Structural Analysis**: Mapping file systems and identifying monorepo boundaries.
+- **Evidence Extraction**: Parsing package manifests, API routes, environment variables, and source signatures.
+- **Semantic Mapping**: Merging raw extraction data into a canonical, AI-ready JSON structure.
+- **Generation Orchestration**: Running the multi-stage LLM pipeline.
+- **Quality Evaluation**: Scoring generated READMEs for clarity, completeness, and accuracy.
+
+---
+
+## 🏗️ Semantic Pipeline
+
+The `analyzer` uses a sophisticated 6-stage pipeline to build high-quality documentation:
+
+1.  **🔍 Evidence Extraction**: Gathers raw project facts (Dependencies, Routes, Env Vars, AST Patterns).
+2.  **🧠 Intent Inference**: Deduces "why" the project exists and its primary goal.
+3.  **✨ Feature Extraction**: Distills user-facing capabilities from extracted signatures.
+4.  **🏛️ Architecture Analysis**: Maps internal project structure and flow.
+5.  **🧩 Semantic Merge**: Consolidates all discoveries into a unified `ProjectAnalysis` object.
+6.  **✍️ Markdown Generation**: Orchestrates the final markdown construction from semantic JSON.
+
+---
+
+## 🛠️ Package Structure
+
+```text
+src/
+├── analyzers/    # Specialized extractors for Files, Routes, Env, and AST
+├── internal/     # Semantic pipeline, Evidence builder, and LLM orchestration
+├── utils/        # Shared prompt engineering and markdown rendering helpers
+├── types.ts      # Repository-wide project analysis and extraction types
+└── constants/    # Persona definitions and prompt templates
+```
+
+---
+
+## 📝 Key Features
+
+### Grounded Generation
+The analyzer ensures that everything in the final README is backed by code evidence.
+- **Rewriting Mode**: Maintains custom sections while updating grounding facts.
+- **Appending Mode**: Intelligently adds new sections to existing documentation.
+
+### Multi-Model Compatibility
+The analyzer's prompts are optimized for:
+- **OpenAI** (GPT-4o / GPT-3.5)
+- **Gemini** (Pro 1.5 / Flash)
+- **Groq** (Llama 3 / Mixtral)
+
+---
+
+## 🛠️ Development
+
+From the workspace root:
+
+```bash
+pnpm --filter @readme-gen/analyzer build
+```
+
+### Dependencies
+- **ts-morph**: For high-fidelity AST analysis and source signature extraction.
+- **ignore**: For respecting `.gitignore` rules during project analysis.
+
+---
+
+<div align="center">
+  <sub>Part of the 🚀 <a href="../../README.md">readme-gen</a> ecosystem.</sub>
+</div>

package/dist/analyzers/ast-feature.detector.d.ts

@@ -0,0 +1,10 @@
+export interface AstFeature {
+    name: string;
+    evidence: {
+        snippet: string;
+        file: string;
+    }[];
+}
+export declare class AstFeatureDetector {
+    static detect(files: Record<string, string>): AstFeature[];
+}

package/dist/analyzers/ast-feature.detector.js

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AstFeatureDetector = void 0;
+const ts_morph_1 = require("ts-morph");
+class AstFeatureDetector {
+    static detect(files) {
+        const project = new ts_morph_1.Project({ useInMemoryFileSystem: true });
+        const features = new Map();
+        const addEvidence = (featureName, snippet, file) => {
+            if (!features.has(featureName)) {
+                features.set(featureName, { name: featureName, evidence: [] });
+            }
+            const feat = features.get(featureName);
+            if (feat.evidence.length < 5) { // Limit evidence to 5 snippets per feature
+                feat.evidence.push({ snippet, file });
+            }
+        };
+        for (const [filePath, content] of Object.entries(files)) {
+            if (!filePath.match(/\.(ts|js|tsx|jsx)$/))
+                continue;
+            const sourceFile = project.createSourceFile(filePath, content);
+            // 1. Scan for Call Expressions (Mainly for app.get, mongoose.connect, etc.)
+            const callExpressions = sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.CallExpression);
+            for (const call of callExpressions) {
+                const expression = call.getExpression();
+                const text = call.getText();
+                // Pattern: app.get, router.post, etc.
+                if (expression.getKind() === ts_morph_1.SyntaxKind.PropertyAccessExpression) {
+                    const pae = expression;
+                    const name = pae.getName().toLowerCase();
+                    const base = pae.getExpression().getText().toLowerCase();
+                    // API Routes
+                    if (['get', 'post', 'put', 'delete', 'patch', 'use'].includes(name)) {
+                        if (['app', 'router', 'server', 'express'].includes(base)) {
+                            addEvidence('API Endpoints', text.substring(0, 150), filePath);
+                        }
+                    }
+                    // Database Integration (Mongoose, pg, MySQL)
+                    if (name === 'connect' && (base === 'mongoose' || base === 'db')) {
+                        addEvidence('Database Integration', text.substring(0, 150), filePath);
+                    }
+                    if (name === 'model' && base === 'mongoose') {
+                        addEvidence('Database Integration', text.substring(0, 150), filePath);
+                    }
+                    if (name === 'createconnection' && (base === 'mysql' || base === 'db')) {
+                        addEvidence('Database Integration', text.substring(0, 150), filePath);
+                    }
+                    // Authentication (JWT, bcrypt, passport)
+                    if (['sign', 'verify'].includes(name) && base === 'jwt') {
+                        addEvidence('Authentication', text.substring(0, 150), filePath);
+                    }
+                    if (['hash', 'compare'].includes(name) && base === 'bcrypt') {
+                        addEvidence('Authentication', text.substring(0, 150), filePath);
+                    }
+                    if (['use', 'authenticate'].includes(name) && base === 'passport') {
+                        addEvidence('Authentication', text.substring(0, 150), filePath);
+                    }
+                    // Environment Configuration
+                    if (name === 'config' && base === 'dotenv') {
+                        addEvidence('Environment Configuration', text.substring(0, 150), filePath);
+                    }
+                    if (name === 'get' && base === 'config') {
+                        addEvidence('Environment Configuration', text.substring(0, 150), filePath);
+                    }
+                    // CLI Tool (Commander)
+                    if (['command', 'option', 'parse', 'version'].includes(name) && ['program', 'cmd'].includes(base)) {
+                        addEvidence('CLI Tool', text.substring(0, 150), filePath);
+                    }
+                }
+                // 2. Scan for New Expressions (Prisma, pg Pool)
+                const newExpressions = sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.NewExpression);
+                for (const newExpr of newExpressions) {
+                    const newText = newExpr.getText().toLowerCase();
+                    if (newText.includes('prismaclient')) {
+                        addEvidence('Database Integration', newExpr.getText().substring(0, 150), filePath);
+                    }
+                    if (newText.includes('pool') || newText.includes('client')) {
+                        addEvidence('Database Integration', newExpr.getText().substring(0, 150), filePath);
+                    }
+                }
+                // 3. Scan for Property Access (process.env)
+                const propAccess = sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.PropertyAccessExpression);
+                for (const pae of propAccess) {
+                    if (pae.getText().startsWith('process.env.')) {
+                        addEvidence('Environment Configuration', pae.getText(), filePath);
+                    }
+                }
+                // 4. Scan for Decorators (NestJS)
+                const decorators = sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.Decorator);
+                for (const dec of decorators) {
+                    const decName = dec.getName().toLowerCase();
+                    if (['get', 'post', 'put', 'delete', 'patch', 'controller'].includes(decName)) {
+                        addEvidence('API Endpoints', dec.getText(), filePath);
+                    }
+                    if (['injectable'].includes(decName)) {
+                        // Marker for service oriented architecture
+                    }
+                }
+            }
+            // 5. File-path based API Route Detection (Next.js, etc.)
+            if (filePath.includes('pages/api/') || filePath.includes('app/api/')) {
+                addEvidence('API Endpoints', `File-based route: ${filePath}`, filePath);
+            }
+            // 6. Direct variable usage for CLI
+            if (content.includes('process.argv')) {
+                addEvidence('CLI Tool', 'process.argv', filePath);
+            }
+        }
+        for (const [filePath, content] of Object.entries(files)) {
+            if (filePath.endsWith('.py')) {
+                if (/@(?:app|router)\.(get|post|put|delete|patch)\s*\(/i.test(content)) {
+                    addEvidence('API Endpoints', 'FastAPI/Starlette-style route decorators', filePath);
+                }
+                if (/flask|Flask\(__name__\)/.test(content) || /@app\.route\s*\(/i.test(content)) {
+                    addEvidence('API Endpoints', 'Flask routes', filePath);
+                }
+                if (/django\.|from\s+django/.test(content)) {
+                    addEvidence('Django application', 'Django imports', filePath);
+                }
+                if (/sqlalchemy|SQLAlchemy/.test(content)) {
+                    addEvidence('Database Integration', 'SQLAlchemy', filePath);
+                }
+                if (/os\.getenv|os\.environ/.test(content)) {
+                    addEvidence('Environment Configuration', 'os.getenv / os.environ', filePath);
+                }
+                if (/celery|Celery/.test(content)) {
+                    addEvidence('Task queue', 'Celery', filePath);
+                }
+            }
+            if (filePath.endsWith('.go')) {
+                if (/gin-gonic\/gin|\.GET\s*\(|\.POST\s*\(/.test(content)) {
+                    addEvidence('API Endpoints', 'Go HTTP handlers (gin / stdlib style)', filePath);
+                }
+                if (/gorm\.io|database\/sql|jackc\/pgx/.test(content)) {
+                    addEvidence('Database Integration', 'Go database client', filePath);
+                }
+                if (/os\.Getenv/.test(content)) {
+                    addEvidence('Environment Configuration', 'os.Getenv', filePath);
+                }
+                if (/spf13\/cobra/.test(content)) {
+                    addEvidence('CLI Tool', 'Cobra CLI', filePath);
+                }
+                if (/grpc\.|google\.golang\.org\/grpc/.test(content)) {
+                    addEvidence('gRPC', 'gRPC imports', filePath);
+                }
+            }
+        }
+        return Array.from(features.values());
+    }
+}
+exports.AstFeatureDetector = AstFeatureDetector;

package/dist/analyzers/definition.extractor.d.ts

@@ -0,0 +1,9 @@
+export declare class DefinitionExtractor {
+    static extract(files: Record<string, string>): Record<string, string[]>;
+    private static walkNode;
+    private static formatSignature;
+    private static formatParamsSnippet;
+    private static formatParams;
+    private static safeGetParamType;
+    private static safeGetReturnType;
+}

package/dist/analyzers/definition.extractor.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefinitionExtractor = void 0;
+const ts_morph_1 = require("ts-morph");
+const polyglot_extractors_1 = require("./polyglot.extractors");
+class DefinitionExtractor {
+    static extract(files) {
+        const project = new ts_morph_1.Project({ useInMemoryFileSystem: true });
+        const result = {};
+        for (const [filePath, content] of Object.entries(files)) {
+            if (!filePath.match(/\.(ts|js|tsx|jsx)$/))
+                continue;
+            console.log(`[Analyzer] Parsing file for definitions: ${filePath}`);
+            project.createSourceFile(filePath, content);
+        }
+        project.getSourceFiles().forEach(sourceFile => {
+            const filePath = sourceFile.getFilePath();
+            const definitions = [];
+            // Extract Imports
+            sourceFile.getImportDeclarations().forEach(imp => {
+                const module = imp.getModuleSpecifierValue();
+                const names = imp.getNamedImports().map(n => n.getName()).join(', ');
+                if (names)
+                    definitions.push(`Import: { ${names} } from "${module}"`);
+                else if (imp.getDefaultImport())
+                    definitions.push(`Import Default: ${imp.getDefaultImport()?.getText()} from "${module}"`);
+            });
+            // Recursive Extraction from all top-level nodes
+            sourceFile.forEachChild(node => {
+                this.walkNode(node, definitions);
+            });
+            // Interfaces/Types (Stay top-level mostly)
+            sourceFile.getInterfaces().forEach(intf => {
+                const name = intf.getName();
+                const properties = intf.getProperties().map(p => `${p.getName()}: ${p.getType().getText()}`).join(', ');
+                definitions.push(`Interface: ${name} { ${properties.substring(0, 200)} }`);
+            });
+            sourceFile.getTypeAliases().forEach(type => {
+                definitions.push(`Type Alias: ${type.getName()} = ${type.getType().getText().substring(0, 200)}`);
+            });
+            if (definitions.length > 0) {
+                const cleanPath = filePath.startsWith('/') ? filePath.substring(1) : filePath;
+                result[cleanPath] = definitions;
+            }
+        });
+        const polyglot = polyglot_extractors_1.PolyglotExtractors.extractDefinitions(files);
+        for (const [p, defs] of Object.entries(polyglot)) {
+            if (!result[p])
+                result[p] = defs;
+            else
+                result[p] = [...result[p], ...defs];
+        }
+        return result;
+    }
+    static walkNode(node, definitions) {
+        // Classes
+        if (ts_morph_1.Node.isClassDeclaration(node)) {
+            const name = node.getName() || "AnonymousClass";
+            definitions.push(`Class: ${name}`);
+            node.getMethods().forEach(m => definitions.push(`  ${this.formatSignature(m, 'Method')}`));
+            node.getConstructors().forEach(c => definitions.push(`  ${this.formatSignature(c, 'Constructor')}`));
+        }
+        // Functions
+        if (ts_morph_1.Node.isFunctionDeclaration(node)) {
+            const signature = this.formatSignature(node, 'Function');
+            console.log(`  [Extractor] Found Function: ${signature}`);
+            definitions.push(signature);
+        }
+        // Variable-based Functions (Arrow or Function Expressions)
+        if (ts_morph_1.Node.isVariableDeclaration(node)) {
+            const initializer = node.getInitializer();
+            if (initializer) {
+                if (ts_morph_1.Node.isArrowFunction(initializer) || ts_morph_1.Node.isFunctionExpression(initializer)) {
+                    const name = node.getName();
+                    const params = this.formatSignature(initializer, 'Function (assigned)');
+                    console.log(`  [Extractor] Found Variable Function: ${name} ${params}`);
+                    definitions.push(params);
+                }
+                else if (ts_morph_1.Node.isObjectLiteralExpression(initializer)) {
+                    // If it's a small object literal with methods, extract them
+                    initializer.getProperties().forEach(prop => {
+                        if (ts_morph_1.Node.isMethodDeclaration(prop) || ts_morph_1.Node.isPropertyAssignment(prop)) {
+                            const propInit = ts_morph_1.Node.isPropertyAssignment(prop) ? prop.getInitializer() : null;
+                            if (ts_morph_1.Node.isMethodDeclaration(prop) || (propInit && (ts_morph_1.Node.isArrowFunction(propInit) || ts_morph_1.Node.isFunctionExpression(propInit)))) {
+                                const name = ts_morph_1.Node.isPropertyAssignment(prop) ? prop.getName() : prop.getName();
+                                const fn = ts_morph_1.Node.isPropertyAssignment(prop) ? propInit : prop;
+                                definitions.push(`  Method (obj-prop): ${name}${this.formatParamsSnippet(fn)}`);
+                            }
+                        }
+                    });
+                }
+            }
+        }
+        // Export Assignments
+        if (ts_morph_1.Node.isExportAssignment(node)) {
+            const expression = node.getExpression();
+            if (ts_morph_1.Node.isArrowFunction(expression) || ts_morph_1.Node.isFunctionExpression(expression)) {
+                definitions.push(`Export Default Function: ${this.formatSignature(expression, '')}`);
+            }
+        }
+        // Recurse into children to find nested functions (but not too deep into implementations)
+        if (!ts_morph_1.Node.isClassDeclaration(node) && !ts_morph_1.Node.isFunctionDeclaration(node) && !ts_morph_1.Node.isMethodDeclaration(node)) {
+            node.forEachChild(child => this.walkNode(child, definitions));
+        }
+    }
+    static formatSignature(node, kind) {
+        const name = node.getName?.() || "";
+        const params = this.formatParamsSnippet(node);
+        const asyncStr = node.isAsync?.() ? 'async ' : '';
+        return `${asyncStr}${kind}${name ? ': ' + name : ''}${params}`;
+    }
+    static formatParamsSnippet(node) {
+        const params = this.formatParams(node.getParameters?.() || []);
+        const returnType = this.safeGetReturnType(node);
+        return `(${params}) -> ${returnType}`;
+    }
+    static formatParams(params) {
+        return params.map(p => {
+            const name = p.getName();
+            const type = this.safeGetParamType(p);
+            return `${name}${p.isOptional() ? '?' : ''}: ${type}`;
+        }).join(', ');
+    }
+    static safeGetParamType(p) {
+        try {
+            return p.getTypeNode()?.getText() || p.getType().getText() || 'any';
+        }
+        catch {
+            return 'any';
+        }
+    }
+    static safeGetReturnType(fn) {
+        try {
+            return fn.getReturnTypeNode()?.getText() || fn.getReturnType().getText() || 'void';
+        }
+        catch {
+            return 'void';
+        }
+    }
+}
+exports.DefinitionExtractor = DefinitionExtractor;

package/dist/analyzers/dependency.analyzer.d.ts

@@ -0,0 +1,14 @@
+interface DependencyGroups {
+    core: string[];
+    database: string[];
+    testing: string[];
+    deployment: string[];
+}
+export declare class DependencyAnalyzer {
+    private static CORE;
+    private static DATABASE;
+    private static TESTING;
+    private static DEPLOYMENT;
+    static analyze(dependencies: string[]): DependencyGroups;
+}
+export {};

package/dist/analyzers/dependency.analyzer.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DependencyAnalyzer = void 0;
+class DependencyAnalyzer {
+    static CORE = ['express', 'fastapi', 'flask', 'django', 'react', 'next', 'vue', 'nest', 'koa'];
+    static DATABASE = ['mongoose', 'prisma', 'pg', 'mysql2', 'redis', 'sequelize', 'mongodb', 'psycopg2', 'sqlalchemy'];
+    static TESTING = ['jest', 'mocha', 'chai', 'cypress', 'pytest', 'vitest', 'playwright'];
+    static DEPLOYMENT = ['docker', 'aws-sdk', 'firebase', 'vercel', 'netlify', 'terraform'];
+    static analyze(dependencies) {
+        const groups = {
+            core: [],
+            database: [],
+            testing: [],
+            deployment: []
+        };
+        dependencies.forEach(dep => {
+            const lower = dep.toLowerCase();
+            if (this.CORE.some(c => lower.includes(c)))
+                groups.core.push(dep);
+            if (this.DATABASE.some(d => lower.includes(d)))
+                groups.database.push(dep);
+            if (this.TESTING.some(t => lower.includes(t)))
+                groups.testing.push(dep);
+            if (this.DEPLOYMENT.some(d => lower.includes(d)))
+                groups.deployment.push(dep);
+        });
+        return groups;
+    }
+}
+exports.DependencyAnalyzer = DependencyAnalyzer;

package/dist/analyzers/devops.analyzer.d.ts

@@ -0,0 +1,3 @@
+export declare class DevOpsAnalyzer {
+    static analyze(files: Record<string, string>): any;
+}

package/dist/analyzers/devops.analyzer.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DevOpsAnalyzer = void 0;
+class DevOpsAnalyzer {
+    static analyze(files) {
+        const devOps = {};
+        // 1. Dockerfile
+        const dockerPath = Object.keys(files).find(f => f.toLowerCase().endsWith('dockerfile'));
+        if (dockerPath) {
+            const content = files[dockerPath];
+            devOps.docker = {
+                baseImage: content.match(/FROM\s+([^\s\n]+)/i)?.[1],
+                ports: [...content.matchAll(/EXPOSE\s+(\d+)/gi)].map(m => m[1]),
+                command: content.match(/CMD\s+\[?([^\]\n]+)\]?/i)?.[1]?.replace(/"/g, '')
+            };
+        }
+        // 2. Docker Compose
+        const composePath = Object.keys(files).find(f => f.toLowerCase().includes('docker-compose') && f.endsWith('.yml'));
+        if (composePath) {
+            const content = files[composePath];
+            const services = [...content.matchAll(/^\s+([a-z0-9_-]+):/gm)]
+                .map(m => m[1])
+                .filter(s => !['services', 'networks', 'volumes', 'version'].includes(s));
+            const networks = [...content.matchAll(/^\s+networks:\s*\n(\s+- [a-z0-9_-]+\n)+/gi)].length > 0 ? ['Enabled'] : [];
+            devOps.compose = { services, networks };
+        }
+        // 3. GitHub Actions
+        const workflowPath = Object.keys(files).find(f => f.includes('.github/workflows') && f.endsWith('.yml'));
+        if (workflowPath) {
+            const content = files[workflowPath];
+            const jobs = [...content.matchAll(/^\s+([a-z0-9_-]+):/gm)]
+                .map(m => m[1])
+                .filter(j => !['jobs', 'on', 'workflow_dispatch', 'name'].includes(j));
+            devOps.pipeline = {
+                provider: 'GitHub Actions',
+                jobs
+            };
+        }
+        return Object.keys(devOps).length > 0 ? devOps : undefined;
+    }
+}
+exports.DevOpsAnalyzer = DevOpsAnalyzer;

package/dist/analyzers/env.extractor.d.ts

@@ -0,0 +1,7 @@
+export interface EnvVar {
+    name: string;
+}
+export declare class EnvExtractor {
+    private static ENV_REGEX;
+    static extract(files: Record<string, string>): string[];
+}

package/dist/analyzers/env.extractor.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnvExtractor = void 0;
+class EnvExtractor {
+    static ENV_REGEX = /process\.env\.([a-zA-Z_][a-zA-Z0-9_]*)/g;
+    static extract(files) {
+        const envVars = new Set();
+        for (const [filePath, content] of Object.entries(files)) {
+            // 1. From .env or .env.example
+            if (filePath.endsWith('.env') || filePath.endsWith('.env.example')) {
+                const lines = content.split('\n');
+                for (const line of lines) {
+                    const trimmed = line.trim();
+                    if (trimmed && !trimmed.startsWith('#')) {
+                        const match = trimmed.match(/^([^=]+)=/);
+                        if (match) {
+                            envVars.add(match[1].trim());
+                        }
+                    }
+                }
+            }
+            // 2. From code usage (process.env.VAR)
+            if (filePath.endsWith('.ts') || filePath.endsWith('.js')) {
+                let match;
+                while ((match = this.ENV_REGEX.exec(content)) !== null) {
+                    envVars.add(match[1]);
+                }
+            }
+            if (filePath.endsWith('.py')) {
+                for (const m of content.matchAll(/os\.(?:getenv|environ\.get)\(\s*["']([a-zA-Z_][a-zA-Z0-9_]*)["']/g)) {
+                    envVars.add(m[1]);
+                }
+                for (const m of content.matchAll(/os\.environ\[\s*["']([a-zA-Z_][a-zA-Z0-9_]*)["']\s*\]/g)) {
+                    envVars.add(m[1]);
+                }
+            }
+            if (filePath.endsWith('.go')) {
+                for (const m of content.matchAll(/os\.Getenv\(\s*["']([a-zA-Z_][a-zA-Z0-9_]*)["']\s*\)/g)) {
+                    envVars.add(m[1]);
+                }
+            }
+        }
+        return Array.from(envVars);
+    }
+}
+exports.EnvExtractor = EnvExtractor;

package/dist/analyzers/example.analyzer.d.ts

@@ -0,0 +1,6 @@
+export declare class ExampleAnalyzer {
+    static analyze(files: Record<string, string>): any[] | undefined;
+    private static isPythonTestPath;
+    private static collectPythonTests;
+    private static collectGoTests;
+}

package/dist/analyzers/example.analyzer.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExampleAnalyzer = void 0;
+const ts_morph_1 = require("ts-morph");
+class ExampleAnalyzer {
+    static analyze(files) {
+        const examples = [];
+        const project = new ts_morph_1.Project({ useInMemoryFileSystem: true });
+        for (const [filePath, content] of Object.entries(files)) {
+            if (filePath.endsWith('.py') && this.isPythonTestPath(filePath)) {
+                this.collectPythonTests(filePath, content, examples);
+                continue;
+            }
+            if (filePath.endsWith('_test.go')) {
+                this.collectGoTests(filePath, content, examples);
+                continue;
+            }
+            if (!filePath.match(/\.(test|spec)\.(ts|js|jsx|tsx)$/) && !filePath.includes('__tests__'))
+                continue;
+            const sourceFile = project.createSourceFile(filePath, content);
+            const callExpressions = sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.CallExpression);
+            for (const call of callExpressions) {
+                const name = call.getExpression().getText().toLowerCase();
+                if (['it', 'test'].includes(name)) {
+                    const args = call.getArguments();
+                    if (args.length >= 2) {
+                        const description = args[0].getText().replace(/['"`]/g, '');
+                        const body = args[1].getText();
+                        // Heuristic for "Good" examples: contain multiple calls or interesting snippets
+                        const isInteresting = body.includes('await') || body.includes('expect') || body.split('\n').length > 5;
+                        if (isInteresting && examples.length < 15) {
+                            const cleanBody = body.replace(/^\(\) => \{|\}$|^\(async \(\) => \{|\}$/g, '').trim();
+                            examples.push({
+                                description,
+                                code: cleanBody,
+                                file: filePath
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        return examples.length > 0 ? examples : undefined;
+    }
+    static isPythonTestPath(filePath) {
+        const base = filePath.split('/').pop() || '';
+        if (base.startsWith('test_') && base.endsWith('.py'))
+            return true;
+        if (filePath.includes('/tests/') || filePath.includes('/test/'))
+            return true;
+        return false;
+    }
+    static collectPythonTests(filePath, content, examples) {
+        const re = /^(async\s+)?def\s+(test_\w+)\s*\([^)]*\):/gm;
+        let m;
+        while ((m = re.exec(content)) !== null) {
+            if (examples.length >= 15)
+                break;
+            const start = m.index;
+            const next = content.indexOf('\ndef ', start + 5);
+            const block = content.slice(start, next === -1 ? Math.min(start + 800, content.length) : Math.min(next, start + 800));
+            examples.push({
+                description: m[2],
+                code: block.trim(),
+                file: filePath,
+            });
+        }
+    }
+    static collectGoTests(filePath, content, examples) {
+        const re = /^func\s+(Test\w+)\s*\(/gm;
+        let m;
+        while ((m = re.exec(content)) !== null) {
+            if (examples.length >= 15)
+                break;
+            const block = content.slice(m.index, m.index + 700);
+            examples.push({
+                description: m[1],
+                code: block.trim(),
+                file: filePath,
+            });
+        }
+    }
+}
+exports.ExampleAnalyzer = ExampleAnalyzer;

package/dist/analyzers/feature.detector.d.ts

@@ -0,0 +1,4 @@
+export declare class FeatureDetector {
+    private static FEATURE_MAP;
+    static detect(dependencies: string[], devDependencies: string[], hasDocker: boolean, hasRoutes: boolean): string[];
+}