claude-code-workflow 6.3.18 → 6.3.19

package/ccw/dist/tools/smart-search.js

@@ -2,21 +2,25 @@
  * Smart Search Tool - Unified intelligent search with CodexLens integration
  *
  * Features:
- * - Intent classification with automatic mode selection
- * - CodexLens integration (init, hybrid, vector, semantic)
+ * - Fuzzy mode: FTS + ripgrep fusion with RRF ranking (default)
+ * - Semantic mode: Dense coarse retrieval + cross-encoder reranking
+ * - CodexLens integration (init, dense_rerank, fts)
  * - Ripgrep fallback for exact mode
  * - Index status checking and warnings
  * - Multi-backend search routing with RRF ranking
  *
  * Actions:
  * - init: Initialize CodexLens index
- * - search: Intelligent search with auto mode selection
+ * - search: Intelligent search with fuzzy (default) or semantic mode
  * - status: Check index status
+ * - update: Incremental index update for changed files
+ * - watch: Start file watcher for automatic updates
  */
 import { z } from 'zod';
 import { spawn, execSync } from 'child_process';
 import { ensureReady as ensureCodexLensReady, executeCodexLens, } from './codex-lens.js';
 import { getProjectRoot } from '../utils/path-validator.js';
+import { EXEC_TIMEOUTS } from '../utils/exec-constants.js';
 // Timing utilities for performance analysis
 const TIMING_ENABLED = process.env.SMART_SEARCH_TIMING === '1' || process.env.DEBUG?.includes('timing');
 function createTimer() {
@@ -45,12 +49,13 @@ function createTimer() {
 }
 // Define Zod schema for validation
 const ParamsSchema = z.object({
-    // Action: search (content), find_files (path/name pattern), init, status
+    // Action: search (content), find_files (path/name pattern), init, init_force, status, update (incremental), watch
     // Note: search_files is deprecated, use search with output_mode='files_only'
-    action: z.enum(['init', 'search', 'search_files', 'find_files', 'status']).default('search'),
+    // init: incremental index (skip existing), init_force: force full rebuild (delete and recreate)
+    action: z.enum(['init', 'init_force', 'search', 'search_files', 'find_files', 'status', 'update', 'watch']).default('search'),
     query: z.string().optional().describe('Content search query (for action="search")'),
     pattern: z.string().optional().describe('Glob pattern for path matching (for action="find_files")'),
-    mode: z.enum(['auto', 'hybrid', 'exact', 'ripgrep', 'priority']).default('auto'),
+    mode: z.enum(['fuzzy', 'semantic']).default('fuzzy'),
     output_mode: z.enum(['full', 'files_only', 'count']).default('full'),
     path: z.string().optional(),
     paths: z.array(z.string()).default([]),
@@ -67,13 +72,16 @@ const ParamsSchema = z.object({
     regex: z.boolean().default(true), // Use regex pattern matching (default: enabled)
     caseSensitive: z.boolean().default(true), // Case sensitivity (default: case-sensitive)
     tokenize: z.boolean().default(true), // Tokenize multi-word queries for OR matching (default: enabled)
-    // File type filtering
+    // File type filtering (default: code only)
     excludeExtensions: z.array(z.string()).optional().describe('File extensions to exclude from results (e.g., ["md", "txt"])'),
-    codeOnly: z.boolean().default(false).describe('Only return code files (excludes md, txt, json, yaml, xml, etc.)'),
+    codeOnly: z.boolean().default(true).describe('Only return code files (excludes md, txt, json, yaml, xml, etc.). Default: true'),
+    withDoc: z.boolean().default(false).describe('Include documentation files (md, txt, rst, etc.). Overrides codeOnly when true'),
+    // Watcher options
+    debounce: z.number().default(1000).describe('Debounce interval in ms for watch action'),
     // Fuzzy matching is implicit in hybrid mode (RRF fusion)
 });
 // Search mode constants
-const SEARCH_MODES = ['auto', 'hybrid', 'exact', 'ripgrep', 'priority'];
+const SEARCH_MODES = ['fuzzy', 'semantic'];
 // Classification confidence threshold
 const CONFIDENCE_THRESHOLD = 0.7;
 // File filtering configuration (ported from code-index)
@@ -230,18 +238,45 @@ function splitResultsWithExtraFiles(allResults, fullContentLimit = 5, extraFiles
  */
 async function checkIndexStatus(path = '.') {
     try {
-        const result = await executeCodexLens(['status', '--json'], { cwd: path });
-        if (!result.success) {
+        // Fetch both status and config in parallel
+        const [statusResult, configResult] = await Promise.all([
+            executeCodexLens(['status', '--json'], { cwd: path }),
+            executeCodexLens(['config', 'show', '--json'], { cwd: path }),
+        ]);
+        // Parse config
+        let config = null;
+        if (configResult.success && configResult.output) {
+            try {
+                const cleanConfigOutput = stripAnsi(configResult.output);
+                const parsedConfig = JSON.parse(cleanConfigOutput);
+                const configData = parsedConfig.result || parsedConfig;
+                config = {
+                    config_file: configData.config_file,
+                    index_dir: configData.index_dir,
+                    embedding_backend: configData.embedding_backend,
+                    embedding_model: configData.embedding_model,
+                    reranker_enabled: configData.reranker_enabled,
+                    reranker_backend: configData.reranker_backend,
+                    reranker_model: configData.reranker_model,
+                    reranker_top_k: configData.reranker_top_k,
+                };
+            }
+            catch {
+                // Config parse failed, continue without it
+            }
+        }
+        if (!statusResult.success) {
             return {
                 indexed: false,
                 has_embeddings: false,
+                config,
                 warning: 'No CodexLens index found. Run smart_search(action="init") to create index for better search results.',
             };
         }
         // Parse status output
         try {
             // Strip ANSI color codes from JSON output
-            const cleanOutput = stripAnsi(result.output || '{}');
+            const cleanOutput = stripAnsi(statusResult.output || '{}');
             const parsed = JSON.parse(cleanOutput);
             // Handle both direct and nested response formats (status returns {success, result: {...}})
             const status = parsed.result || parsed;
@@ -279,6 +314,7 @@ async function checkIndexStatus(path = '.') {
                 total_chunks: totalChunks,
                 // Ensure model_info is null instead of undefined so it's included in JSON
                 model_info: modelInfo ?? null,
+                config,
                 warning,
             };
         }
@@ -286,6 +322,7 @@ async function checkIndexStatus(path = '.') {
             return {
                 indexed: false,
                 has_embeddings: false,
+                config,
                 warning: 'Failed to parse index status',
             };
         }
@@ -397,7 +434,7 @@ function checkToolAvailability(toolName) {
     try {
         const isWindows = process.platform === 'win32';
         const command = isWindows ? 'where' : 'which';
-        execSync(`${command} ${toolName}`, { stdio: 'ignore' });
+        execSync(`${command} ${toolName}`, { stdio: 'ignore', timeout: EXEC_TIMEOUTS.SYSTEM_INFO });
         return true;
     }
     catch {
@@ -465,8 +502,10 @@ function buildRipgrepCommand(params) {
 /**
  * Action: init - Initialize CodexLens index (FTS only, no embeddings)
  * For semantic/vector search, use ccw view dashboard or codexlens CLI directly
+ * @param params - Search parameters
+ * @param force - If true, force full rebuild (delete existing index first)
  */
-async function executeInitAction(params) {
+async function executeInitAction(params, force = false) {
     const { path = '.', languages } = params;
     // Check CodexLens availability
     const readyStatus = await ensureCodexLensReady();
@@ -477,9 +516,13 @@ async function executeInitAction(params) {
         };
     }
     // Build args with --no-embeddings for FTS-only index (faster)
-    const args = ['init', path, '--no-embeddings'];
+    // Use 'index init' subcommand (new CLI structure)
+    const args = ['index', 'init', path, '--no-embeddings'];
+    if (force) {
+        args.push('--force'); // Force full rebuild
+    }
     if (languages && languages.length > 0) {
-        args.push('--languages', languages.join(','));
+        args.push('--language', languages.join(','));
     }
     // Track progress updates
     const progressUpdates = [];
@@ -494,7 +537,7 @@ async function executeInitAction(params) {
     });
     // Build metadata with progress info
     const metadata = {
-        action: 'init',
+        action: force ? 'init_force' : 'init',
         path,
     };
     if (lastProgress !== null) {
@@ -510,8 +553,9 @@ async function executeInitAction(params) {
     if (progressUpdates.length > 0) {
         metadata.progressHistory = progressUpdates.slice(-5); // Keep last 5 progress updates
     }
+    const actionLabel = force ? 'rebuilt (force)' : 'created';
     const successMessage = result.success
-        ? `FTS index created for ${path}. Note: For semantic/vector search, create vector index via "ccw view" dashboard or run "codexlens init ${path}" (without --no-embeddings).`
+        ? `FTS index ${actionLabel} for ${path}. Note: For semantic/vector search, create vector index via "ccw view" dashboard or run "codexlens init ${path}" (without --no-embeddings).`
         : undefined;
     return {
         success: result.success,
@@ -526,10 +570,228 @@ async function executeInitAction(params) {
 async function executeStatusAction(params) {
     const { path = '.' } = params;
     const indexStatus = await checkIndexStatus(path);
+    // Build detailed status message
+    const statusParts = [];
+    // Index status
+    statusParts.push(`Index: ${indexStatus.indexed ? 'indexed' : 'not indexed'}`);
+    if (indexStatus.file_count) {
+        statusParts.push(`Files: ${indexStatus.file_count}`);
+    }
+    // Embeddings status
+    if (indexStatus.embeddings_coverage_percent !== undefined) {
+        statusParts.push(`Embeddings: ${indexStatus.embeddings_coverage_percent.toFixed(1)}%`);
+    }
+    if (indexStatus.total_chunks) {
+        statusParts.push(`Chunks: ${indexStatus.total_chunks}`);
+    }
+    // Config summary
+    if (indexStatus.config) {
+        const cfg = indexStatus.config;
+        // Embedding backend info
+        const embeddingType = cfg.embedding_backend === 'litellm' ? 'API' : 'Local';
+        statusParts.push(`Embedding: ${embeddingType} (${cfg.embedding_model || 'default'})`);
+        // Reranker info
+        if (cfg.reranker_enabled) {
+            const rerankerType = cfg.reranker_backend === 'onnx' ? 'Local' : 'API';
+            statusParts.push(`Reranker: ${rerankerType} (${cfg.reranker_model || 'default'})`);
+        }
+        else {
+            statusParts.push('Reranker: disabled');
+        }
+    }
     return {
         success: true,
         status: indexStatus,
-        message: indexStatus.warning || `Index status: ${indexStatus.indexed ? 'indexed' : 'not indexed'}, embeddings: ${indexStatus.has_embeddings ? 'available' : 'not available'}`,
+        message: indexStatus.warning || statusParts.join(' | '),
+    };
+}
+/**
+ * Action: update - Incremental index update
+ * Updates index for changed files without full rebuild
+ */
+async function executeUpdateAction(params) {
+    const { path = '.', languages } = params;
+    // Check CodexLens availability
+    const readyStatus = await ensureCodexLensReady();
+    if (!readyStatus.ready) {
+        return {
+            success: false,
+            error: `CodexLens not available: ${readyStatus.error}`,
+        };
+    }
+    // Check if index exists first
+    const indexStatus = await checkIndexStatus(path);
+    if (!indexStatus.indexed) {
+        return {
+            success: false,
+            error: `Directory not indexed. Run smart_search(action="init") first.`,
+        };
+    }
+    // Build args for incremental init (without --force)
+    // Use 'index init' subcommand (new CLI structure)
+    const args = ['index', 'init', path];
+    if (languages && languages.length > 0) {
+        args.push('--language', languages.join(','));
+    }
+    // Track progress updates
+    const progressUpdates = [];
+    let lastProgress = null;
+    const result = await executeCodexLens(args, {
+        cwd: path,
+        timeout: 600000, // 10 minutes for incremental updates
+        onProgress: (progress) => {
+            progressUpdates.push(progress);
+            lastProgress = progress;
+        },
+    });
+    // Build metadata with progress info
+    const metadata = {
+        action: 'update',
+        path,
+    };
+    if (lastProgress !== null) {
+        const p = lastProgress;
+        metadata.progress = {
+            stage: p.stage,
+            message: p.message,
+            percent: p.percent,
+            filesProcessed: p.filesProcessed,
+            totalFiles: p.totalFiles,
+        };
+    }
+    if (progressUpdates.length > 0) {
+        metadata.progressHistory = progressUpdates.slice(-5);
+    }
+    return {
+        success: result.success,
+        error: result.error,
+        message: result.success
+            ? `Incremental update completed for ${path}`
+            : undefined,
+        metadata,
+    };
+}
+/**
+ * Action: watch - Start file watcher for automatic incremental updates
+ * Note: This starts a background process, returns immediately with status
+ */
+async function executeWatchAction(params) {
+    const { path = '.', languages, debounce = 1000 } = params;
+    // Check CodexLens availability
+    const readyStatus = await ensureCodexLensReady();
+    if (!readyStatus.ready) {
+        return {
+            success: false,
+            error: `CodexLens not available: ${readyStatus.error}`,
+        };
+    }
+    // Check if index exists first
+    const indexStatus = await checkIndexStatus(path);
+    if (!indexStatus.indexed) {
+        return {
+            success: false,
+            error: `Directory not indexed. Run smart_search(action="init") first.`,
+        };
+    }
+    // Build args for watch command
+    const args = ['watch', path, '--debounce', debounce.toString()];
+    if (languages && languages.length > 0) {
+        args.push('--language', languages.join(','));
+    }
+    // Start watcher in background (non-blocking)
+    // Note: The watcher runs until manually stopped
+    const result = await executeCodexLens(args, {
+        cwd: path,
+        timeout: 5000, // Short timeout for initial startup check
+    });
+    return {
+        success: true,
+        message: `File watcher started for ${path}. Use Ctrl+C or kill the process to stop.`,
+        metadata: {
+            action: 'watch',
+            path,
+            note: 'Watcher runs in background. Changes are indexed automatically with debounce.',
+        },
+    };
+}
+/**
+ * Mode: fuzzy - FTS + ripgrep fusion with RRF ranking
+ * Runs both exact (FTS) and ripgrep searches in parallel, merges and ranks results
+ */
+async function executeFuzzyMode(params) {
+    const { query, path = '.', maxResults = 5, extraFilesCount = 10, codeOnly = true, withDoc = false, excludeExtensions } = params;
+    // withDoc overrides codeOnly
+    const effectiveCodeOnly = withDoc ? false : codeOnly;
+    if (!query) {
+        return {
+            success: false,
+            error: 'Query is required for search',
+        };
+    }
+    const timer = createTimer();
+    // Run both searches in parallel
+    const [ftsResult, ripgrepResult] = await Promise.allSettled([
+        executeCodexLensExactMode(params),
+        executeRipgrepMode(params),
+    ]);
+    timer.mark('parallel_search');
+    // Collect results from both sources
+    const resultsMap = new Map();
+    // Add FTS results if successful
+    if (ftsResult.status === 'fulfilled' && ftsResult.value.success && ftsResult.value.results) {
+        resultsMap.set('exact', ftsResult.value.results);
+    }
+    // Add ripgrep results if successful
+    if (ripgrepResult.status === 'fulfilled' && ripgrepResult.value.success && ripgrepResult.value.results) {
+        resultsMap.set('ripgrep', ripgrepResult.value.results);
+    }
+    // If both failed, return error
+    if (resultsMap.size === 0) {
+        const errors = [];
+        if (ftsResult.status === 'rejected')
+            errors.push(`FTS: ${ftsResult.reason}`);
+        if (ripgrepResult.status === 'rejected')
+            errors.push(`Ripgrep: ${ripgrepResult.reason}`);
+        return {
+            success: false,
+            error: `Both search backends failed: ${errors.join('; ')}`,
+        };
+    }
+    // Apply RRF fusion with fuzzy-optimized weights
+    // Fuzzy mode: balanced between exact and ripgrep
+    const fusionWeights = { exact: 0.5, ripgrep: 0.5 };
+    const totalToFetch = maxResults + extraFilesCount;
+    const fusedResults = applyRRFFusion(resultsMap, fusionWeights, totalToFetch);
+    timer.mark('rrf_fusion');
+    // Apply code-only and extension filtering after fusion
+    const filteredFusedResults = filterNoisyFiles(fusedResults, { codeOnly: effectiveCodeOnly, excludeExtensions });
+    // Normalize results format
+    const normalizedResults = filteredFusedResults.map((item) => ({
+        file: item.file || item.path,
+        line: item.line || 0,
+        column: item.column || 0,
+        content: item.content || '',
+        score: item.fusion_score || 0,
+        matchCount: item.matchCount,
+        matchScore: item.matchScore,
+    }));
+    // Split results: first N with full content, rest as file paths only
+    const { results, extra_files } = splitResultsWithExtraFiles(normalizedResults, maxResults, extraFilesCount);
+    // Log timing
+    timer.log();
+    const timings = timer.getTimings();
+    return {
+        success: true,
+        results,
+        extra_files: extra_files.length > 0 ? extra_files : undefined,
+        metadata: {
+            mode: 'fuzzy',
+            backend: 'fts+ripgrep',
+            count: results.length,
+            query,
+            note: `Fuzzy search using RRF fusion of FTS and ripgrep (weights: exact=${fusionWeights.exact}, ripgrep=${fusionWeights.ripgrep})`,
+            timing: TIMING_ENABLED ? timings : undefined,
+        },
     };
 }
 /**
@@ -588,7 +850,9 @@ async function executeAutoMode(params) {
  * Supports tokenized multi-word queries with OR matching and result ranking
  */
 async function executeRipgrepMode(params) {
-    const { query, paths = [], contextLines = 0, maxResults = 5, extraFilesCount = 10, maxContentLength = 200, includeHidden = false, path = '.', regex = true, caseSensitive = true, tokenize = true } = params;
+    const { query, paths = [], contextLines = 0, maxResults = 5, extraFilesCount = 10, maxContentLength = 200, includeHidden = false, path = '.', regex = true, caseSensitive = true, tokenize = true, codeOnly = true, withDoc = false, excludeExtensions } = params;
+    // withDoc overrides codeOnly
+    const effectiveCodeOnly = withDoc ? false : codeOnly;
     if (!query) {
         return {
             success: false,
@@ -608,8 +872,8 @@ async function executeRipgrepMode(params) {
                 error: 'Neither ripgrep nor CodexLens available. Install ripgrep (rg) or CodexLens for search functionality.',
             };
         }
-        // Use CodexLens exact mode as fallback
-        const args = ['search', query, '--limit', totalToFetch.toString(), '--mode', 'exact', '--json'];
+        // Use CodexLens fts mode as fallback
+        const args = ['search', query, '--limit', totalToFetch.toString(), '--method', 'fts', '--json'];
         const result = await executeCodexLens(args, { cwd: path });
         if (!result.success) {
             return {
@@ -713,9 +977,11 @@ async function executeRipgrepMode(params) {
             // Apply token-based scoring and sorting for multi-word queries
             // Results matching more tokens are ranked higher (exact matches first)
             const scoredResults = tokens.length > 1 ? scoreByTokenMatch(allResults, tokens) : allResults;
-            if (code === 0 || code === 1 || (isWindowsDeviceError && scoredResults.length > 0)) {
+            // Apply code-only and extension filtering
+            const filteredResults = filterNoisyFiles(scoredResults, { codeOnly: effectiveCodeOnly, excludeExtensions });
+            if (code === 0 || code === 1 || (isWindowsDeviceError && filteredResults.length > 0)) {
                 // Split results: first N with full content, rest as file paths only
-                const { results, extra_files } = splitResultsWithExtraFiles(scoredResults, maxResults, extraFilesCount);
+                const { results, extra_files } = splitResultsWithExtraFiles(filteredResults, maxResults, extraFilesCount);
                 // Build warning message for various conditions
                 const warnings = [];
                 if (resultLimitReached) {
@@ -775,7 +1041,9 @@ async function executeRipgrepMode(params) {
  * Requires index
  */
 async function executeCodexLensExactMode(params) {
-    const { query, path = '.', maxResults = 5, extraFilesCount = 10, maxContentLength = 200, enrich = false } = params;
+    const { query, path = '.', maxResults = 5, extraFilesCount = 10, maxContentLength = 200, enrich = false, excludeExtensions, codeOnly = true, withDoc = false, offset = 0 } = params;
+    // withDoc overrides codeOnly
+    const effectiveCodeOnly = withDoc ? false : codeOnly;
     if (!query) {
         return {
             success: false,
@@ -794,10 +1062,18 @@ async function executeCodexLensExactMode(params) {
     const indexStatus = await checkIndexStatus(path);
     // Request more results to support split (full content + extra files)
     const totalToFetch = maxResults + extraFilesCount;
-    const args = ['search', query, '--limit', totalToFetch.toString(), '--mode', 'exact', '--json'];
+    const args = ['search', query, '--limit', totalToFetch.toString(), '--offset', offset.toString(), '--method', 'fts', '--json'];
     if (enrich) {
         args.push('--enrich');
     }
+    // Add code_only filter if requested (default: true)
+    if (effectiveCodeOnly) {
+        args.push('--code-only');
+    }
+    // Add exclude_extensions filter if provided
+    if (excludeExtensions && excludeExtensions.length > 0) {
+        args.push('--exclude-extensions', excludeExtensions.join(','));
+    }
     const result = await executeCodexLens(args, { cwd: path });
     if (!result.success) {
         return {
@@ -829,10 +1105,18 @@ async function executeCodexLensExactMode(params) {
     }
     // Fallback to fuzzy mode if exact returns no results
     if (allResults.length === 0) {
-        const fuzzyArgs = ['search', query, '--limit', totalToFetch.toString(), '--mode', 'fuzzy', '--json'];
+        const fuzzyArgs = ['search', query, '--limit', totalToFetch.toString(), '--offset', offset.toString(), '--method', 'fts', '--use-fuzzy', '--json'];
         if (enrich) {
             fuzzyArgs.push('--enrich');
         }
+        // Add code_only filter if requested (default: true)
+        if (effectiveCodeOnly) {
+            fuzzyArgs.push('--code-only');
+        }
+        // Add exclude_extensions filter if provided
+        if (excludeExtensions && excludeExtensions.length > 0) {
+            fuzzyArgs.push('--exclude-extensions', excludeExtensions.join(','));
+        }
         const fuzzyResult = await executeCodexLens(fuzzyArgs, { cwd: path });
         if (fuzzyResult.success) {
             try {
@@ -884,13 +1168,15 @@ async function executeCodexLensExactMode(params) {
     };
 }
 /**
- * Mode: hybrid - Best quality search with RRF fusion
- * Uses CodexLens hybrid mode (exact + fuzzy + vector)
+ * Mode: hybrid - Best quality semantic search
+ * Uses CodexLens dense_rerank method (dense coarse + cross-encoder rerank)
  * Requires index with embeddings
  */
 async function executeHybridMode(params) {
     const timer = createTimer();
-    const { query, path = '.', maxResults = 5, extraFilesCount = 10, maxContentLength = 200, enrich = false, excludeExtensions, codeOnly = false } = params;
+    const { query, path = '.', maxResults = 5, extraFilesCount = 10, maxContentLength = 200, enrich = false, excludeExtensions, codeOnly = true, withDoc = false, offset = 0 } = params;
+    // withDoc overrides codeOnly
+    const effectiveCodeOnly = withDoc ? false : codeOnly;
     if (!query) {
         return {
             success: false,
@@ -911,10 +1197,18 @@ async function executeHybridMode(params) {
     timer.mark('index_status_check');
     // Request more results to support split (full content + extra files)
     const totalToFetch = maxResults + extraFilesCount;
-    const args = ['search', query, '--limit', totalToFetch.toString(), '--mode', 'hybrid', '--json'];
+    const args = ['search', query, '--limit', totalToFetch.toString(), '--offset', offset.toString(), '--method', 'dense_rerank', '--json'];
     if (enrich) {
         args.push('--enrich');
     }
+    // Add code_only filter if requested (default: true)
+    if (effectiveCodeOnly) {
+        args.push('--code-only');
+    }
+    // Add exclude_extensions filter if provided
+    if (excludeExtensions && excludeExtensions.length > 0) {
+        args.push('--exclude-extensions', excludeExtensions.join(','));
+    }
     const result = await executeCodexLens(args, { cwd: path });
     timer.mark('codexlens_search');
     if (!result.success) {
@@ -958,8 +1252,9 @@ async function executeHybridMode(params) {
         const baselineResult = filterDominantBaselineScores(allResults);
         allResults = baselineResult.filteredResults;
         baselineInfo = baselineResult.baselineInfo;
-        // 1. Filter noisy files (coverage, node_modules, etc.) and excluded extensions
-        allResults = filterNoisyFiles(allResults, { excludeExtensions, codeOnly });
+        // 1. Filter noisy directories (node_modules, etc.)
+        // NOTE: Extension filtering is now done engine-side via --code-only and --exclude-extensions
+        allResults = filterNoisyFiles(allResults, {});
         // 2. Boost results containing query keywords
         allResults = applyKeywordBoosting(allResults, query);
         // 3. Enforce score diversity (penalize identical scores)
@@ -986,7 +1281,7 @@ async function executeHybridMode(params) {
     const { results, extra_files } = splitResultsWithExtraFiles(allResults, maxResults, extraFilesCount);
     timer.mark('split_results');
     // Build metadata with baseline info if detected
-    let note = 'Hybrid mode uses RRF fusion (exact + fuzzy + vector) for best results';
+    let note = 'Using dense_rerank (dense coarse + cross-encoder rerank) for semantic search';
     if (baselineInfo) {
         note += ` | Filtered ${initialCount - allResults.length} hot-spot results with baseline score ~${baselineInfo.score.toFixed(4)}`;
     }
@@ -1087,12 +1382,13 @@ function filterNoisyFiles(results, options = {}) {
         NON_CODE_EXTENSIONS.forEach(ext => excludedExtSet.add(ext));
     }
     return results.filter(r => {
-        const filePath = r.file || '';
+        // Support both 'file' and 'path' field names (different backends use different names)
+        const filePath = r.file || r.path || '';
         if (!filePath)
             return true;
         const segments = filePath.split(/[/\\]/);
         // Accurate directory check: segment must exactly match excluded directory
-        if (segments.some(segment => FILTER_CONFIG.exclude_directories.has(segment))) {
+        if (segments.some((segment) => FILTER_CONFIG.exclude_directories.has(segment))) {
             return false;
         }
         // Accurate file check: pattern matches filename only (not full path)
@@ -1378,14 +1674,16 @@ export const schema = {
 **Actions:**
 - search: Search file content (default)
 - find_files: Find files by path/name pattern (glob matching)
-- init: Create FTS index
+- init: Create FTS index (incremental - skips existing)
+- init_force: Force full rebuild (delete and recreate index)
 - status: Check index status
+- update: Incremental index update (for changed files)
+- watch: Start file watcher for automatic updates
 
 **Content Search (action="search"):**
-  smart_search(query="authentication logic")        # auto mode - routes to best backend
-  smart_search(query="MyClass", mode="exact")       # exact mode - precise FTS matching
-  smart_search(query="auth", mode="ripgrep")        # ripgrep mode - fast literal search
-  smart_search(query="how to auth", mode="hybrid")  # hybrid mode - semantic + fuzzy search
+  smart_search(query="authentication logic")        # fuzzy mode (default) - FTS + ripgrep fusion
+  smart_search(query="MyClass", mode="fuzzy")       # fuzzy mode - fast hybrid search
+  smart_search(query="how to auth", mode="semantic")  # semantic mode - dense + reranker
 
 **File Discovery (action="find_files"):**
   smart_search(action="find_files", pattern="*.ts")           # find all TypeScript files
@@ -1393,28 +1691,23 @@ export const schema = {
   smart_search(action="find_files", pattern="test_*.py")      # find test files
   smart_search(action="find_files", pattern="*.tsx", offset=20, limit=10)  # pagination
 
+**Index Maintenance:**
+  smart_search(action="update", path="/project")              # incremental index update
+  smart_search(action="watch", path="/project")               # start file watcher
+  smart_search(action="watch", debounce=2000)                 # custom debounce interval
+
 **Pagination:** All actions support offset/limit for paginated results:
   smart_search(query="auth", limit=10, offset=0)    # first page
   smart_search(query="auth", limit=10, offset=10)   # second page
 
-**Multi-Word Search (ripgrep mode with tokenization):**
-  smart_search(query="CCW_PROJECT_ROOT CCW_ALLOWED_DIRS", mode="ripgrep")  # tokenized OR matching
-  smart_search(query="auth login user", mode="ripgrep")   # matches any token, ranks by match count
-  smart_search(query="exact phrase", mode="ripgrep", tokenize=false)  # disable tokenization
-
-**Regex Search (ripgrep mode):**
-  smart_search(query="class.*Builder")              # auto-detects regex pattern
-  smart_search(query="def.*\\(.*\\):")              # find function definitions
-  smart_search(query="import.*from", caseSensitive=false)  # case-insensitive
-
-**Modes:** auto (intelligent routing), hybrid (semantic+fuzzy), exact (FTS), ripgrep (fast with tokenization), priority (fallback chain)`,
+**Modes:** fuzzy (FTS + ripgrep fusion, default), semantic (dense + reranker)`,
     inputSchema: {
         type: 'object',
         properties: {
             action: {
                 type: 'string',
-                enum: ['init', 'search', 'find_files', 'status', 'search_files'],
-                description: 'Action: search (content search), find_files (path pattern matching), init (create index), status (check index). Note: search_files is deprecated.',
+                enum: ['init', 'init_force', 'search', 'find_files', 'status', 'update', 'watch', 'search_files'],
+                description: 'Action: search (content search), find_files (path pattern matching), init (create index, incremental), init_force (force full rebuild), status (check index), update (incremental update), watch (auto-update). Note: search_files is deprecated.',
                 default: 'search',
             },
             query: {
@@ -1428,8 +1721,8 @@ export const schema = {
             mode: {
                 type: 'string',
                 enum: SEARCH_MODES,
-                description: 'Search mode: auto, hybrid (best quality), exact (CodexLens FTS), ripgrep (fast, no index), priority (fallback chain)',
-                default: 'auto',
+                description: 'Search mode: fuzzy (FTS + ripgrep fusion, default), semantic (dense + reranker for natural language queries)',
+                default: 'fuzzy',
             },
             output_mode: {
                 type: 'string',
@@ -1800,7 +2093,10 @@ export async function handler(params) {
         // Handle actions
         switch (action) {
             case 'init':
-                result = await executeInitAction(parsed.data);
+                result = await executeInitAction(parsed.data, false);
+                break;
+            case 'init_force':
+                result = await executeInitAction(parsed.data, true);
                 break;
             case 'status':
                 result = await executeStatusAction(parsed.data);
@@ -1809,6 +2105,14 @@ export async function handler(params) {
                 // NEW: File path/name pattern matching (glob-based)
                 result = await executeFindFilesAction(parsed.data);
                 break;
+            case 'update':
+                // Incremental index update
+                result = await executeUpdateAction(parsed.data);
+                break;
+            case 'watch':
+                // Start file watcher (returns status, watcher runs in background)
+                result = await executeWatchAction(parsed.data);
+                break;
             case 'search_files':
                 // DEPRECATED: Redirect to search with files_only output
                 deprecationWarning = 'action="search_files" is deprecated. Use action="search" with output_mode="files_only" for content-to-files search, or action="find_files" for path pattern matching.';
@@ -1816,25 +2120,16 @@ export async function handler(params) {
             // Fall through to search
             case 'search':
             default:
-                // Handle search modes: auto | hybrid | exact | ripgrep | priority
+                // Handle search modes: fuzzy | semantic
                 switch (mode) {
-                    case 'auto':
-                        result = await executeAutoMode(parsed.data);
+                    case 'fuzzy':
+                        result = await executeFuzzyMode(parsed.data);
                         break;
-                    case 'hybrid':
+                    case 'semantic':
                         result = await executeHybridMode(parsed.data);
                         break;
-                    case 'exact':
-                        result = await executeCodexLensExactMode(parsed.data);
-                        break;
-                    case 'ripgrep':
-                        result = await executeRipgrepMode(parsed.data);
-                        break;
-                    case 'priority':
-                        result = await executePriorityFallbackMode(parsed.data);
-                        break;
                     default:
-                        throw new Error(`Unsupported mode: ${mode}. Use: auto, hybrid, exact, ripgrep, or priority`);
+                        throw new Error(`Unsupported mode: ${mode}. Use: fuzzy or semantic`);
                 }
                 break;
         }
@@ -1872,10 +2167,13 @@ export async function handler(params) {
 /**
  * Execute init action with external progress callback
  * Used by MCP server for streaming progress
+ * @param params - Search parameters (path, languages, force)
+ * @param onProgress - Optional callback for progress updates
  */
 export async function executeInitWithProgress(params, onProgress) {
     const path = params.path || '.';
     const languages = params.languages;
+    const force = params.force || false;
     // Check CodexLens availability
     const readyStatus = await ensureCodexLensReady();
     if (!readyStatus.ready) {
@@ -1884,9 +2182,13 @@ export async function executeInitWithProgress(params, onProgress) {
             error: `CodexLens not available: ${readyStatus.error}. CodexLens will be auto-installed on first use.`,
         };
     }
-    const args = ['init', path];
+    // Use 'index init' subcommand (new CLI structure)
+    const args = ['index', 'init', path];
+    if (force) {
+        args.push('--force'); // Force full rebuild
+    }
     if (languages && languages.length > 0) {
-        args.push('--languages', languages.join(','));
+        args.push('--language', languages.join(','));
     }
     // Track progress updates
     const progressUpdates = [];
@@ -1905,7 +2207,7 @@ export async function executeInitWithProgress(params, onProgress) {
     });
     // Build metadata with progress info
     const metadata = {
-        action: 'init',
+        action: force ? 'init_force' : 'init',
         path,
     };
     if (lastProgress !== null) {
@@ -1921,11 +2223,12 @@ export async function executeInitWithProgress(params, onProgress) {
     if (progressUpdates.length > 0) {
         metadata.progressHistory = progressUpdates.slice(-5);
     }
+    const actionLabel = force ? 'rebuilt (force)' : 'created';
     return {
         success: result.success,
         error: result.error,
         message: result.success
-            ? `CodexLens index created successfully for ${path}`
+            ? `CodexLens index ${actionLabel} successfully for ${path}`
             : undefined,
         metadata,
     };