@zokizuan/satori-core 0.1.5 → 0.2.0

package/dist/core/context.d.ts

@@ -17,8 +17,9 @@ export declare class Context {
     private vectorDatabase;
     private codeSplitter;
     private supportedExtensions;
-    private ignorePatterns;
-    private ignoreMatcher;
+    private baseIgnorePatterns;
+    private runtimeCustomIgnorePatterns;
+    private ignoreStateByCollection;
     private synchronizers;
     constructor(config?: ContextConfig);
     /**
@@ -38,9 +39,11 @@ export declare class Context {
      */
     getIndexedExtensions(): string[];
     /**
-     * Get ignore patterns
+     * Get effective ignore patterns.
+     * When codebasePath is provided, returns per-codebase effective rules.
+     * Without a codebase path, returns global base+runtime layers only.
      */
-    getActiveIgnorePatterns(): string[];
+    getActiveIgnorePatterns(codebasePath?: string): string[];
     /**
      * Get synchronizers map
      */
@@ -53,10 +56,31 @@ export declare class Context {
      * Public wrapper for loadIgnorePatterns private method
      */
     loadResolvedIgnorePatterns(codebasePath: string): Promise<void>;
+    /**
+     * Reload ignore rules for a codebase and return the effective pattern list.
+     * This is deterministic (replace semantics), not append-only.
+     */
+    reloadIgnoreRulesForCodebase(codebasePath: string): Promise<string[]>;
     /**
      * Public wrapper for prepareCollection private method
      */
     ensureCollectionPrepared(codebasePath: string): Promise<void>;
+    /**
+     * Recreate synchronizer for a codebase using currently active ignore patterns.
+     * This is used when ignore rules change and we need deterministic reconciliation.
+     */
+    recreateSynchronizerForCodebase(codebasePath: string): Promise<void>;
+    /**
+     * Return currently tracked (indexable under active ignore rules) relative paths
+     * from the active synchronizer snapshot for this codebase.
+     */
+    getTrackedRelativePaths(codebasePath: string): string[];
+    hasSynchronizerForCodebase(codebasePath: string): boolean;
+    /**
+     * Delete indexed chunks for a list of relative paths in a codebase.
+     * Returns the number of file paths processed for deletion.
+     */
+    deleteIndexedPathsByRelativePaths(codebasePath: string, relativePaths: string[]): Promise<number>;
     /**
      * Get isHybrid setting from environment variable with default true
      */
@@ -91,6 +115,7 @@ export declare class Context {
         added: number;
         removed: number;
         modified: number;
+        changedFiles: string[];
     }>;
     private deleteFileChunks;
     /**
@@ -119,8 +144,8 @@ export declare class Context {
         percentage: number;
     }) => void): Promise<void>;
     /**
-     * Update ignore patterns (merges with default patterns and existing patterns)
-     * @param ignorePatterns Array of ignore patterns to add to defaults
+     * Update base ignore patterns (replace semantics, then rebuild effective set).
+     * @param ignorePatterns Array of base ignore patterns
      */
     updateIgnorePatterns(ignorePatterns: string[]): void;
     /**
@@ -132,6 +157,15 @@ export declare class Context {
      * Reset ignore patterns to defaults only
      */
     resetIgnorePatternsToDefaults(): void;
+    private buildEffectiveIgnorePatterns;
+    private rebuildAllIgnoreStates;
+    private getOrCreateIgnoreState;
+    private setFileBasedPatternsForCodebase;
+    private getIgnoreMatcherForCodebase;
+    private canonicalizeCodebasePath;
+    private trimTrailingSeparators;
+    private normalizeRelativePathForCodebase;
+    private normalizeRelativePathsForCodebase;
     /**
      * Update embedding instance
      * @param embedding New embedding instance
@@ -191,13 +225,13 @@ export declare class Context {
      */
     static getIgnorePatternsFromFile(filePath: string): Promise<string[]>;
     /**
-     * Load ignore patterns from various ignore files in the codebase
-     * This method preserves any existing custom patterns that were added before
-     * @param codebasePath Path to the codebase
+     * Load ignore patterns from various ignore files in the codebase.
+     * This uses replace semantics for file-based patterns to avoid stale rules.
      */
     private loadIgnorePatterns;
     /**
-     * Find all .xxxignore files in the codebase directory
+     * Find root-level .xxxignore files in the codebase directory.
+     * v1 policy: only root ignore files are loaded (nested .gitignore files are ignored).
      * @param codebasePath Path to the codebase
      * @returns Array of ignore file paths
      */
@@ -214,12 +248,10 @@ export declare class Context {
      * @returns Array of ignore patterns
      */
     private loadIgnoreFile;
-    private invalidateIgnoreMatcher;
-    private getIgnoreMatcher;
     /**
      * Check if a path matches any ignore pattern
      * @param filePath Path to check
-     * @param basePath Base path for relative pattern matching
+     * @param codebasePath Codebase root path used for relative pattern matching
      * @param isDirectory Whether the path is a directory
      * @returns True if path should be ignored
      */

package/dist/core/context.js

@@ -41,6 +41,7 @@ const splitter_1 = require("../splitter");
 const embedding_1 = require("../embedding");
 const env_manager_1 = require("../utils/env-manager");
 const defaults_1 = require("../config/defaults");
+const language_1 = require("../language");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const crypto = __importStar(require("crypto"));
@@ -48,7 +49,6 @@ const ignore_1 = __importDefault(require("ignore"));
 const synchronizer_1 = require("../sync/synchronizer");
 class Context {
     constructor(config = {}) {
-        this.ignoreMatcher = null;
         this.synchronizers = new Map();
         // Initialize services
         this.embedding = config.embedding || new embedding_1.OpenAIEmbedding({
@@ -74,17 +74,18 @@ class Context {
         this.supportedExtensions = [...new Set(allSupportedExtensions)];
         // Load custom ignore patterns from environment variables
         const envCustomIgnorePatterns = this.getCustomIgnorePatternsFromEnv();
-        // Start with default ignore patterns
+        // Base ignore patterns (defaults + static config + env)
         const allIgnorePatterns = [
             ...defaults_1.DEFAULT_IGNORE_PATTERNS,
             ...(config.ignorePatterns || []),
             ...(config.customIgnorePatterns || []),
             ...envCustomIgnorePatterns
         ];
-        // Remove duplicates
-        this.ignorePatterns = [...new Set(allIgnorePatterns)];
-        this.invalidateIgnoreMatcher();
-        console.log(`[Context] 🔧 Initialized with ${this.supportedExtensions.length} supported extensions and ${this.ignorePatterns.length} ignore patterns`);
+        // Runtime custom ignore patterns added via MCP/manage_index
+        this.baseIgnorePatterns = [...new Set(allIgnorePatterns)];
+        this.runtimeCustomIgnorePatterns = [];
+        this.ignoreStateByCollection = new Map();
+        console.log(`[Context] 🔧 Initialized with ${this.supportedExtensions.length} supported extensions and ${this.baseIgnorePatterns.length + this.runtimeCustomIgnorePatterns.length} base/runtime ignore patterns`);
         if (envCustomExtensions.length > 0) {
             console.log(`[Context] 📎 Loaded ${envCustomExtensions.length} custom extensions from environment: ${envCustomExtensions.join(', ')}`);
         }
@@ -117,10 +118,15 @@ class Context {
         return [...this.supportedExtensions];
     }
     /**
-     * Get ignore patterns
+     * Get effective ignore patterns.
+     * When codebasePath is provided, returns per-codebase effective rules.
+     * Without a codebase path, returns global base+runtime layers only.
      */
-    getActiveIgnorePatterns() {
-        return [...this.ignorePatterns];
+    getActiveIgnorePatterns(codebasePath) {
+        if (!codebasePath) {
+            return [...new Set([...this.baseIgnorePatterns, ...this.runtimeCustomIgnorePatterns])];
+        }
+        return [...this.getOrCreateIgnoreState(codebasePath).effectivePatterns];
     }
     /**
      * Get synchronizers map
@@ -140,12 +146,57 @@ class Context {
     async loadResolvedIgnorePatterns(codebasePath) {
         return this.loadIgnorePatterns(codebasePath);
     }
+    /**
+     * Reload ignore rules for a codebase and return the effective pattern list.
+     * This is deterministic (replace semantics), not append-only.
+     */
+    async reloadIgnoreRulesForCodebase(codebasePath) {
+        await this.loadIgnorePatterns(codebasePath);
+        return this.getActiveIgnorePatterns(codebasePath);
+    }
     /**
      * Public wrapper for prepareCollection private method
      */
     async ensureCollectionPrepared(codebasePath) {
         return this.prepareCollection(codebasePath);
     }
+    /**
+     * Recreate synchronizer for a codebase using currently active ignore patterns.
+     * This is used when ignore rules change and we need deterministic reconciliation.
+     */
+    async recreateSynchronizerForCodebase(codebasePath) {
+        const collectionName = this.resolveCollectionName(codebasePath);
+        const synchronizer = new synchronizer_1.FileSynchronizer(codebasePath, this.getActiveIgnorePatterns(codebasePath));
+        await synchronizer.initialize();
+        this.synchronizers.set(collectionName, synchronizer);
+    }
+    /**
+     * Return currently tracked (indexable under active ignore rules) relative paths
+     * from the active synchronizer snapshot for this codebase.
+     */
+    getTrackedRelativePaths(codebasePath) {
+        const collectionName = this.resolveCollectionName(codebasePath);
+        const synchronizer = this.synchronizers.get(collectionName);
+        if (!synchronizer) {
+            return [];
+        }
+        return this.normalizeRelativePathsForCodebase(codebasePath, synchronizer.getTrackedRelativePaths());
+    }
+    hasSynchronizerForCodebase(codebasePath) {
+        return this.synchronizers.has(this.resolveCollectionName(codebasePath));
+    }
+    /**
+     * Delete indexed chunks for a list of relative paths in a codebase.
+     * Returns the number of file paths processed for deletion.
+     */
+    async deleteIndexedPathsByRelativePaths(codebasePath, relativePaths) {
+        const collectionName = this.resolveCollectionName(codebasePath);
+        const uniquePaths = Array.from(new Set(this.normalizeRelativePathsForCodebase(codebasePath, relativePaths)));
+        for (const relativePath of uniquePaths) {
+            await this.deleteFileChunks(collectionName, relativePath);
+        }
+        return uniquePaths.length;
+    }
     /**
      * Get isHybrid setting from environment variable with default true
      */
@@ -161,8 +212,8 @@ class Context {
      */
     resolveCollectionName(codebasePath) {
         const isHybrid = this.getIsHybrid();
-        const normalizedPath = path.resolve(codebasePath);
-        const hash = crypto.createHash('md5').update(normalizedPath).digest('hex');
+        const canonicalPath = this.canonicalizeCodebasePath(codebasePath);
+        const hash = crypto.createHash('md5').update(canonicalPath).digest('hex');
         const prefix = isHybrid === true ? 'hybrid_code_chunks' : 'code_chunks';
         return `${prefix}_${hash.substring(0, 8)}`;
     }
@@ -227,7 +278,7 @@ class Context {
             // Load project-specific ignore patterns before creating FileSynchronizer
             await this.loadIgnorePatterns(codebasePath);
             // To be safe, let's initialize if it's not there.
-            const newSynchronizer = new synchronizer_1.FileSynchronizer(codebasePath, this.ignorePatterns);
+            const newSynchronizer = new synchronizer_1.FileSynchronizer(codebasePath, this.getActiveIgnorePatterns(codebasePath));
             await newSynchronizer.initialize();
             this.synchronizers.set(collectionName, newSynchronizer);
         }
@@ -238,7 +289,7 @@ class Context {
         if (totalChanges === 0) {
             progressCallback?.({ phase: 'No changes detected', current: 100, total: 100, percentage: 100 });
             console.log('[Context] ✅ No file changes detected.');
-            return { added: 0, removed: 0, modified: 0 };
+            return { added: 0, removed: 0, modified: 0, changedFiles: [] };
         }
         console.log(`[Context] 🔄 Found changes: ${added.length} added, ${removed.length} removed, ${modified.length} modified.`);
         let processedChanges = 0;
@@ -266,7 +317,12 @@ class Context {
         }
         console.log(`[Context] ✅ Re-indexing complete. Added: ${added.length}, Removed: ${removed.length}, Modified: ${modified.length}`);
         progressCallback?.({ phase: 'Re-indexing complete!', current: totalChanges, total: totalChanges, percentage: 100 });
-        return { added: added.length, removed: removed.length, modified: modified.length };
+        return {
+            added: added.length,
+            removed: removed.length,
+            modified: modified.length,
+            changedFiles: Array.from(new Set([...added, ...removed, ...modified]))
+        };
     }
     async deleteFileChunks(collectionName, relativePath) {
         // Escape backslashes for Milvus query expression (Windows path compatibility)
@@ -360,7 +416,10 @@ class Context {
                 endLine: result.document.endLine,
                 language: result.document.metadata.language || 'unknown',
                 score: result.score,
-                breadcrumbs: normalizeBreadcrumbs(result.document.metadata.breadcrumbs)
+                breadcrumbs: normalizeBreadcrumbs(result.document.metadata.breadcrumbs),
+                indexedAt: typeof result.document.metadata.indexedAt === 'string' ? result.document.metadata.indexedAt : undefined,
+                symbolId: typeof result.document.metadata.symbolId === 'string' ? result.document.metadata.symbolId : undefined,
+                symbolLabel: typeof result.document.metadata.symbolLabel === 'string' ? result.document.metadata.symbolLabel : undefined
             }));
             console.log(`[Context] ✅ Found ${results.length} relevant hybrid results`);
             if (results.length > 0) {
@@ -382,7 +441,10 @@ class Context {
                 endLine: result.document.endLine,
                 language: result.document.metadata.language || 'unknown',
                 score: result.score,
-                breadcrumbs: normalizeBreadcrumbs(result.document.metadata.breadcrumbs)
+                breadcrumbs: normalizeBreadcrumbs(result.document.metadata.breadcrumbs),
+                indexedAt: typeof result.document.metadata.indexedAt === 'string' ? result.document.metadata.indexedAt : undefined,
+                symbolId: typeof result.document.metadata.symbolId === 'string' ? result.document.metadata.symbolId : undefined,
+                symbolLabel: typeof result.document.metadata.symbolLabel === 'string' ? result.document.metadata.symbolLabel : undefined
             }));
             console.log(`[Context] ✅ Found ${results.length} relevant results`);
             return results;
@@ -417,18 +479,13 @@ class Context {
         console.log('[Context] ✅ Index data cleaned');
     }
     /**
-     * Update ignore patterns (merges with default patterns and existing patterns)
-     * @param ignorePatterns Array of ignore patterns to add to defaults
+     * Update base ignore patterns (replace semantics, then rebuild effective set).
+     * @param ignorePatterns Array of base ignore patterns
      */
     updateIgnorePatterns(ignorePatterns) {
-        // Merge with default patterns and any existing custom patterns, avoiding duplicates
-        const mergedPatterns = [...defaults_1.DEFAULT_IGNORE_PATTERNS, ...ignorePatterns];
-        const uniquePatterns = [];
-        const patternSet = new Set(mergedPatterns);
-        patternSet.forEach(pattern => uniquePatterns.push(pattern));
-        this.ignorePatterns = uniquePatterns;
-        this.invalidateIgnoreMatcher();
-        console.log(`[Context] 🚫 Updated ignore patterns: ${ignorePatterns.length} new + ${defaults_1.DEFAULT_IGNORE_PATTERNS.length} default = ${this.ignorePatterns.length} total patterns`);
+        this.baseIgnorePatterns = [...new Set([...defaults_1.DEFAULT_IGNORE_PATTERNS, ...ignorePatterns])];
+        this.rebuildAllIgnoreStates();
+        console.log(`[Context] 🚫 Updated base ignore patterns. Base total: ${this.baseIgnorePatterns.length}`);
     }
     /**
      * Add custom ignore patterns (from MCP or other sources) without replacing existing ones
@@ -437,22 +494,135 @@ class Context {
     addCustomIgnorePatterns(customPatterns) {
         if (customPatterns.length === 0)
             return;
-        // Merge current patterns with new custom patterns, avoiding duplicates
-        const mergedPatterns = [...this.ignorePatterns, ...customPatterns];
-        const uniquePatterns = [];
-        const patternSet = new Set(mergedPatterns);
-        patternSet.forEach(pattern => uniquePatterns.push(pattern));
-        this.ignorePatterns = uniquePatterns;
-        this.invalidateIgnoreMatcher();
-        console.log(`[Context] 🚫 Added ${customPatterns.length} custom ignore patterns. Total: ${this.ignorePatterns.length} patterns`);
+        this.runtimeCustomIgnorePatterns = [
+            ...new Set([...this.runtimeCustomIgnorePatterns, ...customPatterns])
+        ];
+        this.rebuildAllIgnoreStates();
+        console.log(`[Context] 🚫 Added ${customPatterns.length} custom ignore patterns. Runtime total: ${this.runtimeCustomIgnorePatterns.length}`);
     }
     /**
      * Reset ignore patterns to defaults only
      */
     resetIgnorePatternsToDefaults() {
-        this.ignorePatterns = [...defaults_1.DEFAULT_IGNORE_PATTERNS];
-        this.invalidateIgnoreMatcher();
-        console.log(`[Context] 🔄 Reset ignore patterns to defaults: ${this.ignorePatterns.length} patterns`);
+        this.baseIgnorePatterns = [...defaults_1.DEFAULT_IGNORE_PATTERNS];
+        this.runtimeCustomIgnorePatterns = [];
+        this.rebuildAllIgnoreStates();
+        console.log(`[Context] 🔄 Reset ignore patterns to defaults: ${this.baseIgnorePatterns.length} patterns`);
+    }
+    buildEffectiveIgnorePatterns(fileBasedPatterns) {
+        return [
+            ...new Set([
+                ...this.baseIgnorePatterns,
+                ...this.runtimeCustomIgnorePatterns,
+                ...fileBasedPatterns
+            ])
+        ];
+    }
+    rebuildAllIgnoreStates() {
+        for (const [collectionName, state] of this.ignoreStateByCollection.entries()) {
+            this.ignoreStateByCollection.set(collectionName, {
+                ...state,
+                effectivePatterns: this.buildEffectiveIgnorePatterns(state.fileBasedPatterns),
+                matcher: null,
+            });
+        }
+    }
+    getOrCreateIgnoreState(codebasePath) {
+        const collectionName = this.resolveCollectionName(codebasePath);
+        const existing = this.ignoreStateByCollection.get(collectionName);
+        if (existing) {
+            return existing;
+        }
+        const initial = {
+            fileBasedPatterns: [],
+            effectivePatterns: this.buildEffectiveIgnorePatterns([]),
+            matcher: null,
+        };
+        this.ignoreStateByCollection.set(collectionName, initial);
+        return initial;
+    }
+    setFileBasedPatternsForCodebase(codebasePath, fileBasedPatterns) {
+        const collectionName = this.resolveCollectionName(codebasePath);
+        const normalizedFileBased = [
+            ...new Set(fileBasedPatterns
+                .filter((pattern) => typeof pattern === 'string')
+                .map((pattern) => pattern.trim())
+                .filter((pattern) => pattern.length > 0))
+        ];
+        const nextState = {
+            fileBasedPatterns: normalizedFileBased,
+            effectivePatterns: this.buildEffectiveIgnorePatterns(normalizedFileBased),
+            matcher: null,
+        };
+        this.ignoreStateByCollection.set(collectionName, nextState);
+    }
+    getIgnoreMatcherForCodebase(codebasePath) {
+        const collectionName = this.resolveCollectionName(codebasePath);
+        const state = this.getOrCreateIgnoreState(codebasePath);
+        if (!state.matcher) {
+            const matcher = (0, ignore_1.default)();
+            matcher.add(state.effectivePatterns);
+            state.matcher = matcher;
+            this.ignoreStateByCollection.set(collectionName, state);
+        }
+        return state.matcher;
+    }
+    canonicalizeCodebasePath(codebasePath) {
+        const resolved = path.resolve(codebasePath);
+        try {
+            const realPath = typeof fs.realpathSync.native === 'function'
+                ? fs.realpathSync.native(resolved)
+                : fs.realpathSync(resolved);
+            return this.trimTrailingSeparators(path.normalize(realPath));
+        }
+        catch {
+            return this.trimTrailingSeparators(path.normalize(resolved));
+        }
+    }
+    trimTrailingSeparators(inputPath) {
+        const parsedRoot = path.parse(inputPath).root;
+        if (inputPath === parsedRoot) {
+            return inputPath;
+        }
+        return inputPath.replace(/[\\/]+$/, '');
+    }
+    normalizeRelativePathForCodebase(codebasePath, candidatePath) {
+        if (typeof candidatePath !== 'string') {
+            return null;
+        }
+        const trimmed = candidatePath.trim();
+        if (trimmed.length === 0) {
+            return null;
+        }
+        const canonicalRoot = this.canonicalizeCodebasePath(codebasePath);
+        const normalizedCandidate = trimmed.replace(/\\/g, '/');
+        let relativePath = normalizedCandidate;
+        if (path.isAbsolute(trimmed)) {
+            const resolvedCandidate = path.resolve(trimmed);
+            relativePath = path.relative(canonicalRoot, resolvedCandidate).replace(/\\/g, '/');
+            // Symlink-safe fallback: if canonical-root relative path is invalid,
+            // retry against resolved (non-realpathed) root before dropping.
+            if (!relativePath || relativePath.startsWith('..')) {
+                const resolvedRoot = this.trimTrailingSeparators(path.normalize(path.resolve(codebasePath)));
+                relativePath = path.relative(resolvedRoot, resolvedCandidate).replace(/\\/g, '/');
+            }
+        }
+        relativePath = relativePath.replace(/^\/+/, '');
+        if (!relativePath || relativePath === '.' || relativePath.startsWith('..')) {
+            return null;
+        }
+        return relativePath;
+    }
+    normalizeRelativePathsForCodebase(codebasePath, relativePaths) {
+        const normalized = [];
+        for (const candidatePath of relativePaths) {
+            const normalizedPath = this.normalizeRelativePathForCodebase(codebasePath, candidatePath);
+            if (!normalizedPath) {
+                continue;
+            }
+            normalized.push(normalizedPath);
+        }
+        return Array.from(new Set(normalized)).sort();
     }
     /**
      * Update embedding instance
@@ -643,6 +813,7 @@ class Context {
      */
     async processChunkBatch(chunks, codebasePath) {
         const isHybrid = this.getIsHybrid();
+        const indexedAt = new Date().toISOString();
         // Generate embedding vectors
         const chunkContents = chunks.map(chunk => chunk.content);
         const embeddings = await this.embedding.embedBatch(chunkContents);
@@ -667,7 +838,8 @@ class Context {
                         ...restMetadata,
                         codebasePath,
                         language: chunk.metadata.language || 'unknown',
-                        chunkIndex: index
+                        chunkIndex: index,
+                        indexedAt
                     }
                 };
             });
@@ -695,7 +867,8 @@ class Context {
                         ...restMetadata,
                         codebasePath,
                         language: chunk.metadata.language || 'unknown',
-                        chunkIndex: index
+                        chunkIndex: index,
+                        indexedAt
                     }
                 };
             });
@@ -707,30 +880,7 @@ class Context {
      * Get programming language based on file extension
      */
     getLanguageFromExtension(ext) {
-        const languageMap = {
-            '.ts': 'typescript',
-            '.tsx': 'typescript',
-            '.js': 'javascript',
-            '.jsx': 'javascript',
-            '.py': 'python',
-            '.java': 'java',
-            '.cpp': 'cpp',
-            '.c': 'c',
-            '.h': 'c',
-            '.hpp': 'cpp',
-            '.cs': 'csharp',
-            '.go': 'go',
-            '.rs': 'rust',
-            '.php': 'php',
-            '.rb': 'ruby',
-            '.swift': 'swift',
-            '.kt': 'kotlin',
-            '.scala': 'scala',
-            '.m': 'objective-c',
-            '.mm': 'objective-c',
-            '.ipynb': 'jupyter'
-        };
-        return languageMap[ext] || 'text';
+        return (0, language_1.getLanguageIdFromExtension)(ext, 'text');
     }
     /**
      * Generate unique ID based on chunk content and location
@@ -764,9 +914,8 @@ class Context {
         }
     }
     /**
-     * Load ignore patterns from various ignore files in the codebase
-     * This method preserves any existing custom patterns that were added before
-     * @param codebasePath Path to the codebase
+     * Load ignore patterns from various ignore files in the codebase.
+     * This uses replace semantics for file-based patterns to avoid stale rules.
      */
     async loadIgnorePatterns(codebasePath) {
         try {
@@ -780,22 +929,22 @@ class Context {
             // Load global ~/.satori/.satoriignore
             const globalIgnorePatterns = await this.loadGlobalIgnoreFile();
             fileBasedPatterns.push(...globalIgnorePatterns);
-            // Merge file-based patterns with existing patterns (which may include custom MCP patterns)
+            this.setFileBasedPatternsForCodebase(codebasePath, fileBasedPatterns);
             if (fileBasedPatterns.length > 0) {
-                this.addCustomIgnorePatterns(fileBasedPatterns);
                 console.log(`[Context] 🚫 Loaded total ${fileBasedPatterns.length} ignore patterns from all ignore files`);
             }
             else {
-                console.log('📄 No ignore files found, keeping existing patterns');
+                console.log('📄 No ignore files found; effective rules reset to base + runtime custom');
             }
         }
         catch (error) {
             console.warn(`[Context] ⚠️ Failed to load ignore patterns: ${error}`);
-            // Continue with existing patterns on error - don't reset them
+            // Keep existing patterns on failure to avoid destructive behavior.
         }
     }
     /**
-     * Find all .xxxignore files in the codebase directory
+     * Find root-level .xxxignore files in the codebase directory.
+     * v1 policy: only root ignore files are loaded (nested .gitignore files are ignored).
      * @param codebasePath Path to the codebase
      * @returns Array of ignore file paths
      */
@@ -863,32 +1012,23 @@ class Context {
             return [];
         }
     }
-    invalidateIgnoreMatcher() {
-        this.ignoreMatcher = null;
-    }
-    getIgnoreMatcher() {
-        if (!this.ignoreMatcher) {
-            this.ignoreMatcher = (0, ignore_1.default)();
-            this.ignoreMatcher.add(this.ignorePatterns);
-        }
-        return this.ignoreMatcher;
-    }
     /**
      * Check if a path matches any ignore pattern
      * @param filePath Path to check
-     * @param basePath Base path for relative pattern matching
+     * @param codebasePath Codebase root path used for relative pattern matching
      * @param isDirectory Whether the path is a directory
      * @returns True if path should be ignored
      */
-    matchesIgnorePattern(filePath, basePath, isDirectory = false) {
-        if (this.ignorePatterns.length === 0) {
+    matchesIgnorePattern(filePath, codebasePath, isDirectory = false) {
+        const effectivePatterns = this.getActiveIgnorePatterns(codebasePath);
+        if (effectivePatterns.length === 0) {
             return false;
         }
-        const relativePath = path.relative(basePath, filePath).replace(/\\/g, '/').replace(/^\/+/, '');
+        const relativePath = path.relative(codebasePath, filePath).replace(/\\/g, '/').replace(/^\/+/, '');
         if (!relativePath || relativePath.startsWith('..')) {
             return false;
         }
-        const matcher = this.getIgnoreMatcher();
+        const matcher = this.getIgnoreMatcherForCodebase(codebasePath);
         if (isDirectory) {
             const withSlash = relativePath.endsWith('/') ? relativePath : `${relativePath}/`;
             return matcher.ignores(relativePath) || matcher.ignores(withSlash);
@@ -961,11 +1101,10 @@ class Context {
     getSplitterInfo() {
         const splitterName = this.codeSplitter.constructor.name;
         if (splitterName === 'AstCodeSplitter') {
-            const { AstCodeSplitter } = require('./splitter/ast-splitter');
             return {
                 type: 'ast',
                 hasBuiltinFallback: true,
-                supportedLanguages: AstCodeSplitter.getSupportedLanguages()
+                supportedLanguages: splitter_1.AstCodeSplitter.getSupportedLanguages()
             };
         }
         else {
@@ -982,8 +1121,7 @@ class Context {
     isLanguageSupported(language) {
         const splitterName = this.codeSplitter.constructor.name;
         if (splitterName === 'AstCodeSplitter') {
-            const { AstCodeSplitter } = require('./splitter/ast-splitter');
-            return AstCodeSplitter.isLanguageSupported(language);
+            return splitter_1.AstCodeSplitter.isLanguageSupported(language);
         }
         // LangChain splitter supports most languages
         return true;
@@ -995,8 +1133,7 @@ class Context {
     getSplitterStrategyForLanguage(language) {
         const splitterName = this.codeSplitter.constructor.name;
         if (splitterName === 'AstCodeSplitter') {
-            const { AstCodeSplitter } = require('./splitter/ast-splitter');
-            const isSupported = AstCodeSplitter.isLanguageSupported(language);
+            const isSupported = splitter_1.AstCodeSplitter.isLanguageSupported(language);
             return {
                 strategy: isSupported ? 'ast' : 'langchain',
                 reason: isSupported

package/dist/index.d.ts

@@ -6,4 +6,5 @@ export * from './context';
 export * from './sync/synchronizer';
 export * from './utils';
 export * from './reranker';
+export * from './language';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -22,4 +22,5 @@ __exportStar(require("./context"), exports);
 __exportStar(require("./sync/synchronizer"), exports);
 __exportStar(require("./utils"), exports);
 __exportStar(require("./reranker"), exports);
+__exportStar(require("./language"), exports);
 //# sourceMappingURL=index.js.map

package/dist/language/index.d.ts

@@ -0,0 +1,2 @@
+export * from './registry';
+//# sourceMappingURL=index.d.ts.map