@autodev/codebase 0.0.6 → 0.0.7

package/dist/index.js

@@ -47,7 +47,21 @@ const DEFAULT_CONFIG = {
     qdrantUrl: "http://localhost:6333",
     vectorSearchMinScore: 0.1,
     vectorSearchMaxResults: 20,
-    rerankerEnabled: false
+    rerankerEnabled: false,
+    rerankerConcurrency: 3,
+    rerankerMaxRetries: 3,
+    rerankerRetryDelayMs: 1000,
+    summarizerProvider: 'ollama',
+    summarizerOllamaBaseUrl: 'http://localhost:11434',
+    summarizerOllamaModelId: 'qwen3-vl:4b-instruct',
+    summarizerOpenAiCompatibleBaseUrl: 'http://localhost:8080/v1',
+    summarizerOpenAiCompatibleModelId: 'gpt-4',
+    summarizerOpenAiCompatibleApiKey: '',
+    summarizerLanguage: 'English',
+    summarizerBatchSize: 2,
+    summarizerConcurrency: 2,
+    summarizerMaxRetries: 3,
+    summarizerRetryDelayMs: 1000
 };
 /**Parser */
 const MAX_BLOCK_CHARS = 2000;
@@ -104,6 +118,14 @@ const MAX_ITEM_TOKENS = 8191;
 const BATCH_PROCESSING_CONCURRENCY = 10;
 /**Gemini Embedder */
 const GEMINI_MAX_ITEM_TOKENS = 2048;
+/**BatchProcessor Truncation - 截断降级功能用于处理超长文本 */
+const TRUNCATION_INITIAL_THRESHOLD = 800; // 初始截断阈值（chars）
+const TRUNCATION_REDUCTION_FACTOR = 0.7; // 每次降低 30%
+const MIN_TRUNCATION_THRESHOLD = 200; // 最小阈值
+const MAX_TRUNCATION_ATTEMPTS = 3; // 最大重试次数
+const INDIVIDUAL_PROCESSING_TIMEOUT_MS = 60000; // 降级处理超时（1分钟）
+/**Feature Flags - 功能开关 */
+const ENABLE_TRUNCATION_FALLBACK = true; // 是否启用截断降级功能
 
 /**
  * Defines profiles for different embedding models, including their dimensions.
@@ -277,6 +299,8 @@ class ConfigValidator {
         ConfigValidator.validateQdrant(config, issues);
         // Validate reranker configuration
         ConfigValidator.validateReranker(config, issues);
+        // Validate summarizer configuration (optional - only when --summarize flag is used)
+        ConfigValidator.validateSummarizer(config, issues);
         // Validate basic configuration consistency
         ConfigValidator.validateBasicConsistency(config, issues);
         return {
@@ -446,6 +470,71 @@ class ConfigValidator {
             });
         }
     }
+    /**
+     * Validate summarizer configuration
+     * Note: This validation is optional and only performed when --summarize flag is actually used.
+     * It doesn't block other operations if summarizer config is incomplete.
+     */
+    static validateSummarizer(config, issues) {
+        // Only validate if summarizer provider is specified
+        if (!config.summarizerProvider) {
+            return;
+        }
+        // Validate provider is supported
+        if (config.summarizerProvider !== 'ollama' && config.summarizerProvider !== 'openai-compatible') {
+            issues.push({
+                path: 'summarizerProvider',
+                code: 'invalid_value',
+                message: `Unsupported summarizer provider: ${config.summarizerProvider}. Supported: 'ollama', 'openai-compatible'.`
+            });
+            return;
+        }
+        // For ollama provider, validate required fields
+        if (config.summarizerProvider === 'ollama') {
+            if (!config.summarizerOllamaBaseUrl) {
+                issues.push({
+                    path: 'summarizerOllamaBaseUrl',
+                    code: 'required',
+                    message: 'Ollama base URL is required for summarizer when provider is ollama'
+                });
+            }
+            if (!config.summarizerOllamaModelId) {
+                issues.push({
+                    path: 'summarizerOllamaModelId',
+                    code: 'required',
+                    message: 'Ollama model ID is required for summarizer when provider is ollama'
+                });
+            }
+        }
+        // For openai-compatible provider, validate required fields
+        if (config.summarizerProvider === 'openai-compatible') {
+            if (!config.summarizerOpenAiCompatibleBaseUrl) {
+                issues.push({
+                    path: 'summarizerOpenAiCompatibleBaseUrl',
+                    code: 'required',
+                    message: 'OpenAI-compatible base URL is required for summarizer when provider is openai-compatible'
+                });
+            }
+            if (!config.summarizerOpenAiCompatibleModelId) {
+                issues.push({
+                    path: 'summarizerOpenAiCompatibleModelId',
+                    code: 'required',
+                    message: 'OpenAI-compatible model ID is required for summarizer when provider is openai-compatible'
+                });
+            }
+            // Note: API key is optional for local servers (e.g., LM Studio)
+        }
+        // Validate language if specified
+        if (config.summarizerLanguage) {
+            if (config.summarizerLanguage !== 'English' && config.summarizerLanguage !== 'Chinese') {
+                issues.push({
+                    path: 'summarizerLanguage',
+                    code: 'invalid_value',
+                    message: `Invalid language: ${config.summarizerLanguage}. Must be 'English' or 'Chinese'.`
+                });
+            }
+        }
+    }
     /**
      * Validate basic configuration consistency
      */
@@ -473,6 +562,27 @@ class ConfigValidator {
                 message: 'Reranker batch size must be positive'
             });
         }
+        if (config.rerankerConcurrency !== undefined && config.rerankerConcurrency <= 0) {
+            issues.push({
+                path: 'rerankerConcurrency',
+                code: 'invalid_range',
+                message: 'Reranker concurrency must be positive'
+            });
+        }
+        if (config.rerankerMaxRetries !== undefined && config.rerankerMaxRetries < 0) {
+            issues.push({
+                path: 'rerankerMaxRetries',
+                code: 'invalid_range',
+                message: 'Reranker max retries must be non-negative'
+            });
+        }
+        if (config.rerankerRetryDelayMs !== undefined && config.rerankerRetryDelayMs < 0) {
+            issues.push({
+                path: 'rerankerRetryDelayMs',
+                code: 'invalid_range',
+                message: 'Reranker retry delay must be non-negative'
+            });
+        }
         if (config.vectorSearchMaxResults !== undefined && config.vectorSearchMaxResults <= 0) {
             issues.push({
                 path: 'vectorSearchMaxResults',
@@ -694,6 +804,17 @@ class CodeIndexConfigManager {
             rerankerOpenAiCompatibleApiKey: config.rerankerOpenAiCompatibleApiKey,
             rerankerMinScore: config.rerankerMinScore,
             rerankerBatchSize: config.rerankerBatchSize,
+            rerankerConcurrency: config.rerankerConcurrency,
+            rerankerMaxRetries: config.rerankerMaxRetries,
+            rerankerRetryDelayMs: config.rerankerRetryDelayMs,
+            summarizerProvider: config.summarizerProvider,
+            summarizerOllamaBaseUrl: config.summarizerOllamaBaseUrl,
+            summarizerOllamaModelId: config.summarizerOllamaModelId,
+            summarizerOpenAiCompatibleBaseUrl: config.summarizerOpenAiCompatibleBaseUrl,
+            summarizerOpenAiCompatibleModelId: config.summarizerOpenAiCompatibleModelId,
+            summarizerOpenAiCompatibleApiKey: config.summarizerOpenAiCompatibleApiKey,
+            summarizerLanguage: config.summarizerLanguage,
+            summarizerTemperature: config.summarizerTemperature,
         };
     }
     /**
@@ -898,7 +1019,32 @@ class CodeIndexConfigManager {
             openAiCompatibleModelId: this.config.rerankerOpenAiCompatibleModelId,
             openAiCompatibleApiKey: this.config.rerankerOpenAiCompatibleApiKey,
             minScore: this.config.rerankerMinScore,
-            batchSize: this.config.rerankerBatchSize || 10
+            batchSize: this.config.rerankerBatchSize || 10,
+            concurrency: this.config.rerankerConcurrency ?? DEFAULT_CONFIG.rerankerConcurrency,
+            maxRetries: this.config.rerankerMaxRetries ?? DEFAULT_CONFIG.rerankerMaxRetries,
+            retryDelayMs: this.config.rerankerRetryDelayMs ?? DEFAULT_CONFIG.rerankerRetryDelayMs
+        };
+    }
+    /**
+     * Gets the summarizer configuration.
+     * Always returns config (never undefined) since summarizer is only used when --summarize flag is present.
+     * Missing values are filled with defaults.
+     */
+    get summarizerConfig() {
+        const provider = this.config?.summarizerProvider || 'ollama';
+        return {
+            provider: provider,
+            ollamaBaseUrl: this.config?.summarizerOllamaBaseUrl || 'http://localhost:11434',
+            ollamaModelId: this.config?.summarizerOllamaModelId || 'qwen3-vl:4b-instruct',
+            openAiCompatibleBaseUrl: this.config?.summarizerOpenAiCompatibleBaseUrl || 'http://localhost:8080/v1',
+            openAiCompatibleModelId: this.config?.summarizerOpenAiCompatibleModelId || 'gpt-4',
+            openAiCompatibleApiKey: this.config?.summarizerOpenAiCompatibleApiKey || '',
+            language: this.config?.summarizerLanguage || 'English',
+            temperature: this.config?.summarizerTemperature,
+            batchSize: this.config?.summarizerBatchSize ?? DEFAULT_CONFIG.summarizerBatchSize,
+            concurrency: this.config?.summarizerConcurrency ?? DEFAULT_CONFIG.summarizerConcurrency,
+            maxRetries: this.config?.summarizerMaxRetries ?? DEFAULT_CONFIG.summarizerMaxRetries,
+            retryDelayMs: this.config?.summarizerRetryDelayMs ?? DEFAULT_CONFIG.summarizerRetryDelayMs
         };
     }
     /**
@@ -33167,7 +33313,7 @@ class OpenAiEmbedder {
 
 // Timeout constants for Ollama API requests
 const OLLAMA_EMBEDDING_TIMEOUT_MS = 120000; // 120 seconds for embedding requests (increased for large models)
-const OLLAMA_VALIDATION_TIMEOUT_MS$1 = 30000; // 30 seconds for validation requests
+const OLLAMA_VALIDATION_TIMEOUT_MS$2 = 30000; // 30 seconds for validation requests
 const OLLAMA_MAX_RETRIES = 2; // Ollama-specific retry count
 const OLLAMA_RETRY_DELAY_MS = 1000; // Initial retry delay for Ollama
 /**
@@ -33339,7 +33485,7 @@ class CodeIndexOllamaEmbedder {
             const modelsUrl = `${this.baseUrl}/api/tags`;
             // Add timeout to prevent indefinite hanging
             const controller = new AbortController();
-            const timeoutId = setTimeout(() => controller.abort(), OLLAMA_VALIDATION_TIMEOUT_MS$1);
+            const timeoutId = setTimeout(() => controller.abort(), OLLAMA_VALIDATION_TIMEOUT_MS$2);
             // 检查环境变量中的代理设置
             const httpsProxy = process.env['HTTPS_PROXY'] || process.env['https_proxy'];
             const httpProxy = process.env['HTTP_PROXY'] || process.env['http_proxy'];
@@ -33398,7 +33544,7 @@ class CodeIndexOllamaEmbedder {
             const testUrl = `${this.baseUrl}/api/embed`;
             // Add timeout for test request too
             const testController = new AbortController();
-            const testTimeoutId = setTimeout(() => testController.abort(), OLLAMA_VALIDATION_TIMEOUT_MS$1);
+            const testTimeoutId = setTimeout(() => testController.abort(), OLLAMA_VALIDATION_TIMEOUT_MS$2);
             const testFetchOptions = {
                 method: "POST",
                 headers: {
@@ -34569,20 +34715,25 @@ OpenRouterEmbedder.globalRateLimitState = {
 
 // Timeout constants for Ollama API requests
 const OLLAMA_RERANK_TIMEOUT_MS = 60000; // 60 seconds for rerank requests
-const OLLAMA_VALIDATION_TIMEOUT_MS = 30000; // 30 seconds for validation requests
+const OLLAMA_VALIDATION_TIMEOUT_MS$1 = 30000; // 30 seconds for validation requests
 /**
  * Implements the IReranker interface using a local Ollama instance with LLM-based reranking.
  */
 class OllamaLLMReranker {
-    constructor(baseUrl = "http://localhost:11434", modelId = "qwen3-vl:4b-instruct", batchSize = 10) {
+    constructor(baseUrl = "http://localhost:11434", modelId = "qwen3-vl:4b-instruct", batchSize = 10, concurrency = 3, maxRetries = 3, retryDelayMs = 1000) {
         // Normalize the baseUrl by removing all trailing slashes
         const normalizedBaseUrl = baseUrl.replace(/\/+$/, "");
         this.baseUrl = normalizedBaseUrl;
         this.modelId = modelId;
         this.batchSize = batchSize;
+        this.concurrency = concurrency;
+        this.maxRetries = maxRetries;
+        this.retryDelayMs = retryDelayMs;
     }
     /**
-     * Reranks candidates using LLM-based scoring.
+     * Reranks candidates using LLM-based scoring with batch-grouped concurrency.
+     * Reference: src/cli-tools/outline.ts generateSummariesWithRetry function
+     *
      * @param query The search query
      * @param candidates Array of candidates to rerank
      * @returns Promise resolving to reranked results with LLM scores
@@ -34591,32 +34742,71 @@ class OllamaLLMReranker {
         if (candidates.length === 0) {
             return [];
         }
-        // If candidates count <= batchSize, process directly (original logic)
+        // If candidates count <= batchSize, process directly
         if (candidates.length <= this.batchSize) {
             return this.rerankSingleBatch(query, candidates);
         }
-        // Process in batches
-        const allResults = [];
-        let processedCount = 0;
+        // Group candidates into batches
+        const batches = [];
         for (let i = 0; i < candidates.length; i += this.batchSize) {
-            const batch = candidates.slice(i, i + this.batchSize);
-            try {
-                const batchResults = await this.rerankSingleBatch(query, batch);
-                allResults.push(...batchResults);
+            batches.push(candidates.slice(i, i + this.batchSize));
+        }
+        // Process batches with concurrency control and retry logic
+        let completedBatches = 0;
+        const allResults = [];
+        const processBatchWithRetry = async (batch, batchIndex) => {
+            let attempt = 0;
+            let lastError = null;
+            while (attempt < this.maxRetries) {
+                try {
+                    const results = await this.rerankSingleBatch(query, batch);
+                    completedBatches++;
+                    if (completedBatches % 5 === 0 || completedBatches === batches.length) {
+                        console.log(`[OllamaReranker] Progress: ${completedBatches}/${batches.length} batches completed`);
+                    }
+                    return results;
+                }
+                catch (error) {
+                    lastError = error instanceof Error ? error : new Error(String(error));
+                    attempt++;
+                    if (attempt < this.maxRetries) {
+                        // Exponential backoff
+                        const delay = this.retryDelayMs * Math.pow(2, attempt - 1);
+                        console.warn(`[OllamaReranker] Batch ${batchIndex + 1} failed (attempt ${attempt}/${this.maxRetries}): ` +
+                            `${lastError.message}. Retrying in ${delay}ms...`);
+                        await new Promise(resolve => setTimeout(resolve, delay));
+                    }
+                    else {
+                        // Max retries reached, use fallback scores
+                        console.warn(`[OllamaReranker] Batch ${batchIndex + 1} failed after ${this.maxRetries} attempts. ` +
+                            `Using fallback scores...`);
+                        const baseScore = 10 - batchIndex * 0.1;
+                        return batch.map((candidate, idx) => ({
+                            id: candidate.id,
+                            score: baseScore - idx * 0.01,
+                            originalScore: candidate.score,
+                            payload: candidate.payload
+                        }));
+                    }
+                }
             }
-            catch (error) {
-                console.error(`Batch ${Math.floor(i / this.batchSize) + 1} failed:`, error);
-                // Fallback for failed batch
-                const fallbackResults = batch.map((candidate, idx) => ({
-                    id: candidate.id,
-                    score: 10 - (processedCount + idx) * 0.1,
-                    originalScore: candidate.score,
-                    payload: candidate.payload
-                }));
-                allResults.push(...fallbackResults);
+            // Should never reach here, but TypeScript needs a return
+            return batch.map((candidate, idx) => ({
+                id: candidate.id,
+                score: 0,
+                originalScore: candidate.score,
+                payload: candidate.payload
+            }));
+        };
+        // Process batches with concurrency control (group-based pattern)
+        const processBatchesWithConcurrency = async () => {
+            for (let i = 0; i < batches.length; i += this.concurrency) {
+                const batchGroup = batches.slice(i, i + this.concurrency);
+                const groupResults = await Promise.all(batchGroup.map((batch, idx) => processBatchWithRetry(batch, i + idx)));
+                allResults.push(...groupResults.flat());
             }
-            processedCount += batch.length;
-        }
+        };
+        await processBatchesWithConcurrency();
         // Merge and re-sort all results
         allResults.sort((a, b) => b.score - a.score);
         return allResults;
@@ -34628,32 +34818,21 @@ class OllamaLLMReranker {
      * @returns Promise resolving to reranked results with LLM scores
      */
     async rerankSingleBatch(query, candidates) {
-        try {
-            // Build the scoring prompt with all candidates
-            const prompt = this.buildScoringPrompt(query, candidates);
-            // Call Ollama /api/generate endpoint
-            const scores = await this.generateScores(prompt);
-            // Combine original candidates with LLM scores
-            const results = candidates.map((candidate, index) => ({
-                id: candidate.id,
-                score: scores[index] || 0, // Default to 0 if no score
-                originalScore: candidate.score,
-                payload: candidate.payload
-            }));
-            // Sort by LLM score (descending) - this maintains order within the batch
-            results.sort((a, b) => b.score - a.score);
-            return results;
-        }
-        catch (error) {
-            console.error("Ollama LLM batch reranking failed, returning original order:", error);
-            // Fallback to original order with default scores
-            return candidates.map((candidate, index) => ({
-                id: candidate.id,
-                score: 10 - index * 0.1, // Slight decreasing scores to maintain order
-                originalScore: candidate.score,
-                payload: candidate.payload
-            }));
-        }
+        // Build the scoring prompt with all candidates
+        const prompt = this.buildScoringPrompt(query, candidates);
+        // Call Ollama /api/generate endpoint
+        // This will throw an error if generation fails, allowing the retry logic to kick in
+        const scores = await this.generateScores(prompt);
+        // Combine original candidates with LLM scores
+        const results = candidates.map((candidate, index) => ({
+            id: candidate.id,
+            score: scores[index] || 0, // Default to 0 if no score
+            originalScore: candidate.score,
+            payload: candidate.payload
+        }));
+        // Sort by LLM score (descending) - this maintains order within the batch
+        results.sort((a, b) => b.score - a.score);
+        return results;
     }
     /**
      * Builds the scoring prompt for the LLM.
@@ -34680,7 +34859,7 @@ Snippets:
 ---
 `;
         });
-        prompt += `Respond with ONLY a JSON object with a relevant "scores" array: {"scores": [${Array.from({ length: candidates.length }, (_, i) => `score${i + 1}`).join(', ')}]}`;
+        prompt += `Respond with ONLY a JSON object with a relevant "scores" array: {"scores": [${Array.from({ length: candidates.length }, (_, i) => `snippet${i + 1}_score`).join(', ')}]}`;
         return prompt;
     }
     /**
@@ -34810,7 +34989,7 @@ Snippets:
             const modelsUrl = `${this.baseUrl}/api/tags`;
             // Add timeout to prevent indefinite hanging
             const controller = new AbortController();
-            const timeoutId = setTimeout(() => controller.abort(), OLLAMA_VALIDATION_TIMEOUT_MS);
+            const timeoutId = setTimeout(() => controller.abort(), OLLAMA_VALIDATION_TIMEOUT_MS$1);
             // Check for proxy settings in environment variables
             const httpsProxy = process.env['HTTPS_PROXY'] || process.env['https_proxy'];
             const httpProxy = process.env['HTTP_PROXY'] || process.env['http_proxy'];
@@ -34869,7 +35048,7 @@ Snippets:
             const testUrl = `${this.baseUrl}/api/generate`;
             // Add timeout for test request too
             const testController = new AbortController();
-            const testTimeoutId = setTimeout(() => testController.abort(), OLLAMA_VALIDATION_TIMEOUT_MS);
+            const testTimeoutId = setTimeout(() => testController.abort(), OLLAMA_VALIDATION_TIMEOUT_MS$1);
             const testFetchOptions = {
                 method: "POST",
                 headers: {
@@ -34940,16 +35119,21 @@ const OPENAI_VALIDATION_TIMEOUT_MS = 30000; // 30 seconds for validation request
  * Implements the IReranker interface using OpenAI-compatible API endpoints with LLM-based reranking.
  */
 class OpenAICompatibleReranker {
-    constructor(baseUrl = "http://localhost:8080/v1", modelId = "gpt-4", apiKey = "", batchSize = 10) {
+    constructor(baseUrl = "http://localhost:8080/v1", modelId = "gpt-4", apiKey = "", batchSize = 10, concurrency = 3, maxRetries = 3, retryDelayMs = 1000) {
         // Normalize the baseUrl by removing all trailing slashes
         const normalizedBaseUrl = baseUrl.replace(/\/+$/, "");
         this.baseUrl = normalizedBaseUrl;
         this.modelId = modelId;
         this.apiKey = apiKey;
         this.batchSize = batchSize;
+        this.concurrency = concurrency;
+        this.maxRetries = maxRetries;
+        this.retryDelayMs = retryDelayMs;
     }
     /**
-     * Reranks candidates using LLM-based scoring.
+     * Reranks candidates using LLM-based scoring with batch-grouped concurrency.
+     * Reference: src/cli-tools/outline.ts generateSummariesWithRetry function
+     *
      * @param query The search query
      * @param candidates Array of candidates to rerank
      * @returns Promise resolving to reranked results with LLM scores
@@ -34958,32 +35142,72 @@ class OpenAICompatibleReranker {
         if (candidates.length === 0) {
             return [];
         }
-        // If candidates count <= batchSize, process directly (original logic)
+        // If candidates count <= batchSize, process directly
         if (candidates.length <= this.batchSize) {
             return this.rerankSingleBatch(query, candidates);
         }
-        // Process in batches
-        const allResults = [];
-        let processedCount = 0;
+        // Group candidates into batches
+        const batches = [];
         for (let i = 0; i < candidates.length; i += this.batchSize) {
-            const batch = candidates.slice(i, i + this.batchSize);
-            try {
-                const batchResults = await this.rerankSingleBatch(query, batch);
-                allResults.push(...batchResults);
+            batches.push(candidates.slice(i, i + this.batchSize));
+        }
+        // Process batches with concurrency control and retry logic
+        let completedBatches = 0;
+        const allResults = [];
+        const processBatchWithRetry = async (batch, batchIndex) => {
+            let attempt = 0;
+            let lastError = null;
+            console.log(`[OpenAICompatibleReranker] Starting batch ${batchIndex + 1}/${batches.length} with ${batch.length} candidates`);
+            while (attempt < this.maxRetries) {
+                try {
+                    const results = await this.rerankSingleBatch(query, batch);
+                    completedBatches++;
+                    if (completedBatches % 5 === 0 || completedBatches === batches.length) {
+                        console.log(`[OpenAICompatibleReranker] Progress: ${completedBatches}/${batches.length} batches completed`);
+                    }
+                    return results;
+                }
+                catch (error) {
+                    lastError = error instanceof Error ? error : new Error(String(error));
+                    attempt++;
+                    if (attempt < this.maxRetries) {
+                        // Exponential backoff
+                        const delay = this.retryDelayMs * Math.pow(2, attempt - 1);
+                        console.warn(`[OpenAICompatibleReranker] Batch ${batchIndex + 1} - Attempt ${attempt}/${this.maxRetries} FAILED: ` +
+                            `${lastError.message}. Retrying in ${delay}ms...`);
+                        await new Promise(resolve => setTimeout(resolve, delay));
+                    }
+                    else {
+                        // Max retries reached, use fallback scores
+                        console.warn(`[OpenAICompatibleReranker] Batch ${batchIndex + 1} - All ${this.maxRetries} attempts FAILED. ` +
+                            `Using fallback scores. Last error: ${lastError.message}`);
+                        const baseScore = 10 - batchIndex * 0.1;
+                        return batch.map((candidate, idx) => ({
+                            id: candidate.id,
+                            score: baseScore - idx * 0.01,
+                            originalScore: candidate.score,
+                            payload: candidate.payload
+                        }));
+                    }
+                }
             }
-            catch (error) {
-                console.error(`Batch ${Math.floor(i / this.batchSize) + 1} failed:`, error);
-                // Fallback for failed batch
-                const fallbackResults = batch.map((candidate, idx) => ({
-                    id: candidate.id,
-                    score: 10 - (processedCount + idx) * 0.1,
-                    originalScore: candidate.score,
-                    payload: candidate.payload
-                }));
-                allResults.push(...fallbackResults);
+            // Should never reach here, but TypeScript needs a return
+            return batch.map((candidate, idx) => ({
+                id: candidate.id,
+                score: 0,
+                originalScore: candidate.score,
+                payload: candidate.payload
+            }));
+        };
+        // Process batches with concurrency control (group-based pattern)
+        const processBatchesWithConcurrency = async () => {
+            for (let i = 0; i < batches.length; i += this.concurrency) {
+                const batchGroup = batches.slice(i, i + this.concurrency);
+                const groupResults = await Promise.all(batchGroup.map((batch, idx) => processBatchWithRetry(batch, i + idx)));
+                allResults.push(...groupResults.flat());
             }
-            processedCount += batch.length;
-        }
+        };
+        await processBatchesWithConcurrency();
         // Merge and re-sort all results
         allResults.sort((a, b) => b.score - a.score);
         return allResults;
@@ -34995,32 +35219,21 @@ class OpenAICompatibleReranker {
      * @returns Promise resolving to reranked results with LLM scores
      */
     async rerankSingleBatch(query, candidates) {
-        try {
-            // Build the scoring prompt with all candidates
-            const prompt = this.buildScoringPrompt(query, candidates);
-            // Call OpenAI-compatible /chat/completions endpoint
-            const scores = await this.generateScores(prompt);
-            // Combine original candidates with LLM scores
-            const results = candidates.map((candidate, index) => ({
-                id: candidate.id,
-                score: scores[index] || 0, // Default to 0 if no score
-                originalScore: candidate.score,
-                payload: candidate.payload
-            }));
-            // Sort by LLM score (descending) - this maintains order within the batch
-            results.sort((a, b) => b.score - a.score);
-            return results;
-        }
-        catch (error) {
-            console.error("OpenAI-compatible LLM batch reranking failed, returning original order:", error);
-            // Fallback to original order with default scores
-            return candidates.map((candidate, index) => ({
-                id: candidate.id,
-                score: 10 - index * 0.1, // Slight decreasing scores to maintain order
-                originalScore: candidate.score,
-                payload: candidate.payload
-            }));
-        }
+        // Build the scoring prompt with all candidates
+        const prompt = this.buildScoringPrompt(query, candidates);
+        // Call OpenAI-compatible /chat/completions endpoint
+        // This will throw an error if generation fails, allowing the retry logic to kick in
+        const scores = await this.generateScores(prompt);
+        // Combine original candidates with LLM scores
+        const results = candidates.map((candidate, index) => ({
+            id: candidate.id,
+            score: scores[index] || 0, // Default to 0 if no score
+            originalScore: candidate.score,
+            payload: candidate.payload
+        }));
+        // Sort by LLM score (descending) - this maintains order within the batch
+        results.sort((a, b) => b.score - a.score);
+        return results;
     }
     /**
      * Builds the scoring prompt for the LLM.
@@ -35047,7 +35260,7 @@ Snippets:
 ---
 `;
         });
-        prompt += `Respond with ONLY a JSON object with a relevant "scores" array: {"scores": [${Array.from({ length: candidates.length }, (_, i) => `score${i + 1}`).join(', ')}]}`;
+        prompt += `Respond with ONLY a JSON object with a relevant "scores" array: {"scores": [${Array.from({ length: candidates.length }, (_, i) => `snippet${i + 1}_score`).join(', ')}]}`;
         return prompt;
     }
     /**
@@ -35365,6 +35578,721 @@ Snippets:
     }
 }
 
+// Timeout constants for Ollama API requests
+const OLLAMA_SUMMARIZE_TIMEOUT_MS = 60000; // 60 seconds for summarization
+const OLLAMA_VALIDATION_TIMEOUT_MS = 30000; // 30 seconds for validation
+/**
+ * Implements the ISummarizer interface using a local Ollama instance with LLM-based summarization.
+ */
+class OllamaSummarizer {
+    constructor(baseUrl = "http://localhost:11434", modelId = "qwen3-vl:4b-instruct", defaultLanguage = 'English', temperature = 0.3) {
+        // Normalize the baseUrl by removing all trailing slashes
+        const normalizedBaseUrl = baseUrl.replace(/\/+$/, "");
+        this.baseUrl = normalizedBaseUrl;
+        this.modelId = modelId;
+        this.defaultLanguage = defaultLanguage;
+        this.temperature = temperature;
+    }
+    /**
+     * Generate a summary for the given code content
+     * Internally delegates to summarizeBatch() for unified processing
+     */
+    async summarize(request) {
+        // Wrap single request as a batch of one
+        const batchRequest = {
+            document: request.document,
+            filePath: request.filePath,
+            blocks: [{
+                    content: request.content,
+                    codeType: request.codeType,
+                    codeName: request.codeName
+                }],
+            language: request.language
+        };
+        const result = await this.summarizeBatch(batchRequest);
+        return result.summaries[0];
+    }
+    /**
+     * Builds a unified batch prompt for summarizing code blocks
+     * Works for both single and batch requests
+     */
+    buildPrompt(request) {
+        const { blocks, language, document, filePath } = request;
+        // Unified English prompt template
+        let prompt = `Generate semantic descriptions for the following code snippets:\n\n`;
+        // Add shared context once at the beginning
+        if (filePath) {
+            prompt += `[File]: ${filePath}\n\n`;
+        }
+        if (document) {
+            prompt += `[Shared Context]:\n\`\`\`\n${document}\n\`\`\`\n\n`;
+        }
+        blocks.forEach((block, index) => {
+            prompt += `### Snippet ${index + 1}\n\n`;
+            prompt += `[Type]: ${block.codeType}${block.codeName ? ` "${block.codeName}"` : ''}\n\n`;
+            prompt += `[Target Code]:\n`;
+            if (block.content === document) {
+                prompt += `(See Shared Context)\n\n---\n\n`;
+            }
+            else {
+                prompt += `\`\`\`\n${block.content}\n\`\`\`\n\n---\n\n`;
+            }
+        });
+        prompt += `Requirements:\n`;
+        prompt += `- Generate semantic description for each snippet\n`;
+        prompt += `- Focus on logic, implementation details, business role\n`;
+        prompt += `- **Start directly with verbs**, NO prefixes like "Function X" or "Class Y"\n`;
+        prompt += `- For core implementations, include keywords like "implements", "logic"\n\n`;
+        // Language-specific output instructions
+        if (language === 'Chinese') {
+            prompt += `IMPORTANT: Respond in **Chinese (中文)**. Each description must be 30-80 Chinese characters.\n\n`;
+        }
+        prompt += `IMPORTANT: Respond with ONLY the JSON object, no extra text.\n\n`;
+        // Different format for single vs multiple blocks
+        if (blocks.length === 1) {
+            prompt += `Return format: {"summaries": "description"} (single string)\n`;
+        }
+        else {
+            const descs = Array.from({ length: blocks.length }, (_, i) => `"snippet${i + 1}_desc"`).join(', ');
+            prompt += `Return format: {"summaries": [${descs}]} (${blocks.length} descriptions)\n`;
+        }
+        return prompt;
+    }
+    /**
+     * Extracts a complete JSON object from text using bracket matching
+     * This handles nested JSON objects correctly, unlike regex greedy matching
+     * @returns The extracted JSON string or null if not found
+     */
+    extractCompleteJsonObject(text) {
+        // Find the first opening brace
+        const startIndex = text.indexOf('{');
+        if (startIndex === -1) {
+            return null;
+        }
+        // Use stack to find matching closing brace
+        let depth = 0;
+        let inString = false;
+        let escapeNext = false;
+        for (let i = startIndex; i < text.length; i++) {
+            const char = text[i];
+            if (escapeNext) {
+                escapeNext = false;
+                continue;
+            }
+            if (char === '\\') {
+                escapeNext = true;
+                continue;
+            }
+            if (char === '"') {
+                inString = !inString;
+                continue;
+            }
+            if (!inString) {
+                if (char === '{') {
+                    depth++;
+                }
+                else if (char === '}') {
+                    depth--;
+                    if (depth === 0) {
+                        // Found matching closing brace
+                        return text.substring(startIndex, i + 1);
+                    }
+                }
+            }
+        }
+        return null;
+    }
+    /**
+     * Generate summaries for multiple code blocks in a single batch request
+     * This is more efficient than calling summarize() multiple times
+     */
+    async summarizeBatch(request) {
+        const prompt = this.buildPrompt(request);
+        const url = `${this.baseUrl}/api/generate`;
+        // Add timeout to prevent indefinite hanging
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), OLLAMA_SUMMARIZE_TIMEOUT_MS);
+        // Check for proxy settings in environment variables
+        const httpsProxy = process.env['HTTPS_PROXY'] || process.env['https_proxy'];
+        const httpProxy = process.env['HTTP_PROXY'] || process.env['http_proxy'];
+        // Choose appropriate proxy based on target URL protocol
+        let dispatcher = undefined;
+        const proxyUrl = url.startsWith('https:') ? httpsProxy : httpProxy;
+        if (proxyUrl) {
+            try {
+                dispatcher = new ProxyAgent_1(proxyUrl);
+            }
+            catch (error) {
+                // Silently fail - proxy is optional
+            }
+        }
+        try {
+            const fetchOptions = {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify({
+                    model: this.modelId,
+                    prompt: prompt,
+                    stream: false,
+                    format: "json",
+                    options: {
+                        num_predict: 500, // Increased for batch responses
+                        temperature: this.temperature
+                    }
+                }),
+                signal: controller.signal,
+            };
+            if (dispatcher) {
+                fetchOptions.dispatcher = dispatcher;
+            }
+            const response = await fetch$1(url, fetchOptions);
+            if (!response.ok) {
+                let errorBody = "Could not read error body";
+                try {
+                    errorBody = await response.text();
+                }
+                catch (e) {
+                    // Ignore error reading body
+                }
+                throw new Error(`Ollama API error: ${response.status} - ${errorBody}`);
+            }
+            const data = await response.json();
+            // Parse response: data.response is a JSON string
+            const responseText = data.response.trim();
+            // Try to extract JSON from the response with multiple fallback strategies
+            let parsedResponse;
+            try {
+                // Strategy 1: Try direct parse
+                parsedResponse = JSON.parse(responseText);
+            }
+            catch {
+                // Strategy 2: Extract JSON from markdown code blocks
+                let jsonMatch = responseText.match(/```json\s*([\s\S]*?)\s*```/) ||
+                    responseText.match(/```\s*([\s\S]*?)\s*```/);
+                if (jsonMatch) {
+                    try {
+                        parsedResponse = JSON.parse(jsonMatch[1].trim());
+                    }
+                    catch {
+                        // Strategy 3: Use bracket matching to find complete JSON object
+                        const extracted = this.extractCompleteJsonObject(responseText);
+                        if (extracted) {
+                            parsedResponse = JSON.parse(extracted);
+                        }
+                        else {
+                            throw new Error(`Failed to parse batch response JSON after multiple attempts`);
+                        }
+                    }
+                }
+                else {
+                    // Strategy 4: Use bracket matching to find complete JSON object
+                    const extracted = this.extractCompleteJsonObject(responseText);
+                    if (extracted) {
+                        parsedResponse = JSON.parse(extracted);
+                    }
+                    else {
+                        throw new Error(`Could not extract JSON from batch response`);
+                    }
+                }
+            }
+            // Validate response format - support both array and string (for single block with small models)
+            let summariesArray = [];
+            if (typeof parsedResponse.summaries === 'string') {
+                // Small model may return {"summaries": "desc"} instead of {"summaries": ["desc"]}
+                summariesArray = [parsedResponse.summaries];
+            }
+            else if (Array.isArray(parsedResponse.summaries)) {
+                summariesArray = parsedResponse.summaries;
+            }
+            else {
+                throw new Error(`Invalid batch response format: 'summaries' must be array or string`);
+            }
+            // Validate response length matches request length
+            if (summariesArray.length !== request.blocks.length) {
+                throw new Error(`Batch response length mismatch: expected ${request.blocks.length}, got ${summariesArray.length}`);
+            }
+            // Transform response to SummarizerBatchResult format
+            const summaries = summariesArray.map((item) => {
+                const text = typeof item === 'string' ? item : (item.desc1 || item.summary || '');
+                return {
+                    summary: text.trim(),
+                    language: request.language
+                };
+            });
+            return { summaries };
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+    }
+    /**
+     * Validates the Ollama summarizer configuration by checking service availability and model existence
+     */
+    async validateConfiguration() {
+        try {
+            // 1. Check if Ollama service is running by trying to list models
+            const modelsUrl = `${this.baseUrl}/api/tags`;
+            // Add timeout to prevent indefinite hanging
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), OLLAMA_VALIDATION_TIMEOUT_MS);
+            // Check for proxy settings in environment variables
+            const httpsProxy = process.env['HTTPS_PROXY'] || process.env['https_proxy'];
+            const httpProxy = process.env['HTTP_PROXY'] || process.env['http_proxy'];
+            let dispatcher = undefined;
+            const proxyUrl = modelsUrl.startsWith('https:') ? httpsProxy : httpProxy;
+            if (proxyUrl) {
+                try {
+                    dispatcher = new ProxyAgent_1(proxyUrl);
+                }
+                catch (error) {
+                    // Silently fail - proxy is optional
+                }
+            }
+            try {
+                const fetchOptions = {
+                    method: "GET",
+                    headers: {
+                        "Content-Type": "application/json",
+                    },
+                    signal: controller.signal,
+                };
+                if (dispatcher) {
+                    fetchOptions.dispatcher = dispatcher;
+                }
+                const modelsResponse = await fetch$1(modelsUrl, fetchOptions);
+                if (!modelsResponse.ok) {
+                    return {
+                        valid: false,
+                        error: `Ollama service unavailable at ${this.baseUrl} (status: ${modelsResponse.status})`
+                    };
+                }
+                // 2. Check if model exists
+                const modelsData = await modelsResponse.json();
+                const models = modelsData.models || [];
+                // Check both with and without :latest suffix
+                const modelExists = models.some((m) => {
+                    const name = m.name || "";
+                    return (name === this.modelId ||
+                        name === `${this.modelId}:latest` ||
+                        name === this.modelId.replace(":latest", ""));
+                });
+                if (!modelExists) {
+                    const available = models.map((m) => m.name).join(', ');
+                    return {
+                        valid: false,
+                        error: `Model '${this.modelId}' not found. Available: ${available}`
+                    };
+                }
+                // 3. Test generation
+                const testUrl = `${this.baseUrl}/api/generate`;
+                // Add timeout for test request too
+                const testController = new AbortController();
+                const testTimeoutId = setTimeout(() => testController.abort(), OLLAMA_VALIDATION_TIMEOUT_MS);
+                try {
+                    const testFetchOptions = {
+                        method: "POST",
+                        headers: {
+                            "Content-Type": "application/json",
+                        },
+                        body: JSON.stringify({
+                            model: this.modelId,
+                            prompt: "test",
+                            stream: false,
+                            options: {
+                                num_predict: 10
+                            }
+                        }),
+                        signal: testController.signal,
+                    };
+                    if (dispatcher) {
+                        testFetchOptions.dispatcher = dispatcher;
+                    }
+                    const testResponse = await fetch$1(testUrl, testFetchOptions);
+                    if (!testResponse.ok) {
+                        return {
+                            valid: false,
+                            error: `Model '${this.modelId}' failed generation test`
+                        };
+                    }
+                }
+                finally {
+                    clearTimeout(testTimeoutId);
+                }
+                return { valid: true };
+            }
+            finally {
+                clearTimeout(timeoutId);
+            }
+        }
+        catch (error) {
+            if (error.name === 'AbortError') {
+                return { valid: false, error: 'Connection timeout' };
+            }
+            if (error.code === 'ECONNREFUSED' || error.message?.includes('ECONNREFUSED')) {
+                return { valid: false, error: `Ollama not running at ${this.baseUrl}` };
+            }
+            return { valid: false, error: error.message };
+        }
+    }
+    get summarizerInfo() {
+        return {
+            name: 'ollama',
+            model: this.modelId
+        };
+    }
+}
+
+// Timeout constants for OpenAI-compatible API requests
+const OPENAI_COMPATIBLE_SUMMARIZE_TIMEOUT_MS = 60000; // 60 seconds for summarization
+const OPENAI_COMPATIBLE_VALIDATION_TIMEOUT_MS = 30000; // 30 seconds for validation
+/**
+ * Extracts a complete JSON object from text using bracket matching
+ * This handles nested JSON objects correctly, unlike regex greedy matching
+ * @returns The extracted JSON string or null if not found
+ */
+function extractCompleteJsonObject(text) {
+    // Find the first opening brace
+    const startIndex = text.indexOf('{');
+    if (startIndex === -1) {
+        return null;
+    }
+    // Use stack to find matching closing brace
+    let depth = 0;
+    let inString = false;
+    let escapeNext = false;
+    for (let i = startIndex; i < text.length; i++) {
+        const char = text[i];
+        if (escapeNext) {
+            escapeNext = false;
+            continue;
+        }
+        if (char === '\\') {
+            escapeNext = true;
+            continue;
+        }
+        if (char === '"') {
+            inString = !inString;
+            continue;
+        }
+        if (!inString) {
+            if (char === '{') {
+                depth++;
+            }
+            else if (char === '}') {
+                depth--;
+                if (depth === 0) {
+                    // Found matching closing brace
+                    return text.substring(startIndex, i + 1);
+                }
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Implements the ISummarizer interface using OpenAI-compatible API endpoints with LLM-based summarization.
+ * Supports any OpenAI-compatible API such as DeepSeek, SiliconFlow, local LM Studio, etc.
+ */
+class OpenAICompatibleSummarizer {
+    constructor(baseUrl = "http://localhost:8080/v1", modelId = "gpt-4", apiKey = "", defaultLanguage = 'English', temperature = 0.3) {
+        // Normalize the baseUrl by removing all trailing slashes
+        const normalizedBaseUrl = baseUrl.replace(/\/+$/, "");
+        this.baseUrl = normalizedBaseUrl;
+        this.modelId = modelId;
+        this.apiKey = apiKey;
+        this.defaultLanguage = defaultLanguage;
+        this.temperature = temperature;
+    }
+    /**
+     * Generate a summary for the given code content
+     * Internally delegates to summarizeBatch() for unified processing
+     */
+    async summarize(request) {
+        // Wrap single request as a batch of one
+        const batchRequest = {
+            document: request.document,
+            filePath: request.filePath,
+            blocks: [{
+                    content: request.content,
+                    codeType: request.codeType,
+                    codeName: request.codeName
+                }],
+            language: request.language
+        };
+        const result = await this.summarizeBatch(batchRequest);
+        return result.summaries[0];
+    }
+    /**
+     * Builds a unified batch prompt for summarizing code blocks
+     * Works for both single and batch requests
+     */
+    buildPrompt(request) {
+        const { blocks, language, document, filePath } = request;
+        // Unified English prompt template
+        let prompt = `Generate semantic descriptions for the following code snippets:\n\n`;
+        // Add shared context once at the beginning
+        if (filePath) {
+            prompt += `[File]: ${filePath}\n\n`;
+        }
+        if (document) {
+            prompt += `[Shared Context]:\n\`\`\`\n${document}\n\`\`\`\n\n`;
+        }
+        blocks.forEach((block, index) => {
+            prompt += `### Snippet ${index + 1}\n\n`;
+            prompt += `[Type]: ${block.codeType}${block.codeName ? ` "${block.codeName}"` : ''}\n\n`;
+            prompt += `[Target Code]:\n`;
+            if (block.content === document) {
+                prompt += `(See Shared Context)\n\n---\n\n`;
+            }
+            else {
+                prompt += `\`\`\`\n${block.content}\n\`\`\`\n\n---\n\n`;
+            }
+        });
+        prompt += `Requirements:\n`;
+        prompt += `- Generate semantic description for each snippet\n`;
+        prompt += `- Focus on logic, implementation details, business role\n`;
+        prompt += `- **Start directly with verbs**, NO prefixes like "Function X" or "Class Y"\n`;
+        prompt += `- For core implementations, include keywords like "implements", "logic"\n\n`;
+        // Language-specific output instructions
+        if (language === 'Chinese') {
+            prompt += `IMPORTANT: Respond in **Chinese (中文)**. Each description must be 30-80 Chinese characters.\n\n`;
+        }
+        prompt += `IMPORTANT: Respond with ONLY the JSON object, no extra text.\n\n`;
+        // Different format for single vs multiple blocks
+        if (blocks.length === 1) {
+            prompt += `Return format: {"summaries": "description"} (single string)\n`;
+        }
+        else {
+            const descs = Array.from({ length: blocks.length }, (_, i) => `"snippet${i + 1}_desc"`).join(', ');
+            prompt += `Return format: {"summaries": [${descs}]} (${blocks.length} descriptions)\n`;
+        }
+        return prompt;
+    }
+    /**
+     * Generate summaries for multiple code blocks in a single batch request
+     * This is more efficient than calling summarize() multiple times
+     */
+    async summarizeBatch(request) {
+        const prompt = this.buildPrompt(request);
+        const url = `${this.baseUrl}/chat/completions`;
+        // Add timeout to prevent indefinite hanging
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), OPENAI_COMPATIBLE_SUMMARIZE_TIMEOUT_MS);
+        // Check for proxy settings in environment variables
+        const httpsProxy = process.env['HTTPS_PROXY'] || process.env['https_proxy'];
+        const httpProxy = process.env['HTTP_PROXY'] || process.env['http_proxy'];
+        // Choose appropriate proxy based on target URL protocol
+        let dispatcher = undefined;
+        const proxyUrl = url.startsWith('https:') ? httpsProxy : httpProxy;
+        if (proxyUrl) {
+            try {
+                dispatcher = new ProxyAgent_1(proxyUrl);
+            }
+            catch (error) {
+                // Silently fail - proxy is optional
+            }
+        }
+        try {
+            const headers = {
+                "Content-Type": "application/json",
+            };
+            // Add Authorization header if API key is provided
+            if (this.apiKey) {
+                headers["Authorization"] = `Bearer ${this.apiKey}`;
+            }
+            const fetchOptions = {
+                method: "POST",
+                headers: headers,
+                body: JSON.stringify({
+                    model: this.modelId,
+                    messages: [
+                        {
+                            role: "user",
+                            content: prompt
+                        }
+                    ],
+                    stream: false,
+                    temperature: this.temperature,
+                    max_tokens: 500 // Increased for batch responses
+                }),
+                signal: controller.signal,
+            };
+            if (dispatcher) {
+                fetchOptions.dispatcher = dispatcher;
+            }
+            const response = await fetch$1(url, fetchOptions);
+            if (!response.ok) {
+                let errorBody = "Could not read error body";
+                try {
+                    errorBody = await response.text();
+                }
+                catch (e) {
+                    // Ignore error reading body
+                }
+                throw new Error(`OpenAI-compatible API error: ${response.status} - ${errorBody}`);
+            }
+            const data = await response.json();
+            // Parse response: data.choices[0].message.content
+            if (!data.choices || !data.choices[0] || !data.choices[0].message) {
+                throw new Error(`Invalid response format: missing 'choices' field`);
+            }
+            const responseText = data.choices[0].message.content.trim();
+            // Try to extract JSON from the response with multiple fallback strategies
+            let parsedResponse;
+            try {
+                // Strategy 1: Try direct parse
+                parsedResponse = JSON.parse(responseText);
+            }
+            catch {
+                // Strategy 2: Extract JSON from markdown code blocks
+                let jsonMatch = responseText.match(/```json\s*([\s\S]*?)\s*```/) ||
+                    responseText.match(/```\s*([\s\S]*?)\s*```/);
+                if (jsonMatch) {
+                    try {
+                        parsedResponse = JSON.parse(jsonMatch[1].trim());
+                    }
+                    catch {
+                        // Strategy 3: Use bracket matching to find complete JSON object
+                        const extracted = extractCompleteJsonObject(responseText);
+                        if (extracted) {
+                            parsedResponse = JSON.parse(extracted);
+                        }
+                        else {
+                            throw new Error(`Failed to parse batch response JSON after multiple attempts`);
+                        }
+                    }
+                }
+                else {
+                    // Strategy 4: Use bracket matching to find complete JSON object
+                    const extracted = extractCompleteJsonObject(responseText);
+                    if (extracted) {
+                        parsedResponse = JSON.parse(extracted);
+                    }
+                    else {
+                        throw new Error(`Could not extract JSON from batch response`);
+                    }
+                }
+            }
+            // Validate response format - support both array and string (for single block with small models)
+            let summariesArray = [];
+            if (typeof parsedResponse.summaries === 'string') {
+                // Small model may return {"summaries": "desc"} instead of {"summaries": ["desc"]}
+                summariesArray = [parsedResponse.summaries];
+            }
+            else if (Array.isArray(parsedResponse.summaries)) {
+                summariesArray = parsedResponse.summaries;
+            }
+            else {
+                throw new Error(`Invalid batch response format: 'summaries' must be array or string`);
+            }
+            // Validate response length matches request length
+            if (summariesArray.length !== request.blocks.length) {
+                throw new Error(`Batch response length mismatch: expected ${request.blocks.length}, got ${summariesArray.length}`);
+            }
+            // Transform response to SummarizerBatchResult format
+            const summaries = summariesArray.map((item) => {
+                const text = typeof item === 'string' ? item : (item.desc1 || item.summary || '');
+                return {
+                    summary: text.trim(),
+                    language: request.language
+                };
+            });
+            return { summaries };
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+    }
+    /**
+     * Validates the OpenAI-compatible summarizer configuration by checking service availability
+     */
+    async validateConfiguration() {
+        try {
+            // Test by calling the chat completions endpoint with a simple prompt
+            const url = `${this.baseUrl}/chat/completions`;
+            // Add timeout to prevent indefinite hanging
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), OPENAI_COMPATIBLE_VALIDATION_TIMEOUT_MS);
+            // Check for proxy settings in environment variables
+            const httpsProxy = process.env['HTTPS_PROXY'] || process.env['https_proxy'];
+            const httpProxy = process.env['HTTP_PROXY'] || process.env['http_proxy'];
+            let dispatcher = undefined;
+            const proxyUrl = url.startsWith('https:') ? httpsProxy : httpProxy;
+            if (proxyUrl) {
+                try {
+                    dispatcher = new ProxyAgent_1(proxyUrl);
+                }
+                catch (error) {
+                    // Silently fail - proxy is optional
+                }
+            }
+            try {
+                const headers = {
+                    "Content-Type": "application/json",
+                };
+                // Add Authorization header if API key is provided
+                if (this.apiKey) {
+                    headers["Authorization"] = `Bearer ${this.apiKey}`;
+                }
+                const fetchOptions = {
+                    method: "POST",
+                    headers: headers,
+                    body: JSON.stringify({
+                        model: this.modelId,
+                        messages: [
+                            {
+                                role: "user",
+                                content: "test"
+                            }
+                        ],
+                        stream: false,
+                        max_tokens: 10
+                    }),
+                    signal: controller.signal,
+                };
+                if (dispatcher) {
+                    fetchOptions.dispatcher = dispatcher;
+                }
+                const response = await fetch$1(url, fetchOptions);
+                if (!response.ok) {
+                    let errorBody = "Could not read error body";
+                    try {
+                        errorBody = await response.text();
+                    }
+                    catch (e) {
+                        // Ignore error reading body
+                    }
+                    return {
+                        valid: false,
+                        error: `API unavailable at ${this.baseUrl} (status: ${response.status}): ${errorBody}`
+                    };
+                }
+                return { valid: true };
+            }
+            finally {
+                clearTimeout(timeoutId);
+            }
+        }
+        catch (error) {
+            if (error.name === 'AbortError') {
+                return { valid: false, error: 'Connection timeout' };
+            }
+            if (error.code === 'ECONNREFUSED' || error.message?.includes('ECONNREFUSED')) {
+                return { valid: false, error: `Service not running at ${this.baseUrl}` };
+            }
+            return { valid: false, error: error.message };
+        }
+    }
+    get summarizerInfo() {
+        return {
+            name: 'openai-compatible',
+            model: this.modelId
+        };
+    }
+}
+
 class ApiError extends Error {
     constructor(response) {
         super(response.statusText);
@@ -41547,6 +42475,8 @@ function processCaptures(captures, lines, language) {
     let formattedOutput = "";
     // Sort captures by their start position
     captures.sort((a, b) => a.node.startPosition.row - b.node.startPosition.row);
+    // Calculate padding width based on file size (minimum 4 digits)
+    const width = Math.max(4, String(lines.length).length);
     // Track already processed lines to avoid duplicates
     const processedLines = new Set();
     const promoteToLineStartAncestor = (node) => {
@@ -41620,14 +42550,16 @@ function processCaptures(captures, lines, language) {
             if (docstringLineCount >= getMinComponentLines()) {
                 const docstringKey = `${startLine}-${docstringEndLine}`;
                 if (!processedLines.has(docstringKey)) {
-                    formattedOutput += `${startLine + 1}--${docstringEndLine + 1} | ${lines[startLine]}\n`;
+                    const range = `${startLine + 1}--${docstringEndLine + 1}`.padStart(width * 2 + 2, " ");
+                    formattedOutput += `${range} | ${lines[startLine]}\n`;
                     processedLines.add(docstringKey);
                 }
             }
             return;
         }
         // For other component definitions (classes, functions, etc.)
-        formattedOutput += `${displayStartLine + 1}--${endLine + 1} | ${lines[displayStartLine]}\n`;
+        const range = `${displayStartLine + 1}--${endLine + 1}`.padStart(width * 2 + 2, " ");
+        formattedOutput += `${range} | ${lines[displayStartLine]}\n`;
         processedLines.add(lineKey);
     });
     if (formattedOutput.length > 0) {
@@ -42866,9 +43798,193 @@ function generateRelativeFilePath(normalizedAbsolutePath, workspaceRoot) {
  * - Embedding generation
  * - Vector store upserts
  * - Cache updates
- * - Retry logic
+ * - Retry logic with truncation fallback for oversized content
  */
 class BatchProcessor {
+    /**
+     * Determines if an error is recoverable (e.g., context length exceeded)
+     * Only these types of errors will trigger the truncation fallback
+     */
+    _isRecoverableError(error) {
+        const msg = error.message.toLowerCase();
+        return (msg.includes("context length") ||
+            msg.includes("exceeds") ||
+            msg.includes("too long") ||
+            msg.includes("input length") ||
+            msg.includes("invalid input") ||
+            msg.includes("token limit"));
+    }
+    /**
+     * Truncates text by lines to maintain code integrity
+     * Does not add language-specific truncation markers to avoid syntax compatibility issues
+     */
+    _truncateTextByLines(text, maxChars) {
+        if (text.length <= maxChars) {
+            return text;
+        }
+        const lines = text.split('\n');
+        const result = [];
+        let currentLength = 0;
+        for (const line of lines) {
+            const lineWithNewline = line.length + 1;
+            // Stop if adding this line would exceed the limit and we already have content
+            if (currentLength + lineWithNewline > maxChars && result.length > 0) {
+                break;
+            }
+            result.push(line);
+            currentLength += lineWithNewline;
+        }
+        // Preserve at least part of the first line if nothing else was kept
+        if (result.length === 0 && lines.length > 0) {
+            result.push(lines[0].substring(0, maxChars));
+        }
+        return result.join('\n');
+    }
+    /**
+     * Processes a single item with truncation retry logic
+     * Uses the smaller of original text length and initial threshold as starting point
+     * Recursively reduces threshold until success or minimum reached
+     */
+    async _processItemWithTruncation(item, options, result, itemIndex) {
+        const originalText = options.itemToText(item);
+        const filePath = options.itemToFilePath(item);
+        // Use the smaller of original text length and initial threshold
+        let threshold = Math.min(originalText.length, TRUNCATION_INITIAL_THRESHOLD);
+        // If original text is already short, this might be a different error - skip truncation
+        if (originalText.length <= MIN_TRUNCATION_THRESHOLD) {
+            console.warn(`[BatchProcessor] Original text is already short (${originalText.length} chars), ` +
+                `skipping truncation for: ${filePath}`);
+            return false;
+        }
+        for (let attempt = 0; attempt < MAX_TRUNCATION_ATTEMPTS; attempt++) {
+            try {
+                const textToEmbed = this._truncateTextByLines(originalText, threshold);
+                // Skip if truncated text is too short
+                if (textToEmbed.length < MIN_TRUNCATION_THRESHOLD) {
+                    console.warn(`[BatchProcessor] Text too short after truncation ` +
+                        `(${textToEmbed.length} chars < ${MIN_TRUNCATION_THRESHOLD}), skipping: ${filePath}`);
+                    return false;
+                }
+                // Try to generate embedding
+                const { embeddings } = await options.embedder.createEmbeddings([textToEmbed]);
+                // Use correct itemIndex for unique point ID
+                const point = options.itemToPoint(item, embeddings[0], itemIndex);
+                await options.vectorStore.upsertPoints([point]);
+                const wasTruncated = textToEmbed.length < originalText.length;
+                if (wasTruncated) {
+                    console.info(`[BatchProcessor] Successfully indexed truncated content: ` +
+                        `${filePath} (${textToEmbed.length}/${originalText.length} chars, ` +
+                        `${(textToEmbed.length / originalText.length * 100).toFixed(1)}%)`);
+                }
+                // Update cache (store original file hash)
+                const fileHash = options.getFileHash?.(item);
+                if (fileHash) {
+                    options.cacheManager.updateHash(filePath, fileHash);
+                }
+                result.processed++;
+                result.processedFiles.push({
+                    path: filePath,
+                    status: "success",
+                    newHash: fileHash,
+                    truncated: wasTruncated
+                });
+                options.onProgress?.(result.processed, result.processed + result.failed, filePath);
+                options.onItemIndexed?.(1);
+                return true;
+            }
+            catch (error) {
+                const nextThreshold = Math.floor(threshold * TRUNCATION_REDUCTION_FACTOR);
+                // Stop retrying if below minimum threshold
+                if (nextThreshold < MIN_TRUNCATION_THRESHOLD) {
+                    console.warn(`[BatchProcessor] Truncation attempt ${attempt + 1} failed, ` +
+                        `next threshold ${nextThreshold} below minimum ${MIN_TRUNCATION_THRESHOLD}, giving up`);
+                    break;
+                }
+                console.warn(`[BatchProcessor] Truncation attempt ${attempt + 1} failed at ${threshold} chars, ` +
+                    `will try ${nextThreshold} chars. Error: ${error.message}`);
+                threshold = nextThreshold;
+            }
+        }
+        // All attempts failed
+        console.error(`[BatchProcessor] All truncation attempts failed for: ${filePath}`);
+        return false;
+    }
+    /**
+     * Fallback to individual item processing with timeout protection
+     */
+    async _processItemsIndividually(batchItems, options, result, startIndex) {
+        // Boundary check
+        if (!batchItems || batchItems.length === 0) {
+            return;
+        }
+        console.log(`[BatchProcessor] Falling back to individual processing for ${batchItems.length} items`);
+        const startTime = Date.now();
+        let successCount = 0;
+        let failureCount = 0;
+        for (let i = 0; i < batchItems.length; i++) {
+            // Timeout protection
+            if (Date.now() - startTime > INDIVIDUAL_PROCESSING_TIMEOUT_MS) {
+                console.warn(`[BatchProcessor] Individual processing timeout after ${INDIVIDUAL_PROCESSING_TIMEOUT_MS}ms, ` +
+                    `skipping remaining ${batchItems.length - i} items`);
+                // Mark remaining items as failed
+                for (let j = i; j < batchItems.length; j++) {
+                    const filePath = options.itemToFilePath(batchItems[j]);
+                    result.failed++;
+                    result.processedFiles.push({
+                        path: filePath,
+                        status: "error",
+                        error: new Error("Individual processing timeout")
+                    });
+                }
+                break;
+            }
+            const item = batchItems[i];
+            const filePath = options.itemToFilePath(item);
+            try {
+                // First try without truncation
+                const text = options.itemToText(item);
+                const { embeddings } = await options.embedder.createEmbeddings([text]);
+                const point = options.itemToPoint(item, embeddings[0], startIndex + i);
+                await options.vectorStore.upsertPoints([point]);
+                const fileHash = options.getFileHash?.(item);
+                if (fileHash) {
+                    options.cacheManager.updateHash(filePath, fileHash);
+                }
+                result.processed++;
+                successCount++;
+                result.processedFiles.push({
+                    path: filePath,
+                    status: "success",
+                    newHash: fileHash,
+                    truncated: false
+                });
+                options.onProgress?.(result.processed, result.processed + result.failed, filePath);
+                options.onItemIndexed?.(1);
+            }
+            catch (itemError) {
+                // Individual item failed, try truncation
+                console.warn(`[BatchProcessor] Individual item failed, trying truncation: ${filePath}`);
+                // Pass correct itemIndex
+                const success = await this._processItemWithTruncation(item, options, result, startIndex + i);
+                if (success) {
+                    successCount++;
+                }
+                else {
+                    // Truncation also failed, record error
+                    failureCount++;
+                    result.failed++;
+                    result.processedFiles.push({
+                        path: filePath,
+                        status: "error",
+                        error: itemError
+                    });
+                    options.onProgress?.(result.processed, result.processed + result.failed, filePath);
+                }
+            }
+        }
+        console.log(`[BatchProcessor] Individual processing completed: ` +
+            `${successCount} succeeded, ${failureCount} failed`);
+    }
     async processBatch(items, options) {
         // console.log(`[BatchProcessor] Starting batch processing for ${items.length} items`)
         const result = { processed: 0, failed: 0, errors: [], processedFiles: [] };
@@ -42936,6 +44052,9 @@ class BatchProcessor {
             await this.processSingleBatch(batchItems, options, result, i);
         }
     }
+    /**
+     * Process a single batch with fallback to individual processing on recoverable errors
+     */
     async processSingleBatch(batchItems, options, result, startIndex) {
         let attempts = 0;
         let success = false;
@@ -42962,7 +44081,8 @@ class BatchProcessor {
                     result.processedFiles.push({
                         path: filePath,
                         status: "success",
-                        newHash: fileHash
+                        newHash: fileHash,
+                        truncated: false
                     });
                     options.onProgress?.(result.processed, result.processed + result.failed, filePath);
                 }
@@ -42977,12 +44097,26 @@ class BatchProcessor {
                 }
             }
         }
+        // Fallback: batch failed, try individual processing for recoverable errors
         if (!success && lastError) {
+            // Check if this is a recoverable error and truncation fallback is enabled
+            if (this._isRecoverableError(lastError)) {
+                console.warn(`[BatchProcessor] Batch failed with recoverable error: "${lastError.message}". ` +
+                    `Falling back to individual processing...`);
+                try {
+                    await this._processItemsIndividually(batchItems, options, result, startIndex);
+                    return; // Fallback completed successfully, don't throw error
+                }
+                catch (fallbackError) {
+                    // Fallback also failed, log and continue with original error handling
+                    console.error(`[BatchProcessor] Fallback processing also failed:`, fallbackError);
+                }
+            }
+            // Fatal error: mark entire batch as failed (preserve original behavior)
             result.failed += batchItems.length;
             result.errors.push(lastError);
             const errorMessage = `Failed to process batch after ${MAX_BATCH_RETRIES} attempts: ${lastError.message}`;
             const batchError = new Error(errorMessage);
-            result.errors.push(batchError);
             options.onError?.(batchError);
             // Record failed items and still report progress
             for (const item of batchItems) {
@@ -44978,10 +46112,10 @@ class CodeIndexServiceFactory {
             return undefined;
         }
         if (config.provider === 'ollama') {
-            return new OllamaLLMReranker(config.ollamaBaseUrl || 'http://localhost:11434', config.ollamaModelId || 'qwen3-vl:4b-instruct', config.batchSize || 10);
+            return new OllamaLLMReranker(config.ollamaBaseUrl || 'http://localhost:11434', config.ollamaModelId || 'qwen3-vl:4b-instruct', config.batchSize || 10, config.concurrency || 3, config.maxRetries || 3, config.retryDelayMs || 1000);
         }
         if (config.provider === 'openai-compatible') {
-            return new OpenAICompatibleReranker(config.openAiCompatibleBaseUrl || 'http://localhost:8080/v1', config.openAiCompatibleModelId || 'gpt-4', config.openAiCompatibleApiKey || '', config.batchSize || 10);
+            return new OpenAICompatibleReranker(config.openAiCompatibleBaseUrl || 'http://localhost:8080/v1', config.openAiCompatibleModelId || 'gpt-4', config.openAiCompatibleApiKey || '', config.batchSize || 10, config.concurrency || 3, config.maxRetries || 3, config.retryDelayMs || 1000);
         }
         // If provider is undefined or unknown, return undefined
         return undefined;
@@ -45003,6 +46137,37 @@ class CodeIndexServiceFactory {
             };
         }
     }
+    /**
+     * Creates a summarizer instance based on the current configuration.
+     * @returns ISummarizer instance (always returns an instance, configuration is validated when used)
+     */
+    createSummarizer() {
+        const config = this.configManager.summarizerConfig;
+        if (config.provider === 'ollama') {
+            return new OllamaSummarizer(config.ollamaBaseUrl || 'http://localhost:11434', config.ollamaModelId || 'qwen3-vl:4b-instruct', config.language || 'English', config.temperature ?? 0);
+        }
+        if (config.provider === 'openai-compatible') {
+            return new OpenAICompatibleSummarizer(config.openAiCompatibleBaseUrl || 'http://localhost:8080/v1', config.openAiCompatibleModelId || 'gpt-4', config.openAiCompatibleApiKey || '', config.language || 'English', config.temperature ?? 0);
+        }
+        // Fallback to ollama if provider unknown
+        return new OllamaSummarizer('http://localhost:11434', 'qwen3-vl:4b-instruct', 'English');
+    }
+    /**
+     * Validates a summarizer instance
+     * @param summarizer The summarizer instance to validate
+     * @returns Promise resolving to validation result
+     */
+    async validateSummarizer(summarizer) {
+        try {
+            return await summarizer.validateConfiguration();
+        }
+        catch (error) {
+            return {
+                valid: false,
+                error: error instanceof Error ? error.message : 'Summarizer validation failed'
+            };
+        }
+    }
 }
 
 /**
@@ -45339,39 +46504,41 @@ class CodeIndexOrchestrator {
                 if (!result) {
                     throw new Error("Full scan failed, is scanner initialized?");
                 }
-                // Enhanced error detection and reporting
-                if (batchErrors.length > 0) {
-                    const firstError = batchErrors[0];
-                    throw new Error(`Indexing failed: ${firstError.message}`);
+                // Enhanced error detection and reporting - tolerate partial failures
+                // Only throw if we found blocks but indexed NONE of them (complete failure)
+                if (cumulativeBlocksFoundSoFar > 0 && cumulativeBlocksIndexed === 0) {
+                    const firstError = batchErrors.length > 0 ? batchErrors[0] : null;
+                    const errorMsg = firstError
+                        ? `Indexing failed completely: ${firstError.message}`
+                        : t("embeddings:orchestrator.indexingFailedCritical");
+                    throw new Error(errorMsg);
                 }
-                else {
-                    // Check for critical failure scenarios
-                    if (cumulativeBlocksFoundSoFar > 0 && cumulativeBlocksIndexed === 0) {
-                        throw new Error(t("embeddings:orchestrator.indexingFailedCritical"));
+                // Partial failures: log warnings but don't throw
+                // This allows indexing to complete even when some batches fail (e.g., oversized content)
+                if (batchErrors.length > 0) {
+                    const successRate = cumulativeBlocksFoundSoFar > 0
+                        ? (cumulativeBlocksIndexed / cumulativeBlocksFoundSoFar * 100).toFixed(1)
+                        : "0";
+                    this.warn(`[CodeIndexOrchestrator] Indexing completed with partial failures. ` +
+                        `Success rate: ${successRate}% (${cumulativeBlocksIndexed}/${cumulativeBlocksFoundSoFar} blocks). ` +
+                        `Batch errors: ${batchErrors.length}`);
+                    // Log first 3 errors in detail
+                    for (const error of batchErrors.slice(0, 3)) {
+                        this.warn(`[CodeIndexOrchestrator] Batch error: ${error.message}`);
+                    }
+                    if (batchErrors.length > 3) {
+                        this.warn(`[CodeIndexOrchestrator] ... and ${batchErrors.length - 3} more errors`);
                     }
-                }
-                // Check for partial failures - if a significant portion of blocks failed
-                const failureRate = (cumulativeBlocksFoundSoFar - cumulativeBlocksIndexed) / cumulativeBlocksFoundSoFar;
-                if (batchErrors.length > 0 && failureRate > 0.1) {
-                    // More than 10% of blocks failed to index
-                    const firstError = batchErrors[0];
-                    throw new Error(`Indexing partially failed: Only ${cumulativeBlocksIndexed} of ${cumulativeBlocksFoundSoFar} blocks were indexed. ${firstError.message}`);
-                }
-                // CRITICAL: If there were ANY batch errors and NO blocks were successfully indexed,
-                // this is a complete failure regardless of the failure rate calculation
-                if (batchErrors.length > 0 && cumulativeBlocksIndexed === 0) {
-                    const firstError = batchErrors[0];
-                    throw new Error(`Indexing failed completely: ${firstError.message}`);
-                }
-                // Final sanity check: If we found blocks but indexed none and somehow no errors were reported,
-                // this is still a failure
-                if (cumulativeBlocksFoundSoFar > 0 && cumulativeBlocksIndexed === 0) {
-                    throw new Error(t("embeddings:orchestrator.indexingFailedCritical"));
                 }
                 await this._startWatcher();
                 // Mark indexing as complete after successful full scan
                 await this.vectorStore.markIndexingComplete();
-                this.stateManager.setSystemState("Indexed", t("embeddings:orchestrator.fileWatcherStarted"));
+                // Set state message - include error info if there were partial failures
+                const message = batchErrors.length > 0
+                    ? `Indexing completed with ${batchErrors.length} errors. ` +
+                        `${cumulativeBlocksIndexed}/${cumulativeBlocksFoundSoFar} blocks indexed.`
+                    : t("embeddings:orchestrator.fileWatcherStarted");
+                this.stateManager.setSystemState("Indexed", message);
             }
         }
         catch (error) {
@@ -46237,6 +47404,26 @@ class CodeIndexManager {
             workspacePath: this.workspacePath,
         };
     }
+    /**
+     * Get components needed for dry-run mode
+     * Provides controlled access to internal components for preview operations
+     * @returns Object containing all necessary components for dry-run
+     */
+    getDryRunComponents() {
+        if (!this._orchestrator || !this._cacheManager) {
+            throw new Error('Manager not initialized. Call initialize() first.');
+        }
+        // Get vector store from orchestrator
+        const vectorStore = this._orchestrator.getVectorStore();
+        return {
+            scanner: this._orchestrator.scanner,
+            cacheManager: this._cacheManager,
+            vectorStore: vectorStore,
+            workspace: this.dependencies.workspace,
+            fileSystem: this.dependencies.fileSystem,
+            pathUtils: this.dependencies.pathUtils
+        };
+    }
     async reconcileIndex(vectorStore, scanner) {
         const logger = this.dependencies.logger;
         logger?.info("Reconciling index with filesystem...");
@@ -46291,6 +47478,10 @@ class CodeIndexManager {
             return;
         }
         // Create .gitignore instance
+        // First ensure ignore rules are loaded by calling shouldIgnore on a dummy path
+        // Use a dummy file path to trigger loading without causing empty path errors
+        const dummyPath = path__default.join(workspacePath, "dummy.txt");
+        await this.dependencies.workspace.shouldIgnore(dummyPath);
         const ignoreRules = this.dependencies.workspace.getIgnoreRules();
         ignoreInstance.add(ignoreRules);
         // (Re)Create shared service instances
@@ -46719,6 +47910,7 @@ class NodeWorkspace {
         this.ignoreRulesLoaded = false;
         this.rootPath = options.rootPath;
         this.ignoreFiles = options.ignoreFiles || ['.gitignore', '.rooignore', '.codebaseignore'];
+        this.ignoreInstance = ignore$1();
     }
     getRootPath() {
         return this.rootPath;
@@ -46729,30 +47921,48 @@ class NodeWorkspace {
         return path.relative(this.rootPath, fullPath);
     }
     getIgnoreRules() {
+        // Ensure rules are loaded before returning
+        if (!this.ignoreRulesLoaded) {
+            // Note: This is a sync method, but loadIgnoreRules is async
+            // In practice, rules should be loaded by shouldIgnore() before this is called
+            // We'll return the current rules (may be empty if not loaded yet)
+            console.warn('getIgnoreRules() called before loadIgnoreRules() - rules may be empty');
+        }
         return this.ignoreRules;
     }
+    /**
+     * Get ignore patterns formatted for fast-glob
+     * Converts simple directory names to glob patterns with /** suffix
+     */
+    async getGlobIgnorePatterns() {
+        await this.loadIgnoreRules();
+        const allIgnores = [...NodeWorkspace.DEFAULT_IGNORES, ...this.ignoreRules];
+        // Convert to fast-glob format
+        return allIgnores.map(pattern => {
+            // If pattern contains no path separator and no wildcard, treat as directory
+            if (!pattern.includes('/') && !pattern.includes('*')) {
+                return `${pattern}/**`;
+            }
+            // If pattern ends with /, add **
+            if (pattern.endsWith('/')) {
+                return `${pattern}**`;
+            }
+            // Otherwise return as-is (already a glob pattern)
+            return pattern;
+        });
+    }
     async shouldIgnore(filePath) {
         await this.loadIgnoreRules();
         const relativePath = this.getRelativePath(filePath);
-        // Basic ignore patterns
-        const defaultIgnores = [
-            'node_modules',
-            '.git',
-            '.svn',
-            '.hg',
-            'dist',
-            'build',
-            'coverage',
-            '*.log',
-            '.env',
-            '.env.local',
-            '.DS_Store',
-            'Thumbs.db'
-        ];
-        const allIgnores = [...defaultIgnores, ...this.ignoreRules];
-        return allIgnores.some(pattern => {
-            return this.matchPattern(relativePath, pattern);
-        });
+        // Handle empty relative path (when filePath equals rootPath)
+        if (relativePath === '') {
+            return false; // Root directory itself is not ignored
+        }
+        // Use ignore instance for proper gitignore semantics
+        this.ignoreInstance = ignore$1().add(NodeWorkspace.DEFAULT_IGNORES).add(this.ignoreRules);
+        // ignore expects paths to use forward slashes
+        const normalizedPath = relativePath.split(path.sep).join('/');
+        return this.ignoreInstance.ignores(normalizedPath);
     }
     getName() {
         return path.basename(this.rootPath) || 'workspace';
@@ -46802,9 +48012,11 @@ class NodeWorkspace {
         }
         this.ignoreRulesLoaded = true;
     }
+    /**
+     * Simple glob pattern matching for findFiles method
+     * Note: This is NOT used for gitignore semantics (shouldIgnore uses ignore library)
+     */
     matchPattern(filePath, pattern) {
-        // Simple glob pattern matching
-        // Convert glob pattern to regex
         const regexPattern = pattern
             .replace(/\./g, '\\.')
             .replace(/\*/g, '.*')
@@ -46831,6 +48043,21 @@ class NodeWorkspace {
         }
     }
 }
+// Default ignore patterns (common across all projects)
+NodeWorkspace.DEFAULT_IGNORES = [
+    'node_modules',
+    '.git',
+    '.svn',
+    '.hg',
+    'dist',
+    'build',
+    'coverage',
+    '*.log',
+    '.env',
+    '.env.local',
+    '.DS_Store',
+    'Thumbs.db'
+];
 class NodePathUtils {
     join(...paths) {
         return path.join(...paths);
@@ -49900,5 +51127,5 @@ function codebase() {
     return 'codebase';
 }
 
-export { BATCH_PROCESSING_CONCURRENCY, BATCH_SEGMENT_THRESHOLD, CacheManager, CodeIndexConfigManager, CodeIndexManager, CodeIndexOllamaEmbedder, CodeIndexOrchestrator, CodeIndexSearchService, CodeIndexServiceFactory, CodeIndexStateManager, CodeParser, DEFAULT_CONFIG, DEFAULT_MAX_SEARCH_RESULTS, DEFAULT_SEARCH_MIN_SCORE, DirectoryScanner, EMBEDDER_BATCH_SIZES, FileWatcher, GEMINI_MAX_ITEM_TOKENS, INITIAL_RETRY_DELAY_MS, MAX_BATCH_RETRIES, MAX_BATCH_TOKENS, MAX_BLOCK_CHARS, MAX_CHARS_TOLERANCE_FACTOR, MAX_FILE_SIZE_BYTES, MAX_ITEM_TOKENS, MAX_LIST_FILES_LIMIT_CODE_INDEX, MAX_PENDING_BATCHES, MIN_BLOCK_CHARS, MIN_CHUNK_REMAINDER_CHARS, NodeConfigProvider, NodeEventBus, NodeFileSystem, NodeFileWatcher, NodeLogger, NodePathUtils, NodeStorage, NodeWorkspace, OpenAICompatibleEmbedder, OpenAiEmbedder, PARSING_CONCURRENCY, QDRANT_CODE_BLOCK_NAMESPACE, QdrantVectorStore, codeParser, codebase, createNodeDependencies, createSimpleNodeDependencies, executeRipgrep, executeRipgrepForFiles, extensions, fallbackExtensions, generateNormalizedAbsolutePath, generateRelativeFilePath, getBatchSizeForEmbedder, getMinComponentLines, listFiles, parseSourceCodeDefinitionsForFile, parseSourceCodeForDefinitionsTopLevel, scannerExtensions, searchWorkspaceFiles, setMinComponentLines, shouldUseFallbackChunking };
+export { BATCH_PROCESSING_CONCURRENCY, BATCH_SEGMENT_THRESHOLD, CacheManager, CodeIndexConfigManager, CodeIndexManager, CodeIndexOllamaEmbedder, CodeIndexOrchestrator, CodeIndexSearchService, CodeIndexServiceFactory, CodeIndexStateManager, CodeParser, DEFAULT_CONFIG, DEFAULT_MAX_SEARCH_RESULTS, DEFAULT_SEARCH_MIN_SCORE, DirectoryScanner, EMBEDDER_BATCH_SIZES, ENABLE_TRUNCATION_FALLBACK, FileWatcher, GEMINI_MAX_ITEM_TOKENS, INDIVIDUAL_PROCESSING_TIMEOUT_MS, INITIAL_RETRY_DELAY_MS, MAX_BATCH_RETRIES, MAX_BATCH_TOKENS, MAX_BLOCK_CHARS, MAX_CHARS_TOLERANCE_FACTOR, MAX_FILE_SIZE_BYTES, MAX_ITEM_TOKENS, MAX_LIST_FILES_LIMIT_CODE_INDEX, MAX_PENDING_BATCHES, MAX_TRUNCATION_ATTEMPTS, MIN_BLOCK_CHARS, MIN_CHUNK_REMAINDER_CHARS, MIN_TRUNCATION_THRESHOLD, NodeConfigProvider, NodeEventBus, NodeFileSystem, NodeFileWatcher, NodeLogger, NodePathUtils, NodeStorage, NodeWorkspace, OpenAICompatibleEmbedder, OpenAiEmbedder, PARSING_CONCURRENCY, QDRANT_CODE_BLOCK_NAMESPACE, QdrantVectorStore, TRUNCATION_INITIAL_THRESHOLD, TRUNCATION_REDUCTION_FACTOR, codeParser, codebase, createNodeDependencies, createSimpleNodeDependencies, executeRipgrep, executeRipgrepForFiles, extensions, fallbackExtensions, generateNormalizedAbsolutePath, generateRelativeFilePath, getBatchSizeForEmbedder, getMinComponentLines, listFiles, parseSourceCodeDefinitionsForFile, parseSourceCodeForDefinitionsTopLevel, scannerExtensions, searchWorkspaceFiles, setMinComponentLines, shouldUseFallbackChunking };
 //# sourceMappingURL=index.js.map