nexusforge-cli 1.1.1 → 1.2.1

package/dist/modules/contextBuilder.js

@@ -0,0 +1,725 @@
+/**
+ * Context Builder for NexusForge CLI
+ * Manages context for LLM interactions
+ * Ported from Python nexusforge/modules/llm/context_builder.py
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+// ============================================================================
+// CONTEXT BUILDER CLASS
+// ============================================================================
+export class ContextBuilder {
+    projectPath;
+    maxContextTokens = 30000;
+    tokenEstimateRatio = 1.3;
+    projectPatterns;
+    // Directories to ignore
+    static IGNORE_PATTERNS = new Set([
+        '.git', '__pycache__', 'node_modules', '.nexusforge',
+        'venv', 'env', '.env', 'dist', 'build', 'target',
+        '.venv', 'coverage', '.pytest_cache', '.mypy_cache',
+    ]);
+    // Extension to language mapping
+    static EXT_MAP = {
+        '.py': 'python',
+        '.js': 'javascript',
+        '.ts': 'typescript',
+        '.jsx': 'javascript',
+        '.tsx': 'typescript',
+        '.rs': 'rust',
+        '.go': 'go',
+        '.java': 'java',
+        '.cpp': 'cpp',
+        '.c': 'c',
+        '.cs': 'csharp',
+        '.rb': 'ruby',
+        '.php': 'php',
+    };
+    constructor(projectPath) {
+        this.projectPath = path.resolve(projectPath);
+        this.projectPatterns = this.detectProjectPatterns();
+    }
+    // ========================================================================
+    // MAIN CONTEXT BUILDING
+    // ========================================================================
+    buildContextForQuery(query) {
+        // Extract file references from query
+        const referencedFiles = this.extractFileReferences(query);
+        // Find relevant files based on query content
+        const relevantFiles = this.findRelevantFiles(query, referencedFiles);
+        // Add project structure info for multi-file operations
+        const multiFileKeywords = [
+            'create feature', 'add feature', 'new service', 'new component',
+            'implement', 'monitoring', 'control', 'dashboard',
+        ];
+        if (multiFileKeywords.some(keyword => query.toLowerCase().includes(keyword))) {
+            const structureContext = this.getProjectStructureContext();
+            if (structureContext) {
+                return structureContext + '\n\n' + this.buildHierarchicalContext(relevantFiles);
+            }
+        }
+        // If user requested specific files that weren't found, provide feedback
+        if (referencedFiles.size > 0 && relevantFiles.length === 0) {
+            const missingFiles = Array.from(referencedFiles).slice(0, 5);
+            let context = 'Could not find the following files:\n';
+            for (const f of missingFiles) {
+                context += `  - ${f}\n`;
+            }
+            context += '\nSearching for similar files...\n';
+            // Try to find similar files
+            for (const ref of referencedFiles) {
+                const similar = this.findSimilarFiles(ref);
+                if (similar.length > 0) {
+                    context += `\nFiles similar to '${ref}':\n`;
+                    for (const s of similar.slice(0, 3)) {
+                        context += `  - ${s}\n`;
+                    }
+                }
+            }
+            return context;
+        }
+        // Build hierarchical context
+        return this.buildHierarchicalContext(relevantFiles);
+    }
+    // ========================================================================
+    // FILE REFERENCE EXTRACTION
+    // ========================================================================
+    extractFileReferences(query) {
+        const references = new Set();
+        // Pattern 1: @filename or @path/to/file
+        const atPattern = /@(\S+)/g;
+        let match;
+        while ((match = atPattern.exec(query)) !== null) {
+            references.add(match[1]);
+        }
+        // Pattern 2: "in file.py" or "from file.js"
+        const inPattern = /(?:in|from)\s+(\S+\.\w+)/gi;
+        while ((match = inPattern.exec(query)) !== null) {
+            references.add(match[1]);
+        }
+        // Pattern 3: Quoted filenames
+        const quotePattern = /["']([^"']+\.\w+)["']/g;
+        while ((match = quotePattern.exec(query)) !== null) {
+            references.add(match[1]);
+        }
+        // Pattern 4: Function/class references
+        const funcPattern = /(?:function|class|def)\s+(\w+)/gi;
+        const potentialFuncs = [];
+        while ((match = funcPattern.exec(query)) !== null) {
+            potentialFuncs.push(match[1]);
+        }
+        // Search for files containing these functions
+        for (const func of potentialFuncs) {
+            const matchingFiles = this.searchForSymbol(func);
+            for (const f of matchingFiles) {
+                references.add(f);
+            }
+        }
+        // Pattern 5: Common file patterns
+        const extensions = 'js|jsx|ts|tsx|py|rs|java|cpp|c|h|hpp|go|rb|php|swift|kt|scala|' +
+            'html|htm|css|scss|sass|less|vue|svelte|' +
+            'json|yaml|yml|toml|xml|env|ini|conf|cfg|' +
+            'md|mdx|rst|txt|' +
+            'sh|bash|ps1|bat|cmd';
+        const reviewPatterns = [
+            new RegExp(`(?:review|check|look at|examine|analyze|find|open)\\s+(?:the\\s+)?(\\S+?)(?:\\s+file)?`, 'gi'),
+            new RegExp(`(?:find|analyze|review)\\s+(?:the\\s+)?(\\S+\\.(?:${extensions}))\\b`, 'gi'),
+            new RegExp(`(\\S+\\.(?:${extensions}))\\s+file`, 'gi'),
+        ];
+        for (const pattern of reviewPatterns) {
+            while ((match = pattern.exec(query)) !== null) {
+                const cleanMatch = match[1].replace(/[.,;:!?]$/, '');
+                if (!['the', 'a', 'an'].some(word => cleanMatch.startsWith(word)) && cleanMatch.length > 2) {
+                    references.add(cleanMatch);
+                }
+            }
+        }
+        return references;
+    }
+    // ========================================================================
+    // FILE FINDING AND RELEVANCE
+    // ========================================================================
+    findRelevantFiles(query, explicitRefs) {
+        const relevantFiles = [];
+        // First, add explicitly referenced files
+        for (const ref of explicitRefs) {
+            const filePath = path.join(this.projectPath, ref);
+            if (fs.existsSync(filePath) && fs.statSync(filePath).isFile()) {
+                const content = this.readFileSafely(filePath);
+                if (content) {
+                    relevantFiles.push({
+                        path: filePath,
+                        relevanceScore: 1.0,
+                        content,
+                        language: this.detectLanguage(filePath),
+                    });
+                }
+            }
+            else {
+                // Try to find file by name in subdirectories (LIMITED SEARCH)
+                const foundFiles = this.findFileByName(ref);
+                for (const foundPath of foundFiles.slice(0, 3)) {
+                    const content = this.readFileSafely(foundPath);
+                    if (content) {
+                        relevantFiles.push({
+                            path: foundPath,
+                            relevanceScore: 0.9,
+                            content,
+                            language: this.detectLanguage(foundPath),
+                        });
+                    }
+                }
+            }
+        }
+        // If no explicit files found, scan current directory
+        if (relevantFiles.length === 0) {
+            const keywords = this.extractKeywords(query);
+            const scannedFiles = this.scanCurrentDirectory(keywords);
+            relevantFiles.push(...scannedFiles);
+        }
+        // Extract keywords from query
+        const keywords = this.extractKeywords(query);
+        // Search for files containing keywords
+        for (const filePath of this.iterateProjectFiles()) {
+            if (Array.from(explicitRefs).some(ref => filePath.endsWith(ref))) {
+                continue;
+            }
+            const content = this.readFileSafely(filePath);
+            if (!content)
+                continue;
+            // Calculate relevance score
+            const score = this.calculateRelevance(content, keywords, query);
+            if (score > 0.3) {
+                relevantFiles.push({
+                    path: filePath,
+                    relevanceScore: score,
+                    content,
+                    language: this.detectLanguage(filePath),
+                });
+            }
+        }
+        // Sort by relevance
+        relevantFiles.sort((a, b) => b.relevanceScore - a.relevanceScore);
+        // Limit to top files that fit in context
+        return this.limitByContextSize(relevantFiles);
+    }
+    findFileByName(name) {
+        const results = [];
+        const scan = (dir, depth) => {
+            if (depth > 2)
+                return; // Only search 2 levels deep
+            try {
+                const entries = fs.readdirSync(dir, { withFileTypes: true });
+                for (const entry of entries) {
+                    const fullPath = path.join(dir, entry.name);
+                    if (entry.isDirectory()) {
+                        if (!this.shouldIgnore(fullPath)) {
+                            scan(fullPath, depth + 1);
+                        }
+                    }
+                    else if (entry.name.includes(name) || name.includes(entry.name)) {
+                        results.push(fullPath);
+                    }
+                }
+            }
+            catch {
+                // Ignore errors
+            }
+        };
+        scan(this.projectPath, 0);
+        return results;
+    }
+    scanCurrentDirectory(keywords) {
+        const relevantFiles = [];
+        // Scan project root and immediate subdirectories
+        const scanPaths = [this.projectPath];
+        try {
+            for (const item of fs.readdirSync(this.projectPath, { withFileTypes: true })) {
+                if (item.isDirectory() && !this.shouldIgnore(path.join(this.projectPath, item.name))) {
+                    scanPaths.push(path.join(this.projectPath, item.name));
+                }
+            }
+        }
+        catch {
+            // Ignore errors
+        }
+        for (const scanPath of scanPaths) {
+            try {
+                for (const file of fs.readdirSync(scanPath, { withFileTypes: true })) {
+                    if (file.isFile() && !this.shouldIgnore(path.join(scanPath, file.name))) {
+                        const filePath = path.join(scanPath, file.name);
+                        const content = this.readFileSafely(filePath);
+                        if (content) {
+                            const score = this.calculateRelevance(content, keywords, keywords.join(' '));
+                            if (score > 0.1) {
+                                relevantFiles.push({
+                                    path: filePath,
+                                    relevanceScore: score,
+                                    content,
+                                    language: this.detectLanguage(filePath),
+                                });
+                            }
+                        }
+                    }
+                }
+            }
+            catch {
+                // Ignore errors
+            }
+        }
+        return relevantFiles;
+    }
+    shouldIgnore(filepath) {
+        const parts = filepath.split(path.sep);
+        return parts.some(part => ContextBuilder.IGNORE_PATTERNS.has(part));
+    }
+    searchForSymbol(symbol) {
+        const matches = new Set();
+        try {
+            for (const filePath of this.iterateProjectFiles()) {
+                const content = this.readFileSafely(filePath);
+                if (!content)
+                    continue;
+                try {
+                    const regex = new RegExp(`\\b${symbol}\\b`);
+                    if (regex.test(content)) {
+                        matches.add(path.relative(this.projectPath, filePath));
+                    }
+                }
+                catch {
+                    // Fallback to simple includes
+                    if (content.includes(symbol)) {
+                        matches.add(path.relative(this.projectPath, filePath));
+                    }
+                }
+            }
+        }
+        catch {
+            // Ignore errors
+        }
+        return matches;
+    }
+    extractKeywords(query) {
+        const stopWords = new Set([
+            'the', 'a', 'an', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 'for',
+            'of', 'with', 'by', 'from', 'up', 'about', 'into', 'through', 'during',
+            'how', 'when', 'where', 'what', 'which', 'who', 'why', 'can', 'could',
+            'should', 'would', 'will', 'add', 'create', 'make', 'build', 'implement',
+            'update', 'modify', 'change', 'fix', 'improve', 'refactor',
+        ]);
+        const words = query.toLowerCase().match(/\b\w+\b/g) || [];
+        const keywords = [];
+        for (const word of words) {
+            if (word.length > 2 && !stopWords.has(word)) {
+                keywords.push(word);
+                if (word.includes('_')) {
+                    keywords.push(word.replace(/_/g, ''));
+                    keywords.push(word.split('_').map(p => p.charAt(0).toUpperCase() + p.slice(1)).join(''));
+                }
+            }
+        }
+        return keywords;
+    }
+    calculateRelevance(content, keywords, query) {
+        let score = 0.0;
+        const contentLower = content.toLowerCase();
+        // Keyword matches
+        for (const keyword of keywords) {
+            const count = (contentLower.match(new RegExp(keyword.toLowerCase(), 'g')) || []).length;
+            if (count > 0) {
+                score += Math.min(count * 0.1, 0.3);
+            }
+        }
+        // Special patterns
+        if (query.toLowerCase().includes('test') &&
+            (contentLower.includes('test') || contentLower.includes('spec'))) {
+            score += 0.2;
+        }
+        if (query.toLowerCase().includes('error') &&
+            (contentLower.includes('error') || contentLower.includes('exception'))) {
+            score += 0.2;
+        }
+        if (query.toLowerCase().includes('config') &&
+            ['config', 'settings', 'env'].some(word => contentLower.includes(word))) {
+            score += 0.2;
+        }
+        if (['import', 'require', 'use'].some(word => contentLower.includes(word))) {
+            score += 0.1;
+        }
+        return Math.min(score, 1.0);
+    }
+    // ========================================================================
+    // CONTEXT SIZE MANAGEMENT
+    // ========================================================================
+    limitByContextSize(files) {
+        const selected = [];
+        let currentTokens = 0;
+        for (const fileCtx of files) {
+            const tokens = fileCtx.content.split(/\s+/).length * this.tokenEstimateRatio;
+            if (currentTokens + tokens > this.maxContextTokens) {
+                if (fileCtx.relevanceScore > 0.8 && currentTokens < this.maxContextTokens * 0.9) {
+                    const lines = fileCtx.content.split('\n');
+                    fileCtx.content = lines.slice(0, 50).join('\n') + '\n... (truncated)';
+                    selected.push(fileCtx);
+                }
+                break;
+            }
+            selected.push(fileCtx);
+            currentTokens += tokens;
+        }
+        return selected;
+    }
+    // ========================================================================
+    // CONTEXT BUILDING AND FORMATTING
+    // ========================================================================
+    buildHierarchicalContext(files) {
+        if (files.length === 0) {
+            return '';
+        }
+        const contextParts = [];
+        // High relevance files
+        const highRelevance = files.filter(f => f.relevanceScore >= 0.8);
+        if (highRelevance.length > 0) {
+            contextParts.push('=== Highly Relevant Files ===\n');
+            for (const fileCtx of highRelevance) {
+                const relPath = path.relative(this.projectPath, fileCtx.path);
+                contextParts.push(`\n--- ${relPath} ---\n`);
+                contextParts.push(fileCtx.content);
+                contextParts.push('\n');
+            }
+        }
+        // Medium relevance files
+        const mediumRelevance = files.filter(f => f.relevanceScore >= 0.5 && f.relevanceScore < 0.8);
+        if (mediumRelevance.length > 0) {
+            contextParts.push('\n=== Related Files ===\n');
+            for (const fileCtx of mediumRelevance) {
+                const relPath = path.relative(this.projectPath, fileCtx.path);
+                contextParts.push(`\n--- ${relPath} (key sections) ---\n`);
+                const keyContent = this.extractKeySections(fileCtx.content, fileCtx.language);
+                contextParts.push(keyContent);
+                contextParts.push('\n');
+            }
+        }
+        // Low relevance files
+        const lowRelevance = files.filter(f => f.relevanceScore < 0.5);
+        if (lowRelevance.length > 0) {
+            contextParts.push('\n=== Project Structure ===\n');
+            for (const fileCtx of lowRelevance) {
+                const relPath = path.relative(this.projectPath, fileCtx.path);
+                const structure = this.extractStructure(fileCtx.content, fileCtx.language);
+                if (structure) {
+                    contextParts.push(`${relPath}: ${structure}\n`);
+                }
+            }
+        }
+        return contextParts.join('');
+    }
+    extractKeySections(content, language) {
+        const lines = content.split('\n');
+        const keyLines = [];
+        if (language === 'python') {
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                if (line.startsWith('import ') || line.startsWith('from ') ||
+                    line.startsWith('class ') || line.startsWith('def ') ||
+                    line.trim().startsWith('@')) {
+                    keyLines.push(line);
+                    // Include docstring if present
+                    if (i + 1 < lines.length && lines[i + 1].includes('"""')) {
+                        let j = i + 1;
+                        while (j < lines.length && !lines[j].slice(3).includes('"""')) {
+                            keyLines.push(lines[j]);
+                            j++;
+                            if (j < lines.length) {
+                                keyLines.push(lines[j]);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        else if (language === 'javascript' || language === 'typescript') {
+            for (const line of lines) {
+                if (line.startsWith('import ') || line.startsWith('export ') ||
+                    line.includes('class ') || line.includes('function ') || line.includes('const ')) {
+                    keyLines.push(line);
+                }
+            }
+        }
+        else if (language === 'rust') {
+            for (const line of lines) {
+                if (line.startsWith('use ') || line.startsWith('pub ') ||
+                    line.startsWith('struct ') || line.startsWith('trait ') ||
+                    line.startsWith('fn ') || line.startsWith('impl ')) {
+                    keyLines.push(line);
+                }
+            }
+        }
+        return keyLines.slice(0, 100).join('\n');
+    }
+    findSimilarFiles(target) {
+        const similarFiles = [];
+        const targetLower = target.toLowerCase();
+        const targetParts = targetLower.replace(/\./g, ' ').replace(/_/g, ' ').replace(/-/g, ' ').split(' ');
+        try {
+            for (const filePath of this.iterateProjectFiles()) {
+                const fileName = path.basename(filePath).toLowerCase();
+                if (targetParts.some(part => part.length > 2 && fileName.includes(part))) {
+                    const relPath = path.relative(this.projectPath, filePath);
+                    similarFiles.push(relPath);
+                }
+                if (targetLower.replace('.', '').includes(fileName.replace('.', ''))) {
+                    const relPath = path.relative(this.projectPath, filePath);
+                    if (!similarFiles.includes(relPath)) {
+                        similarFiles.push(relPath);
+                    }
+                }
+            }
+        }
+        catch {
+            // Ignore errors
+        }
+        return similarFiles.slice(0, 10);
+    }
+    extractStructure(content, language) {
+        const structures = [];
+        if (language === 'python') {
+            const classes = content.match(/^class\s+(\w+)/gm);
+            const functions = content.match(/^def\s+(\w+)/gm);
+            if (classes) {
+                const classNames = classes.map(c => c.replace('class ', '')).slice(0, 5);
+                structures.push(`classes: ${classNames.join(', ')}`);
+            }
+            if (functions) {
+                const funcNames = functions.map(f => f.replace('def ', '')).slice(0, 5);
+                structures.push(`functions: ${funcNames.join(', ')}`);
+            }
+        }
+        else if (language === 'javascript' || language === 'typescript') {
+            const exports = content.match(/export\s+(?:default\s+)?(?:class|function|const)\s+(\w+)/g);
+            if (exports) {
+                const exportNames = exports.map(e => e.replace(/export\s+(default\s+)?(class|function|const)\s+/, '')).slice(0, 5);
+                structures.push(`exports: ${exportNames.join(', ')}`);
+            }
+        }
+        return structures.join('; ');
+    }
+    // ========================================================================
+    // FILE I/O UTILITIES
+    // ========================================================================
+    readFileSafely(filePath) {
+        try {
+            const content = fs.readFileSync(filePath, 'utf-8');
+            const lines = content.split('\n');
+            return lines.slice(0, 2000).join('\n');
+        }
+        catch {
+            try {
+                const content = fs.readFileSync(filePath, 'latin1');
+                const lines = content.split('\n');
+                return lines.slice(0, 2000).join('\n');
+            }
+            catch {
+                return null;
+            }
+        }
+    }
+    detectLanguage(filePath) {
+        return ContextBuilder.EXT_MAP[path.extname(filePath).toLowerCase()] || 'text';
+    }
+    *iterateProjectFiles() {
+        const maxDepth = 2;
+        function* scan(dir, depth, self) {
+            if (depth > maxDepth)
+                return;
+            try {
+                const entries = fs.readdirSync(dir, { withFileTypes: true });
+                for (const entry of entries) {
+                    const fullPath = path.join(dir, entry.name);
+                    if (ContextBuilder.IGNORE_PATTERNS.has(entry.name))
+                        continue;
+                    if (entry.isFile()) {
+                        const ext = path.extname(entry.name).toLowerCase();
+                        if (!['.pyc', '.exe', '.dll', '.so', '.dylib', '.jpg', '.png', '.gif', '.pdf'].includes(ext)) {
+                            yield fullPath;
+                        }
+                    }
+                    else if (entry.isDirectory() && depth < maxDepth) {
+                        yield* scan(fullPath, depth + 1, self);
+                    }
+                }
+            }
+            catch {
+                // Ignore errors
+            }
+        }
+        yield* scan(this.projectPath, 0, this);
+    }
+    // ========================================================================
+    // PROJECT PATTERN DETECTION
+    // ========================================================================
+    detectProjectPatterns() {
+        const patterns = {
+            serviceLocations: [],
+            uiLocations: [],
+            logicLocations: [],
+            configLocations: [],
+            styleLocations: [],
+            apiLocations: [],
+        };
+        try {
+            for (const filePath of this.iterateProjectFiles()) {
+                const relPath = path.relative(this.projectPath, filePath).replace(/\\/g, '/');
+                if (['service', 'monitor', 'reporter'].some(p => relPath.toLowerCase().includes(p))) {
+                    patterns.serviceLocations.push(path.dirname(relPath));
+                }
+                if (['.tsx', '.jsx'].some(ext => relPath.includes(ext)) ||
+                    ['pages', 'components'].some(p => relPath.includes(p))) {
+                    patterns.uiLocations.push(path.dirname(relPath));
+                }
+                if (['logic', 'controller'].some(p => relPath.toLowerCase().includes(p))) {
+                    patterns.logicLocations.push(path.dirname(relPath));
+                }
+                if (relPath.toLowerCase().includes('config') ||
+                    ['.json', '.yaml', '.yml'].some(ext => relPath.endsWith(ext))) {
+                    patterns.configLocations.push(path.dirname(relPath));
+                }
+                if (['.css', '.scss', '.less'].some(ext => relPath.endsWith(ext)) ||
+                    relPath.includes('styles')) {
+                    patterns.styleLocations.push(path.dirname(relPath));
+                }
+                if (['api', 'routes', 'server'].some(p => relPath.toLowerCase().includes(p))) {
+                    patterns.apiLocations.push(path.dirname(relPath));
+                }
+            }
+        }
+        catch {
+            // Ignore errors
+        }
+        // Deduplicate and sort by frequency
+        for (const key of Object.keys(patterns)) {
+            const counts = new Map();
+            for (const loc of patterns[key]) {
+                counts.set(loc, (counts.get(loc) || 0) + 1);
+            }
+            patterns[key] = Array.from(counts.entries())
+                .sort((a, b) => b[1] - a[1])
+                .map(e => e[0])
+                .slice(0, 5);
+        }
+        return patterns;
+    }
+    getProjectStructureContext() {
+        let context = 'PROJECT STRUCTURE PATTERNS DETECTED:\n';
+        context += '='.repeat(50) + '\n\n';
+        if (this.projectPatterns.serviceLocations.length > 0) {
+            context += 'SERVICE FILES LOCATION:\n';
+            for (const loc of this.projectPatterns.serviceLocations.slice(0, 3)) {
+                context += `  - ${loc}/\n`;
+            }
+            context += '\n';
+        }
+        if (this.projectPatterns.uiLocations.length > 0) {
+            context += 'UI COMPONENTS LOCATION:\n';
+            for (const loc of this.projectPatterns.uiLocations.slice(0, 3)) {
+                context += `  - ${loc}/\n`;
+            }
+            context += '\n';
+        }
+        if (this.projectPatterns.logicLocations.length > 0) {
+            context += 'LOGIC/CONTROLLER FILES LOCATION:\n';
+            for (const loc of this.projectPatterns.logicLocations.slice(0, 3)) {
+                context += `  - ${loc}/\n`;
+            }
+            context += '\n';
+        }
+        if (this.projectPatterns.configLocations.length > 0) {
+            context += 'CONFIGURATION FILES LOCATION:\n';
+            for (const loc of this.projectPatterns.configLocations.slice(0, 3)) {
+                context += `  - ${loc}/\n`;
+            }
+            context += '\n';
+        }
+        if (this.projectPatterns.styleLocations.length > 0) {
+            context += 'STYLES/CSS FILES LOCATION:\n';
+            for (const loc of this.projectPatterns.styleLocations.slice(0, 3)) {
+                context += `  - ${loc}/\n`;
+            }
+            context += '\n';
+        }
+        if (this.projectPatterns.apiLocations.length > 0) {
+            context += 'API/SERVER FILES LOCATION:\n';
+            for (const loc of this.projectPatterns.apiLocations.slice(0, 3)) {
+                context += `  - ${loc}/\n`;
+            }
+            context += '\n';
+        }
+        context += 'EXAMPLE FILES TO FOLLOW PATTERNS FROM:\n';
+        try {
+            const examples = this.findExampleFiles();
+            for (const [category, files] of Object.entries(examples)) {
+                if (files.length > 0) {
+                    context += `\n${category}:\n`;
+                    for (const f of files.slice(0, 2)) {
+                        context += `  - ${f}\n`;
+                    }
+                }
+            }
+        }
+        catch {
+            // Ignore errors
+        }
+        context += '\nREMEMBER: When creating new features, create ALL necessary files following these patterns!\n';
+        return context;
+    }
+    findExampleFiles() {
+        const examples = {
+            'Services': [],
+            'UI Components': [],
+            'Logic Files': [],
+            'API Routes': [],
+        };
+        try {
+            for (const filePath of this.iterateProjectFiles()) {
+                const relPath = path.relative(this.projectPath, filePath).replace(/\\/g, '/');
+                const ext = path.extname(filePath);
+                if (relPath.toLowerCase().includes('service') && ['.js', '.ts', '.py'].includes(ext)) {
+                    examples['Services'].push(relPath);
+                }
+                if (['.tsx', '.jsx'].includes(ext) && (['pages', 'components'].some(p => relPath.includes(p)))) {
+                    examples['UI Components'].push(relPath);
+                }
+                if (relPath.toLowerCase().includes('logic') && ['.js', '.ts', '.py'].includes(ext)) {
+                    examples['Logic Files'].push(relPath);
+                }
+                if (['server', 'api'].some(p => relPath.toLowerCase().includes(p)) && ['.js', '.ts', '.py'].includes(ext)) {
+                    examples['API Routes'].push(relPath);
+                }
+                // Limit to 2 per category
+                for (const key of Object.keys(examples)) {
+                    if (examples[key].length >= 2) {
+                        examples[key] = examples[key].slice(0, 2);
+                    }
+                }
+            }
+        }
+        catch {
+            // Ignore errors
+        }
+        return examples;
+    }
+}
+// ============================================================================
+// SINGLETON INSTANCE
+// ============================================================================
+let builderInstance = null;
+export function getContextBuilder(projectPath) {
+    if (!builderInstance || (projectPath && builderInstance['projectPath'] !== path.resolve(projectPath))) {
+        builderInstance = new ContextBuilder(projectPath || process.cwd());
+    }
+    return builderInstance;
+}
+export function resetContextBuilder() {
+    builderInstance = null;
+}
+//# sourceMappingURL=contextBuilder.js.map