codehere 0.2.2 → 0.3.0-rc.2

package/dist/agents/orchestrator-model-driven.js

@@ -1,141 +0,0 @@
-/**
- * Model-Driven Orchestrator
- * Uses minimal prompts to let model make routing decisions
- * Following Claude Code approach: minimal prompts, model-driven decisions
- */
-import { BaseAgent } from './base.js';
-import { chatWithContext } from '../chat.js';
-import { getToolRegistry } from '../tools/registry.js';
-import { ToolExecutor } from '../tools/executor.js';
-import { parseToolCalls } from '../tools/parser.js';
-export class ModelDrivenOrchestratorAgent extends BaseAgent {
-    name = 'orchestrator';
-    description = 'Model-driven orchestrator that lets AI choose agents and tools';
-    capabilities = ['routing', 'model-driven-decisions', 'tool-execution'];
-    canCall = [];
-    registry;
-    toolExecutor;
-    constructor(registry) {
-        super();
-        this.registry = registry;
-        this.agentRegistry = registry;
-        this.toolExecutor = new ToolExecutor();
-    }
-    /**
-     * Handle query - let model choose the agent or tool
-     */
-    async handle(request) {
-        // Get list of available agents
-        const availableAgents = this.getAvailableAgents();
-        // Get list of available tools
-        const toolRegistry = getToolRegistry();
-        const availableTools = toolRegistry.getAll();
-        // Let model choose agent or tool
-        const prompt = this.buildPrompt(request.query, availableAgents, availableTools);
-        try {
-            const response = await this.getLLMResponse(prompt);
-            // 1. Check for tool calls first
-            const toolCalls = parseToolCalls(response);
-            if (toolCalls.length > 0) {
-                console.log(`🛠️ Orchestrator: Executing ${toolCalls.length} tool call(s)`);
-                const results = await this.toolExecutor.executeAll(toolCalls);
-                // Check if any tool failed
-                const failures = results.filter(r => !r.success);
-                if (failures.length > 0) {
-                    return {
-                        success: false,
-                        error: `Tool execution failed: ${failures.map(f => f.error).join(', ')}`,
-                        message: `I tried to execute some tools but encountered errors:\n${failures.map(f => `- ${f.tool}: ${f.error}`).join('\n')}`,
-                    };
-                }
-                // Format tool results
-                const output = results.map(r => `Tool '${r.tool}' executed successfully:\n${JSON.stringify(r.result, null, 2)}`).join('\n\n');
-                return {
-                    success: true,
-                    message: output,
-                    metadata: { toolResults: results }
-                };
-            }
-            // 2. If no tools, check for agent selection
-            const selectedAgentName = response.trim().split('\n')[0].toLowerCase(); // Simple heuristic
-            const selectedAgent = this.registry.get(selectedAgentName);
-            if (selectedAgent) {
-                console.log(`🤖 Orchestrator: Routing to ${selectedAgentName}`);
-                return await selectedAgent.handle(request);
-            }
-            // 3. Fallback: Treat response as direct answer
-            return {
-                success: true,
-                message: response
-            };
-        }
-        catch (err) {
-            return {
-                success: false,
-                error: err instanceof Error ? err.message : String(err),
-                message: await this.generateError(request.query, err instanceof Error ? err.message : String(err)),
-                suggestions: await this.generateSuggestions(request.query),
-            };
-        }
-    }
-    /**
-     * Get LLM response (can be overridden for testing)
-     */
-    async getLLMResponse(prompt) {
-        return chatWithContext(prompt, []);
-    }
-    /**
-     * Build prompt for model
-     */
-    buildPrompt(query, agents, tools) {
-        const agentList = agents.map(a => `- ${a.name}: ${a.description}`).join('\n');
-        const toolList = tools.map(t => `- ${t.name}: ${t.modelDescription}`).join('\n');
-        return `Query: "${query}"
-
-Available Agents:
-${agentList}
-
-Available Tools:
-${toolList}
-
-INSTRUCTIONS:
-1. If a specific agent is best suited, respond with JUST the agent name.
-2. If a tool can solve this directly (e.g. running a command, editing a file), use the tool.
-3. If you can answer directly, provide the answer.
-
-What should be done?`;
-    }
-    /**
-     * Get available agents with descriptions
-     */
-    getAvailableAgents() {
-        const agents = [];
-        const allAgents = this.registry.getAll();
-        for (const agent of allAgents) {
-            if (agent.name !== 'orchestrator') { // Don't include self
-                agents.push({
-                    name: agent.name,
-                    description: agent.description || `Handles ${agent.name} requests`,
-                });
-            }
-        }
-        return agents;
-    }
-    /**
-     * Generate contextual error message
-     */
-    async generateError(query, error) {
-        return `An error occurred while processing your query: ${error}`;
-    }
-    /**
-     * Generate contextual suggestions
-     */
-    async generateSuggestions(query) {
-        return [
-            'Try rephrasing your query',
-            'Be more specific about what you want',
-            'Check if all required information is provided',
-        ];
-    }
-}
-//# sourceMappingURL=orchestrator-model-driven.js.map

package/dist/agents/react-orchestrator-agent.js

@@ -1,54 +0,0 @@
-/**
- * ReAct Orchestrator Agent
- * Uses ReAct loop for reasoning and tool execution
- */
-import { BaseAgent } from './base.js';
-import { container } from '../application/services/dependency-container.js';
-import { getToolRegistry } from '../tools/registry.js';
-export class ReActOrchestratorAgent extends BaseAgent {
-    name = 'react-orchestrator';
-    description = 'ReAct-based orchestrator with iterative reasoning';
-    capabilities = ['react-reasoning', 'tool-execution', 'memory-integration'];
-    canCall = [];
-    async handle(request) {
-        const useCase = container.reactOrchestrationUseCase;
-        const toolRegistry = getToolRegistry();
-        // Build context with available tools
-        const context = {
-            availableTools: toolRegistry.getToolList(),
-            availableAgents: this.getAvailableAgents(),
-        };
-        try {
-            const result = await useCase.execute({
-                query: request.query,
-                context,
-                maxTurns: 20,
-            });
-            // Record observation in memory
-            if (result.trajectory.success) {
-                await container.memoryStreamService.recordObservation(`Successfully handled: ${request.query}`, { trajectory: result.trajectory });
-            }
-            return {
-                success: result.trajectory.success,
-                message: result.answer,
-                metadata: {
-                    trajectory: result.trajectory,
-                    memoriesUsed: result.memoriesUsed.length,
-                    steps: result.trajectory.steps.length,
-                },
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : String(error),
-                message: `ReAct orchestration failed: ${error instanceof Error ? error.message : String(error)}`,
-            };
-        }
-    }
-    getAvailableAgents() {
-        // Return list of available agent names
-        return ['editor', 'search', 'code-analysis', 'scaffold', 'general'];
-    }
-}
-//# sourceMappingURL=react-orchestrator-agent.js.map