codehere 0.2.2 → 0.3.0-rc.10

package/dist/application/services/tool-executor-service.js

@@ -1,94 +0,0 @@
-/**
- * Application Service: ToolExecutorService
- * Wraps tool executor for ReAct loop integration
- */
-import { ToolExecutor } from '../../tools/executor.js';
-import { getToolRegistry } from '../../tools/registry.js';
-export class ToolExecutorService {
-    executor;
-    constructor() {
-        this.executor = new ToolExecutor();
-    }
-    /**
-     * Execute action from ReAct loop
-     */
-    async executeAction(action) {
-        if (action.type === 'tool') {
-            try {
-                const toolRegistry = getToolRegistry();
-                const tool = toolRegistry.get(action.name);
-                if (!tool) {
-                    return {
-                        result: null,
-                        success: false,
-                        error: `Tool "${action.name}" not found. Available: ${toolRegistry.getAll().map(t => t.name).join(', ')}`,
-                    };
-                }
-                // Convert action parameters to tool call format
-                const toolCall = {
-                    tool: action.name,
-                    parameters: action.parameters || {},
-                };
-                const result = await this.executor.execute(toolCall);
-                // Ensure structured output (JSON format)
-                // All tools must return { success: boolean, result?: any, error?: string }
-                if (!result || typeof result !== 'object') {
-                    return {
-                        result: null,
-                        success: false,
-                        error: `Tool "${action.name}" returned invalid output: expected object, got ${typeof result}`,
-                    };
-                }
-                // Validate required fields
-                if (typeof result.success !== 'boolean') {
-                    return {
-                        result: null,
-                        success: false,
-                        error: `Tool "${action.name}" returned invalid output: missing or invalid "success" field`,
-                    };
-                }
-                // Format result for observation (preserve structure)
-                let formattedResult = result.result;
-                // If result is an object with specific structure, extract key info for display
-                // But preserve full structure in result
-                if (result.result && typeof result.result === 'object') {
-                    // Keep full object structure for tool chaining
-                    formattedResult = result.result;
-                }
-                // Return structured observation
-                return {
-                    result: formattedResult,
-                    success: result.success,
-                    error: result.error || (result.success ? undefined : 'Tool execution failed'),
-                };
-            }
-            catch (error) {
-                return {
-                    result: null,
-                    success: false,
-                    error: error instanceof Error ? error.message : String(error),
-                };
-            }
-        }
-        if (action.type === 'agent') {
-            // TODO: Wire up agent calls
-            return {
-                result: `Agent "${action.name}" called (not yet implemented)`,
-                success: false,
-                error: 'Agent calls not yet integrated',
-            };
-        }
-        if (action.type === 'answer') {
-            return {
-                result: action.parameters?.answer || 'No answer provided',
-                success: true,
-            };
-        }
-        return {
-            result: null,
-            success: false,
-            error: `Unknown action type: ${action.type}`,
-        };
-    }
-}
-//# sourceMappingURL=tool-executor-service.js.map

package/dist/application/use-cases/ask-question-use-case.js

@@ -1,338 +0,0 @@
-/**
- * Application Use Case: AskQuestionUseCase
- * Handles the "ask" command - answers questions about codebase
- */
-import { MemoryRetriever } from '../../domain/services/memory-retriever.js';
-import { getEmbeddingCache } from '../../infrastructure/cache/embedding-cache.js';
-import { getQueryResultCache } from '../../infrastructure/cache/query-result-cache.js';
-import { getResponseCache } from '../../infrastructure/cache/response-cache.js';
-export class AskQuestionUseCase {
-    embeddingRepository;
-    aiService;
-    memoryRepository;
-    uncertaintyQuantifier;
-    memoryRetriever;
-    embeddingCache = getEmbeddingCache();
-    queryResultCache = getQueryResultCache();
-    responseCache = getResponseCache();
-    constructor(embeddingRepository, aiService, memoryRepository, uncertaintyQuantifier) {
-        this.embeddingRepository = embeddingRepository;
-        this.aiService = aiService;
-        this.memoryRepository = memoryRepository;
-        this.uncertaintyQuantifier = uncertaintyQuantifier;
-        this.memoryRetriever = new MemoryRetriever();
-    }
-    async execute(request) {
-        // 0. Check if query is git-related and use git tool directly
-        const gitKeywords = ['git', 'modified', 'changed', 'status', 'commit', 'branch', 'diff', 'staged', 'untracked'];
-        const isGitQuery = gitKeywords.some(keyword => request.query.toLowerCase().includes(keyword));
-        if (isGitQuery) {
-            try {
-                const { GitTool } = await import('../../tools/git-tool.js');
-                // Use process.cwd() for working directory (request doesn't have context property)
-                const gitTool = new GitTool(process.cwd());
-                // Check if it's a git repository first
-                const isRepo = await gitTool.isRepository();
-                if (!isRepo) {
-                    return {
-                        answer: 'This directory is not a Git repository. Initialize a Git repository first with `git init`.',
-                        chunks: [],
-                        memories: [],
-                    };
-                }
-                const gitStatus = await gitTool.status();
-                // Format git status response
-                let gitAnswer = `Git Repository Status:\n`;
-                gitAnswer += `Branch: ${gitStatus.branch}\n\n`;
-                if (gitStatus.modified.length > 0) {
-                    gitAnswer += `Modified files:\n${gitStatus.modified.map(f => `  - ${f}`).join('\n')}\n\n`;
-                }
-                if (gitStatus.staged.length > 0) {
-                    gitAnswer += `Staged files:\n${gitStatus.staged.map(f => `  - ${f}`).join('\n')}\n\n`;
-                }
-                if (gitStatus.untracked.length > 0) {
-                    gitAnswer += `Untracked files:\n${gitStatus.untracked.map(f => `  - ${f}`).join('\n')}\n\n`;
-                }
-                if (gitStatus.modified.length === 0 && gitStatus.staged.length === 0 && gitStatus.untracked.length === 0) {
-                    gitAnswer += `No changes detected. Working directory is clean.`;
-                }
-                return {
-                    answer: gitAnswer,
-                    chunks: [],
-                    memories: [],
-                };
-            }
-            catch (error) {
-                // Fallback to regular search if git tool fails
-                // Log error for debugging but don't show to user
-                const errorMessage = error instanceof Error ? error.message : String(error);
-                console.warn('[AskQuestionUseCase] Git tool failed, falling back to regular search:', errorMessage);
-                // Continue to regular search flow below
-            }
-        }
-        // 1. Generate query embedding using search_query input type (better matching!)
-        // Performance: Check cache first to avoid redundant API calls
-        const embeddingStart = Date.now();
-        let queryEmbedding = this.embeddingCache.get(request.query);
-        const embeddingCacheTime = Date.now() - embeddingStart;
-        let embeddingGenTime = 0;
-        if (!queryEmbedding) {
-            const genStart = Date.now();
-            // Use embedQuery if available, fallback to embed for backward compatibility
-            if ('embedQuery' in this.aiService && typeof this.aiService.embedQuery === 'function') {
-                const embedding = await this.aiService.embedQuery(request.query);
-                queryEmbedding = Array.isArray(embedding) && !Array.isArray(embedding[0]) ? embedding : null;
-            }
-            else {
-                const embedding = await this.aiService.embed(request.query);
-                if (Array.isArray(embedding[0])) {
-                    throw new Error('Expected single embedding vector');
-                }
-                queryEmbedding = embedding;
-            }
-            embeddingGenTime = Date.now() - genStart;
-            if (!queryEmbedding) {
-                throw new Error('Failed to generate query embedding');
-            }
-            // Cache the embedding for future use
-            this.embeddingCache.set(request.query, queryEmbedding);
-        }
-        // Ensure we have a valid embedding
-        if (!queryEmbedding) {
-            throw new Error('Failed to generate query embedding');
-        }
-        // 2. PARALLEL EXECUTION: Search codebase and retrieve memories simultaneously
-        // OPTIMIZATION: For simple queries, reduce operations and skip memory if not needed
-        const isSimpleQuery = this.isSimpleQuery(request.query);
-        // AGGRESSIVE OPTIMIZATION: For simple queries, use minimal operations
-        // OPTIMIZATION: Reduce initial search limit to reduce processing time
-        const initialLimit = isSimpleQuery
-            ? 3 // Only need top 3 chunks for simple queries (fast!)
-            : Math.min((request.maxResults || 8) * 2, 20); // Reduced from 50 to 20 for faster search
-        // Check query result cache first (performance optimization)
-        const cachedResults = this.queryResultCache.get(request.query, initialLimit);
-        let initialChunks;
-        let allMemories = [];
-        let searchTime = 0; // Performance metrics
-        let rerankTime = 0; // Performance metrics
-        // Progress is owned by the caller (REPL spinner or CLI command)
-        let searchProgress = null;
-        if (cachedResults) {
-            // Cache hit - use cached results
-            this.queryResultCache.recordHit();
-            initialChunks = cachedResults;
-            // Still retrieve memories in parallel (if not simple query)
-            if (!isSimpleQuery && this.memoryRepository && queryEmbedding) {
-                allMemories = await this.memoryRepository.retrieve(request.query, 10).catch(() => []);
-            }
-        }
-        else {
-            // Cache miss - perform search
-            this.queryResultCache.recordMiss();
-            // Run code search and memory retrieval in parallel (skip memory for simple queries)
-            const searchStart = Date.now();
-            const results = await Promise.all([
-                // Code search - minimal for simple queries
-                this.embeddingRepository.searchWithEmbedding(queryEmbedding, initialLimit),
-                // Memory retrieval: Skip for simple queries to save time (they don't need context)
-                !isSimpleQuery && this.memoryRepository && queryEmbedding
-                    ? this.memoryRepository.retrieve(request.query, 10).catch(() => []) // Graceful fallback
-                    : Promise.resolve([]),
-            ]);
-            searchTime = Date.now() - searchStart;
-            initialChunks = results[0];
-            allMemories = results[1];
-            // Cache the results for future use
-            this.queryResultCache.set(request.query, initialLimit, initialChunks);
-            // Stop progress indicator
-            if (searchProgress) {
-                searchProgress.stop(true, `Found ${initialChunks.length} chunks`);
-            }
-        }
-        if (initialChunks.length === 0) {
-            return {
-                answer: 'No relevant code found. Please run "codehere index" first.',
-                chunks: [],
-            };
-        }
-        // 3. PARALLEL EXECUTION: Rerank + Memory Processing (Story 1: Parallel Context Processing)
-        // OPTIMIZATION: These operations are independent and can run in parallel
-        // OPTIMIZATION: Skip rerank for simple queries to improve speed
-        let chunks = initialChunks;
-        let memories = [];
-        // For simple queries, use minimal chunks (top 3) for fastest response
-        // Story 2: Optimized execution path - reduced context window, minimal processing
-        if (isSimpleQuery) {
-            chunks = initialChunks.slice(0, 3); // Top 3 for simple queries (aggressive optimization)
-            // Process memories synchronously for simple queries (minimal processing, already fast)
-            if (allMemories.length > 0 && queryEmbedding) {
-                memories = this.memoryRetriever.retrieve(allMemories, queryEmbedding, 3); // Minimal for simple queries
-            }
-        }
-        else {
-            // For complex queries: Parallelize rerank + memory processing
-            const documents = initialChunks.map((chunk) => chunk.content);
-            // Run rerank and memory processing in parallel (they're independent)
-            // OPTIMIZATION: Reduce maxResults for complex queries to reduce AI Chat latency
-            // Target: 8 chunks max (down from 15) to reduce context window by ~47%
-            const maxChunksForAI = Math.min(request.maxResults || 8, 8); // Aggressive: max 8 chunks
-            const rerankStart = Date.now();
-            const [rerankResults, processedMemories] = await Promise.all([
-                // Rerank operation (only if we have enough results)
-                initialChunks.length > 5
-                    ? this.aiService.rerank(request.query, documents, maxChunksForAI)
-                        .then(results => results.map((result) => {
-                        const chunk = initialChunks[result.index];
-                        return {
-                            ...chunk,
-                            score: result.relevanceScore,
-                        };
-                    }))
-                        .catch((error) => {
-                        // Fallback to initial results if rerank fails
-                        console.warn('Rerank API failed, using initial results:', error instanceof Error ? error.message : String(error));
-                        return initialChunks.slice(0, maxChunksForAI);
-                    })
-                    : Promise.resolve(initialChunks.slice(0, maxChunksForAI)),
-                // Memory processing (reuse query embedding, no recomputation needed)
-                allMemories.length > 0 && queryEmbedding
-                    ? Promise.resolve(this.memoryRetriever.retrieve(allMemories, queryEmbedding, 5))
-                    : Promise.resolve([]),
-            ]);
-            rerankTime = Date.now() - rerankStart;
-            chunks = rerankResults;
-            memories = processedMemories;
-        }
-        // 3. Pass conversation history through context chunks (metadata) for AI service
-        const chunksWithHistory = request.conversationHistory && request.conversationHistory.length > 0
-            ? chunks.map((chunk, idx) => {
-                if (idx === 0) {
-                    // Attach conversation history to first chunk as metadata
-                    return {
-                        ...chunk,
-                        conversationHistory: request.conversationHistory,
-                    };
-                }
-                return chunk;
-            })
-            : chunks;
-        // 3. Generate AI response with context (with optional streaming)
-        // OPTIMIZATION: Check response cache first to avoid redundant AI calls
-        const contextHash = this.responseCache.generateContextHash(chunks);
-        let answer = '';
-        let chatTime = 0;
-        let wasResponseCached = false;
-        // Check cache (skip for streaming as it's real-time)
-        if (!request.streamHandler) {
-            const cachedAnswer = this.responseCache.get(request.query, contextHash, true);
-            if (cachedAnswer) {
-                answer = cachedAnswer;
-                wasResponseCached = true;
-                chatTime = 0; // Cache hit = instant
-            }
-        }
-        // If not cached, call AI service
-        if (!wasResponseCached) {
-            const chatStart = Date.now();
-            if (request.streamHandler && 'chatStream' in this.aiService && typeof this.aiService.chatStream === 'function') {
-                // Use streaming if available
-                answer = await this.aiService.chatStream(request.query, chunksWithHistory, memories, request.streamHandler);
-            }
-            else {
-                // Fallback to regular chat
-                answer = await this.aiService.chat(request.query, chunksWithHistory, memories);
-            }
-            chatTime = Date.now() - chatStart;
-            // Cache the response for future use
-            if (answer && !request.streamHandler) {
-                this.responseCache.set(request.query, answer, contextHash);
-            }
-        }
-        // 4. Estimate tokens (rough: 1 token ≈ 4 characters)
-        const tokenEstimate = chunks.reduce((sum, chunk) => sum + Math.ceil(chunk.content.length / 4), 0);
-        // 5. Quantify uncertainty in answer (XAI Foundation - Research: Uncertainty Quantification)
-        let uncertainty;
-        if (this.uncertaintyQuantifier && answer) {
-            uncertainty = await this.uncertaintyQuantifier.quantifyUncertainty(request.query, answer, { chunks });
-        }
-        // Get cache statistics
-        const cacheStats = this.queryResultCache.getStats();
-        const wasCacheHit = cachedResults !== null;
-        // Get compression metrics from execution tracer if available
-        let compressionMetrics;
-        try {
-            const { executionTracer } = await import('../../infrastructure/observability/execution-tracer.js');
-            const runId = executionTracer.getCurrentRunId();
-            if (runId) {
-                // Get the current run to find compression trace
-                const currentRun = executionTracer.currentRun;
-                if (currentRun) {
-                    const compressionTrace = currentRun.traces.find((t) => t.operationType === 'context_compression' && t.operationName === 'compress_context');
-                    if (compressionTrace && compressionTrace.output) {
-                        compressionMetrics = {
-                            originalTokens: compressionTrace.output.originalTokens || 0,
-                            compressedTokens: compressionTrace.output.compressedTokens || 0,
-                            reductionPercent: compressionTrace.output.reductionPercent || 0,
-                        };
-                    }
-                }
-            }
-        }
-        catch {
-            // Execution tracer not available, skip compression metrics
-        }
-        // Calculate total time
-        const totalTime = Date.now() - request.__startTime || 0;
-        return {
-            answer,
-            chunks,
-            memories,
-            tokenEstimate,
-            uncertainty, // XAI Foundation - Uncertainty quantification for transparency
-            cacheHit: wasCacheHit,
-            performanceMetrics: {
-                embeddingCacheTime,
-                embeddingGenTime,
-                searchTime: cachedResults ? 0 : searchTime,
-                rerankTime: isSimpleQuery ? 0 : rerankTime,
-                chatTime,
-                totalTime,
-            },
-            cacheStats: {
-                hitRate: cacheStats.hitRate,
-                totalHits: cacheStats.totalHits,
-                totalMisses: cacheStats.totalMisses,
-            },
-            compressionMetrics, // Context compression metrics (P1)
-        };
-    }
-    /**
-     * Check if query is simple (short, question-like, single intent)
-     * Simple queries can skip rerank for better performance
-     */
-    /**
-     * Check if query is simple (short, question-like, single intent)
-     * Story 2: Enhanced detection with improved accuracy (target: >90%)
-     * Simple queries can skip rerank for better performance
-     */
-    isSimpleQuery(query) {
-        const lower = query.toLowerCase().trim();
-        // Enhanced detection patterns (Story 2: Query Simplification)
-        // 1. Short query (< 50 chars) - primary indicator
-        const isShort = query.length < 50;
-        // 2. Question-like patterns (expanded list for better accuracy)
-        const questionPatterns = /^(what|where|how|why|when|who|which|is|are|does|do|can|could|will|would|explain|describe|tell|show|find|locate|search|where|what's|what is|how to|how do|how does)/i;
-        const isQuestion = questionPatterns.test(lower);
-        // 3. Single intent indicators (no complex conjunctions)
-        const complexIndicators = /(and|also|then|next|first|second|finally|multiple|several|steps|after|before|while|during|create|implement|add|modify|refactor|change|update|delete|remove)/i;
-        const isSingleIntent = !complexIndicators.test(lower);
-        // 4. Simple structure (no nested clauses, no semicolons, no colons for lists)
-        const hasComplexStructure = /[;:]|\(|\)|\[|\]/.test(query);
-        // 5. No code-specific keywords (indicates need for code analysis)
-        const codeKeywords = /(function|class|interface|type|import|export|const|let|var|async|await|return|if|else|for|while|try|catch)/i;
-        const hasCodeKeywords = codeKeywords.test(lower);
-        // Simple query if: short + question-like + single intent + no complex structure + no code keywords
-        return isShort && isQuestion && isSingleIntent && !hasComplexStructure && !hasCodeKeywords;
-    }
-}
-//# sourceMappingURL=ask-question-use-case.js.map