codehere 0.2.2 → 0.3.0-rc.10

package/dist/application/use-cases/react-orchestration-use-case.js

@@ -1,329 +0,0 @@
-/**
- * Application Use Case: ReActOrchestrationUseCase
- * Orchestrates ReAct loop with Memory Stream
- */
-import { ReActLoop } from '../../domain/services/react-loop.js';
-import { ToolExecutorService } from '../services/tool-executor-service.js';
-import { DecisionTreeLog } from '../../infrastructure/xai/decision-tree-log.js';
-export class ReActOrchestrationUseCase {
-    aiService;
-    memoryStream;
-    toolExecutor;
-    decisionTreeLog;
-    uncertaintyQuantifier;
-    cotVisualizer;
-    attentionVisualizer;
-    constructor(aiService, memoryStream, toolExecutor, decisionTreeLog, uncertaintyQuantifier, cotVisualizer, attentionVisualizer) {
-        this.aiService = aiService;
-        this.memoryStream = memoryStream;
-        this.toolExecutor = toolExecutor || new ToolExecutorService();
-        this.decisionTreeLog = decisionTreeLog || new DecisionTreeLog();
-        this.uncertaintyQuantifier = uncertaintyQuantifier;
-        this.cotVisualizer = cotVisualizer;
-        this.attentionVisualizer = attentionVisualizer;
-    }
-    async execute(request) {
-        const reactLoop = new ReActLoop(request.maxTurns || 20);
-        this.decisionTreeLog.clear(); // Start fresh for this execution
-        // 0. Create CoT trajectory for visualization (XAI Foundation - Research: CoT visualization)
-        let cotTrajectory;
-        if (this.cotVisualizer) {
-            cotTrajectory = this.cotVisualizer.createTrajectory(request.query);
-        }
-        // 1. Retrieve relevant memories
-        const memories = await this.memoryStream.retrieve(request.query, 10);
-        // 2. Get available tools for context
-        const { getToolRegistry } = await import('../../tools/registry.js');
-        const toolRegistry = getToolRegistry();
-        // getToolList() returns a string, getAll() returns Tool[] array
-        const availableTools = toolRegistry.getAll().map(tool => tool.name); // Get array of tool names
-        // 3. Log goal interpretation (XAI Foundation - Research: Full auditability required)
-        const goalId = `goal-${Date.now()}`;
-        const goalInterpretation = {
-            parsedIntent: request.query,
-            constraints: request.context?.constraints || [],
-            dependencies: memories.map(m => m.description).slice(0, 3), // Top dependencies
-            confidence: memories.length > 0 ? 0.8 : 0.6, // Higher confidence with memories
-        };
-        this.decisionTreeLog.logGoalInterpretation(goalId, goalInterpretation);
-        // 4. Build context with memories and tools
-        const context = {
-            ...request.context,
-            memories,
-            query: request.query,
-            availableTools, // Now guaranteed to be an array
-            goalId, // Include goal ID for linking tool calls
-        };
-        // 4. Execute ReAct loop (with streaming support if handler provided)
-        const generateThoughtWithStreaming = async (query, context, trajectory) => {
-            const thought = await this.generateThought(query, context, trajectory);
-            // Add thought to CoT trajectory (XAI Foundation - Research: CoT visualization)
-            if (this.cotVisualizer && cotTrajectory) {
-                this.cotVisualizer.addThought(cotTrajectory, thought.content, {
-                    reasoning: thought.reasoning,
-                });
-            }
-            // Stream thought if handler provided
-            if (request.streamHandler?.onThought) {
-                request.streamHandler.onThought(thought.content);
-            }
-            return thought;
-        };
-        const generateActionWithStreaming = async (thought, context) => {
-            const action = await this.generateAction(thought, context);
-            // Add action to CoT trajectory (XAI Foundation - Research: CoT visualization)
-            if (this.cotVisualizer && cotTrajectory) {
-                const actionDesc = action.type === 'tool'
-                    ? `${action.type}: ${action.name}`
-                    : `${action.type}: ${action.answer || 'final answer'}`;
-                this.cotVisualizer.addAction(cotTrajectory, actionDesc, {
-                    tool: action.type === 'tool' ? action.name : undefined,
-                    toolParams: action.type === 'tool' ? action.parameters : undefined,
-                    reasoning: `Action selected based on thought: ${thought.content.substring(0, 100)}`,
-                });
-            }
-            // Stream action if handler provided
-            if (request.streamHandler?.onAction) {
-                const actionDesc = `${action.type}: ${action.name}`;
-                request.streamHandler.onAction(actionDesc);
-            }
-            return action;
-        };
-        const executeActionWithStreaming = async (action) => {
-            const startTime = Date.now();
-            // Log tool rationale before execution (XAI Foundation - Research: Tool Rationale Logging)
-            if (action.type === 'tool') {
-                const toolId = `tool-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
-                const toolRationale = {
-                    toolName: action.name,
-                    parameters: action.parameters || {},
-                    reasoning: `Tool selected based on thought and available context`,
-                    alternativeTools: Array.isArray(context.availableTools)
-                        ? context.availableTools.filter((t) => t !== action.name).slice(0, 3)
-                        : [],
-                };
-                this.decisionTreeLog.logToolExecution(toolId, toolRationale, context.goalId || goalId);
-                // Store tool ID for linking observation
-                action.toolId = toolId;
-            }
-            const observation = await this.toolExecutor.executeAction(action);
-            const executionTime = Date.now() - startTime;
-            // Update tool execution with raw output and execution time (XAI Foundation - Research: Raw Output Capture)
-            if (action.type === 'tool' && action.toolId) {
-                const toolId = action.toolId;
-                // Re-log with execution results (Note: This is a simplified approach - in production, we'd update the node)
-                const toolRationaleWithResults = {
-                    toolName: action.name,
-                    parameters: action.parameters || {},
-                    reasoning: `Tool executed successfully`,
-                    executionTime,
-                    rawOutput: observation.result, // Unaltered tool result for provenance
-                };
-                this.decisionTreeLog.logToolExecution(`tool-result-${toolId}`, toolRationaleWithResults, toolId);
-            }
-            // Add observation to CoT trajectory (XAI Foundation - Research: CoT visualization)
-            if (this.cotVisualizer && cotTrajectory) {
-                const obsContent = observation.success
-                    ? String(observation.result).substring(0, 500) // Truncate for display
-                    : `Error: ${observation.error || 'Failed'}`;
-                this.cotVisualizer.addObservation(cotTrajectory, obsContent, {
-                    success: observation.success,
-                    executionTime,
-                });
-            }
-            // Stream observation result if handler provided
-            if (request.streamHandler?.onObservation) {
-                const obsDesc = observation.success
-                    ? `✓ ${String(observation.result).substring(0, 100)}`
-                    : `✗ ${observation.error || 'Failed'}`;
-                request.streamHandler.onObservation(obsDesc);
-            }
-            // Log error if execution failed (XAI Foundation - Research: Error Trace for Fault Attribution)
-            if (!observation.success && action.toolId) {
-                this.decisionTreeLog.logError(`error-${Date.now()}`, new Error(observation.error || 'Tool execution failed'), { action, observation }, action.toolId);
-                // Add error to CoT trajectory
-                if (this.cotVisualizer && cotTrajectory) {
-                    this.cotVisualizer.addError(cotTrajectory, observation.error || 'Tool execution failed', {
-                        tool: action.name,
-                        executionTime,
-                    });
-                }
-            }
-            return observation;
-        };
-        const trajectory = await reactLoop.execute(request.query, context, generateThoughtWithStreaming, generateActionWithStreaming, executeActionWithStreaming, this.isFinalAnswer.bind(this));
-        // 5. Record observation
-        if (trajectory.success) {
-            await this.memoryStream.recordObservation(`Successfully completed: ${request.query}`, { trajectory });
-        }
-        // Get complete execution tree for auditability (XAI Foundation - Research: Full auditability)
-        const executionTree = this.decisionTreeLog.getExecutionTree();
-        // Quantify uncertainty in final answer (XAI Foundation - Research: Uncertainty Quantification)
-        let uncertainty;
-        const finalAnswer = trajectory.finalAnswer || 'Max iterations reached';
-        if (this.uncertaintyQuantifier && finalAnswer) {
-            uncertainty = await this.uncertaintyQuantifier.quantifyUncertainty(request.query, finalAnswer, {
-                chunks: memories.map(m => ({ content: m.description, filepath: m.filepath || '' })),
-            });
-        }
-        // Finalize CoT trajectory (XAI Foundation - Research: CoT visualization)
-        if (this.cotVisualizer && cotTrajectory) {
-            this.cotVisualizer.completeTrajectory(cotTrajectory);
-            // Update status based on trajectory success
-            if (!trajectory.success) {
-                cotTrajectory.status = 'failed';
-            }
-        }
-        // Generate attention map from memories (XAI Foundation - Research: Attention visualization)
-        let attentionMap;
-        if (this.attentionVisualizer && memories.length > 0) {
-            attentionMap = this.attentionVisualizer.generateAttentionMap(request.query, memories.map(m => ({
-                filepath: m.filepath || '',
-                content: m.description,
-                score: m.relevanceScore || 0.5, // Default score if not available
-            })));
-        }
-        return {
-            trajectory,
-            answer: finalAnswer,
-            memoriesUsed: memories,
-            decisionTree: executionTree, // Complete audit trail
-            uncertainty, // XAI Foundation - Uncertainty quantification for transparency
-            cotTrajectory, // XAI Foundation - Chain-of-Thought visualization
-            attentionMap, // XAI Foundation - Attention visualization
-        };
-    }
-    async generateThought(query, context, trajectory) {
-        const memoryContext = context.memories?.length > 0
-            ? `\n\nPrevious experiences:\n${context.memories.map((m) => `- ${m.description}`).join('\n')}`
-            : '';
-        const trajectoryContext = trajectory.steps.length > 0
-            ? `\n\nPrevious steps:\n${trajectory.steps.map((s, i) => `${i + 1}. Thought: ${s.thought.content}\n   Action: ${s.action.name}\n   Result: ${s.observation.success ? 'Success' : 'Failed'}`).join('\n')}`
-            : '';
-        const prompt = `You are a reasoning agent. Generate a thought about how to solve this query.
-
-Query: ${query}${memoryContext}${trajectoryContext}
-
-Generate a thought that:
-1. Analyzes the current situation
-2. Considers what needs to be done next
-3. Reasons about the best approach
-
-Thought:`;
-        const response = await this.aiService.chat(prompt, [], context.memories || []);
-        return {
-            content: response,
-            reasoning: response,
-        };
-    }
-    async generateAction(thought, context) {
-        const availableTools = context.availableTools || 'No tools available';
-        const trajectory = context.trajectory || { steps: [] };
-        const trajectoryContext = trajectory.steps.length > 0
-            ? `\n\nPrevious actions:\n${trajectory.steps.map((s, i) => `${i + 1}. ${s.action.type}: ${s.action.name} - ${s.observation.success ? 'Success' : 'Failed: ' + (s.observation.error || 'Unknown')}`).join('\n')}`
-            : '';
-        const memoryContext = context.memories?.length > 0
-            ? `\n\nRelevant past experiences:\n${context.memories.slice(0, 3).map((m) => `- ${m.description}`).join('\n')}`
-            : '';
-        const prompt = `You are a reasoning agent. Based on this thought, decide the next action.
-
-Thought: ${thought.content}${memoryContext}${trajectoryContext}
-
-Available tools:
-${availableTools}
-
-CRITICAL: Respond with ONLY valid JSON in this exact format:
-{
-  "type": "tool" | "agent" | "answer",
-  "name": "tool_or_agent_name",
-  "parameters": {...}
-}
-
-Examples:
-- Use search tool: {"type": "tool", "name": "search", "parameters": {"query": "authentication"}}
-- View file: {"type": "tool", "name": "edit_view", "parameters": {"filepath": "src/auth.ts"}}
-- Final answer: {"type": "answer", "name": "final", "parameters": {"answer": "The answer is..."}}
-
-JSON only, no other text:`;
-        const response = await this.aiService.chat(prompt, [], context.memories || []);
-        try {
-            // Extract JSON - try multiple patterns
-            let jsonStr = response.trim();
-            // Remove markdown code blocks if present
-            jsonStr = jsonStr.replace(/```json\n?/g, '').replace(/```\n?/g, '').trim();
-            // Find JSON object
-            const jsonMatch = jsonStr.match(/\{[\s\S]*\}/);
-            if (jsonMatch) {
-                const parsed = JSON.parse(jsonMatch[0]);
-                if (parsed.type && parsed.name) {
-                    return {
-                        type: parsed.type,
-                        name: parsed.name,
-                        parameters: parsed.parameters || {},
-                    };
-                }
-            }
-        }
-        catch (e) {
-            // Fall through to fallback
-        }
-        // Fallback: analyze thought to determine action
-        const thoughtLower = thought.content.toLowerCase();
-        if (thoughtLower.includes('search') || thoughtLower.includes('find') || thoughtLower.includes('look')) {
-            // Extract query from thought
-            const queryMatch = thought.content.match(/(?:search|find|look for|locate)\s+(.+)/i);
-            return {
-                type: 'tool',
-                name: 'search',
-                parameters: { query: queryMatch ? queryMatch[1] : thought.content },
-            };
-        }
-        if (thoughtLower.includes('view') || thoughtLower.includes('read') || thoughtLower.includes('file')) {
-            // Try to extract filepath
-            const fileMatch = thought.content.match(/(?:view|read|file|open)\s+([^\s]+\.(ts|js|tsx|jsx|py|java|cpp))/i);
-            if (fileMatch) {
-                return {
-                    type: 'tool',
-                    name: 'edit_view',
-                    parameters: { filepath: fileMatch[1] },
-                };
-            }
-        }
-        if (thoughtLower.includes('answer') || thoughtLower.includes('complete') || thoughtLower.includes('done') || thoughtLower.includes('solution')) {
-            return {
-                type: 'answer',
-                name: 'final_answer',
-                parameters: { answer: thought.content },
-            };
-        }
-        // Default: provide answer based on thought
-        return {
-            type: 'answer',
-            name: 'direct_answer',
-            parameters: { answer: thought.content },
-        };
-    }
-    isFinalAnswer(observation) {
-        // If observation failed, not a final answer
-        if (!observation.success)
-            return false;
-        // Check if result is a meaningful string answer
-        if (typeof observation.result === 'string') {
-            const lower = observation.result.toLowerCase();
-            const result = observation.result.trim();
-            // Not a final answer if it's a tool execution message or empty
-            if (result.length === 0)
-                return false;
-            if (lower.includes('executed') || lower.includes('tool') || lower.includes('found 0')) {
-                return false;
-            }
-            // If it's a substantial answer (more than just status), it's final
-            if (result.length > 20 && !lower.includes('error')) {
-                return true;
-            }
-        }
-        // Check if it's an answer type action result
-        return false;
-    }
-}
-//# sourceMappingURL=react-orchestration-use-case.js.map

package/dist/application/use-cases/reflexion-use-case.js

@@ -1,30 +0,0 @@
-/**
- * Application Use Case: ReflexionUseCase
- * Implements Reflexion pattern - converts failures to learnings
- */
-export class ReflexionUseCase {
-    aiService;
-    memoryStream;
-    constructor(aiService, memoryStream) {
-        this.aiService = aiService;
-        this.memoryStream = memoryStream;
-    }
-    async execute(request) {
-        // Only generate reflection if failed (reward < 1)
-        if (request.reward >= 1.0) {
-            return {
-                reflection: 'Task completed successfully',
-                stored: false,
-            };
-        }
-        // Generate reflection using self-reflection model
-        const reflection = await this.aiService.generateReflection(request.trajectory, request.reward, request.errors);
-        // Store reflection in memory stream
-        await this.memoryStream.recordReflection(reflection, request.trajectory, request.reward, request.errors);
-        return {
-            reflection,
-            stored: true,
-        };
-    }
-}
-//# sourceMappingURL=reflexion-use-case.js.map

package/dist/application/workflows/deterministic-workflows.js

@@ -1,189 +0,0 @@
-/**
- * Application: Deterministic Workflows
- * Replace overloaded prompts with deterministic workflows for common patterns
- * Faster, more predictable, lower cost than ReAct for common operations
- *
- * Based on ARCHITECTURAL_DECOMPOSITION.md analysis
- */
-/**
- * Deterministic workflow for explain operations
- * Faster than ReAct - direct path with minimal LLM calls
- */
-export class ExplainWorkflow {
-    embeddingRepository;
-    aiService;
-    constructor(embeddingRepository, aiService) {
-        this.embeddingRepository = embeddingRepository;
-        this.aiService = aiService;
-    }
-    async execute(query, filepath) {
-        try {
-            // 1. Find file if not provided
-            let resolvedFilepath = filepath;
-            if (!resolvedFilepath) {
-                const foundFilepath = await this.findFile(query);
-                resolvedFilepath = foundFilepath || undefined;
-                if (!resolvedFilepath) {
-                    return {
-                        result: null,
-                        success: false,
-                        error: 'Could not find file to explain',
-                    };
-                }
-            }
-            // 2. Read file content
-            const { readFileSync } = await import('fs');
-            const { join } = await import('path');
-            const fullPath = join(process.cwd(), resolvedFilepath);
-            const content = readFileSync(fullPath, 'utf-8');
-            // 3. Generate explanation (single LLM call)
-            const explanation = await this.aiService.chat(`Explain this code file clearly and concisely:\n\n${content}\n\nFile: ${resolvedFilepath}`, [], []);
-            return {
-                result: {
-                    filepath: resolvedFilepath,
-                    explanation,
-                },
-                success: true,
-            };
-        }
-        catch (error) {
-            return {
-                result: null,
-                success: false,
-                error: error instanceof Error ? error.message : String(error),
-            };
-        }
-    }
-    async findFile(query) {
-        // Extract filepath from query or search
-        // Simplified for now
-        return null;
-    }
-}
-/**
- * Deterministic workflow for find/search operations
- * Direct semantic search + answer generation
- */
-export class FindWorkflow {
-    embeddingRepository;
-    aiService;
-    constructor(embeddingRepository, aiService) {
-        this.embeddingRepository = embeddingRepository;
-        this.aiService = aiService;
-    }
-    async execute(query, maxResults = 5) {
-        try {
-            // 1. Generate query embedding
-            const queryEmbedding = await this.aiService.embedQuery?.(query) ||
-                await this.aiService.embed(query);
-            const embedding = Array.isArray(queryEmbedding[0]) ? queryEmbedding[0] : queryEmbedding;
-            // 2. Search codebase
-            const chunks = await this.embeddingRepository.searchWithEmbedding(embedding, maxResults);
-            // 3. Generate concise answer (single LLM call)
-            const contextText = chunks
-                .slice(0, 3) // Top 3 for speed
-                .map((chunk, idx) => `[${idx + 1}] ${chunk.filepath}:\n${chunk.content.substring(0, 300)}`)
-                .join('\n\n');
-            const answer = await this.aiService.chat(`Query: ${query}\n\nRelevant code:\n${contextText}\n\nProvide a concise answer.`, [], []);
-            return {
-                result: {
-                    answer,
-                    chunks: chunks.slice(0, 3),
-                },
-                success: true,
-            };
-        }
-        catch (error) {
-            return {
-                result: null,
-                success: false,
-                error: error instanceof Error ? error.message : String(error),
-            };
-        }
-    }
-}
-/**
- * Deterministic workflow for simple edits
- * Direct edit generation without multi-step reasoning
- */
-export class SimpleEditWorkflow {
-    aiService;
-    constructor(aiService) {
-        this.aiService = aiService;
-    }
-    async execute(filepath, instruction) {
-        try {
-            // 1. Read file
-            const { readFileSync } = await import('fs');
-            const { join } = await import('path');
-            const fullPath = join(process.cwd(), filepath);
-            const content = readFileSync(fullPath, 'utf-8');
-            // 2. Generate edit (single LLM call)
-            const diff = await this.aiService.generateEdit(content, instruction, filepath);
-            return {
-                result: {
-                    filepath,
-                    diff,
-                },
-                success: true,
-            };
-        }
-        catch (error) {
-            return {
-                result: null,
-                success: false,
-                error: error instanceof Error ? error.message : String(error),
-            };
-        }
-    }
-}
-/**
- * Workflow Router
- * Routes to appropriate deterministic workflow
- */
-export class WorkflowRouter {
-    explainWorkflow;
-    findWorkflow;
-    simpleEditWorkflow;
-    constructor(explainWorkflow, findWorkflow, simpleEditWorkflow) {
-        this.explainWorkflow = explainWorkflow;
-        this.findWorkflow = findWorkflow;
-        this.simpleEditWorkflow = simpleEditWorkflow;
-    }
-    async route(request) {
-        switch (request.type) {
-            case 'explain':
-                return await this.explainWorkflow.execute(request.query);
-            case 'find':
-                return await this.findWorkflow.execute(request.query);
-            case 'simple-edit':
-                // Extract filepath and instruction
-                const { filepath, instruction } = this.parseEditQuery(request.query);
-                if (!filepath || !instruction) {
-                    return {
-                        result: null,
-                        success: false,
-                        error: 'Could not extract filepath and instruction',
-                    };
-                }
-                return await this.simpleEditWorkflow.execute(filepath, instruction);
-            case 'search':
-                return await this.findWorkflow.execute(request.query);
-            default:
-                return {
-                    result: null,
-                    success: false,
-                    error: `Unknown workflow type: ${request.type}`,
-                };
-        }
-    }
-    parseEditQuery(query) {
-        // Extract filepath and instruction from query
-        // Simplified - should use IntelligentRouter's extraction logic
-        const filepathMatch = query.match(/(?:file|in|at)\s+([^\s]+\.(ts|js|tsx|jsx|py|java|cpp|go|rs|rb|php|vue|svelte|html|css|json|yaml|yml|md|txt|sh|bash))/i);
-        const filepath = filepathMatch ? filepathMatch[1] : null;
-        const instruction = query.replace(new RegExp(filepath || '', 'gi'), '').trim();
-        return { filepath, instruction };
-    }
-}
-//# sourceMappingURL=deterministic-workflows.js.map