claude-code-workflow 6.2.7 → 6.3.0

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

@@ -29,10 +29,12 @@ const ParamsSchema = z.object({
     path: z.string().optional(),
     paths: z.array(z.string()).default([]),
     contextLines: z.number().default(0),
-    maxResults: z.number().default(20), // Increased default
+    maxResults: z.number().default(5), // Default 5 with full content
     includeHidden: z.boolean().default(false),
     languages: z.array(z.string()).optional(),
-    limit: z.number().default(20), // Increased default
+    limit: z.number().default(5), // Default 5 with full content
+    extraFilesCount: z.number().default(10), // Additional file-only results
+    maxContentLength: z.number().default(200), // Max content length for truncation (50-2000)
     offset: z.number().default(0), // NEW: Pagination offset (start_index)
     enrich: z.boolean().default(false),
     // Search modifiers for ripgrep mode
@@ -163,6 +165,35 @@ function scoreByTokenMatch(results, tokens) {
 function stripAnsi(str) {
     return str.replace(/\x1b\[[0-9;]*m/g, '');
 }
+/** Default maximum content length to return (avoid excessive output) */
+const DEFAULT_MAX_CONTENT_LENGTH = 200;
+/**
+ * Truncate content to specified length with ellipsis
+ * @param content - The content to truncate
+ * @param maxLength - Maximum length (default: 200)
+ */
+function truncateContent(content, maxLength = DEFAULT_MAX_CONTENT_LENGTH) {
+    if (!content)
+        return '';
+    if (content.length <= maxLength)
+        return content;
+    return content.slice(0, maxLength) + '...';
+}
+/**
+ * Split results into full content results and extra file-only results
+ * Generic function supporting both SemanticMatch and ExactMatch types
+ * @param allResults - All search results (must have 'file' property)
+ * @param fullContentLimit - Number of results with full content (default: 5)
+ * @param extraFilesCount - Number of additional file-only results (default: 10)
+ */
+function splitResultsWithExtraFiles(allResults, fullContentLimit = 5, extraFilesCount = 10) {
+    // First N results with full content
+    const results = allResults.slice(0, fullContentLimit);
+    // Next M results as file paths only (deduplicated)
+    const extraResults = allResults.slice(fullContentLimit, fullContentLimit + extraFilesCount);
+    const extra_files = [...new Set(extraResults.map(r => r.file))];
+    return { results, extra_files };
+}
 /**
  * Check if CodexLens index exists for current directory
  * @param path - Directory path to check
@@ -190,6 +221,17 @@ async function checkIndexStatus(path = '.') {
             const embeddingsData = status.embeddings || {};
             const embeddingsCoverage = embeddingsData.coverage_percent || 0;
             const has_embeddings = embeddingsCoverage >= 50; // Threshold: 50%
+            const totalChunks = embeddingsData.total_chunks || 0;
+            // Extract model info if available
+            const modelInfoData = embeddingsData.model_info;
+            const modelInfo = modelInfoData ? {
+                model_profile: modelInfoData.model_profile,
+                model_name: modelInfoData.model_name,
+                embedding_dim: modelInfoData.embedding_dim,
+                backend: modelInfoData.backend,
+                created_at: modelInfoData.created_at,
+                updated_at: modelInfoData.updated_at,
+            } : undefined;
             let warning;
             if (!indexed) {
                 warning = 'No CodexLens index found. Run smart_search(action="init") to create index for better search results.';
@@ -205,6 +247,9 @@ async function checkIndexStatus(path = '.') {
                 has_embeddings,
                 file_count: status.total_files,
                 embeddings_coverage_percent: embeddingsCoverage,
+                total_chunks: totalChunks,
+                // Ensure model_info is null instead of undefined so it's included in JSON
+                model_info: modelInfo ?? null,
                 warning,
             };
         }
@@ -514,7 +559,7 @@ 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 = 10, 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 } = params;
     if (!query) {
         return {
             success: false,
@@ -523,6 +568,8 @@ async function executeRipgrepMode(params) {
     }
     // Check if ripgrep is available
     const hasRipgrep = checkToolAvailability('rg');
+    // Calculate total to fetch for split (full content + extra files)
+    const totalToFetch = maxResults + extraFilesCount;
     // If ripgrep not available, fall back to CodexLens exact mode
     if (!hasRipgrep) {
         const readyStatus = await ensureCodexLensReady();
@@ -533,7 +580,7 @@ async function executeRipgrepMode(params) {
             };
         }
         // Use CodexLens exact mode as fallback
-        const args = ['search', query, '--limit', maxResults.toString(), '--mode', 'exact', '--json'];
+        const args = ['search', query, '--limit', totalToFetch.toString(), '--mode', 'exact', '--json'];
         const result = await executeCodexLens(args, { cwd: path });
         if (!result.success) {
             return {
@@ -548,23 +595,26 @@ async function executeRipgrepMode(params) {
             };
         }
         // Parse results
-        let results = [];
+        let allResults = [];
         try {
             const parsed = JSON.parse(stripAnsi(result.output || '{}'));
             const data = parsed.result?.results || parsed.results || parsed;
-            results = (Array.isArray(data) ? data : []).map((item) => ({
+            allResults = (Array.isArray(data) ? data : []).map((item) => ({
                 file: item.path || item.file,
                 score: item.score || 0,
-                content: item.excerpt || item.content || '',
+                content: truncateContent(item.content || item.excerpt, maxContentLength),
                 symbol: item.symbol || null,
             }));
         }
         catch {
             // Keep empty results
         }
+        // Split results: first N with full content, rest as file paths only
+        const { results, extra_files } = splitResultsWithExtraFiles(allResults, maxResults, extraFilesCount);
         return {
             success: true,
             results,
+            extra_files: extra_files.length > 0 ? extra_files : undefined,
             metadata: {
                 mode: 'ripgrep',
                 backend: 'codexlens-fallback',
@@ -574,12 +624,12 @@ async function executeRipgrepMode(params) {
             },
         };
     }
-    // Use ripgrep
+    // Use ripgrep - request more results to support split
     const { command, args, tokens } = buildRipgrepCommand({
         query,
         paths: paths.length > 0 ? paths : [path],
         contextLines,
-        maxResults,
+        maxResults: totalToFetch, // Fetch more to support split
         includeHidden,
         regex,
         caseSensitive,
@@ -600,13 +650,13 @@ async function executeRipgrepMode(params) {
             stderr += data.toString();
         });
         child.on('close', (code) => {
-            const results = [];
+            const allResults = [];
             const lines = stdout.split('\n').filter((line) => line.trim());
             // Limit total results to prevent memory overflow (--max-count only limits per-file)
-            const effectiveLimit = maxResults > 0 ? maxResults : 500;
+            const effectiveLimit = totalToFetch > 0 ? totalToFetch : 500;
             for (const line of lines) {
                 // Stop collecting if we've reached the limit
-                if (results.length >= effectiveLimit) {
+                if (allResults.length >= effectiveLimit) {
                     resultLimitReached = true;
                     break;
                 }
@@ -621,7 +671,7 @@ async function executeRipgrepMode(params) {
                                 : 1,
                             content: item.data.lines.text.trim(),
                         };
-                        results.push(match);
+                        allResults.push(match);
                     }
                 }
                 catch {
@@ -633,8 +683,10 @@ async function executeRipgrepMode(params) {
             const isWindowsDeviceError = stderr.includes('os error 1') || stderr.includes('函数不正确');
             // 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(results, tokens) : results;
+            const scoredResults = tokens.length > 1 ? scoreByTokenMatch(allResults, tokens) : allResults;
             if (code === 0 || code === 1 || (isWindowsDeviceError && scoredResults.length > 0)) {
+                // Split results: first N with full content, rest as file paths only
+                const { results, extra_files } = splitResultsWithExtraFiles(scoredResults, maxResults, extraFilesCount);
                 // Build warning message for various conditions
                 const warnings = [];
                 if (resultLimitReached) {
@@ -645,11 +697,12 @@ async function executeRipgrepMode(params) {
                 }
                 resolve({
                     success: true,
-                    results: scoredResults,
+                    results,
+                    extra_files: extra_files.length > 0 ? extra_files : undefined,
                     metadata: {
                         mode: 'ripgrep',
                         backend: 'ripgrep',
-                        count: scoredResults.length,
+                        count: results.length,
                         query,
                         tokens: tokens.length > 1 ? tokens : undefined, // Include tokens in metadata for debugging
                         tokenized: tokens.length > 1,
@@ -657,7 +710,7 @@ async function executeRipgrepMode(params) {
                     },
                 });
             }
-            else if (isWindowsDeviceError && results.length === 0) {
+            else if (isWindowsDeviceError && allResults.length === 0) {
                 // Windows device error but no results - might be the only issue
                 resolve({
                     success: true,
@@ -693,7 +746,7 @@ async function executeRipgrepMode(params) {
  * Requires index
  */
 async function executeCodexLensExactMode(params) {
-    const { query, path = '.', maxResults = 10, enrich = false } = params;
+    const { query, path = '.', maxResults = 5, extraFilesCount = 10, maxContentLength = 200, enrich = false } = params;
     if (!query) {
         return {
             success: false,
@@ -710,7 +763,9 @@ async function executeCodexLensExactMode(params) {
     }
     // Check index status
     const indexStatus = await checkIndexStatus(path);
-    const args = ['search', query, '--limit', maxResults.toString(), '--mode', 'exact', '--json'];
+    // Request more results to support split (full content + extra files)
+    const totalToFetch = maxResults + extraFilesCount;
+    const args = ['search', query, '--limit', totalToFetch.toString(), '--mode', 'exact', '--json'];
     if (enrich) {
         args.push('--enrich');
     }
@@ -729,14 +784,14 @@ async function executeCodexLensExactMode(params) {
         };
     }
     // Parse results
-    let results = [];
+    let allResults = [];
     try {
         const parsed = JSON.parse(stripAnsi(result.output || '{}'));
         const data = parsed.result?.results || parsed.results || parsed;
-        results = (Array.isArray(data) ? data : []).map((item) => ({
+        allResults = (Array.isArray(data) ? data : []).map((item) => ({
             file: item.path || item.file,
             score: item.score || 0,
-            content: item.excerpt || item.content || '',
+            content: truncateContent(item.content || item.excerpt, maxContentLength),
             symbol: item.symbol || null,
         }));
     }
@@ -744,8 +799,8 @@ async function executeCodexLensExactMode(params) {
         // Keep empty results
     }
     // Fallback to fuzzy mode if exact returns no results
-    if (results.length === 0) {
-        const fuzzyArgs = ['search', query, '--limit', maxResults.toString(), '--mode', 'fuzzy', '--json'];
+    if (allResults.length === 0) {
+        const fuzzyArgs = ['search', query, '--limit', totalToFetch.toString(), '--mode', 'fuzzy', '--json'];
         if (enrich) {
             fuzzyArgs.push('--enrich');
         }
@@ -754,20 +809,23 @@ async function executeCodexLensExactMode(params) {
             try {
                 const parsed = JSON.parse(stripAnsi(fuzzyResult.output || '{}'));
                 const data = parsed.result?.results || parsed.results || parsed;
-                results = (Array.isArray(data) ? data : []).map((item) => ({
+                allResults = (Array.isArray(data) ? data : []).map((item) => ({
                     file: item.path || item.file,
                     score: item.score || 0,
-                    content: item.excerpt || item.content || '',
+                    content: truncateContent(item.content || item.excerpt, maxContentLength),
                     symbol: item.symbol || null,
                 }));
             }
             catch {
                 // Keep empty results
             }
-            if (results.length > 0) {
+            if (allResults.length > 0) {
+                // Split results: first N with full content, rest as file paths only
+                const { results, extra_files } = splitResultsWithExtraFiles(allResults, maxResults, extraFilesCount);
                 return {
                     success: true,
                     results,
+                    extra_files: extra_files.length > 0 ? extra_files : undefined,
                     metadata: {
                         mode: 'exact',
                         backend: 'codexlens',
@@ -781,9 +839,12 @@ async function executeCodexLensExactMode(params) {
             }
         }
     }
+    // Split results: first N with full content, rest as file paths only
+    const { results, extra_files } = splitResultsWithExtraFiles(allResults, maxResults, extraFilesCount);
     return {
         success: true,
         results,
+        extra_files: extra_files.length > 0 ? extra_files : undefined,
         metadata: {
             mode: 'exact',
             backend: 'codexlens',
@@ -799,7 +860,7 @@ async function executeCodexLensExactMode(params) {
  * Requires index with embeddings
  */
 async function executeHybridMode(params) {
-    const { query, path = '.', maxResults = 10, enrich = false } = params;
+    const { query, path = '.', maxResults = 5, extraFilesCount = 10, maxContentLength = 200, enrich = false } = params;
     if (!query) {
         return {
             success: false,
@@ -816,7 +877,9 @@ async function executeHybridMode(params) {
     }
     // Check index status
     const indexStatus = await checkIndexStatus(path);
-    const args = ['search', query, '--limit', maxResults.toString(), '--mode', 'hybrid', '--json'];
+    // Request more results to support split (full content + extra files)
+    const totalToFetch = maxResults + extraFilesCount;
+    const args = ['search', query, '--limit', totalToFetch.toString(), '--mode', 'hybrid', '--json'];
     if (enrich) {
         args.push('--enrich');
     }
@@ -835,13 +898,13 @@ async function executeHybridMode(params) {
         };
     }
     // Parse results
-    let results = [];
+    let allResults = [];
     let baselineInfo = null;
     let initialCount = 0;
     try {
         const parsed = JSON.parse(stripAnsi(result.output || '{}'));
         const data = parsed.result?.results || parsed.results || parsed;
-        results = (Array.isArray(data) ? data : []).map((item) => {
+        allResults = (Array.isArray(data) ? data : []).map((item) => {
             const rawScore = item.score || 0;
             // Hybrid mode returns distance scores (lower is better).
             // Convert to similarity scores (higher is better) for consistency.
@@ -850,24 +913,24 @@ async function executeHybridMode(params) {
             return {
                 file: item.path || item.file,
                 score: similarityScore,
-                content: item.excerpt || item.content || '',
+                content: truncateContent(item.content || item.excerpt, maxContentLength),
                 symbol: item.symbol || null,
             };
         });
-        initialCount = results.length;
+        initialCount = allResults.length;
         // Post-processing pipeline to improve semantic search quality
         // 0. Filter dominant baseline scores (hot spot detection)
-        const baselineResult = filterDominantBaselineScores(results);
-        results = baselineResult.filteredResults;
+        const baselineResult = filterDominantBaselineScores(allResults);
+        allResults = baselineResult.filteredResults;
         baselineInfo = baselineResult.baselineInfo;
         // 1. Filter noisy files (coverage, node_modules, etc.)
-        results = filterNoisyFiles(results);
+        allResults = filterNoisyFiles(allResults);
         // 2. Boost results containing query keywords
-        results = applyKeywordBoosting(results, query);
+        allResults = applyKeywordBoosting(allResults, query);
         // 3. Enforce score diversity (penalize identical scores)
-        results = enforceScoreDiversity(results);
+        allResults = enforceScoreDiversity(allResults);
         // 4. Re-sort by adjusted scores
-        results.sort((a, b) => b.score - a.score);
+        allResults.sort((a, b) => b.score - a.score);
     }
     catch {
         return {
@@ -883,14 +946,17 @@ async function executeHybridMode(params) {
             },
         };
     }
+    // Split results: first N with full content, rest as file paths only
+    const { results, extra_files } = splitResultsWithExtraFiles(allResults, maxResults, extraFilesCount);
     // Build metadata with baseline info if detected
     let note = 'Hybrid mode uses RRF fusion (exact + fuzzy + vector) for best results';
     if (baselineInfo) {
-        note += ` | Filtered ${initialCount - results.length} hot-spot results with baseline score ~${baselineInfo.score.toFixed(4)}`;
+        note += ` | Filtered ${initialCount - allResults.length} hot-spot results with baseline score ~${baselineInfo.score.toFixed(4)}`;
     }
     return {
         success: true,
         results,
+        extra_files: extra_files.length > 0 ? extra_files : undefined,
         metadata: {
             mode: 'hybrid',
             backend: 'codexlens',
@@ -1258,7 +1324,7 @@ export const schema = {
             mode: {
                 type: 'string',
                 enum: SEARCH_MODES,
-                description: 'Search mode: auto (default), hybrid (best quality), exact (CodexLens FTS), ripgrep (fast, no index), priority (fallback: hybrid->exact->ripgrep)',
+                description: 'Search mode: auto, hybrid (best quality), exact (CodexLens FTS), ripgrep (fast, no index), priority (fallback chain)',
                 default: 'auto',
             },
             output_mode: {
@@ -1294,6 +1360,16 @@ export const schema = {
                 description: 'Alias for maxResults (default: 20)',
                 default: 20,
             },
+            extraFilesCount: {
+                type: 'number',
+                description: 'Number of additional file-only results (paths without content)',
+                default: 10,
+            },
+            maxContentLength: {
+                type: 'number',
+                description: 'Maximum content length for truncation (50-2000)',
+                default: 200,
+            },
             offset: {
                 type: 'number',
                 description: 'Pagination offset - skip first N results (default: 0)',