@compass-ai/nova 1.0.72 → 1.0.74

package/dist/core/context-builder.js

@@ -0,0 +1,1018 @@
+/**
+ * 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