codehere 0.2.2 → 0.3.0-rc.10

package/dist/planner.js

@@ -1,198 +0,0 @@
-/**
- * Intelligent Planning & Execution System
- * Agentic behavior for complex multi-step tasks
- */
-import { getEnhancedContext } from './context.js';
-/**
- * Decompose complex instruction into actionable tasks
- */
-export async function planTask(instruction, context) {
-    const tasks = [];
-    const dependencies = new Map();
-    // Analyze instruction to determine task type
-    const lowerInstruction = instruction.toLowerCase();
-    // Search/Query tasks
-    if (lowerInstruction.includes('find') || lowerInstruction.includes('search') || lowerInstruction.includes('where') || lowerInstruction.includes('how')) {
-        tasks.push({
-            id: 'task_1',
-            description: `Search codebase: ${instruction}`,
-            type: 'search',
-            dependencies: [],
-            status: 'pending',
-        });
-    }
-    // Edit tasks
-    if (lowerInstruction.includes('add') || lowerInstruction.includes('remove') || lowerInstruction.includes('change') || lowerInstruction.includes('update') || lowerInstruction.includes('fix')) {
-        if (context?.files && context.files.length > 1) {
-            // Multi-file refactor
-            tasks.push({
-                id: 'task_1',
-                description: `Refactor multiple files: ${instruction}`,
-                type: 'refactor',
-                dependencies: [],
-                status: 'pending',
-            });
-        }
-        else {
-            // Single file edit
-            tasks.push({
-                id: 'task_1',
-                description: `Edit file: ${instruction}`,
-                type: 'edit',
-                dependencies: [],
-                status: 'pending',
-            });
-        }
-    }
-    // Review tasks
-    if (lowerInstruction.includes('review') || lowerInstruction.includes('check') || lowerInstruction.includes('analyze')) {
-        tasks.push({
-            id: 'task_1',
-            description: `Review code: ${instruction}`,
-            type: 'review',
-            dependencies: [],
-            status: 'pending',
-        });
-    }
-    // If no specific type detected, create a search task first
-    if (tasks.length === 0) {
-        tasks.push({
-            id: 'task_1',
-            description: `Analyze: ${instruction}`,
-            type: 'analyze',
-            dependencies: [],
-            status: 'pending',
-        });
-    }
-    // Build dependency graph
-    for (const task of tasks) {
-        dependencies.set(task.id, task.dependencies);
-    }
-    return {
-        tasks,
-        estimatedSteps: tasks.length,
-        dependencies,
-    };
-}
-/**
- * Execute a plan step by step
- */
-export async function executePlan(plan, context) {
-    const results = new Map();
-    const errors = [];
-    let completedTasks = 0;
-    // Execute tasks in dependency order
-    const taskQueue = [...plan.tasks];
-    const completed = new Set();
-    while (taskQueue.length > 0) {
-        const task = taskQueue.shift();
-        if (!task)
-            break;
-        // Check if dependencies are met
-        const depsMet = task.dependencies.every(dep => completed.has(dep));
-        if (!depsMet) {
-            // Re-queue for later
-            taskQueue.push(task);
-            continue;
-        }
-        // Execute task
-        task.status = 'in_progress';
-        try {
-            let result;
-            switch (task.type) {
-                case 'search':
-                    result = await executeSearchTask(task, context);
-                    break;
-                case 'edit':
-                    result = await executeEditTask(task, context);
-                    break;
-                case 'refactor':
-                    result = await executeRefactorTask(task, context);
-                    break;
-                case 'review':
-                    result = await executeReviewTask(task, context);
-                    break;
-                case 'analyze':
-                    result = await executeAnalyzeTask(task, context);
-                    break;
-                default:
-                    throw new Error(`Unknown task type: ${task.type}`);
-            }
-            task.result = result;
-            task.status = 'completed';
-            results.set(task.id, result);
-            completed.add(task.id);
-            completedTasks++;
-        }
-        catch (error) {
-            task.status = 'failed';
-            task.error = error instanceof Error ? error.message : String(error);
-            errors.push({ task: task.id, error: task.error });
-        }
-    }
-    return {
-        success: errors.length === 0 && completedTasks === plan.tasks.length,
-        completedTasks,
-        results,
-        errors,
-    };
-}
-async function executeSearchTask(task, context) {
-    const enhancedContext = await getEnhancedContext(context.instruction || task.description, {
-        primaryChunks: 15,
-        relatedChunks: 5,
-        includeRelationships: true,
-    });
-    return [...enhancedContext.primaryChunks, ...enhancedContext.relatedChunks];
-}
-async function executeEditTask(task, context) {
-    // This would integrate with the edit system
-    // For now, return placeholder
-    return {
-        file: context.files?.[0] || 'unknown',
-        success: true,
-    };
-}
-async function executeRefactorTask(task, context) {
-    // This would integrate with the refactor system
-    return {
-        files: context.files || [],
-        success: true,
-    };
-}
-async function executeReviewTask(task, context) {
-    // This would integrate with the review system
-    return {
-        suggestions: [],
-    };
-}
-async function executeAnalyzeTask(task, context) {
-    const enhancedContext = await getEnhancedContext(context.instruction || task.description, {
-        primaryChunks: 20,
-        relatedChunks: 10,
-        includeRelationships: true,
-    });
-    return {
-        analysis: `Found ${enhancedContext.totalChunks} relevant chunks from ${enhancedContext.primaryChunks.length} files`,
-    };
-}
-/**
- * Format plan for display
- */
-export function formatPlan(plan) {
-    let output = `Plan: ${plan.estimatedSteps} step(s)\n\n`;
-    for (const task of plan.tasks) {
-        const statusIcon = {
-            pending: '○',
-            in_progress: '⟳',
-            completed: '✓',
-            failed: '✗',
-        }[task.status];
-        output += `${statusIcon} [${task.type}] ${task.description}\n`;
-        if (task.dependencies.length > 0) {
-            output += `   Depends on: ${task.dependencies.join(', ')}\n`;
-        }
-    }
-    return output;
-}
-//# sourceMappingURL=planner.js.map

package/dist/policy.js

@@ -1,26 +0,0 @@
-export function checkPolicy(filepath, diffStats) {
-    // Check 1: Maximum 50 changed lines
-    const totalChanges = diffStats.linesAdded + diffStats.linesRemoved;
-    if (totalChanges > 50) {
-        return {
-            allowed: false,
-            reason: `Change exceeds 50 line limit (${totalChanges} lines changed)`,
-        };
-    }
-    // Check 2: Restricted folders
-    if (filepath.includes('infra/') || filepath.includes('billing/')) {
-        return {
-            allowed: false,
-            reason: `File is in restricted folder: ${filepath}`,
-        };
-    }
-    // Check 3: Only one file can be changed
-    if (diffStats.filesChanged > 1) {
-        return {
-            allowed: false,
-            reason: `Patch edits ${diffStats.filesChanged} files (only 1 file allowed)`,
-        };
-    }
-    return { allowed: true };
-}
-//# sourceMappingURL=policy.js.map

package/dist/presentation/cli/commands/ask-command.js

@@ -1,314 +0,0 @@
-/**
- * CLI Command: Ask
- * Uses clean architecture - AskQuestionUseCase
- */
-import { container } from '../../../application/services/dependency-container.js';
-import { colors, sectionHeader, formatNumber, formatPath, formatScore, createTable, newline, warning, info, separator, isMinimalStyle, printMinimalHeader, printContextSummary, } from '../../../ui.js';
-import { executionTracer } from '../../../infrastructure/observability/execution-tracer.js';
-import { findCodebaseRoot } from '../../../domain/services/codebase-detector.js';
-import { displayError } from '../error-display.js';
-export async function executeAskCommand(question, options) {
-    // Track start time for summary statistics
-    const startTime = Date.now();
-    // Capability Boundaries: Check for unsupported operations
-    try {
-        const { CapabilityBoundaryDetector, displayCapabilityBoundary } = await import('../../../infrastructure/ux/capability-boundaries.js');
-        const detector = new CapabilityBoundaryDetector();
-        const boundary = detector.detectUnsupported(question);
-        if (boundary) {
-            displayCapabilityBoundary(boundary);
-            executionTracer.endRun();
-            return; // Don't proceed with unsupported operation
-        }
-    }
-    catch {
-        // Capability boundary check failed - continue anyway (non-blocking)
-    }
-    // Start execution tracing
-    const codebaseInfo = findCodebaseRoot(process.cwd());
-    const runId = executionTracer.startRun('ask', {
-        query: question,
-        codebaseId: codebaseInfo?.rootPath || process.cwd(),
-    });
-    // Get user ID for Progressive Disclosure (use codebase path or default)
-    const userId = codebaseInfo?.rootPath || process.cwd() || 'cli-user';
-    // Progressive Disclosure: Record feature usage
-    const progressiveDisclosure = container.progressiveDisclosure;
-    if (progressiveDisclosure) {
-        progressiveDisclosure.recordFeatureUsage(userId, 'ask_question');
-    }
-    // Capability assessment (silent — no disclaimer wall)
-    const expectationManagement = container.expectationManagement;
-    let capabilityAssessment = null;
-    if (expectationManagement) {
-        capabilityAssessment = expectationManagement.assessCapability('ask_question', {
-            complexity: question.split(' ').length > 20 ? 'complex' : question.split(' ').length > 10 ? 'moderate' : 'simple',
-            uncertainty: undefined,
-        });
-    }
-    try {
-        // Check if embeddings exist for this repository (skip check if using fake AI for testing)
-        if (process.env.CODEHERE_FAKE_AI !== '1') {
-            const embeddingRepo = container.getEmbeddingRepository(process.cwd());
-            const hasEmbeddings = await embeddingRepo.hasEmbeddings();
-            if (!hasEmbeddings) {
-                newline();
-                console.error(colors.red('No embeddings found for this repository.'));
-                newline();
-                console.log('Run:');
-                console.log(colors.cyan('  codehere index'));
-                console.log('');
-                console.log('then re-run this command.');
-                newline();
-                executionTracer.endRun();
-                process.exit(1);
-            }
-        }
-        // Use per-repo embedding repository for codebase isolation
-        const useCase = container.getAskQuestionUseCase(process.cwd());
-        const minimal = isMinimalStyle();
-        // Print minimal header
-        if (minimal) {
-            printMinimalHeader('ask', question);
-            console.log(colors.bold('Answer:'));
-        }
-        // Enable streaming by default for better UX - disable in minimal mode for cleaner output
-        const enableStreaming = !minimal && options?.stream !== false;
-        let streamingAnswer = '';
-        // Set up streaming handler (only in verbose mode)
-        const streamHandler = enableStreaming ? {
-            onToken: (token) => {
-                process.stdout.write(token);
-                streamingAnswer += token;
-            },
-            onComplete: (fullText) => {
-                streamingAnswer = fullText;
-            },
-            onError: (error) => {
-                console.error(colors.red(`\nStreaming error: ${error.message}`));
-            },
-        } : undefined;
-        // Get conversation context and resolve references
-        const { conversationContextManager } = await import('../../../infrastructure/context/conversation-context.js');
-        const { sessionManager } = await import('../../../infrastructure/context/session-manager.js');
-        const sessionId = sessionManager.getSessionId(process.cwd());
-        const history = conversationContextManager.getHistory(sessionId, 5);
-        // Resolve references in query (e.g., "it", "that", "the previous")
-        const resolvedQuestion = conversationContextManager.resolveReferences(sessionId, question);
-        const entities = conversationContextManager.extractEntities(resolvedQuestion);
-        // Display search results first (before streaming answer)
-        const result = await useCase.execute({
-            query: resolvedQuestion,
-            maxResults: 15,
-            streamHandler,
-            conversationHistory: history.map(turn => ({
-                query: turn.query,
-                response: turn.response,
-                timestamp: typeof turn.timestamp === 'string' ? Date.parse(turn.timestamp) : turn.timestamp,
-            })),
-        });
-        // Check if this is a git status response (has answer but no chunks)
-        const isGitResponse = result.answer && result.answer.includes('Git Repository Status');
-        // With FAKE_AI, we still want to show structured output even if chunks are empty
-        // Only show "No relevant code found" for real providers when there are truly no chunks
-        if (result.chunks.length === 0 && !isGitResponse && process.env.CODEHERE_FAKE_AI !== '1') {
-            console.log('No relevant code found. Run "codehere index" first.');
-            return;
-        }
-        // If git response, display it directly
-        if (isGitResponse) {
-            if (!minimal)
-                sectionHeader('Response');
-            const { formatMarkdownForTerminal } = await import('../../../infrastructure/ux/stream-markdown.js');
-            console.log(formatMarkdownForTerminal(result.answer));
-            newline();
-            return;
-        }
-        const retrievedFiles = [...new Set(result.chunks.map(r => r.filepath))];
-        // With FAKE_AI, show at least a placeholder context even if chunks are empty
-        // This ensures tests can verify the structured output format
-        const showContext = retrievedFiles.length > 0 || process.env.CODEHERE_FAKE_AI === '1';
-        // Minimal style: skip verbose search results table
-        if (!minimal) {
-            // Display search results
-            sectionHeader('Search Results');
-            const fileTable = createTable(['File', 'Relevance', 'Preview'], result.chunks.slice(0, 10).map(r => [
-                formatPath(r.filepath),
-                formatScore(r.score),
-                colors.dim(r.content.substring(0, 50) + '...'),
-            ]));
-            console.log(fileTable.toString());
-            console.log(colors.dim(`\nFound ${formatNumber(result.chunks.length)} chunks from ${formatNumber(retrievedFiles.length)} file(s)`));
-            if (result.tokenEstimate) {
-                console.log(colors.dim(`Token estimate: ${formatNumber(result.tokenEstimate)}`));
-            }
-            console.log();
-        }
-        // Display response
-        if (minimal) {
-            // In minimal mode — format markdown for terminal
-            const { formatMarkdownForTerminal } = await import('../../../infrastructure/ux/stream-markdown.js');
-            console.log(formatMarkdownForTerminal(result.answer || ''));
-            newline();
-            if (showContext) {
-                // Show context even if empty (for FAKE_AI tests) or with actual files
-                if (retrievedFiles.length > 0) {
-                    printContextSummary(retrievedFiles);
-                }
-                else if (process.env.CODEHERE_FAKE_AI === '1') {
-                    // For FAKE_AI tests, show a placeholder context to maintain output structure
-                    console.log(colors.dim('Context:'));
-                    console.log(colors.dim('  - (Using test mode - no real embeddings)'));
-                }
-                newline();
-            }
-            newline();
-        }
-        else {
-            // Verbose mode
-            sectionHeader('Response');
-            if (enableStreaming && streamingAnswer) {
-                // Streaming already displayed, just add newline
-                console.log();
-            }
-            else {
-                const { formatMarkdownForTerminal } = await import('../../../infrastructure/ux/stream-markdown.js');
-                console.log(formatMarkdownForTerminal(result.answer || ''));
-            }
-            newline();
-        }
-        // Verbose style: show summary statistics
-        if (!minimal) {
-            const executionTime = ((Date.now() - startTime) / 1000).toFixed(2);
-            const summaryRows = [];
-            summaryRows.push(['Execution Time', `${executionTime}s`]);
-            // Performance metrics breakdown (if available)
-            if (result.performanceMetrics) {
-                const pm = result.performanceMetrics;
-                if (pm.embeddingGenTime && pm.embeddingGenTime > 0) {
-                    summaryRows.push(['  Embedding Generation', `${(pm.embeddingGenTime / 1000).toFixed(2)}s`]);
-                }
-                if (pm.searchTime && pm.searchTime > 0) {
-                    summaryRows.push(['  Code Search', `${(pm.searchTime / 1000).toFixed(2)}s`]);
-                }
-                if (pm.rerankTime && pm.rerankTime > 0) {
-                    summaryRows.push(['  Rerank', `${(pm.rerankTime / 1000).toFixed(2)}s`]);
-                }
-                if (pm.chatTime && pm.chatTime > 0) {
-                    summaryRows.push(['  AI Chat', `${(pm.chatTime / 1000).toFixed(2)}s`]);
-                }
-            }
-            if (result.chunks.length > 0) {
-                summaryRows.push(['Files Found', formatNumber(result.chunks.length)]);
-                summaryRows.push(['Chunks Retrieved', formatNumber(result.chunks.length)]);
-            }
-            if (result.tokenEstimate) {
-                summaryRows.push(['Tokens', formatNumber(result.tokenEstimate)]);
-            }
-            if (result.memories && result.memories.length > 0) {
-                summaryRows.push(['Memories Used', formatNumber(result.memories.length)]);
-            }
-            if (result.compressionMetrics && result.compressionMetrics.reductionPercent > 0) {
-                summaryRows.push(['Context Compression', `${result.compressionMetrics.reductionPercent.toFixed(1)}% reduction`]);
-                summaryRows.push(['  Original Tokens', formatNumber(result.compressionMetrics.originalTokens)]);
-                summaryRows.push(['  Compressed Tokens', formatNumber(result.compressionMetrics.compressedTokens)]);
-            }
-            if (summaryRows.length > 1) {
-                console.log(separator('─', 80));
-                sectionHeader('Summary');
-                const summaryTable = createTable(['Metric', 'Value'], summaryRows);
-                console.log(summaryTable.toString());
-                newline();
-            }
-            // Expectation Management: Show warnings if uncertainty is high
-            if (result.uncertainty && expectationManagement) {
-                if (result.uncertainty.isHallucinationRisk) {
-                    console.log(warning('\n⚠️  High uncertainty detected - please verify the response carefully.'));
-                }
-                // Update capability assessment with actual uncertainty
-                if (capabilityAssessment) {
-                    const updatedAssessment = expectationManagement.assessCapability('ask_question', {
-                        complexity: question.split(' ').length > 20 ? 'complex' : question.split(' ').length > 10 ? 'moderate' : 'simple',
-                        uncertainty: result.uncertainty.combined.value,
-                    });
-                    if (updatedAssessment.warnings.length > 0 && updatedAssessment.capability === 'risky') {
-                        console.log(warning(`\n⚠️  ${updatedAssessment.warnings[0]}\n`));
-                    }
-                }
-            }
-            // Contextual Feature Discovery: Show relevant features based on query (Task 2.2)
-            const { shouldShowContextualSuggestion } = await import('../../../infrastructure/ux/contextual-feature-discovery.js');
-            const contextualSuggestion = shouldShowContextualSuggestion(question, 'ask');
-            if (contextualSuggestion) {
-                newline();
-                console.log(colors.bold(`💡 Tip: ${contextualSuggestion.reason}`));
-                console.log(colors.dim(`   Try: ${colors.cyan(contextualSuggestion.command)}`));
-                console.log(colors.dim(`   ${contextualSuggestion.description}`));
-                newline();
-            }
-            else {
-                // Progressive Disclosure: Suggest next features for beginner users (fallback)
-                if (progressiveDisclosure) {
-                    const profile = progressiveDisclosure.getUserProfile(userId);
-                    if (profile.level === 'beginner' || profile.level === 'intermediate') {
-                        const nextFeatures = progressiveDisclosure.getNextSuggestedFeatures(userId, 1);
-                        if (nextFeatures.length > 0) {
-                            const feature = nextFeatures[0];
-                            console.log(info(`💡 Tip: Try "${feature.featureName}" - ${feature.description}`));
-                            console.log(colors.dim(`   Run: codehere ${feature.featureId === 'edit_file' ? 'edit' : feature.featureId === 'react_loop' ? 'react' : 'help'} for more info\n`));
-                        }
-                    }
-                }
-            }
-            // Task 6.1: Explicit Feedback Mechanisms - Prompt for feedback after response
-            try {
-                const { promptForFeedback, storeFeedback, displayFeedbackConfirmation } = await import('../../../infrastructure/ux/feedback-prompt.js');
-                const { BiDirectionalLearning } = await import('../../../infrastructure/ux/bi-directional-learning.js');
-                // Get learning system from container (or create instance if not available)
-                const learningSystem = container.biDirectionalLearning || new BiDirectionalLearning();
-                const userId = process.env.USER || 'default-user';
-                const feedback = await promptForFeedback('ask', {
-                    query: question,
-                    response: result.answer,
-                    sessionId: executionTracer.getCurrentRunId() || undefined,
-                });
-                if (feedback) {
-                    storeFeedback(learningSystem, userId, feedback, {
-                        operation: 'ask',
-                        query: question,
-                        response: result.answer,
-                        sessionId: executionTracer.getCurrentRunId() || undefined,
-                    });
-                    displayFeedbackConfirmation(feedback);
-                }
-            }
-            catch (feedbackError) {
-                // Don't fail the command if feedback collection fails
-            }
-        }
-        // Store conversation turn for future reference resolution (always)
-        try {
-            const { conversationContextManager } = await import('../../../infrastructure/context/conversation-context.js');
-            const { sessionManager } = await import('../../../infrastructure/context/session-manager.js');
-            const sessionId = sessionManager.getSessionId(process.cwd());
-            const response = result.answer || 'No answer generated';
-            const entities = conversationContextManager.extractEntities(resolvedQuestion);
-            conversationContextManager.addTurn(sessionId, question, response, entities, 'ask');
-        }
-        catch (error) {
-            // Don't fail if conversation tracking fails
-        }
-    }
-    catch (err) {
-        displayError(err, {
-            operation: 'ask',
-            query: question,
-            showSuggestions: true,
-        });
-        throw err;
-    }
-    finally {
-        executionTracer.endRun();
-    }
-}
-//# sourceMappingURL=ask-command.js.map