bobs-workshop 0.3.3 → 3.1.0

package/dist/tools/searchTools.js

@@ -1,1107 +0,0 @@
-// src/tools/searchTools.ts
-import { exec, spawn } from "child_process";
-import { promisify } from "util";
-import { z } from "zod";
-import fs from "fs-extra";
-import path from "path";
-import { fileURLToPath } from "url";
-import { searchCache } from "./searchCache.js";
-import { SemgrepPatternGenerator } from "./semgrep-patterns.js";
-import { StructuralSearchOrchestrator } from "./structural/index.js";
-const execAsync = promisify(exec);
-// ES module __dirname equivalent
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-// Tool-specific exit code semantics
-const EXIT_CODE_SEMANTICS = {
-    'rg': { 0: 'success', 1: 'no_matches', 2: 'error' },
-    'semgrep': {
-        0: 'no_findings',
-        1: 'error',
-        2: 'findings',
-        7: 'config_not_available' // Config rulesets not found (non-fatal)
-    }
-};
-// Production-ready spawn execution with timeout handling
-function spawnAsync(command, args, options = {}) {
-    return new Promise((resolve, reject) => {
-        const child = spawn(command, args, {
-            ...options,
-            stdio: ['ignore', 'pipe', 'pipe'] // Explicitly set stdio
-        });
-        let stdout = '';
-        let stderr = '';
-        let isResolved = false;
-        // Production timeout handling (default 60 seconds - MCP standard)
-        const timeout = options.timeout || 60000;
-        const timeoutId = setTimeout(() => {
-            if (!isResolved) {
-                isResolved = true;
-                child.kill('SIGTERM'); // Graceful termination
-                setTimeout(() => {
-                    if (!child.killed) {
-                        child.kill('SIGKILL'); // Force kill if still running
-                    }
-                }, 5000);
-                reject(new Error(`Command timed out after ${timeout}ms`));
-            }
-        }, timeout);
-        child.stdout?.on('data', (data) => {
-            stdout += data.toString();
-        });
-        child.stderr?.on('data', (data) => {
-            stderr += data.toString();
-        });
-        child.on('close', (code) => {
-            if (!isResolved) {
-                isResolved = true;
-                clearTimeout(timeoutId);
-                const toolName = options.toolName || 'unknown';
-                const semantics = EXIT_CODE_SEMANTICS[toolName];
-                const meaning = semantics?.[code ?? 0] || 'error';
-                // Treat success, no_matches, no_findings, findings, and config_not_available as successful outcomes
-                if (meaning === 'success' || meaning === 'no_matches' || meaning === 'no_findings' || meaning === 'findings' || meaning === 'config_not_available') {
-                    resolve({ stdout, stderr, exitCode: code ?? 0 });
-                }
-                else {
-                    const error = new Error(`${toolName} failed with code ${code}: ${meaning}`);
-                    error.code = code;
-                    error.exitCode = code;
-                    error.stdout = stdout;
-                    error.stderr = stderr;
-                    reject(error);
-                }
-            }
-        });
-        child.on('error', (err) => {
-            if (!isResolved) {
-                isResolved = true;
-                clearTimeout(timeoutId);
-                reject(err);
-            }
-        });
-    });
-}
-// Cross-platform tool path finder with multiple fallback strategies
-async function findToolPath(toolName) {
-    console.log(`[TOOL PATH] Finding path for: ${toolName}`);
-    // Strategy 1: Try system PATH first (most portable)
-    try {
-        await execAsync(`${toolName} --version`, { timeout: 3000 });
-        console.log(`[TOOL PATH] Found ${toolName} in system PATH`);
-        return toolName;
-    }
-    catch (error) {
-        console.log(`[TOOL PATH] ${toolName} not in system PATH, trying fallbacks`);
-    }
-    // Strategy 2: Try npm packages in current project
-    try {
-        const projectPath = path.resolve(process.cwd(), `node_modules/.bin/${toolName}`);
-        if (await fs.pathExists(projectPath)) {
-            await execAsync(`${projectPath} --version`, { timeout: 3000 });
-            console.log(`[TOOL PATH] Found ${toolName} in project node_modules/.bin`);
-            return projectPath;
-        }
-    }
-    catch (error) {
-        console.log(`[TOOL PATH] ${toolName} not in project node_modules/.bin`);
-    }
-    // Strategy 3: Try npm packages in bobs-workshop directory
-    try {
-        const bobsPath = path.resolve(__dirname, `../../node_modules/.bin/${toolName}`);
-        if (await fs.pathExists(bobsPath)) {
-            await execAsync(`${bobsPath} --version`, { timeout: 3000 });
-            console.log(`[TOOL PATH] Found ${toolName} in bobs-workshop node_modules/.bin`);
-            return bobsPath;
-        }
-    }
-    catch (error) {
-        console.log(`[TOOL PATH] ${toolName} not in bobs-workshop node_modules/.bin`);
-    }
-    // Strategy 4: Tool-specific fallback paths
-    if (toolName === 'rg') {
-        // Try @vscode/ripgrep package
-        const rgPaths = [
-            path.resolve(process.cwd(), 'node_modules/@vscode/ripgrep/bin/rg'),
-            path.resolve(__dirname, '../../node_modules/@vscode/ripgrep/bin/rg'),
-            // Claude Code location as last resort
-            `/Users/${process.env.USER}/.claude/local/node_modules/@anthropic-ai/claude-code/vendor/ripgrep/arm64-darwin/rg`
-        ];
-        for (const rgPath of rgPaths) {
-            try {
-                if (await fs.pathExists(rgPath)) {
-                    await execAsync(`${rgPath} --version`, { timeout: 3000 });
-                    console.log(`[TOOL PATH] Found ripgrep at: ${rgPath}`);
-                    return rgPath;
-                }
-            }
-            catch (error) {
-                console.log(`[TOOL PATH] ripgrep not found at: ${rgPath}`);
-            }
-        }
-    }
-    // Strategy 5: Final fallback with warning
-    console.log(`[TOOL PATH] Warning: ${toolName} not found, using system fallback`);
-    return toolName;
-}
-export const FileSearchInput = z.object({
-    query: z.string(),
-    max_results: z.number().optional().default(50),
-    path_filters: z.array(z.string()).optional()
-});
-export const FileSearchOutput = z.object({
-    results: z.array(z.object({
-        file: z.string(),
-        line: z.number(),
-        snippet: z.string(),
-        score: z.number()
-    }))
-});
-export const SymbolSearchInput = z.object({
-    symbol: z.string()
-});
-export const SymbolSearchOutput = z.object({
-    definitions: z.array(z.object({
-        file: z.string(),
-        line: z.number()
-    }))
-});
-export const ReferencesSearchInput = z.object({
-    symbol: z.string()
-});
-export const ReferencesSearchOutput = z.object({
-    references: z.array(z.object({
-        file: z.string(),
-        line: z.number()
-    }))
-});
-export const SummarizeInput = z.object({
-    file: z.string()
-});
-export const SummarizeOutput = z.object({
-    summary: z.string()
-});
-export const AnalyzeInput = z.object({
-    file: z.string()
-});
-export const AnalyzeOutput = z.object({
-    imports: z.array(z.string()),
-    classes: z.array(z.string()),
-    functions: z.array(z.string())
-});
-// New semgrep-based search input/output schemas
-export const SemgrepSearchInput = z.object({
-    pattern: z.string().describe("Semgrep pattern to search for (e.g., 'function verifyToken($TOKEN)' for structured AST search)"),
-    language: z.enum(["typescript", "javascript", "python", "go", "java", "auto"]).optional().default("auto").describe("Language for pattern matching"),
-    path_filters: z.array(z.string()).optional().describe("File path filters/globs to limit search scope"),
-    max_results: z.number().optional().default(50).describe("Maximum number of results to return")
-});
-export const SemgrepSearchOutput = z.object({
-    results: z.array(z.object({
-        file: z.string(),
-        line: z.number(),
-        snippet: z.string(),
-        rule_id: z.string().optional(),
-        message: z.string().optional()
-    }))
-});
-// Enhanced file search with more options
-export const EnhancedFileSearchInput = z.object({
-    query: z.string().describe("Search query (regex pattern supported)"),
-    search_type: z.enum(["text", "regex", "exact"]).optional().default("text").describe("Type of search to perform"),
-    file_extensions: z.array(z.string()).optional().describe("File extensions to include (e.g., ['.ts', '.js'])"),
-    exclude_patterns: z.array(z.string()).optional().describe("Patterns to exclude from search"),
-    max_results: z.number().optional().default(50),
-    include_context: z.boolean().optional().default(false).describe("Include surrounding lines for context")
-});
-// Hybrid Search schemas - unified entry point for lexical + semantic search
-export const HybridSearchInput = z.object({
-    query: z.string().describe("Search query to find in codebase. Multi-word queries (3+ words) are automatically routed to semantic search in auto mode for better conceptual matching. Structural queries (e.g., 'find references to X', 'show dependencies') use AST-based analysis. For exact phrases, use fewer words or specify mode=lexical."),
-    mode: z.enum(["lexical", "semantic", "structural", "auto"]).optional().default("auto").describe("Search mode: lexical (ripgrep), semantic (semgrep), structural (AST-based), or auto (intelligent routing based on query). Auto mode uses semantic for multi-word conceptual queries, structural for symbol/dependency queries, and falls back to lexical OR search if tools unavailable."),
-    phase: z.enum(["architect", "engineer", "debugger", "reviewer"]).optional().describe("Caller phase for phase-aware Semgrep rule selection"),
-    path: z.string().optional().describe("Root path or subdirectory to search (optional)"),
-    includeHidden: z.boolean().optional().default(false).describe("Include hidden/ignored files (equivalent to rg -uuu)"),
-    followGitIgnore: z.boolean().optional().default(true).describe("Respect .gitignore rules"),
-    fileTypes: z.array(z.string()).optional().describe("File types to include (e.g., ['ts', 'tsx', 'py'])"),
-    maxHits: z.number().optional().default(30).describe("Maximum total results to return (default: 30 for token efficiency)"),
-    perFileLimit: z.number().optional().default(5).describe("Maximum matches per file (default: 5 to prevent single-file domination)"),
-    contextLines: z.number().optional().default(2).describe("Context lines before/after matches"),
-    timeoutMs: z.number().optional().default(4000).describe("Timeout in milliseconds"),
-    verbose: z.boolean().optional().default(false).describe("Include full lexicalHits/semanticHits arrays for debugging (increases token usage)")
-});
-export const HybridSearchOutput = z.object({
-    summary: z.string().describe("Human-readable summary of search results"),
-    results: z.array(z.object({
-        file: z.string(),
-        line: z.number(),
-        text: z.string(),
-        score: z.number(),
-        source: z.enum(['lexical', 'semantic'])
-    })).describe("Top ranked search results (sorted by relevance score)"),
-    truncated: z.boolean().describe("True if results were capped at maxHits"),
-    stats: z.object({
-        elapsedMs: z.number(),
-        rgHits: z.number(),
-        semgrepHits: z.number(),
-        totalResults: z.number()
-    }).describe("Search execution statistics"),
-    errors: z.array(z.string()).optional().describe("Non-fatal errors during search"),
-    _verbose: z.object({
-        lexicalHits: z.array(z.object({
-            file: z.string(),
-            line: z.number(),
-            text: z.string(),
-            before: z.array(z.string()).optional(),
-            after: z.array(z.string()).optional()
-        })),
-        semanticHits: z.array(z.object({
-            file: z.string(),
-            line: z.number(),
-            ruleId: z.string(),
-            message: z.string(),
-            severity: z.string().optional(),
-            confidence: z.number().optional()
-        }))
-    }).optional().describe("Full detailed results (only included when verbose=true)")
-});
-// Helper function to parse ripgrep JSON output into normalized format
-async function parseRipgrepJSON(stdout, contextLines = 2) {
-    const results = [];
-    const lines = stdout.split('\n').filter(Boolean);
-    for (const line of lines) {
-        try {
-            const parsed = JSON.parse(line);
-            if (parsed.type === 'match') {
-                const result = {
-                    file: parsed.data.path.text,
-                    line: parsed.data.line_number,
-                    text: parsed.data.lines.text.trim()
-                };
-                // Add context lines if available
-                if (contextLines > 0 && parsed.data.submatches) {
-                    const before = [];
-                    const after = [];
-                    // ripgrep context would be in separate events, for now just add the match
-                    result.before = before;
-                    result.after = after;
-                }
-                results.push(result);
-            }
-        }
-        catch (e) {
-            // Skip non-JSON lines or malformed JSON
-            continue;
-        }
-    }
-    return results;
-}
-// Helper function to normalize Semgrep results into our format
-function normalizeSemgrepResults(semgrepOutput) {
-    if (!semgrepOutput.results)
-        return [];
-    return semgrepOutput.results.map((result) => ({
-        file: result.path,
-        line: result.start?.line || 0,
-        ruleId: result.check_id || 'semgrep-rule',
-        message: result.extra?.message || result.message || 'Semgrep match',
-        severity: result.extra?.severity || 'info',
-        confidence: result.extra?.metadata?.confidence || 0.8
-    }));
-}
-export async function fileSearchHandler(input) {
-    const validated = FileSearchInput.parse(input);
-    try {
-        const rgPath = await findToolPath('rg');
-        let rgCmd = `${rgPath} --line-number --max-count ${validated.max_results} '${validated.query}'`;
-        if (validated.path_filters && validated.path_filters.length > 0) {
-            const globs = validated.path_filters.map(filter => `--glob '${filter}'`).join(' ');
-            rgCmd += ` ${globs}`;
-        }
-        const { stdout } = await execAsync(rgCmd);
-        const results = stdout.split("\n").filter(Boolean).map(line => {
-            const parts = line.split(":", 3);
-            if (parts.length >= 3) {
-                const [file, lineNo, snippet] = parts;
-                return { file, line: parseInt(lineNo, 10) || 0, snippet: snippet.trim(), score: 1.0 };
-            }
-            return null;
-        }).filter(Boolean);
-        return { results };
-    }
-    catch (error) {
-        // If ripgrep fails (command not found or no matches), return empty results
-        return { results: [] };
-    }
-}
-export async function symbolSearchHandler(input) {
-    const validated = SymbolSearchInput.parse(input);
-    try {
-        // Use ripgrep to find symbol definitions (functions, classes, etc.)
-        const patterns = [
-            `function\\s+${validated.symbol}`,
-            `class\\s+${validated.symbol}`,
-            `const\\s+${validated.symbol}`,
-            `let\\s+${validated.symbol}`,
-            `var\\s+${validated.symbol}`,
-            `export.*${validated.symbol}`,
-            `interface\\s+${validated.symbol}`,
-            `type\\s+${validated.symbol}`
-        ];
-        const definitions = [];
-        for (const pattern of patterns) {
-            try {
-                const rgPath = await findToolPath('rg');
-                const { stdout } = await execAsync(`${rgPath} --line-number '${pattern}'`);
-                const matches = stdout.split("\n").filter(Boolean).map(line => {
-                    const parts = line.split(":", 2);
-                    if (parts.length >= 2) {
-                        return { file: parts[0], line: parseInt(parts[1], 10) || 0 };
-                    }
-                    return null;
-                }).filter(Boolean);
-                definitions.push(...matches);
-            }
-            catch (error) {
-                // Continue with next pattern if this one fails
-            }
-        }
-        return { definitions };
-    }
-    catch (error) {
-        return { definitions: [] };
-    }
-}
-export async function referencesSearchHandler(input) {
-    const validated = ReferencesSearchInput.parse(input);
-    try {
-        const rgPath = await findToolPath('rg');
-        const { stdout } = await execAsync(`${rgPath} --line-number '\\b${validated.symbol}\\b'`);
-        const references = stdout.split("\n").filter(Boolean).map(line => {
-            const parts = line.split(":", 2);
-            if (parts.length >= 2) {
-                return { file: parts[0], line: parseInt(parts[1], 10) || 0 };
-            }
-            return null;
-        }).filter(Boolean);
-        return { references };
-    }
-    catch (error) {
-        return { references: [] };
-    }
-}
-export async function summarizeHandler(input) {
-    const validated = SummarizeInput.parse(input);
-    try {
-        if (!await fs.pathExists(validated.file)) {
-            throw new Error(`File ${validated.file} not found`);
-        }
-        const content = await fs.readFile(validated.file, 'utf8');
-        const lines = content.split('\n');
-        const totalLines = lines.length;
-        // Basic analysis
-        const imports = lines.filter(line => line.trim().startsWith('import') || line.trim().startsWith('from')).length;
-        const functions = lines.filter(line => line.includes('function ') || line.includes('def ') || line.includes('=>')).length;
-        const classes = lines.filter(line => line.includes('class ')).length;
-        const comments = lines.filter(line => line.trim().startsWith('//') || line.trim().startsWith('#')).length;
-        const summary = `File: ${validated.file}
-Lines: ${totalLines}
-Imports: ${imports}
-Functions: ${functions}
-Classes: ${classes}
-Comments: ${comments}
-Estimated complexity: ${functions + classes > 10 ? 'high' : functions + classes > 5 ? 'medium' : 'low'}`;
-        return { summary };
-    }
-    catch (error) {
-        throw new Error(`Failed to summarize file: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}
-export async function analyzeHandler(input) {
-    const validated = AnalyzeInput.parse(input);
-    try {
-        if (!await fs.pathExists(validated.file)) {
-            throw new Error(`File ${validated.file} not found`);
-        }
-        const content = await fs.readFile(validated.file, 'utf8');
-        const lines = content.split('\n');
-        // Extract imports
-        const imports = lines
-            .filter(line => line.trim().startsWith('import') || line.trim().startsWith('from'))
-            .map(line => line.trim());
-        // Extract function names
-        const functions = [];
-        const functionRegex = /(?:function\s+(\w+)|(\w+)\s*(?:=\s*(?:async\s+)?(?:\([^)]*\)\s*=>|\([^)]*\)\s*\{)|:\s*(?:async\s+)?(?:\([^)]*\)\s*=>|\([^)]*\)\s*\{))|def\s+(\w+))/g;
-        for (const line of lines) {
-            let match;
-            while ((match = functionRegex.exec(line)) !== null) {
-                const funcName = match[1] || match[2] || match[3];
-                if (funcName && !functions.includes(funcName)) {
-                    functions.push(funcName);
-                }
-            }
-        }
-        // Extract class names
-        const classes = [];
-        const classRegex = /class\s+(\w+)/g;
-        for (const line of lines) {
-            let match;
-            while ((match = classRegex.exec(line)) !== null) {
-                if (!classes.includes(match[1])) {
-                    classes.push(match[1]);
-                }
-            }
-        }
-        return { imports, classes, functions };
-    }
-    catch (error) {
-        throw new Error(`Failed to analyze file: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}
-// New semgrep-based search handler with debug logging
-export async function semgrepSearchHandler(input) {
-    const validated = SemgrepSearchInput.parse(input);
-    console.log('[SEMGREP DEBUG] Semgrep search started with input:', JSON.stringify(validated, null, 2));
-    try {
-        const semgrepPath = await findToolPath('semgrep');
-        console.log('[SEMGREP DEBUG] Found semgrep path:', semgrepPath);
-        // Build semgrep command
-        let semgrepCmd = `${semgrepPath} --json --no-git-ignore`;
-        // Add language specification
-        if (validated.language !== "auto") {
-            semgrepCmd += ` --lang ${validated.language}`;
-        }
-        // Add pattern
-        semgrepCmd += ` --pattern '${validated.pattern}'`;
-        // Add path filters
-        if (validated.path_filters && validated.path_filters.length > 0) {
-            const includes = validated.path_filters.map(filter => `--include '${filter}'`).join(' ');
-            semgrepCmd += ` ${includes}`;
-        }
-        console.log('[SEMGREP DEBUG] Executing command:', semgrepCmd);
-        console.log('[SEMGREP DEBUG] Working directory:', process.cwd());
-        // Execute semgrep
-        const { stdout, stderr } = await execAsync(semgrepCmd);
-        console.log('[SEMGREP DEBUG] Command executed, stdout length:', stdout.length);
-        if (stderr)
-            console.log('[SEMGREP DEBUG] stderr:', stderr);
-        const semgrepOutput = JSON.parse(stdout || '{"results": []}');
-        console.log('[SEMGREP DEBUG] Parsed semgrep output, results count:', semgrepOutput.results?.length || 0);
-        // Convert semgrep results to our format
-        const results = (semgrepOutput.results || [])
-            .slice(0, validated.max_results)
-            .map((result) => ({
-            file: result.path,
-            line: result.start?.line || 0,
-            snippet: result.extra?.lines || '',
-            rule_id: result.check_id,
-            message: result.extra?.message || ''
-        }));
-        console.log('[SEMGREP DEBUG] Returning results:', results.length);
-        return { results };
-    }
-    catch (error) {
-        console.warn('[SEMGREP WARN] Semgrep failed, falling back to ripgrep:', error);
-        try {
-            const rgPath = await findToolPath('rg');
-            console.log('[SEMGREP FALLBACK] Using ripgrep at:', rgPath);
-            const { stdout } = await execAsync(`${rgPath} --line-number --max-count ${validated.max_results} '${validated.pattern}'`);
-            const results = stdout.split("\n").filter(Boolean).map(line => {
-                const parts = line.split(":", 3);
-                if (parts.length >= 3) {
-                    const [file, lineNo, snippet] = parts;
-                    return {
-                        file,
-                        line: parseInt(lineNo, 10) || 0,
-                        snippet: snippet.trim(),
-                        rule_id: "ripgrep-fallback",
-                        message: "Fallback search using ripgrep"
-                    };
-                }
-                return null;
-            }).filter(Boolean);
-            console.log('[SEMGREP FALLBACK] Fallback results:', results.length);
-            return { results };
-        }
-        catch (fallbackError) {
-            console.error('[SEMGREP ERROR] Both semgrep and fallback failed:', fallbackError);
-            throw new Error(`Semgrep search failed: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-}
-// Enhanced file search with better options and debug logging
-export async function enhancedFileSearchHandler(input) {
-    const validated = EnhancedFileSearchInput.parse(input);
-    console.log('[SEARCH DEBUG] Enhanced search started with input:', JSON.stringify(validated, null, 2));
-    try {
-        const rgPath = await findToolPath('rg');
-        console.log('[SEARCH DEBUG] Found rg path:', rgPath);
-        // Use spawn approach (based on successful MCP patterns)
-        const args = ['--line-number', '--no-heading'];
-        // Add search type options
-        if (validated.search_type === "exact") {
-            args.push('--fixed-strings');
-        }
-        else if (validated.search_type === "regex") {
-            args.push('--regexp');
-        }
-        // Add context if requested
-        if (validated.include_context) {
-            args.push('--context', '2');
-        }
-        // Add file extension filters
-        if (validated.file_extensions && validated.file_extensions.length > 0) {
-            validated.file_extensions.forEach(ext => {
-                const cleanExt = ext.startsWith('.') ? ext : '.' + ext;
-                args.push('--glob', `*${cleanExt}`);
-            });
-        }
-        // Add exclusion patterns
-        if (validated.exclude_patterns && validated.exclude_patterns.length > 0) {
-            validated.exclude_patterns.forEach(pattern => {
-                args.push('--glob', `!${pattern}`);
-            });
-        }
-        // Add max results and query
-        args.push('--max-count', validated.max_results.toString());
-        args.push(validated.query);
-        console.log('[SEARCH DEBUG] Executing command:', rgPath, 'with args:', args);
-        console.log('[SEARCH DEBUG] Working directory:', process.cwd());
-        let stdout, stderr;
-        try {
-            const result = await spawnAsync(rgPath, args, {
-                cwd: process.cwd(),
-                timeout: 60000 // 60 second timeout (MCP TypeScript client standard)
-            });
-            stdout = result.stdout;
-            stderr = result.stderr;
-            console.log('[SEARCH DEBUG] Command executed successfully, stdout length:', stdout.length);
-            if (stderr)
-                console.log('[SEARCH DEBUG] stderr:', stderr);
-        }
-        catch (spawnError) {
-            console.error('[SEARCH ERROR] Spawn failed:', spawnError);
-            throw new Error(`Search execution failed: ${spawnError.message}`);
-        }
-        const results = stdout.split("\n").filter(Boolean).map(line => {
-            const parts = line.split(":", 3);
-            if (parts.length >= 3) {
-                const [file, lineNo, snippet] = parts;
-                return {
-                    file,
-                    line: parseInt(lineNo, 10) || 0,
-                    snippet: snippet.trim(),
-                    score: 1.0
-                };
-            }
-            return null;
-        }).filter(Boolean);
-        console.log('[SEARCH DEBUG] Found results:', results.length);
-        return { results };
-    }
-    catch (error) {
-        console.error('[SEARCH ERROR] Enhanced search failed:', error);
-        throw new Error(`Search failed: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}
-// Phase-aware Semgrep rule selection based on caller context
-function getPhaseAwareSemgrepRules(mode, phase) {
-    const phaseRules = {
-        'architect': [
-            '--config', 'p/security-audit',
-            '--config', 'p/performance'
-        ],
-        'engineer': [
-        // Use basic pattern-based search for engineer
-        ],
-        'debugger': [
-            '--config', 'p/security-audit',
-            '--config', 'p/correctness'
-        ],
-        'reviewer': [
-            '--config', 'p/security-audit',
-            '--config', 'p/performance',
-            '--config', 'p/correctness'
-        ]
-    };
-    return phaseRules[phase || 'engineer'] || [];
-}
-// Enhanced Hybrid Search Handler - unified entry point for lexical + semantic search
-export async function hybridSearchHandler(input) {
-    const validated = HybridSearchInput.parse(input);
-    // Check cache first
-    const cached = searchCache.get(validated);
-    if (cached) {
-        return { ...cached, _cached: true };
-    }
-    const startTime = Date.now();
-    const errors = [];
-    console.log('[HYBRID DEBUG] Hybrid search started with input:', JSON.stringify(validated, null, 2));
-    // Phase 0: Structural Search Detection (NEW)
-    const normalized = validated.query.toLowerCase();
-    const isStructuralQuery = (normalized.match(/find references (to|for|of)\s+\w+/) ||
-        normalized.match(/show (all )?usages? (of|for)\s+\w+/) ||
-        normalized.match(/go to definition (of|for)\s+\w+/) ||
-        normalized.match(/where is \w+ defined/) ||
-        normalized.match(/show dependencies (for|of)\s+/) ||
-        normalized.match(/what does .+ import/) ||
-        normalized.match(/dependencies (of|for)\s+/) ||
-        normalized.match(/find (circular|architectural|unused) (dependencies|issues|exports)/) ||
-        normalized.match(/check architecture/) ||
-        normalized.match(/analyze (architecture|structure)/) ||
-        normalized.match(/what calls \w+/) ||
-        normalized.match(/call graph/));
-    if (validated.mode === 'structural' || (validated.mode === 'auto' && isStructuralQuery)) {
-        try {
-            console.log('[HYBRID DEBUG] Routing to structural search');
-            const orchestrator = new StructuralSearchOrchestrator();
-            const structuralResults = await orchestrator.search(validated.query, {
-                scope: validated.path || process.cwd(),
-                maxResults: validated.maxHits,
-                phase: validated.phase,
-                includeDefinition: true
-            });
-            // Format structural results to match HybridSearchOutput schema
-            const results = structuralResults.map(result => ({
-                file: result.file,
-                line: result.line,
-                text: result.context || `${result.symbol} (${result.kind})`,
-                match: result.symbol,
-                relevance: result.relevance || 1.0,
-                source: 'structural'
-            }));
-            const output = {
-                summary: `Found ${structuralResults.length} structural match${structuralResults.length !== 1 ? 'es' : ''} using AST analysis`,
-                results,
-                totalHits: structuralResults.length,
-                rgHits: 0,
-                semgrepHits: 0,
-                structuralHits: structuralResults.length,
-                durationMs: Date.now() - startTime,
-                interpretation: `Structural search: AST-based symbol analysis for "${validated.query}"`
-            };
-            searchCache.set(validated, output);
-            return output;
-        }
-        catch (error) {
-            console.error('[HYBRID DEBUG] Structural search failed:', error);
-            errors.push(`⚠️  Structural search failed: ${error instanceof Error ? error.message : String(error)}`);
-            // Fall through to lexical/semantic search
-        }
-    }
-    // Smart query analysis for auto mode
-    const queryWords = validated.query.trim().split(/\s+/).filter(w => w.length > 0);
-    const isMultiWordQuery = queryWords.length >= 3;
-    const isSemanticPhase = ['architect', 'debugger', 'reviewer'].includes(validated.phase || '');
-    // Auto mode routing: prefer semantic for multi-word conceptual queries
-    let effectiveMode = validated.mode;
-    if (validated.mode === 'auto' && isMultiWordQuery && isSemanticPhase) {
-        effectiveMode = 'semantic';
-        console.log('[HYBRID DEBUG] Auto mode: routing multi-word query to semantic search');
-    }
-    let lexicalHits = [];
-    let semanticHits = [];
-    let rgHits = 0;
-    let semgrepHits = 0;
-    let semgrepFailed = false;
-    // Phase 1: Run ripgrep for lexical search (ALWAYS run in auto mode, unless explicit semantic-only)
-    if (validated.mode !== "semantic") {
-        try {
-            console.log('[HYBRID DEBUG] Running lexical search with ripgrep');
-            const rgPath = await findToolPath('rg');
-            // Build ripgrep command with JSON output
-            const args = ['--json', '--line-number'];
-            // Handle gitignore and hidden files
-            if (!validated.followGitIgnore) {
-                args.push('--no-ignore');
-            }
-            if (validated.includeHidden) {
-                args.push('--hidden', '--no-ignore');
-            }
-            // Add context lines
-            if (validated.contextLines && validated.contextLines > 0) {
-                args.push('--context', validated.contextLines.toString());
-            }
-            // Add file type filters
-            if (validated.fileTypes && validated.fileTypes.length > 0) {
-                validated.fileTypes.forEach(type => {
-                    args.push('--type', type);
-                });
-            }
-            // Add per-file limit to prevent single-file domination
-            args.push('--max-count', validated.perFileLimit.toString());
-            // Smart Multi-Word Cascade for lexical search
-            let interpretedPattern = validated.query;
-            let interpretationNote = "";
-            let triedMethodCall = false;
-            if (queryWords.length >= 2 && effectiveMode === "lexical") {
-                // Priority 1: Method/Property Call (2 words, both identifiers)
-                if (queryWords.length === 2 &&
-                    queryWords[0].match(/^[a-zA-Z_$][a-zA-Z0-9_$]*$/) &&
-                    queryWords[1].match(/^[a-zA-Z_$][a-zA-Z0-9_$]*$/)) {
-                    interpretedPattern = `${queryWords[0]}\\.(${queryWords[1]})`;
-                    interpretationNote = `Auto-interpreted: Method/property call: ${queryWords[0]}.${queryWords[1]}()`;
-                    triedMethodCall = true;
-                    console.log('[HYBRID DEBUG] Smart cascade: Priority 1 (method call):', interpretedPattern);
-                }
-                // Priority 2: Ordered Proximity (3+ words or not a method call pattern)
-                else {
-                    interpretedPattern = queryWords.join('.*');
-                    interpretationNote = `Auto-interpreted: Ordered proximity: ${queryWords.join(' → ')}`;
-                    console.log('[HYBRID DEBUG] Smart cascade: Priority 2 (ordered proximity):', interpretedPattern);
-                }
-                if (interpretationNote) {
-                    errors.push(`ℹ️  ${interpretationNote}`);
-                }
-            }
-            // Add query and path
-            args.push(interpretedPattern);
-            if (validated.path) {
-                args.push(validated.path);
-            }
-            console.log('[HYBRID DEBUG] Ripgrep command:', rgPath, args.join(' '));
-            const { stdout, stderr, exitCode } = await spawnAsync(rgPath, args, {
-                cwd: process.cwd(),
-                timeout: validated.timeoutMs,
-                toolName: 'rg'
-            });
-            if (stderr) {
-                console.warn('[HYBRID WARN] Ripgrep stderr:', stderr);
-                errors.push(`ripgrep warning: ${stderr}`);
-            }
-            // exitCode 0 = success with results, exitCode 1 = no matches (both are successful outcomes)
-            if (exitCode === 0 || exitCode === 1) {
-                lexicalHits = await parseRipgrepJSON(stdout, validated.contextLines);
-                rgHits = lexicalHits.length;
-                console.log('[HYBRID DEBUG] Ripgrep found', rgHits, 'results');
-                // Priority 1→2 Fallback: If method call returned 0, try ordered proximity
-                if (rgHits === 0 && triedMethodCall && queryWords.length >= 2 && effectiveMode === "lexical") {
-                    console.log('[HYBRID DEBUG] Priority 1 (method call) returned 0 results, falling back to Priority 2 (ordered proximity)');
-                    const proximityPattern = queryWords.join('.*');
-                    const proximityArgs = args.slice(0, -1 - (validated.path ? 1 : 0));
-                    proximityArgs.push(proximityPattern);
-                    if (validated.path) {
-                        proximityArgs.push(validated.path);
-                    }
-                    console.log('[HYBRID DEBUG] Retrying with ordered proximity:', proximityPattern);
-                    const { stdout: proxStdout, exitCode: proxExitCode } = await spawnAsync(rgPath, proximityArgs, {
-                        cwd: process.cwd(),
-                        timeout: validated.timeoutMs,
-                        toolName: 'rg'
-                    });
-                    if (proxExitCode === 0 || proxExitCode === 1) {
-                        lexicalHits = await parseRipgrepJSON(proxStdout, validated.contextLines);
-                        rgHits = lexicalHits.length;
-                        if (rgHits > 0) {
-                            const lastNoteIndex = errors.findIndex(e => e.startsWith('ℹ️  Auto-interpreted:'));
-                            if (lastNoteIndex !== -1) {
-                                errors[lastNoteIndex] = `ℹ️  Auto-interpreted: Method call (0 results) → Ordered proximity: ${queryWords.join(' → ')} (${rgHits} results)`;
-                            }
-                            console.log('[HYBRID DEBUG] Ordered proximity found', rgHits, 'results');
-                        }
-                    }
-                }
-                // Priority 2→3 Fallback: If ordered proximity returned 0, try OR
-                if (rgHits === 0 && queryWords.length >= 2 &&
-                    (interpretedPattern.includes('.*') || triedMethodCall) && effectiveMode === "lexical") {
-                    console.log('[HYBRID DEBUG] Priority 2 returned 0 results, trying Priority 3 (OR fallback)');
-                    // Rebuild args with OR pattern
-                    const orPattern = `\\b(${queryWords.join('|')})\\b`;
-                    const orArgs = args.slice(0, -1 - (validated.path ? 1 : 0)); // Remove pattern and path if exists
-                    orArgs.push(orPattern);
-                    if (validated.path) {
-                        orArgs.push(validated.path);
-                    }
-                    console.log('[HYBRID DEBUG] Retrying with OR pattern:', orPattern);
-                    const { stdout: orStdout, exitCode: orExitCode } = await spawnAsync(rgPath, orArgs, {
-                        cwd: process.cwd(),
-                        timeout: validated.timeoutMs,
-                        toolName: 'rg'
-                    });
-                    if (orExitCode === 0 || orExitCode === 1) {
-                        lexicalHits = await parseRipgrepJSON(orStdout, validated.contextLines);
-                        rgHits = lexicalHits.length;
-                        if (rgHits > 0) {
-                            // Update interpretation note
-                            const lastNoteIndex = errors.findIndex(e => e.startsWith('ℹ️  Auto-interpreted:'));
-                            if (lastNoteIndex !== -1) {
-                                errors[lastNoteIndex] = `ℹ️  Auto-interpreted: Ordered proximity (0 results) → Broadened to OR search: ${queryWords.join(' | ')}`;
-                            }
-                            console.log('[HYBRID DEBUG] OR fallback found', rgHits, 'results');
-                        }
-                    }
-                }
-            }
-        }
-        catch (error) {
-            console.warn('[HYBRID WARN] Ripgrep failed:', error);
-            const errorMsg = error instanceof Error ? error.message : String(error);
-            const stderr = error?.stderr;
-            errors.push(`ripgrep failed: ${errorMsg}${stderr ? ` - ${stderr.trim()}` : ''}`);
-        }
-    }
-    // Phase 2: Run Semgrep for semantic search (ALWAYS run in auto mode, unless explicit lexical-only)
-    if (validated.mode !== "lexical") {
-        try {
-            console.log('[HYBRID DEBUG] Running semantic search with multi-pattern semgrep');
-            // NEW: Use multi-pattern generator instead of broken single pattern
-            const patternGenerator = new SemgrepPatternGenerator();
-            const projectPath = validated.path || process.cwd();
-            const language = patternGenerator.detectLanguageFromProject(projectPath);
-            console.log('[HYBRID DEBUG] Detected language:', language);
-            // Generate 7 core patterns for the query
-            const patterns = patternGenerator.generateCorePatterns(validated.query, language);
-            console.log('[HYBRID DEBUG] Generated', patterns.length, 'patterns');
-            // Run all patterns in parallel
-            const semgrepResults = await patternGenerator.runPatterns(patterns, projectPath, validated.timeoutMs);
-            // Normalize results
-            semanticHits = semgrepResults.map(result => ({
-                file: result.file,
-                line: result.line,
-                ruleId: result.ruleId,
-                message: result.message,
-                severity: 'info',
-                confidence: 0.8
-            }));
-            semgrepHits = semanticHits.length;
-            console.log('[HYBRID DEBUG] Multi-pattern semgrep found', semgrepHits, 'total results');
-        }
-        catch (error) {
-            console.warn('[HYBRID WARN] Semgrep failed:', error);
-            errors.push(`semgrep failed: ${error instanceof Error ? error.message : String(error)}`);
-            semgrepFailed = true;
-        }
-    }
-    // Phase 2.5: Fallback - if semantic search failed and we have a multi-word query, try lexical OR search
-    console.log('[HYBRID DEBUG] Fallback check:', { semgrepFailed, isMultiWordQuery, effectiveMode, lexicalHitsLength: lexicalHits.length });
-    if (semgrepFailed && isMultiWordQuery && effectiveMode === 'semantic' && lexicalHits.length === 0) {
-        try {
-            console.log('[HYBRID DEBUG] Semgrep unavailable, falling back to lexical OR search for multi-word query');
-            const rgPath = await findToolPath('rg');
-            // Build OR search with multiple -e flags
-            const args = ['--json', '--line-number'];
-            if (!validated.followGitIgnore) {
-                args.push('--no-ignore');
-            }
-            if (validated.includeHidden) {
-                args.push('--hidden', '--no-ignore');
-            }
-            if (validated.contextLines && validated.contextLines > 0) {
-                args.push('--context', validated.contextLines.toString());
-            }
-            if (validated.fileTypes && validated.fileTypes.length > 0) {
-                validated.fileTypes.forEach(type => {
-                    args.push('--type', type);
-                });
-            }
-            args.push('--max-count', validated.maxHits.toString());
-            // Add each word as a separate pattern for OR search
-            queryWords.forEach(word => {
-                args.push('-e', word);
-            });
-            if (validated.path) {
-                args.push(validated.path);
-            }
-            console.log('[HYBRID DEBUG] Fallback ripgrep OR command:', rgPath, args.join(' '));
-            const { stdout, stderr, exitCode } = await spawnAsync(rgPath, args, {
-                cwd: process.cwd(),
-                timeout: validated.timeoutMs,
-                toolName: 'rg'
-            });
-            if (stderr) {
-                console.warn('[HYBRID WARN] Fallback ripgrep stderr:', stderr);
-            }
-            if (exitCode === 0 || exitCode === 1) {
-                lexicalHits = await parseRipgrepJSON(stdout, validated.contextLines);
-                rgHits = lexicalHits.length;
-                console.log('[HYBRID DEBUG] Fallback OR search found', rgHits, 'results');
-            }
-        }
-        catch (error) {
-            console.warn('[HYBRID WARN] Fallback lexical OR search failed:', error);
-            const errorMsg = error instanceof Error ? error.message : String(error);
-            const stderr = error?.stderr;
-            errors.push(`fallback search failed: ${errorMsg}${stderr ? ` - ${stderr.trim()}` : ''}`);
-        }
-    }
-    // Phase 3: Score, rank, and limit results
-    const scoringStart = Date.now();
-    const scoredResults = await scoreAndRankResults(lexicalHits, semanticHits);
-    const scoringMs = Date.now() - scoringStart;
-    const totalHits = scoredResults.length;
-    const truncated = totalHits > validated.maxHits;
-    // Slice to maxHits (top ranked results)
-    const topResults = scoredResults.slice(0, validated.maxHits);
-    const elapsedMs = Date.now() - startTime;
-    // Generate structured summary for terminal display
-    const modeBanner = generateModeBanner(validated.mode, validated.phase, validated.query, topResults.length, elapsedMs);
-    // Build result object based on verbose flag
-    const result = {
-        summary: modeBanner,
-        results: topResults,
-        truncated,
-        stats: {
-            elapsedMs,
-            rgHits,
-            semgrepHits,
-            totalResults: topResults.length
-        }
-    };
-    // Add errors if any
-    if (errors.length > 0) {
-        result.errors = errors;
-    }
-    // Include full hits arrays only in verbose mode
-    if (validated.verbose) {
-        result._verbose = {
-            lexicalHits,
-            semanticHits
-        };
-    }
-    console.log('[HYBRID DEBUG] Hybrid search completed in', elapsedMs, 'ms (scoring:', scoringMs, 'ms)');
-    console.log('[HYBRID DEBUG] Final result:', JSON.stringify({
-        totalHits,
-        returnedResults: topResults.length,
-        truncated,
-        topScores: topResults.slice(0, 5).map(r => r.score),
-        errors: errors.length
-    }, null, 2));
-    // Cache the result before returning
-    searchCache.set(validated, result);
-    return result;
-}
-// Helper function to generate mode banner for structured output
-function generateModeBanner(mode, phase, query, totalResults, elapsedMs) {
-    const phaseLabel = phase ? ` | Phase: ${phase}` : '';
-    const modeLabel = mode === 'auto' ? 'hybrid' : mode;
-    const resultsLabel = totalResults === 1 ? 'result' : 'results';
-    const timeLabel = elapsedMs < 1000 ? `${elapsedMs}ms` : `${(elapsedMs / 1000).toFixed(1)}s`;
-    return `🔍 [${modeLabel.charAt(0).toUpperCase() + modeLabel.slice(1)} Search]${phaseLabel} | Query: '${query}' | ${totalResults} ${resultsLabel} (${timeLabel})`;
-}
-// Helper function to generate summary hits for terminal display
-function generateSummaryHits(lexicalHits, semanticHits, maxDisplay = 10) {
-    const summaryHits = [];
-    let displayCount = 0;
-    // Combine and prioritize hits (lexical first, then semantic)
-    const allHits = [
-        ...lexicalHits.map(hit => ({
-            type: 'lexical',
-            file: hit.file,
-            line: hit.line,
-            preview: hit.text?.substring(0, 100) || hit.snippet?.substring(0, 100) || ''
-        })),
-        ...semanticHits.map(hit => ({
-            type: 'semantic',
-            file: hit.file,
-            line: hit.line,
-            preview: hit.message?.substring(0, 100) || hit.ruleId || ''
-        }))
-    ];
-    // Generate concise file:line → preview format
-    for (const hit of allHits) {
-        if (displayCount >= maxDisplay)
-            break;
-        const preview = hit.preview.replace(/\s+/g, ' ').trim();
-        const truncatedPreview = preview.length > 80 ? preview.substring(0, 80) + '...' : preview;
-        const typeIcon = hit.type === 'semantic' ? '🎯' : '📄';
-        summaryHits.push(`${typeIcon} ${hit.file}:${hit.line} → ${truncatedPreview}`);
-        displayCount++;
-    }
-    if (allHits.length > maxDisplay) {
-        summaryHits.push(`... and ${allHits.length - maxDisplay} more results`);
-    }
-    return summaryHits;
-}
-// Cache for git recency checks (session-level)
-const gitRecencyCache = new Map();
-async function calculateRelevanceScore(file, source, matchCount = 1) {
-    let score = 0;
-    // 1. File priority based on path (0-100)
-    if (file.includes('/src/'))
-        score += 100;
-    else if (file.includes('/lib/'))
-        score += 80;
-    else if (file.includes('/test/'))
-        score += 60;
-    else if (file.includes('/docs/'))
-        score += 40;
-    else if (file.includes('node_modules'))
-        score = 0; // Skip node_modules
-    else
-        score += 50; // Default for other files
-    // 2. Semantic boost (+30 for semgrep matches)
-    if (source === 'semantic') {
-        score += 30;
-    }
-    // 3. Git recency boost (cached)
-    if (!gitRecencyCache.has(file)) {
-        try {
-            const { stdout } = await execAsync(`git log --format=%ct --max-count=1 "${file}"`, {
-                cwd: process.cwd(),
-                timeout: 2000
-            });
-            const timestamp = parseInt(stdout.trim(), 10);
-            if (!isNaN(timestamp)) {
-                const ageMs = Date.now() - (timestamp * 1000);
-                const ageDays = ageMs / (1000 * 60 * 60 * 24);
-                let recencyBoost = 0;
-                if (ageDays <= 7)
-                    recencyBoost = 20;
-                else if (ageDays <= 30)
-                    recencyBoost = 10;
-                else if (ageDays <= 365)
-                    recencyBoost = 5;
-                gitRecencyCache.set(file, recencyBoost);
-                score += recencyBoost;
-            }
-        }
-        catch (error) {
-            // File not in git or error - no recency boost
-            gitRecencyCache.set(file, 0);
-        }
-    }
-    else {
-        score += gitRecencyCache.get(file) || 0;
-    }
-    // 4. Match density penalty (fewer files with matches = higher relevance)
-    // If a file has many matches, slightly reduce its score to avoid one file dominating
-    if (matchCount > 10) {
-        score -= Math.min(20, matchCount - 10);
-    }
-    return Math.max(0, Math.min(150, score)); // Clamp to 0-150
-}
-// Score and rank search results
-async function scoreAndRankResults(lexicalHits, semanticHits) {
-    const scoredResults = [];
-    // Count matches per file for density calculation
-    const fileMatchCounts = new Map();
-    [...lexicalHits, ...semanticHits].forEach(hit => {
-        fileMatchCounts.set(hit.file, (fileMatchCounts.get(hit.file) || 0) + 1);
-    });
-    // Score lexical hits
-    for (const hit of lexicalHits) {
-        const matchCount = fileMatchCounts.get(hit.file) || 1;
-        const score = await calculateRelevanceScore(hit.file, 'lexical', matchCount);
-        scoredResults.push({
-            file: hit.file,
-            line: hit.line,
-            text: hit.text || '',
-            score,
-            source: 'lexical'
-        });
-    }
-    // Score semantic hits
-    for (const hit of semanticHits) {
-        const matchCount = fileMatchCounts.get(hit.file) || 1;
-        const score = await calculateRelevanceScore(hit.file, 'semantic', matchCount);
-        scoredResults.push({
-            file: hit.file,
-            line: hit.line,
-            text: hit.message || hit.ruleId || '',
-            score,
-            source: 'semantic'
-        });
-    }
-    // Sort by score descending (highest relevance first)
-    return scoredResults.sort((a, b) => b.score - a.score);
-}
-//# sourceMappingURL=searchTools.js.map