@zilliz/claude-context-core 0.0.13 → 0.1.1

package/dist/context.d.ts

@@ -2,6 +2,7 @@ import { Splitter } from './splitter';
 import { Embedding } from './embedding';
 import { VectorDatabase } from './vectordb';
 import { SemanticSearchResult } from './types';
+import { FileSynchronizer } from './sync/synchronizer';
 export interface ContextConfig {
     embedding?: Embedding;
     vectorDatabase?: VectorDatabase;
@@ -20,13 +21,54 @@ export declare class Context {
     private synchronizers;
     constructor(config?: ContextConfig);
     /**
-     * Generate collection name based on codebase path
+     * Get embedding instance
      */
-    private getCollectionName;
+    getEmbedding(): Embedding;
     /**
-     * Index entire codebase
-     * @param codebasePath Codebase path
+     * Get vector database instance
+     */
+    getVectorDatabase(): VectorDatabase;
+    /**
+     * Get code splitter instance
+     */
+    getCodeSplitter(): Splitter;
+    /**
+     * Get supported extensions
+     */
+    getSupportedExtensions(): string[];
+    /**
+     * Get ignore patterns
+     */
+    getIgnorePatterns(): string[];
+    /**
+     * Get synchronizers map
+     */
+    getSynchronizers(): Map<string, FileSynchronizer>;
+    /**
+     * Set synchronizer for a collection
+     */
+    setSynchronizer(collectionName: string, synchronizer: FileSynchronizer): void;
+    /**
+     * Public wrapper for loadIgnorePatterns private method
+     */
+    getLoadedIgnorePatterns(codebasePath: string): Promise<void>;
+    /**
+     * Public wrapper for prepareCollection private method
+     */
+    getPreparedCollection(codebasePath: string): Promise<void>;
+    /**
+     * Get isHybrid setting from environment variable with default true
+     */
+    private getIsHybrid;
+    /**
+     * Generate collection name based on codebase path and hybrid mode
+     */
+    getCollectionName(codebasePath: string): string;
+    /**
+     * Index a codebase for semantic search
+     * @param codebasePath Codebase root path
      * @param progressCallback Optional progress callback function
+     * @param forceReindex Whether to recreate the collection even if it exists
      * @returns Indexing statistics
      */
     indexCodebase(codebasePath: string, progressCallback?: (progress: {
@@ -34,7 +76,7 @@ export declare class Context {
         current: number;
         total: number;
         percentage: number;
-    }) => void): Promise<{
+    }) => void, forceReindex?: boolean): Promise<{
         indexedFiles: number;
         totalChunks: number;
         status: 'completed' | 'limit_reached';
@@ -51,13 +93,13 @@ export declare class Context {
     }>;
     private deleteFileChunks;
     /**
-     * Semantic search
+     * Semantic search with unified implementation
      * @param codebasePath Codebase path to search in
      * @param query Search query
      * @param topK Number of results to return
      * @param threshold Similarity threshold
      */
-    semanticSearch(codebasePath: string, query: string, topK?: number, threshold?: number): Promise<SemanticSearchResult[]>;
+    semanticSearch(codebasePath: string, query: string, topK?: number, threshold?: number, filterExpr?: string): Promise<SemanticSearchResult[]>;
     /**
      * Check if index exists for codebase
      * @param codebasePath Codebase path to check
@@ -152,9 +194,9 @@ export declare class Context {
      * This method preserves any existing custom patterns that were added before
      * @param codebasePath Path to the codebase
      */
-    private loadGitignorePatterns;
+    private loadIgnorePatterns;
     /**
-     * Find all .xxxignore files in the codebase directory (excluding .gitignore as it's handled separately)
+     * Find all .xxxignore files in the codebase directory
      * @param codebasePath Path to the codebase
      * @returns Array of ignore file paths
      */

package/dist/context.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../src/context.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../src/context.ts"],"names":[],"mappings":"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"}

package/dist/context.js

@@ -141,27 +141,96 @@ class Context {
         }
     }
     /**
-     * Generate collection name based on codebase path
+     * Get embedding instance
+     */
+    getEmbedding() {
+        return this.embedding;
+    }
+    /**
+     * Get vector database instance
+     */
+    getVectorDatabase() {
+        return this.vectorDatabase;
+    }
+    /**
+     * Get code splitter instance
+     */
+    getCodeSplitter() {
+        return this.codeSplitter;
+    }
+    /**
+     * Get supported extensions
+     */
+    getSupportedExtensions() {
+        return [...this.supportedExtensions];
+    }
+    /**
+     * Get ignore patterns
+     */
+    getIgnorePatterns() {
+        return [...this.ignorePatterns];
+    }
+    /**
+     * Get synchronizers map
+     */
+    getSynchronizers() {
+        return new Map(this.synchronizers);
+    }
+    /**
+     * Set synchronizer for a collection
+     */
+    setSynchronizer(collectionName, synchronizer) {
+        this.synchronizers.set(collectionName, synchronizer);
+    }
+    /**
+     * Public wrapper for loadIgnorePatterns private method
+     */
+    async getLoadedIgnorePatterns(codebasePath) {
+        return this.loadIgnorePatterns(codebasePath);
+    }
+    /**
+     * Public wrapper for prepareCollection private method
+     */
+    async getPreparedCollection(codebasePath) {
+        return this.prepareCollection(codebasePath);
+    }
+    /**
+     * Get isHybrid setting from environment variable with default true
+     */
+    getIsHybrid() {
+        const isHybridEnv = env_manager_1.envManager.get('HYBRID_MODE');
+        if (isHybridEnv === undefined || isHybridEnv === null) {
+            return true; // Default to true
+        }
+        return isHybridEnv.toLowerCase() === 'true';
+    }
+    /**
+     * Generate collection name based on codebase path and hybrid mode
      */
     getCollectionName(codebasePath) {
+        const isHybrid = this.getIsHybrid();
         const normalizedPath = path.resolve(codebasePath);
         const hash = crypto.createHash('md5').update(normalizedPath).digest('hex');
-        return `code_chunks_${hash.substring(0, 8)}`;
+        const prefix = isHybrid === true ? 'hybrid_code_chunks' : 'code_chunks';
+        return `${prefix}_${hash.substring(0, 8)}`;
     }
     /**
-     * Index entire codebase
-     * @param codebasePath Codebase path
+     * Index a codebase for semantic search
+     * @param codebasePath Codebase root path
      * @param progressCallback Optional progress callback function
+     * @param forceReindex Whether to recreate the collection even if it exists
      * @returns Indexing statistics
      */
-    async indexCodebase(codebasePath, progressCallback) {
-        console.log(`🚀 Starting to index codebase: ${codebasePath}`);
+    async indexCodebase(codebasePath, progressCallback, forceReindex = false) {
+        const isHybrid = this.getIsHybrid();
+        const searchType = isHybrid === true ? 'hybrid search' : 'semantic search';
+        console.log(`🚀 Starting to index codebase with ${searchType}: ${codebasePath}`);
         // 1. Load ignore patterns from various ignore files
-        await this.loadGitignorePatterns(codebasePath);
+        await this.loadIgnorePatterns(codebasePath);
         // 2. Check and prepare vector collection
         progressCallback?.({ phase: 'Preparing collection...', current: 0, total: 100, percentage: 0 });
-        console.log(`Debug2: Preparing vector collection for codebase`);
-        await this.prepareCollection(codebasePath);
+        console.log(`Debug2: Preparing vector collection for codebase${forceReindex ? ' (FORCE REINDEX)' : ''}`);
+        await this.prepareCollection(codebasePath, forceReindex);
         // 3. Recursively traverse codebase to get all supported files
         progressCallback?.({ phase: 'Scanning files...', current: 5, total: 100, percentage: 5 });
         const codeFiles = await this.getCodeFiles(codebasePath);
@@ -204,7 +273,7 @@ class Context {
         const synchronizer = this.synchronizers.get(collectionName);
         if (!synchronizer) {
             // Load project-specific ignore patterns before creating FileSynchronizer
-            await this.loadGitignorePatterns(codebasePath);
+            await this.loadIgnorePatterns(codebasePath);
             // To be safe, let's initialize if it's not there.
             const newSynchronizer = new synchronizer_1.FileSynchronizer(codebasePath, this.ignorePatterns);
             await newSynchronizer.initialize();
@@ -260,29 +329,99 @@ class Context {
         }
     }
     /**
-     * Semantic search
+     * Semantic search with unified implementation
      * @param codebasePath Codebase path to search in
      * @param query Search query
      * @param topK Number of results to return
      * @param threshold Similarity threshold
      */
-    async semanticSearch(codebasePath, query, topK = 5, threshold = 0.5) {
-        console.log(`🔍 Executing semantic search: "${query}" in ${codebasePath}`);
-        // 1. Generate query vector
-        const queryEmbedding = await this.embedding.embed(query);
-        // 2. Search in vector database
-        const searchResults = await this.vectorDatabase.search(this.getCollectionName(codebasePath), queryEmbedding.vector, { topK, threshold });
-        // 3. Convert to semantic search result format
-        const results = searchResults.map(result => ({
-            content: result.document.content,
-            relativePath: result.document.relativePath,
-            startLine: result.document.startLine,
-            endLine: result.document.endLine,
-            language: result.document.metadata.language || 'unknown',
-            score: result.score
-        }));
-        console.log(`✅ Found ${results.length} relevant results`);
-        return results;
+    async semanticSearch(codebasePath, query, topK = 5, threshold = 0.5, filterExpr) {
+        const isHybrid = this.getIsHybrid();
+        const searchType = isHybrid === true ? 'hybrid search' : 'semantic search';
+        console.log(`🔍 Executing ${searchType}: "${query}" in ${codebasePath}`);
+        const collectionName = this.getCollectionName(codebasePath);
+        console.log(`🔍 Using collection: ${collectionName}`);
+        // Check if collection exists and has data
+        const hasCollection = await this.vectorDatabase.hasCollection(collectionName);
+        if (!hasCollection) {
+            console.log(`⚠️  Collection '${collectionName}' does not exist. Please index the codebase first.`);
+            return [];
+        }
+        if (isHybrid === true) {
+            try {
+                // Check collection stats to see if it has data
+                const stats = await this.vectorDatabase.query(collectionName, '', ['id'], 1);
+                console.log(`🔍 Collection '${collectionName}' exists and appears to have data`);
+            }
+            catch (error) {
+                console.log(`⚠️  Collection '${collectionName}' exists but may be empty or not properly indexed:`, error);
+            }
+            // 1. Generate query vector
+            console.log(`🔍 Generating embeddings for query: "${query}"`);
+            const queryEmbedding = await this.embedding.embed(query);
+            console.log(`✅ Generated embedding vector with dimension: ${queryEmbedding.vector.length}`);
+            console.log(`🔍 First 5 embedding values: [${queryEmbedding.vector.slice(0, 5).join(', ')}]`);
+            // 2. Prepare hybrid search requests
+            const searchRequests = [
+                {
+                    data: queryEmbedding.vector,
+                    anns_field: "vector",
+                    param: { "nprobe": 10 },
+                    limit: topK
+                },
+                {
+                    data: query,
+                    anns_field: "sparse_vector",
+                    param: { "drop_ratio_search": 0.2 },
+                    limit: topK
+                }
+            ];
+            console.log(`🔍 Search request 1 (dense): anns_field="${searchRequests[0].anns_field}", vector_dim=${queryEmbedding.vector.length}, limit=${searchRequests[0].limit}`);
+            console.log(`🔍 Search request 2 (sparse): anns_field="${searchRequests[1].anns_field}", query_text="${query}", limit=${searchRequests[1].limit}`);
+            // 3. Execute hybrid search
+            console.log(`🔍 Executing hybrid search with RRF reranking...`);
+            const searchResults = await this.vectorDatabase.hybridSearch(collectionName, searchRequests, {
+                rerank: {
+                    strategy: 'rrf',
+                    params: { k: 100 }
+                },
+                limit: topK,
+                filterExpr
+            });
+            console.log(`🔍 Raw search results count: ${searchResults.length}`);
+            // 4. Convert to semantic search result format
+            const results = searchResults.map(result => ({
+                content: result.document.content,
+                relativePath: result.document.relativePath,
+                startLine: result.document.startLine,
+                endLine: result.document.endLine,
+                language: result.document.metadata.language || 'unknown',
+                score: result.score
+            }));
+            console.log(`✅ Found ${results.length} relevant hybrid results`);
+            if (results.length > 0) {
+                console.log(`🔍 Top result score: ${results[0].score}, path: ${results[0].relativePath}`);
+            }
+            return results;
+        }
+        else {
+            // Regular semantic search
+            // 1. Generate query vector
+            const queryEmbedding = await this.embedding.embed(query);
+            // 2. Search in vector database
+            const searchResults = await this.vectorDatabase.search(collectionName, queryEmbedding.vector, { topK, threshold, filterExpr });
+            // 3. Convert to semantic search result format
+            const results = searchResults.map(result => ({
+                content: result.document.content,
+                relativePath: result.document.relativePath,
+                startLine: result.document.startLine,
+                endLine: result.document.endLine,
+                language: result.document.metadata.language || 'unknown',
+                score: result.score
+            }));
+            console.log(`✅ Found ${results.length} relevant results`);
+            return results;
+        }
     }
     /**
      * Check if index exists for codebase
@@ -374,17 +513,32 @@ class Context {
     /**
      * Prepare vector collection
      */
-    async prepareCollection(codebasePath) {
-        // Create new collection
-        console.log(`🔧 Preparing vector collection for codebase: ${codebasePath}`);
+    async prepareCollection(codebasePath, forceReindex = false) {
+        const isHybrid = this.getIsHybrid();
+        const collectionType = isHybrid === true ? 'hybrid vector' : 'vector';
+        console.log(`🔧 Preparing ${collectionType} collection for codebase: ${codebasePath}${forceReindex ? ' (FORCE REINDEX)' : ''}`);
         const collectionName = this.getCollectionName(codebasePath);
-        // For Ollama embeddings, ensure dimension is detected before creating collection
-        if (this.embedding.getProvider() === 'Ollama' && typeof this.embedding.initializeDimension === 'function') {
-            await this.embedding.initializeDimension();
+        // Check if collection already exists
+        const collectionExists = await this.vectorDatabase.hasCollection(collectionName);
+        if (collectionExists && !forceReindex) {
+            console.log(`📋 Collection ${collectionName} already exists, skipping creation`);
+            return;
+        }
+        if (collectionExists && forceReindex) {
+            console.log(`🗑️  Dropping existing collection ${collectionName} for force reindex...`);
+            await this.vectorDatabase.dropCollection(collectionName);
+            console.log(`✅ Collection ${collectionName} dropped successfully`);
         }
-        const dimension = this.embedding.getDimension();
+        console.log(`🔍 Detecting embedding dimension for ${this.embedding.getProvider()} provider...`);
+        const dimension = await this.embedding.detectDimension();
+        console.log(`📏 Detected dimension: ${dimension} for ${this.embedding.getProvider()}`);
         const dirName = path.basename(codebasePath);
-        await this.vectorDatabase.createCollection(collectionName, dimension, `Index for ${dirName}`);
+        if (isHybrid === true) {
+            await this.vectorDatabase.createHybridCollection(collectionName, dimension, `Hybrid Index for ${dirName}`);
+        }
+        else {
+            await this.vectorDatabase.createCollection(collectionName, dimension, `Index for ${dirName}`);
+        }
         console.log(`✅ Collection ${collectionName} created successfully (dimension: ${dimension})`);
     }
     /**
@@ -422,6 +576,7 @@ class Context {
  * @returns Object with processed file count and total chunk count
  */
     async processFileList(filePaths, codebasePath, onFileProcessed) {
+        const isHybrid = this.getIsHybrid();
         const EMBEDDING_BATCH_SIZE = Math.max(1, parseInt(env_manager_1.envManager.get('EMBEDDING_BATCH_SIZE') || '100', 10));
         const CHUNK_LIMIT = 450000;
         console.log(`🔧 Using EMBEDDING_BATCH_SIZE: ${EMBEDDING_BATCH_SIZE}`);
@@ -452,8 +607,11 @@ class Context {
                             await this.processChunkBuffer(chunkBuffer);
                         }
                         catch (error) {
-                            // TODO: 
-                            console.error(`❌ Failed to process chunk batch: ${error}`);
+                            const searchType = isHybrid === true ? 'hybrid' : 'regular';
+                            console.error(`❌ Failed to process chunk batch for ${searchType}:`, error);
+                            if (error instanceof Error) {
+                                console.error('Stack trace:', error.stack);
+                            }
                         }
                         finally {
                             chunkBuffer = []; // Always clear buffer, even on failure
@@ -478,12 +636,16 @@ class Context {
         }
         // Process any remaining chunks in the buffer
         if (chunkBuffer.length > 0) {
-            console.log(`📝 Processing final batch of ${chunkBuffer.length} chunks`);
+            const searchType = isHybrid === true ? 'hybrid' : 'regular';
+            console.log(`📝 Processing final batch of ${chunkBuffer.length} chunks for ${searchType}`);
             try {
                 await this.processChunkBuffer(chunkBuffer);
             }
             catch (error) {
-                console.error(`❌ Failed to process final chunk batch: ${error}`);
+                console.error(`❌ Failed to process final chunk batch for ${searchType}:`, error);
+                if (error instanceof Error) {
+                    console.error('Stack trace:', error.stack);
+                }
             }
         }
         return {
@@ -503,43 +665,75 @@ class Context {
         const codebasePath = chunkBuffer[0].codebasePath;
         // Estimate tokens (rough estimation: 1 token ≈ 4 characters)
         const estimatedTokens = chunks.reduce((sum, chunk) => sum + Math.ceil(chunk.content.length / 4), 0);
-        console.log(`🔄 Processing batch of ${chunks.length} chunks (~${estimatedTokens} tokens)`);
+        const isHybrid = this.getIsHybrid();
+        const searchType = isHybrid === true ? 'hybrid' : 'regular';
+        console.log(`🔄 Processing batch of ${chunks.length} chunks (~${estimatedTokens} tokens) for ${searchType}`);
         await this.processChunkBatch(chunks, codebasePath);
     }
     /**
      * Process a batch of chunks
      */
     async processChunkBatch(chunks, codebasePath) {
+        const isHybrid = this.getIsHybrid();
         // Generate embedding vectors
         const chunkContents = chunks.map(chunk => chunk.content);
         const embeddings = await this.embedding.embedBatch(chunkContents);
-        // Prepare vector documents
-        const documents = chunks.map((chunk, index) => {
-            if (!chunk.metadata.filePath) {
-                throw new Error(`Missing filePath in chunk metadata at index ${index}`);
-            }
-            const relativePath = path.relative(codebasePath, chunk.metadata.filePath);
-            const fileExtension = path.extname(chunk.metadata.filePath);
-            // Extract metadata that should be stored separately
-            const { filePath, startLine, endLine, ...restMetadata } = chunk.metadata;
-            return {
-                id: this.generateId(relativePath, chunk.metadata.startLine || 0, chunk.metadata.endLine || 0, chunk.content),
-                vector: embeddings[index].vector,
-                content: chunk.content,
-                relativePath,
-                startLine: chunk.metadata.startLine || 0,
-                endLine: chunk.metadata.endLine || 0,
-                fileExtension,
-                metadata: {
-                    ...restMetadata,
-                    codebasePath,
-                    language: chunk.metadata.language || 'unknown',
-                    chunkIndex: index
+        if (isHybrid === true) {
+            // Create hybrid vector documents
+            const documents = chunks.map((chunk, index) => {
+                if (!chunk.metadata.filePath) {
+                    throw new Error(`Missing filePath in chunk metadata at index ${index}`);
                 }
-            };
-        });
-        // Store to vector database
-        await this.vectorDatabase.insert(this.getCollectionName(codebasePath), documents);
+                const relativePath = path.relative(codebasePath, chunk.metadata.filePath);
+                const fileExtension = path.extname(chunk.metadata.filePath);
+                const { filePath, startLine, endLine, ...restMetadata } = chunk.metadata;
+                return {
+                    id: this.generateId(relativePath, chunk.metadata.startLine || 0, chunk.metadata.endLine || 0, chunk.content),
+                    content: chunk.content, // Full text content for BM25 and storage
+                    vector: embeddings[index].vector, // Dense vector
+                    relativePath,
+                    startLine: chunk.metadata.startLine || 0,
+                    endLine: chunk.metadata.endLine || 0,
+                    fileExtension,
+                    metadata: {
+                        ...restMetadata,
+                        codebasePath,
+                        language: chunk.metadata.language || 'unknown',
+                        chunkIndex: index
+                    }
+                };
+            });
+            // Store to vector database
+            await this.vectorDatabase.insertHybrid(this.getCollectionName(codebasePath), documents);
+        }
+        else {
+            // Create regular vector documents
+            const documents = chunks.map((chunk, index) => {
+                if (!chunk.metadata.filePath) {
+                    throw new Error(`Missing filePath in chunk metadata at index ${index}`);
+                }
+                const relativePath = path.relative(codebasePath, chunk.metadata.filePath);
+                const fileExtension = path.extname(chunk.metadata.filePath);
+                const { filePath, startLine, endLine, ...restMetadata } = chunk.metadata;
+                return {
+                    id: this.generateId(relativePath, chunk.metadata.startLine || 0, chunk.metadata.endLine || 0, chunk.content),
+                    vector: embeddings[index].vector,
+                    content: chunk.content,
+                    relativePath,
+                    startLine: chunk.metadata.startLine || 0,
+                    endLine: chunk.metadata.endLine || 0,
+                    fileExtension,
+                    metadata: {
+                        ...restMetadata,
+                        codebasePath,
+                        language: chunk.metadata.language || 'unknown',
+                        chunkIndex: index
+                    }
+                };
+            });
+            // Store to vector database
+            await this.vectorDatabase.insert(this.getCollectionName(codebasePath), documents);
+        }
     }
     /**
      * Get programming language based on file extension
@@ -606,23 +800,19 @@ class Context {
      * This method preserves any existing custom patterns that were added before
      * @param codebasePath Path to the codebase
      */
-    async loadGitignorePatterns(codebasePath) {
+    async loadIgnorePatterns(codebasePath) {
         try {
             let fileBasedPatterns = [];
-            // 1. Load .gitignore
-            const gitignorePath = path.join(codebasePath, '.gitignore');
-            const gitignorePatterns = await this.loadIgnoreFile(gitignorePath, '.gitignore');
-            fileBasedPatterns.push(...gitignorePatterns);
-            // 2. Load all .xxxignore files in codebase directory
+            // Load all .xxxignore files in codebase directory
             const ignoreFiles = await this.findIgnoreFiles(codebasePath);
             for (const ignoreFile of ignoreFiles) {
                 const patterns = await this.loadIgnoreFile(ignoreFile, path.basename(ignoreFile));
                 fileBasedPatterns.push(...patterns);
             }
-            // 3. Load global ~/.context/.contextignore
+            // Load global ~/.context/.contextignore
             const globalIgnorePatterns = await this.loadGlobalIgnoreFile();
             fileBasedPatterns.push(...globalIgnorePatterns);
-            // 4. Merge file-based patterns with existing patterns (which may include custom MCP patterns)
+            // Merge file-based patterns with existing patterns (which may include custom MCP patterns)
             if (fileBasedPatterns.length > 0) {
                 this.addCustomIgnorePatterns(fileBasedPatterns);
                 console.log(`🚫 Loaded total ${fileBasedPatterns.length} ignore patterns from all ignore files`);
@@ -637,7 +827,7 @@ class Context {
         }
     }
     /**
-     * Find all .xxxignore files in the codebase directory (excluding .gitignore as it's handled separately)
+     * Find all .xxxignore files in the codebase directory
      * @param codebasePath Path to the codebase
      * @returns Array of ignore file paths
      */
@@ -648,13 +838,12 @@ class Context {
             for (const entry of entries) {
                 if (entry.isFile() &&
                     entry.name.startsWith('.') &&
-                    entry.name.endsWith('ignore') &&
-                    entry.name !== '.gitignore') { // Exclude .gitignore as it's handled separately
+                    entry.name.endsWith('ignore')) {
                     ignoreFiles.push(path.join(codebasePath, entry.name));
                 }
             }
             if (ignoreFiles.length > 0) {
-                console.log(`📄 Found additional ignore files: ${ignoreFiles.map(f => path.basename(f)).join(', ')}`);
+                console.log(`📄 Found ignore files: ${ignoreFiles.map(f => path.basename(f)).join(', ')}`);
             }
             return ignoreFiles;
         }
@@ -699,7 +888,7 @@ class Context {
             }
         }
         catch (error) {
-            if (fileName === '.gitignore' || fileName.includes('global')) {
+            if (fileName.includes('global')) {
                 console.log(`📄 No ${fileName} file found`);
             }
             return [];