bobs-workshop 0.1.4

package/dist/tools/searchTools.js

@@ -0,0 +1,788 @@
+// src/tools/searchTools.ts
+import { exec, spawn } from "child_process";
+import { promisify } from "util";
+import { z } from "zod";
+import fs from "fs-extra";
+const execAsync = promisify(exec);
+// 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);
+                if (code === 0) {
+                    resolve({ stdout, stderr });
+                }
+                else {
+                    const error = new Error(`Command failed with code ${code}`);
+                    error.code = code;
+                    error.stdout = stdout;
+                    error.stderr = stderr;
+                    reject(error);
+                }
+            }
+        });
+        child.on('error', (err) => {
+            if (!isResolved) {
+                isResolved = true;
+                clearTimeout(timeoutId);
+                reject(err);
+            }
+        });
+    });
+}
+// Simplified tool path finder based on successful MCP implementations
+async function findToolPath(toolName) {
+    // Research shows successful MCP servers use simple PATH-based discovery
+    // Try system PATH first, then fallback to known locations
+    try {
+        // Test if tool is in PATH (like successful MCP implementations do)
+        await execAsync(`${toolName} --version`, { timeout: 3000 });
+        return toolName; // Tool found in PATH
+    }
+    catch (error) {
+        // Fallback to specific locations only if PATH fails
+        if (toolName === 'rg') {
+            // Claude Code provides rg, try that location
+            const claudeRg = `/Users/${process.env.USER}/.claude/local/node_modules/@anthropic-ai/claude-code/vendor/ripgrep/arm64-darwin/rg`;
+            try {
+                await execAsync(`${claudeRg} --version`, { timeout: 3000 });
+                return claudeRg;
+            }
+            catch (e) {
+                // Final fallback
+                return 'rg';
+            }
+        }
+        // For semgrep and others, just return the tool name (PATH should work after installation)
+        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"),
+    mode: z.enum(["lexical", "semantic", "auto"]).optional().default("auto").describe("Search mode: lexical (ripgrep), semantic (semgrep), or auto (both)"),
+    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(200).describe("Maximum total results across lexical and semantic"),
+    contextLines: z.number().optional().default(2).describe("Context lines before/after matches"),
+    timeoutMs: z.number().optional().default(4000).describe("Timeout in milliseconds")
+});
+export const HybridSearchOutput = 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()
+    })).describe("Ripgrep lexical search results"),
+    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()
+    })).describe("Semgrep semantic search results"),
+    truncated: z.boolean().describe("True if results were capped at maxHits"),
+    stats: z.object({
+        elapsedMs: z.number(),
+        rgHits: z.number(),
+        semgrepHits: z.number()
+    }).describe("Search execution statistics"),
+    errors: z.array(z.string()).optional().describe("Non-fatal errors during search")
+});
+// 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);
+    const startTime = Date.now();
+    const errors = [];
+    console.log('[HYBRID DEBUG] Hybrid search started with input:', JSON.stringify(validated, null, 2));
+    let lexicalHits = [];
+    let semanticHits = [];
+    let rgHits = 0;
+    let semgrepHits = 0;
+    // Phase 1: Run ripgrep for lexical search (unless mode is purely semantic)
+    if (validated.mode === "lexical" || validated.mode === "auto") {
+        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 max results (split between lexical and semantic)
+            const maxLexical = validated.mode === "lexical" ? validated.maxHits : Math.floor(validated.maxHits / 2);
+            args.push('--max-count', maxLexical.toString());
+            // Add query and path
+            args.push(validated.query);
+            if (validated.path) {
+                args.push(validated.path);
+            }
+            console.log('[HYBRID DEBUG] Ripgrep command:', rgPath, args.join(' '));
+            const { stdout, stderr } = await spawnAsync(rgPath, args, {
+                cwd: process.cwd(),
+                timeout: validated.timeoutMs
+            });
+            if (stderr) {
+                console.warn('[HYBRID WARN] Ripgrep stderr:', stderr);
+                errors.push(`ripgrep warning: ${stderr}`);
+            }
+            // Parse ripgrep JSON output
+            lexicalHits = await parseRipgrepJSON(stdout, validated.contextLines);
+            rgHits = lexicalHits.length;
+            console.log('[HYBRID DEBUG] Ripgrep found', rgHits, 'results');
+        }
+        catch (error) {
+            console.warn('[HYBRID WARN] Ripgrep failed:', error);
+            errors.push(`ripgrep failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    // Phase 2: Run Semgrep for semantic search (if mode allows and we have target files)
+    if (validated.mode === "semantic" || (validated.mode === "auto" && lexicalHits.length > 0)) {
+        try {
+            console.log('[HYBRID DEBUG] Running semantic search with semgrep');
+            const semgrepPath = await findToolPath('semgrep');
+            // Build semgrep command with phase-aware configuration
+            const semgrepArgs = ['--json', '--no-git-ignore', '--quiet', '--metrics=off'];
+            // Add phase-aware rule configuration
+            const phaseRules = getPhaseAwareSemgrepRules(validated.mode, input.phase);
+            // If no rules available (like engineer phase) or semantic mode, use pattern-based search
+            if (phaseRules.length === 0 || validated.mode === "semantic") {
+                // Use a pattern based on the query for semantic analysis
+                const semanticPattern = `$FUNC(..., ${validated.query}, ...)`;
+                semgrepArgs.push('--pattern', semanticPattern);
+            }
+            else {
+                // Use phase-aware rules
+                semgrepArgs.push(...phaseRules);
+            }
+            // Determine target files to scan
+            const targetFiles = [];
+            // Scope to files from lexical search if available
+            if (lexicalHits.length > 0 && validated.mode === "auto") {
+                const uniqueFiles = Array.from(new Set(lexicalHits.map(hit => hit.file)));
+                console.log('[HYBRID DEBUG] Scoping semgrep to', uniqueFiles.length, 'files from lexical search');
+                targetFiles.push(...uniqueFiles);
+            }
+            else {
+                // Default to current directory or specified path
+                targetFiles.push(validated.path || '.');
+            }
+            // Add target files to args
+            semgrepArgs.push(...targetFiles);
+            // Add language specification
+            if (validated.fileTypes && validated.fileTypes.length > 0) {
+                const langMap = {
+                    'ts': 'typescript',
+                    'tsx': 'typescript',
+                    'js': 'javascript',
+                    'jsx': 'javascript',
+                    'py': 'python',
+                    'go': 'go',
+                    'java': 'java'
+                };
+                const lang = validated.fileTypes.map(t => langMap[t] || t)[0];
+                if (lang) {
+                    semgrepArgs.push('--lang', lang);
+                }
+            }
+            console.log('[HYBRID DEBUG] Semgrep command:', semgrepPath, semgrepArgs.join(' '));
+            const { stdout: semgrepStdout, stderr: semgrepStderr } = await spawnAsync(semgrepPath, semgrepArgs, {
+                cwd: process.cwd(),
+                timeout: validated.timeoutMs
+            });
+            if (semgrepStderr) {
+                console.warn('[HYBRID WARN] Semgrep stderr:', semgrepStderr);
+                errors.push(`semgrep warning: ${semgrepStderr}`);
+            }
+            // Parse semgrep output
+            const semgrepOutput = JSON.parse(semgrepStdout || '{"results": []}');
+            semanticHits = normalizeSemgrepResults(semgrepOutput);
+            semgrepHits = semanticHits.length;
+            console.log('[HYBRID DEBUG] Semgrep found', semgrepHits, 'results');
+        }
+        catch (error) {
+            // Handle Semgrep exit codes properly:
+            // 0 = success, no findings
+            // 1 = error (configuration, parsing, etc.)
+            // 2 = success, findings found
+            if (error.code === 2) {
+                // Exit code 2 means findings were found - this is success for Semgrep
+                try {
+                    const semgrepOutput = JSON.parse(error.stdout || '{"results": []}');
+                    semanticHits = normalizeSemgrepResults(semgrepOutput);
+                    semgrepHits = semanticHits.length;
+                    console.log('[HYBRID DEBUG] Semgrep found', semgrepHits, 'results via exit code 2');
+                }
+                catch (parseError) {
+                    console.warn('[HYBRID WARN] Semgrep exit code 2 but failed to parse output:', parseError);
+                    errors.push(`semgrep output parsing failed: ${parseError instanceof Error ? parseError.message : String(parseError)}`);
+                }
+            }
+            else {
+                console.warn('[HYBRID WARN] Semgrep failed:', error);
+                errors.push(`semgrep failed: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+    }
+    // Phase 3: Merge, deduplicate, and cap results
+    const totalHits = rgHits + semgrepHits;
+    const truncated = totalHits > validated.maxHits;
+    if (truncated) {
+        const lexicalCap = Math.floor(validated.maxHits * 0.7); // Favor lexical results
+        const semanticCap = validated.maxHits - lexicalCap;
+        lexicalHits = lexicalHits.slice(0, lexicalCap);
+        semanticHits = semanticHits.slice(0, semanticCap);
+    }
+    const elapsedMs = Date.now() - startTime;
+    // Generate structured summary for terminal display (as per reliability manifest)
+    const totalResults = lexicalHits.length + semanticHits.length;
+    const modeBanner = generateModeBanner(validated.mode, validated.phase, validated.query, totalResults, elapsedMs);
+    // Create summary hits for terminal display
+    const summaryHits = generateSummaryHits(lexicalHits, semanticHits, validated.maxHits);
+    const result = {
+        // Summary output for terminal (concise, human-readable)
+        summary: modeBanner,
+        hits: summaryHits,
+        // Detailed output for manual/verbose logging
+        lexicalHits,
+        semanticHits,
+        truncated,
+        stats: {
+            elapsedMs,
+            rgHits,
+            semgrepHits,
+            totalResults
+        },
+        errors: errors.length > 0 ? errors : undefined
+    };
+    console.log('[HYBRID DEBUG] Hybrid search completed in', elapsedMs, 'ms');
+    console.log('[HYBRID DEBUG] Final result:', JSON.stringify({
+        lexicalCount: lexicalHits.length,
+        semanticCount: semanticHits.length,
+        truncated,
+        errors: errors.length
+    }, null, 2));
+    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;
+}
+//# sourceMappingURL=searchTools.js.map