@compass-ai/nova 1.0.74 → 1.0.76

package/dist/core/context-builder.js

@@ -1,1018 +0,0 @@
-/**
- * Context building logic for assembling relevant codebase context for LLM queries.
- * This module is responsible for gathering and organizing project files, code snippets,
- * and metadata to provide Claude with the necessary context for development tasks.
- */
-import path from 'path';
-import { glob } from 'glob';
-import { safeReadFile, pathExists, stat } from '../utils/file-system.js';
-import { sanitizePath, toForwardSlashes } from '../utils/path.js';
-import { estimateTokens } from '../utils/token-counter.js';
-import { logger } from '../utils/logger.js';
-import { DEFAULT_CONFIG } from '../constants/defaults.js';
-import { DEFAULT_IGNORE_PATTERNS, shouldExcludeDirectory, shouldExcludeFile, mergeSessionExclusions, shouldExcludeSessionPath, loadIgnorePatterns, } from '../utils/ignore-patterns.js';
-import { getSessionManager } from '../services/session-manager.js';
-/**
- * Marker files used to detect project type
- */
-const PROJECT_MARKERS = {
-    nodejs: ['package.json'],
-    typescript: ['tsconfig.json', 'tsconfig.base.json'],
-    python: ['pyproject.toml', 'setup.py', 'requirements.txt', 'Pipfile'],
-    go: ['go.mod', 'go.sum'],
-    rust: ['Cargo.toml', 'Cargo.lock'],
-    java: ['pom.xml', 'build.gradle', 'build.gradle.kts'],
-    csharp: ['*.csproj', '*.sln'],
-    ruby: ['Gemfile', 'Rakefile', '*.gemspec'],
-    php: ['composer.json', 'composer.lock'],
-    unknown: [],
-};
-/**
- * Language detection mapping based on file extensions
- */
-const EXTENSION_TO_LANGUAGE = {
-    '.ts': 'typescript',
-    '.tsx': 'typescript',
-    '.js': 'javascript',
-    '.jsx': 'javascript',
-    '.mjs': 'javascript',
-    '.cjs': 'javascript',
-    '.py': 'python',
-    '.rb': 'ruby',
-    '.go': 'go',
-    '.rs': 'rust',
-    '.java': 'java',
-    '.kt': 'kotlin',
-    '.swift': 'swift',
-    '.c': 'c',
-    '.cpp': 'cpp',
-    '.h': 'c',
-    '.hpp': 'cpp',
-    '.cs': 'csharp',
-    '.php': 'php',
-    '.vue': 'vue',
-    '.svelte': 'svelte',
-    '.html': 'html',
-    '.css': 'css',
-    '.scss': 'scss',
-    '.sass': 'sass',
-    '.less': 'less',
-    '.json': 'json',
-    '.yaml': 'yaml',
-    '.yml': 'yaml',
-    '.xml': 'xml',
-    '.md': 'markdown',
-    '.mdx': 'markdown',
-    '.sql': 'sql',
-    '.sh': 'shell',
-    '.bash': 'shell',
-    '.zsh': 'shell',
-    '.fish': 'shell',
-    '.ps1': 'powershell',
-    '.dockerfile': 'dockerfile',
-    '.toml': 'toml',
-    '.ini': 'ini',
-    '.env': 'env',
-    '.graphql': 'graphql',
-    '.gql': 'graphql',
-    '.proto': 'protobuf',
-};
-/**
- * ContextBuilder class for assembling relevant codebase context for LLM queries.
- * Handles file discovery, content loading, token estimation, and context optimization.
- */
-class ContextBuilder {
-    projectRoot;
-    maxTokens;
-    maxFiles;
-    includePatterns;
-    excludePatterns;
-    priorityFiles;
-    fileCache = new Map();
-    constructor(options = {}) {
-        this.projectRoot = options.projectRoot || process.cwd();
-        this.maxTokens = options.maxTokens || 100000;
-        this.maxFiles = options.maxFiles || 100;
-        this.includePatterns = options.includePatterns || ['**/*'];
-        this.excludePatterns = options.excludePatterns || DEFAULT_IGNORE_PATTERNS;
-        this.priorityFiles = options.priorityFiles || [];
-    }
-    /**
-     * Sets the project root directory
-     */
-    setProjectRoot(projectRoot) {
-        this.projectRoot = projectRoot;
-        this.clearCache();
-    }
-    /**
-     * Sets the maximum token limit for context
-     */
-    setMaxTokens(maxTokens) {
-        this.maxTokens = maxTokens;
-    }
-    /**
-     * Sets the maximum number of files to include
-     */
-    setMaxFiles(maxFiles) {
-        this.maxFiles = maxFiles;
-    }
-    /**
-     * Adds files to the priority list
-     */
-    addPriorityFiles(files) {
-        this.priorityFiles = [...new Set([...this.priorityFiles, ...files])];
-    }
-    /**
-     * Clears the file cache
-     */
-    clearCache() {
-        this.fileCache.clear();
-    }
-    /**
-     * Gets the effective exclude patterns including session exclusions.
-     * If custom excludePatterns were provided in constructor options, uses those.
-     * Otherwise loads patterns from .gitignore files (including nested ones).
-     */
-    async getEffectiveExcludePatterns() {
-        const sessionManager = getSessionManager();
-        const sessionExcludedFolders = sessionManager.getExcludedFolders();
-        // If custom patterns were provided, use those; otherwise load from .gitignore files
-        const basePatterns = this.excludePatterns === DEFAULT_IGNORE_PATTERNS
-            ? await loadIgnorePatterns(this.projectRoot)
-            : this.excludePatterns;
-        return mergeSessionExclusions(sessionExcludedFolders, basePatterns);
-    }
-    /**
-     * Discovers all relevant files in the project
-     */
-    async discoverFiles() {
-        try {
-            const effectiveExcludePatterns = await this.getEffectiveExcludePatterns();
-            // Debug: show patterns being used
-            logger.debug(`Using ${effectiveExcludePatterns.length} exclude patterns for file discovery`);
-            const nodeModulesPatterns = effectiveExcludePatterns.filter(p => p.includes('node_modules'));
-            logger.debug(`node_modules patterns: ${nodeModulesPatterns.slice(0, 5).join(', ')}${nodeModulesPatterns.length > 5 ? `... (${nodeModulesPatterns.length} total)` : ''}`);
-            const files = await glob(this.includePatterns, {
-                cwd: this.projectRoot,
-                nodir: true,
-                ignore: effectiveExcludePatterns,
-                absolute: false,
-                dot: false,
-            });
-            // Filter out binary and large files
-            const filteredFiles = [];
-            for (const file of files) {
-                if (this.isTextFile(file)) {
-                    const absolutePath = path.join(this.projectRoot, file);
-                    const stats = await stat(absolutePath);
-                    if (stats && stats.size <= DEFAULT_CONFIG.project.maxFileSize) {
-                        filteredFiles.push(file);
-                    }
-                }
-            }
-            logger.debug(`Discovered ${filteredFiles.length} files in project`);
-            // Debug: show sample of discovered files to understand what's being included
-            const nodeModuleFiles = filteredFiles.filter(f => f.includes('node_modules'));
-            if (nodeModuleFiles.length > 0) {
-                logger.debug(`WARNING: Found ${nodeModuleFiles.length} files in node_modules! Sample: ${nodeModuleFiles.slice(0, 3).join(', ')}`);
-            }
-            return filteredFiles;
-        }
-        catch (error) {
-            logger.error('Failed to discover files', error);
-            return [];
-        }
-    }
-    /**
-     * Loads a file and creates a ContextFile object
-     */
-    async loadFile(relativePath) {
-        // Check cache first
-        if (this.fileCache.has(relativePath)) {
-            return this.fileCache.get(relativePath);
-        }
-        const absolutePath = path.join(this.projectRoot, relativePath);
-        const sanitized = sanitizePath(relativePath, this.projectRoot);
-        if (!sanitized) {
-            logger.warn(`Path traversal attempt blocked: ${relativePath}`);
-            return null;
-        }
-        if (!await pathExists(absolutePath)) {
-            logger.debug(`File not found: ${relativePath}`);
-            return null;
-        }
-        try {
-            const content = await safeReadFile(absolutePath);
-            if (content === null) {
-                return null;
-            }
-            const stats = await stat(absolutePath);
-            const tokenCount = estimateTokens(content);
-            const language = this.detectLanguage(relativePath);
-            const contextFile = {
-                path: absolutePath,
-                relativePath: toForwardSlashes(relativePath),
-                content,
-                tokenCount,
-                size: stats?.size || 0,
-                lastModified: stats?.mtime || new Date(),
-                language,
-            };
-            // Cache the file
-            this.fileCache.set(relativePath, contextFile);
-            return contextFile;
-        }
-        catch (error) {
-            logger.error(`Failed to load file: ${relativePath}`, error);
-            return null;
-        }
-    }
-    /**
-     * Loads multiple files in parallel
-     */
-    async loadFiles(relativePaths) {
-        const results = await Promise.all(relativePaths.map((p) => this.loadFile(p)));
-        return results.filter((f) => f !== null);
-    }
-    /**
-     * Builds context from specified files
-     */
-    async buildContext(files) {
-        const filesToLoad = files || await this.discoverFiles();
-        const loadedFiles = await this.loadFiles(filesToLoad);
-        // Sort files by priority
-        const sortedFiles = this.sortFilesByPriority(loadedFiles);
-        // Select files within token budget
-        const selectedFiles = this.selectFilesWithinBudget(sortedFiles);
-        const totalTokens = selectedFiles.reduce((sum, f) => sum + f.tokenCount, 0);
-        const summary = this.generateContextSummary(selectedFiles);
-        return {
-            files: selectedFiles,
-            totalTokens,
-            summary,
-            projectRoot: this.projectRoot,
-            timestamp: new Date().toISOString(),
-        };
-    }
-    /**
-     * Builds context for specific file patterns
-     */
-    async buildContextForPatterns(patterns) {
-        const effectiveExcludePatterns = await this.getEffectiveExcludePatterns();
-        const files = await glob(patterns, {
-            cwd: this.projectRoot,
-            nodir: true,
-            ignore: effectiveExcludePatterns,
-            absolute: false,
-        });
-        return this.buildContext(files);
-    }
-    /**
-     * Builds context including specific files with priority
-     */
-    async buildContextWithPriority(priorityFiles, additionalFiles) {
-        // Load priority files first
-        const priorityLoaded = await this.loadFiles(priorityFiles);
-        // Calculate remaining token budget
-        const priorityTokens = priorityLoaded.reduce((sum, f) => sum + f.tokenCount, 0);
-        const remainingBudget = this.maxTokens - priorityTokens;
-        // Load additional files if budget allows
-        let additionalLoaded = [];
-        if (remainingBudget > 0 && additionalFiles) {
-            const loaded = await this.loadFiles(additionalFiles);
-            additionalLoaded = this.selectFilesWithinBudget(loaded, remainingBudget);
-        }
-        const allFiles = [...priorityLoaded, ...additionalLoaded];
-        const totalTokens = allFiles.reduce((sum, f) => sum + f.tokenCount, 0);
-        const summary = this.generateContextSummary(allFiles);
-        return {
-            files: allFiles,
-            totalTokens,
-            summary,
-            projectRoot: this.projectRoot,
-            timestamp: new Date().toISOString(),
-        };
-    }
-    /**
-     * Formats context for LLM consumption
-     */
-    formatContextForLLM(context) {
-        const parts = [];
-        parts.push('## Project Context');
-        parts.push('');
-        parts.push(`Project Root: ${context.projectRoot}`);
-        parts.push(`Files Included: ${context.files.length}`);
-        parts.push(`Total Tokens: ${context.totalTokens.toLocaleString()}`);
-        parts.push('');
-        parts.push('---');
-        parts.push('');
-        for (const file of context.files) {
-            parts.push(`### File: ${file.relativePath}`);
-            parts.push(`Language: ${file.language} | Tokens: ${file.tokenCount.toLocaleString()}`);
-            parts.push('');
-            parts.push('```' + file.language);
-            parts.push(file.content);
-            parts.push('```');
-            parts.push('');
-        }
-        return parts.join('\n');
-    }
-    /**
-     * Formats context as a compact summary
-     */
-    formatContextSummary(context) {
-        const parts = [];
-        parts.push(`📁 Project: ${path.basename(context.projectRoot)}`);
-        parts.push(`📄 Files: ${context.files.length}`);
-        parts.push(`🔤 Tokens: ${context.totalTokens.toLocaleString()}`);
-        parts.push('');
-        parts.push('Files included:');
-        for (const file of context.files) {
-            parts.push(`  • ${file.relativePath} (${file.tokenCount.toLocaleString()} tokens)`);
-        }
-        return parts.join('\n');
-    }
-    /**
-     * Gets context usage statistics
-     */
-    getContextStats(context, contextWindow) {
-        const usedTokens = context.totalTokens;
-        const remainingTokens = Math.max(0, contextWindow - usedTokens);
-        const usagePercent = Math.round((usedTokens / contextWindow) * 100);
-        return {
-            usedTokens,
-            remainingTokens,
-            usagePercent,
-            fileCount: context.files.length,
-        };
-    }
-    /**
-     * Detects the programming language based on file extension
-     */
-    detectLanguage(filePath) {
-        const ext = path.extname(filePath).toLowerCase();
-        // Check for special filenames
-        const basename = path.basename(filePath).toLowerCase();
-        if (basename === 'dockerfile' || basename.startsWith('dockerfile.')) {
-            return 'dockerfile';
-        }
-        if (basename === 'makefile' || basename === 'gnumakefile') {
-            return 'makefile';
-        }
-        if (basename === '.gitignore' || basename === '.dockerignore') {
-            return 'gitignore';
-        }
-        return EXTENSION_TO_LANGUAGE[ext] || 'text';
-    }
-    /**
-     * Checks if a file is likely a text file based on extension
-     */
-    isTextFile(filePath) {
-        const ext = path.extname(filePath).toLowerCase();
-        const basename = path.basename(filePath).toLowerCase();
-        // Binary file extensions to exclude
-        const binaryExtensions = new Set([
-            '.png', '.jpg', '.jpeg', '.gif', '.bmp', '.ico', '.webp', '.svg',
-            '.mp3', '.mp4', '.wav', '.avi', '.mov', '.mkv', '.webm',
-            '.zip', '.tar', '.gz', '.rar', '.7z', '.bz2',
-            '.pdf', '.doc', '.docx', '.xls', '.xlsx', '.ppt', '.pptx',
-            '.exe', '.dll', '.so', '.dylib', '.bin',
-            '.woff', '.woff2', '.ttf', '.otf', '.eot',
-            '.sqlite', '.db',
-        ]);
-        if (binaryExtensions.has(ext)) {
-            return false;
-        }
-        // Known text files without extensions
-        const textFilenames = new Set([
-            'dockerfile', 'makefile', 'gnumakefile', 'rakefile',
-            'gemfile', 'procfile', 'brewfile', 'vagrantfile',
-            '.gitignore', '.dockerignore', '.npmignore', '.eslintignore',
-            '.prettierignore', '.editorconfig', '.env', '.env.example',
-            'license', 'readme', 'changelog', 'contributing', 'authors',
-        ]);
-        if (textFilenames.has(basename)) {
-            return true;
-        }
-        // If extension is in our language map, it's a text file
-        if (EXTENSION_TO_LANGUAGE[ext]) {
-            return true;
-        }
-        // Default to true for unknown extensions (will be filtered by size later)
-        return ext === '' || ext.length <= 5;
-    }
-    /**
-     * Sorts files by priority for context inclusion
-     */
-    sortFilesByPriority(files) {
-        const priorities = files.map((file) => ({
-            path: file.relativePath,
-            priority: this.calculateFilePriority(file),
-            tokenCount: file.tokenCount,
-        }));
-        // Sort by priority (higher first), then by token count (smaller first for ties)
-        priorities.sort((a, b) => {
-            if (b.priority !== a.priority) {
-                return b.priority - a.priority;
-            }
-            return a.tokenCount - b.tokenCount;
-        });
-        // Return files in sorted order
-        const pathOrder = new Map(priorities.map((p, i) => [p.path, i]));
-        return [...files].sort((a, b) => {
-            const orderA = pathOrder.get(a.relativePath) ?? Infinity;
-            const orderB = pathOrder.get(b.relativePath) ?? Infinity;
-            return orderA - orderB;
-        });
-    }
-    /**
-     * Calculates priority score for a file
-     */
-    calculateFilePriority(file) {
-        let priority = 0;
-        // Priority files get highest score
-        if (this.priorityFiles.some((p) => file.relativePath.includes(p))) {
-            priority += 1000;
-        }
-        // Configuration files are important
-        const configPatterns = [
-            'package.json', 'tsconfig.json', 'webpack.config',
-            'vite.config', 'rollup.config', '.eslintrc', '.prettierrc',
-            'pyproject.toml', 'setup.py', 'requirements.txt',
-            'Cargo.toml', 'go.mod', 'pom.xml', 'build.gradle',
-        ];
-        if (configPatterns.some((p) => file.relativePath.includes(p))) {
-            priority += 100;
-        }
-        // Entry points and main files
-        const entryPatterns = [
-            'index.ts', 'index.js', 'main.ts', 'main.js',
-            'app.ts', 'app.js', 'cli.ts', 'cli.js',
-            '__init__.py', 'main.py', 'app.py',
-            'main.go', 'main.rs', 'Main.java',
-        ];
-        if (entryPatterns.some((p) => file.relativePath.endsWith(p))) {
-            priority += 80;
-        }
-        // Source files in src directory
-        if (file.relativePath.startsWith('src/')) {
-            priority += 50;
-        }
-        // Type definitions
-        if (file.relativePath.includes('/types/') || file.relativePath.endsWith('.d.ts')) {
-            priority += 40;
-        }
-        // Test files get lower priority
-        if (file.relativePath.includes('test') || file.relativePath.includes('spec')) {
-            priority -= 20;
-        }
-        // Recently modified files (if we had that info)
-        // This could be enhanced with git integration
-        // Smaller files are slightly preferred (easier to include more context)
-        if (file.tokenCount < 500) {
-            priority += 10;
-        }
-        else if (file.tokenCount > 5000) {
-            priority -= 10;
-        }
-        return priority;
-    }
-    /**
-     * Selects files that fit within the token budget
-     */
-    selectFilesWithinBudget(files, budget) {
-        const maxBudget = budget ?? this.maxTokens;
-        const selected = [];
-        let currentTokens = 0;
-        for (const file of files) {
-            if (selected.length >= this.maxFiles) {
-                break;
-            }
-            if (currentTokens + file.tokenCount <= maxBudget) {
-                selected.push(file);
-                currentTokens += file.tokenCount;
-            }
-        }
-        return selected;
-    }
-    /**
-     * Generates a summary of the context
-     */
-    generateContextSummary(files) {
-        const languageCounts = {};
-        let totalTokens = 0;
-        for (const file of files) {
-            languageCounts[file.language] = (languageCounts[file.language] || 0) + 1;
-            totalTokens += file.tokenCount;
-        }
-        const languageList = Object.entries(languageCounts)
-            .sort((a, b) => b[1] - a[1])
-            .map(([lang, count]) => `${lang}: ${count}`)
-            .join(', ');
-        return `${files.length} files (${totalTokens.toLocaleString()} tokens) - ${languageList}`;
-    }
-    /**
-     * Detects the project type based on marker files present in the project root
-     */
-    async detectProjectType() {
-        // Check for TypeScript first (more specific than nodejs)
-        for (const marker of PROJECT_MARKERS.typescript) {
-            if (await pathExists(path.join(this.projectRoot, marker))) {
-                return 'typescript';
-            }
-        }
-        // Check other project types in order of specificity
-        const typeOrder = [
-            'rust', 'go', 'python', 'java', 'csharp', 'ruby', 'php', 'nodejs'
-        ];
-        for (const projectType of typeOrder) {
-            const markers = PROJECT_MARKERS[projectType];
-            for (const marker of markers) {
-                // Handle glob patterns like *.csproj
-                if (marker.includes('*')) {
-                    const matches = await glob(marker, {
-                        cwd: this.projectRoot,
-                        nodir: true,
-                    });
-                    if (matches.length > 0) {
-                        return projectType;
-                    }
-                }
-                else if (await pathExists(path.join(this.projectRoot, marker))) {
-                    return projectType;
-                }
-            }
-        }
-        return 'unknown';
-    }
-    /**
-     * Generates a directory tree in markdown format
-     * @param maxDepth - Maximum depth to traverse (default: 6)
-     * @param maxItems - Maximum items per directory to show (default: 20)
-     */
-    async getDirectoryTree(maxDepth = 6, maxItems = 20) {
-        const lines = [];
-        const rootName = path.basename(this.projectRoot);
-        lines.push(rootName + '/');
-        // Get session excluded folders for tree filtering
-        const sessionManager = getSessionManager();
-        const sessionExcludedFolders = sessionManager.getExcludedFolders();
-        await this.buildTreeRecursive('', 0, maxDepth, maxItems, lines, '', sessionExcludedFolders);
-        return lines.join('\n');
-    }
-    /**
-     * Generates a compact directory tree for classifier/routing prompts.
-     * Uses shallow traversal and emits summary lines at the depth boundary
-     * instead of enumerating every file.
-     * @param maxDepth - Maximum depth to traverse (default: 3)
-     * @param maxItems - Maximum items per directory to show (default: 15)
-     */
-    async getCompactDirectoryTree(maxDepth = 3, maxItems = 15) {
-        const lines = [];
-        const rootName = path.basename(this.projectRoot);
-        lines.push(rootName + '/');
-        const sessionManager = getSessionManager();
-        const sessionExcludedFolders = sessionManager.getExcludedFolders();
-        await this.buildCompactTreeRecursive('', 0, maxDepth, maxItems, lines, '', sessionExcludedFolders);
-        return lines.join('\n');
-    }
-    /**
-     * Recursively builds a compact directory tree.
-     * At the depth boundary, directories are summarized with file/subdir counts
-     * instead of being traversed further.
-     */
-    async buildCompactTreeRecursive(relativePath, depth, maxDepth, maxItems, lines, prefix, sessionExcludedFolders = []) {
-        const currentPath = path.join(this.projectRoot, relativePath);
-        try {
-            const { readdir } = await import('fs/promises');
-            const entries = await readdir(currentPath, { withFileTypes: true });
-            const filtered = entries.filter((entry) => {
-                const name = entry.name;
-                if (entry.isDirectory()) {
-                    if (shouldExcludeDirectory(name))
-                        return false;
-                    const entryRelativePath = relativePath ? `${relativePath}/${name}` : name;
-                    return !shouldExcludeSessionPath(entryRelativePath, sessionExcludedFolders);
-                }
-                return !shouldExcludeFile(name);
-            });
-            filtered.sort((a, b) => {
-                if (a.isDirectory() && !b.isDirectory())
-                    return -1;
-                if (!a.isDirectory() && b.isDirectory())
-                    return 1;
-                return a.name.localeCompare(b.name);
-            });
-            const itemsToShow = filtered.slice(0, maxItems);
-            const hasMore = filtered.length > maxItems;
-            // At max depth, summarize directories instead of recursing
-            if (depth >= maxDepth) {
-                // Just report that this directory has content (caller will summarize)
-                return filtered.length > 0;
-            }
-            // Build visible entries with child content or summaries
-            const visibleEntries = [];
-            for (const entry of itemsToShow) {
-                if (entry.isDirectory()) {
-                    const childRelPath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
-                    if (depth + 1 >= maxDepth) {
-                        // At the boundary: summarize instead of recursing
-                        const summary = await this.summarizeDirectory(childRelPath, sessionExcludedFolders);
-                        visibleEntries.push({ entry, summary });
-                    }
-                    else {
-                        // Still within depth: recurse normally
-                        const childLines = [];
-                        const hasContent = await this.buildCompactTreeRecursive(childRelPath, depth + 1, maxDepth, maxItems, childLines, '', sessionExcludedFolders);
-                        if (hasContent) {
-                            visibleEntries.push({ entry, childLines });
-                        }
-                    }
-                }
-                else {
-                    visibleEntries.push({ entry });
-                }
-            }
-            if (hasMore) {
-                visibleEntries.push({ entry: null });
-            }
-            if (visibleEntries.length === 0)
-                return false;
-            for (let i = 0; i < visibleEntries.length; i++) {
-                const { entry, childLines, summary } = visibleEntries[i];
-                const isLast = i === visibleEntries.length - 1;
-                const connector = isLast ? '└── ' : '├── ';
-                const childPrefix = isLast ? '    ' : '│   ';
-                if (entry === null) {
-                    lines.push(prefix + connector + '... (' + (filtered.length - maxItems) + ' more items)');
-                }
-                else if (entry.isDirectory()) {
-                    if (summary) {
-                        lines.push(prefix + connector + entry.name + '/  ' + summary);
-                    }
-                    else {
-                        lines.push(prefix + connector + entry.name + '/');
-                        for (const childLine of childLines) {
-                            lines.push(prefix + childPrefix + childLine);
-                        }
-                    }
-                }
-                else {
-                    lines.push(prefix + connector + entry.name);
-                }
-            }
-            return true;
-        }
-        catch (error) {
-            logger.debug(`Failed to read directory: ${currentPath}`, error);
-            return false;
-        }
-    }
-    /**
-     * Summarizes a directory by counting subdirectories and files recursively.
-     * Returns a string like "(8 subdirs, 42 files)".
-     */
-    async summarizeDirectory(relativePath, sessionExcludedFolders = []) {
-        let subdirs = 0;
-        let files = 0;
-        const countRecursive = async (relPath) => {
-            const fullPath = path.join(this.projectRoot, relPath);
-            try {
-                const { readdir } = await import('fs/promises');
-                const entries = await readdir(fullPath, { withFileTypes: true });
-                for (const entry of entries) {
-                    if (entry.isDirectory()) {
-                        if (shouldExcludeDirectory(entry.name))
-                            continue;
-                        const entryRelPath = relPath ? `${relPath}/${entry.name}` : entry.name;
-                        if (shouldExcludeSessionPath(entryRelPath, sessionExcludedFolders))
-                            continue;
-                        subdirs++;
-                        await countRecursive(entryRelPath);
-                    }
-                    else {
-                        if (!shouldExcludeFile(entry.name)) {
-                            files++;
-                        }
-                    }
-                }
-            }
-            catch {
-                // Skip unreadable directories
-            }
-        };
-        await countRecursive(relativePath);
-        const parts = [];
-        if (subdirs > 0)
-            parts.push(`${subdirs} subdir${subdirs !== 1 ? 's' : ''}`);
-        if (files > 0)
-            parts.push(`${files} file${files !== 1 ? 's' : ''}`);
-        return parts.length > 0 ? `(${parts.join(', ')})` : '(empty)';
-    }
-    /**
-     * Recursively builds the directory tree
-     */
-    async buildTreeRecursive(relativePath, depth, maxDepth, maxItems, lines, prefix, sessionExcludedFolders = []) {
-        if (depth >= maxDepth)
-            return false;
-        const currentPath = path.join(this.projectRoot, relativePath);
-        try {
-            const { readdir } = await import('fs/promises');
-            const entries = await readdir(currentPath, { withFileTypes: true });
-            // Filter out excluded directories/files using shared patterns and session exclusions
-            const filtered = entries.filter((entry) => {
-                const name = entry.name;
-                if (entry.isDirectory()) {
-                    // Check default exclusions first
-                    if (shouldExcludeDirectory(name)) {
-                        return false;
-                    }
-                    // Check session exclusions using full relative path
-                    const entryRelativePath = relativePath ? `${relativePath}/${name}` : name;
-                    return !shouldExcludeSessionPath(entryRelativePath, sessionExcludedFolders);
-                }
-                return !shouldExcludeFile(name);
-            });
-            // Sort: directories first, then files, alphabetically
-            filtered.sort((a, b) => {
-                if (a.isDirectory() && !b.isDirectory())
-                    return -1;
-                if (!a.isDirectory() && b.isDirectory())
-                    return 1;
-                return a.name.localeCompare(b.name);
-            });
-            // Limit items shown
-            const itemsToShow = filtered.slice(0, maxItems);
-            const hasMore = filtered.length > maxItems;
-            // First pass: resolve directories to determine which have visible content
-            // Each visible entry is { entry, childLines } where childLines is set for non-empty dirs
-            const visibleEntries = [];
-            for (const entry of itemsToShow) {
-                if (entry.isDirectory()) {
-                    // Recurse into a temporary buffer to check for content
-                    const childLines = [];
-                    const hasContent = await this.buildTreeRecursive(path.join(relativePath, entry.name), depth + 1, maxDepth, maxItems, childLines, '', // Use empty prefix; we'll re-prefix when rendering
-                    sessionExcludedFolders);
-                    if (hasContent) {
-                        visibleEntries.push({ entry, childLines });
-                    }
-                }
-                else {
-                    visibleEntries.push({ entry });
-                }
-            }
-            if (hasMore) {
-                // Count as a visible entry for connector logic
-                visibleEntries.push({ entry: null });
-            }
-            if (visibleEntries.length === 0)
-                return false;
-            // Second pass: render with correct connectors
-            for (let i = 0; i < visibleEntries.length; i++) {
-                const { entry, childLines } = visibleEntries[i];
-                const isLast = i === visibleEntries.length - 1;
-                const connector = isLast ? '└── ' : '├── ';
-                const childPrefix = isLast ? '    ' : '│   ';
-                if (entry === null) {
-                    // "has more" marker
-                    lines.push(prefix + connector + '... (' + (filtered.length - maxItems) + ' more items)');
-                }
-                else if (entry.isDirectory()) {
-                    lines.push(prefix + connector + entry.name + '/');
-                    // Re-prefix the child lines collected with empty prefix
-                    for (const childLine of childLines) {
-                        lines.push(prefix + childPrefix + childLine);
-                    }
-                }
-                else {
-                    lines.push(prefix + connector + entry.name);
-                }
-            }
-            return true;
-        }
-        catch (error) {
-            logger.debug(`Failed to read directory: ${currentPath}`, error);
-            return false;
-        }
-    }
-    /**
-     * Extracts a summary of project configuration files (package.json, etc.)
-     * Returns only essential fields to minimize token usage
-     */
-    async getConfigSummary() {
-        const summary = {};
-        // Try package.json first (Node.js/TypeScript projects)
-        const packageJsonPath = path.join(this.projectRoot, 'package.json');
-        if (await pathExists(packageJsonPath)) {
-            try {
-                const content = await safeReadFile(packageJsonPath);
-                if (content) {
-                    const pkg = JSON.parse(content);
-                    summary.name = pkg.name;
-                    summary.description = pkg.description;
-                    summary.version = pkg.version;
-                    summary.main = pkg.main || pkg.module;
-                    // Only include script names and commands (useful for LLM to know available commands)
-                    if (pkg.scripts && typeof pkg.scripts === 'object') {
-                        summary.scripts = pkg.scripts;
-                    }
-                    // Only include dependency names (not versions) to save tokens
-                    if (pkg.dependencies) {
-                        summary.dependencies = Object.keys(pkg.dependencies);
-                    }
-                    if (pkg.devDependencies) {
-                        summary.devDependencies = Object.keys(pkg.devDependencies);
-                    }
-                }
-            }
-            catch (error) {
-                logger.debug('Failed to parse package.json', error);
-            }
-        }
-        // Try pyproject.toml (Python projects)
-        const pyprojectPath = path.join(this.projectRoot, 'pyproject.toml');
-        if (await pathExists(pyprojectPath) && !summary.name) {
-            try {
-                const content = await safeReadFile(pyprojectPath);
-                if (content) {
-                    // Basic TOML parsing for project name/description
-                    const nameMatch = content.match(/name\s*=\s*["']([^"']+)["']/);
-                    const descMatch = content.match(/description\s*=\s*["']([^"']+)["']/);
-                    const versionMatch = content.match(/version\s*=\s*["']([^"']+)["']/);
-                    if (nameMatch)
-                        summary.name = nameMatch[1];
-                    if (descMatch)
-                        summary.description = descMatch[1];
-                    if (versionMatch)
-                        summary.version = versionMatch[1];
-                }
-            }
-            catch (error) {
-                logger.debug('Failed to parse pyproject.toml', error);
-            }
-        }
-        // Try Cargo.toml (Rust projects)
-        const cargoPath = path.join(this.projectRoot, 'Cargo.toml');
-        if (await pathExists(cargoPath) && !summary.name) {
-            try {
-                const content = await safeReadFile(cargoPath);
-                if (content) {
-                    const nameMatch = content.match(/name\s*=\s*["']([^"']+)["']/);
-                    const descMatch = content.match(/description\s*=\s*["']([^"']+)["']/);
-                    const versionMatch = content.match(/version\s*=\s*["']([^"']+)["']/);
-                    if (nameMatch)
-                        summary.name = nameMatch[1];
-                    if (descMatch)
-                        summary.description = descMatch[1];
-                    if (versionMatch)
-                        summary.version = versionMatch[1];
-                }
-            }
-            catch (error) {
-                logger.debug('Failed to parse Cargo.toml', error);
-            }
-        }
-        // Try go.mod (Go projects)
-        const goModPath = path.join(this.projectRoot, 'go.mod');
-        if (await pathExists(goModPath) && !summary.name) {
-            try {
-                const content = await safeReadFile(goModPath);
-                if (content) {
-                    const moduleMatch = content.match(/module\s+(\S+)/);
-                    if (moduleMatch)
-                        summary.name = moduleMatch[1];
-                }
-            }
-            catch (error) {
-                logger.debug('Failed to parse go.mod', error);
-            }
-        }
-        return summary;
-    }
-    /**
-     * Gets a complete lightweight project summary suitable for system prompt injection
-     */
-    async getProjectSummary() {
-        // Gather all information in parallel where possible
-        const [projectType, directoryTree, compactDirectoryTree, config, files] = await Promise.all([
-            this.detectProjectType(),
-            this.getDirectoryTree(),
-            this.getCompactDirectoryTree(),
-            this.getConfigSummary(),
-            this.discoverFiles(),
-        ]);
-        // Detect primary languages from discovered files
-        const languageCounts = {};
-        for (const file of files) {
-            const ext = path.extname(file).toLowerCase();
-            const lang = EXTENSION_TO_LANGUAGE[ext];
-            if (lang && lang !== 'text') {
-                languageCounts[lang] = (languageCounts[lang] || 0) + 1;
-            }
-        }
-        const languages = Object.entries(languageCounts)
-            .sort((a, b) => b[1] - a[1])
-            .slice(0, 5)
-            .map(([lang]) => lang);
-        const name = config.name || path.basename(this.projectRoot);
-        const summary = {
-            projectType,
-            name,
-            projectRoot: this.projectRoot,
-            directoryTree,
-            compactDirectoryTree,
-            config,
-            languages,
-            fileCount: files.length,
-            formatted: '', // Will be set below
-        };
-        // Generate formatted string for system prompt
-        summary.formatted = this.formatProjectSummaryForPrompt(summary);
-        return summary;
-    }
-    /**
-     * Formats the project summary as a string suitable for system prompt injection
-     */
-    formatProjectSummaryForPrompt(summary) {
-        const parts = [];
-        parts.push('## Project Context');
-        parts.push('');
-        parts.push(`**Project:** ${summary.name}`);
-        parts.push(`**Type:** ${summary.projectType}`);
-        parts.push(`**Languages:** ${summary.languages.join(', ') || 'unknown'}`);
-        parts.push(`**Files:** ${summary.fileCount}`);
-        parts.push('');
-        // Add config info if available
-        if (summary.config.description) {
-            parts.push(`**Description:** ${summary.config.description}`);
-            parts.push('');
-        }
-        // Add available scripts (very useful for LLM to know what commands exist)
-        if (summary.config.scripts && Object.keys(summary.config.scripts).length > 0) {
-            parts.push('**Available Scripts:**');
-            for (const [scriptName, scriptCmd] of Object.entries(summary.config.scripts)) {
-                parts.push(`- \`npm run ${scriptName}\`: ${scriptCmd}`);
-            }
-            parts.push('');
-        }
-        // Add dependencies summary (just names, not full list if too long)
-        if (summary.config.dependencies && summary.config.dependencies.length > 0) {
-            const deps = summary.config.dependencies;
-            if (deps.length <= 10) {
-                parts.push(`**Dependencies:** ${deps.join(', ')}`);
-            }
-            else {
-                parts.push(`**Dependencies:** ${deps.slice(0, 10).join(', ')} (+${deps.length - 10} more)`);
-            }
-            parts.push('');
-        }
-        // Add directory tree
-        parts.push('**Directory Structure:**');
-        parts.push('```');
-        parts.push(summary.directoryTree);
-        parts.push('```');
-        return parts.join('\n');
-    }
-}
-// Singleton instance
-let contextBuilderInstance = null;
-/**
- * Gets the singleton ContextBuilder instance.
- * Creates the instance on first call with default options.
- *
- * @param options - Optional configuration options
- * @returns The ContextBuilder instance
- */
-export function getContextBuilder(options) {
-    if (!contextBuilderInstance) {
-        contextBuilderInstance = new ContextBuilder(options);
-    }
-    else if (options) {
-        // Update options if provided
-        if (options.projectRoot) {
-            contextBuilderInstance.setProjectRoot(options.projectRoot);
-        }
-        if (options.maxTokens) {
-            contextBuilderInstance.setMaxTokens(options.maxTokens);
-        }
-        if (options.maxFiles) {
-            contextBuilderInstance.setMaxFiles(options.maxFiles);
-        }
-        if (options.priorityFiles) {
-            contextBuilderInstance.addPriorityFiles(options.priorityFiles);
-        }
-    }
-    return contextBuilderInstance;
-}
-/**
- * Creates a new ContextBuilder instance with the specified options.
- * Use this when you need a separate instance from the singleton.
- *
- * @param options - Configuration options
- * @returns A new ContextBuilder instance
- */
-export function createContextBuilder(options) {
-    return new ContextBuilder(options);
-}
-export { ContextBuilder, DEFAULT_IGNORE_PATTERNS, EXTENSION_TO_LANGUAGE, PROJECT_MARKERS, };
-//# sourceMappingURL=context-builder.js.map