@defai.digital/ax-cli 2.8.0 → 3.0.1

package/dist/agent/llm-agent.js

@@ -2,6 +2,7 @@ import { LLMClient } from "../llm/client.js";
 import { getAllGrokTools, getMCPManager, initializeMCPServers, } from "../llm/tools.js";
 import { loadMCPConfig } from "../mcp/config.js";
 import { TextEditorTool, BashTool, TodoTool, SearchTool, } from "../tools/index.js";
+import { BashOutputTool } from "../tools/bash-output.js";
 import { EventEmitter } from "events";
 import { AGENT_CONFIG } from "../constants.js";
 import { createTokenCounter } from "../utils/token-counter.js";
@@ -13,10 +14,13 @@ import { getUsageTracker } from "../utils/usage-tracker.js";
 import { extractErrorMessage } from "../utils/error-handler.js";
 import { getCheckpointManager } from "../checkpoint/index.js";
 import { SubagentOrchestrator } from "./subagent-orchestrator.js";
+import { getTaskPlanner, isComplexRequest, } from "../planner/index.js";
+import { PLANNER_CONFIG } from "../constants.js";
 export class LLMAgent extends EventEmitter {
     llmClient;
     textEditor;
     bash;
+    bashOutput;
     todoTool;
     search;
     chatHistory = [];
@@ -28,6 +32,9 @@ export class LLMAgent extends EventEmitter {
     recentToolCalls = new Map(); // Track recent tool calls to detect loops
     checkpointManager;
     subagentOrchestrator;
+    taskPlanner;
+    currentPlan = null;
+    planningEnabled = PLANNER_CONFIG.ENABLED;
     constructor(apiKey, baseURL, model, maxToolRounds) {
         super();
         const manager = getSettingsManager();
@@ -40,12 +47,14 @@ export class LLMAgent extends EventEmitter {
         this.llmClient = new LLMClient(apiKey, modelToUse, baseURL);
         this.textEditor = new TextEditorTool();
         this.bash = new BashTool();
+        this.bashOutput = new BashOutputTool();
         this.todoTool = new TodoTool();
         this.search = new SearchTool();
         this.tokenCounter = createTokenCounter(modelToUse);
         this.contextManager = new ContextManager({ model: modelToUse });
         this.checkpointManager = getCheckpointManager();
         this.subagentOrchestrator = new SubagentOrchestrator({ maxConcurrentAgents: 5 });
+        this.taskPlanner = getTaskPlanner();
         // Wire up checkpoint callback for automatic checkpoint creation
         this.textEditor.setCheckpointCallback(async (files, description) => {
             await this.checkpointManager.createCheckpoint({
@@ -185,8 +194,7 @@ export class LLMAgent extends EventEmitter {
             // Clean up old entries (keep only last N unique calls)
             if (this.recentToolCalls.size > AGENT_CONFIG.MAX_RECENT_TOOL_CALLS) {
                 const firstKey = this.recentToolCalls.keys().next().value;
-                // Map.keys().next().value is guaranteed to exist when size > 0, but TypeScript doesn't know this
-                if (firstKey) {
+                if (firstKey !== undefined) {
                     this.recentToolCalls.delete(firstKey);
                 }
             }
@@ -238,6 +246,509 @@ export class LLMAgent extends EventEmitter {
             return true;
         return false;
     }
+    // ============================================================================
+    // Multi-Phase Planning Integration
+    // ============================================================================
+    /**
+     * Check if a request should trigger multi-phase planning
+     */
+    shouldCreatePlan(message) {
+        if (!this.planningEnabled)
+            return false;
+        return isComplexRequest(message);
+    }
+    /**
+     * Get the current plan if any
+     */
+    getCurrentPlan() {
+        return this.currentPlan;
+    }
+    /**
+     * Execute a single phase using the LLM
+     */
+    async executePhase(phase, context) {
+        const startTime = Date.now();
+        const startTokens = this.tokenCounter.countMessageTokens(this.messages);
+        const filesModified = [];
+        let lastAssistantContent = "";
+        // Emit phase started event
+        this.emit("phase:started", { phase, planId: context.planId });
+        try {
+            // Build phase-specific prompt
+            const phasePrompt = this.buildPhasePrompt(phase, context);
+            // Execute through normal message processing (without recursively planning)
+            const savedPlanningState = this.planningEnabled;
+            this.planningEnabled = false; // Temporarily disable planning for phase execution
+            // Add phase context to messages
+            this.messages.push({
+                role: "user",
+                content: phasePrompt,
+            });
+            // Execute using the standard tool loop
+            const tools = await getAllGrokTools();
+            let toolRounds = 0;
+            const maxPhaseRounds = Math.min(this.maxToolRounds, 50); // Limit per phase
+            while (toolRounds < maxPhaseRounds) {
+                const response = await this.llmClient.chat(this.messages, tools);
+                const assistantMessage = response.choices[0]?.message;
+                if (!assistantMessage)
+                    break;
+                // Capture the assistant's content for phase output
+                if (assistantMessage.content) {
+                    lastAssistantContent = assistantMessage.content;
+                }
+                // Add to messages
+                this.messages.push({
+                    role: "assistant",
+                    content: assistantMessage.content || "",
+                    tool_calls: assistantMessage.tool_calls,
+                });
+                // Check for tool calls
+                if (!assistantMessage.tool_calls || assistantMessage.tool_calls.length === 0) {
+                    break; // No more tool calls, phase complete
+                }
+                toolRounds++;
+                // Execute tools and track file modifications
+                for (const toolCall of assistantMessage.tool_calls) {
+                    const result = await this.executeTool(toolCall);
+                    // Track file modifications from text_editor tool
+                    if (toolCall.function.name === "text_editor" ||
+                        toolCall.function.name === "str_replace_editor") {
+                        try {
+                            const args = JSON.parse(toolCall.function.arguments);
+                            if (args.path && result.success) {
+                                if (!filesModified.includes(args.path)) {
+                                    filesModified.push(args.path);
+                                }
+                            }
+                        }
+                        catch {
+                            // Ignore parse errors
+                        }
+                    }
+                    this.messages.push({
+                        role: "tool",
+                        tool_call_id: toolCall.id,
+                        content: result.output || result.error || "No output",
+                    });
+                }
+            }
+            // Restore planning state
+            this.planningEnabled = savedPlanningState;
+            // Prune context if configured
+            if (PLANNER_CONFIG.PRUNE_AFTER_PHASE) {
+                if (this.contextManager.shouldPrune(this.messages, this.tokenCounter)) {
+                    this.messages = this.contextManager.pruneMessages(this.messages, this.tokenCounter);
+                }
+            }
+            const endTokens = this.tokenCounter.countMessageTokens(this.messages);
+            const duration = Date.now() - startTime;
+            // Build meaningful output
+            const output = lastAssistantContent ||
+                `Phase "${phase.name}" completed (${toolRounds} tool rounds, ${filesModified.length} files modified)`;
+            // Emit phase completed event
+            this.emit("phase:completed", {
+                phase,
+                planId: context.planId,
+                result: { success: true, output, filesModified }
+            });
+            return {
+                phaseId: phase.id,
+                success: true,
+                output,
+                duration,
+                tokensUsed: endTokens - startTokens,
+                filesModified,
+                wasRetry: false,
+                retryAttempt: 0,
+            };
+        }
+        catch (error) {
+            const duration = Date.now() - startTime;
+            const errorMessage = extractErrorMessage(error);
+            // Emit phase failed event
+            this.emit("phase:failed", {
+                phase,
+                planId: context.planId,
+                error: errorMessage
+            });
+            return {
+                phaseId: phase.id,
+                success: false,
+                error: errorMessage,
+                duration,
+                tokensUsed: 0,
+                filesModified,
+                wasRetry: false,
+                retryAttempt: 0,
+            };
+        }
+    }
+    /**
+     * Build a prompt for phase execution
+     */
+    buildPhasePrompt(phase, context) {
+        let prompt = `## Phase ${phase.index + 1}: ${phase.name}\n\n`;
+        prompt += `**Objective:** ${phase.description}\n\n`;
+        if (phase.objectives.length > 0) {
+            prompt += "**Tasks to complete:**\n";
+            for (const obj of phase.objectives) {
+                prompt += `- ${obj}\n`;
+            }
+            prompt += "\n";
+        }
+        if (context.completedPhases.length > 0) {
+            prompt += `**Previously completed phases:** ${context.completedPhases.join(", ")}\n\n`;
+        }
+        prompt += `**Original request:** ${context.originalRequest}\n\n`;
+        prompt += "Please complete this phase. Focus only on the objectives listed above.";
+        return prompt;
+    }
+    /**
+     * Generate and execute a plan for a complex request
+     * Uses TodoWrite for Claude Code-style seamless progress display
+     */
+    async *processWithPlanning(message) {
+        // Add user message to history
+        const userEntry = {
+            type: "user",
+            content: message,
+            timestamp: new Date(),
+        };
+        this.chatHistory.push(userEntry);
+        this.messages.push({ role: "user", content: message });
+        // Silent mode: no explicit banner, just start working
+        if (!PLANNER_CONFIG.SILENT_MODE) {
+            yield {
+                type: "content",
+                content: "📋 **Analyzing request and creating execution plan...**\n\n",
+            };
+        }
+        try {
+            // Generate plan using LLM
+            const plan = await this.taskPlanner.generatePlan(message, async (systemPrompt, userPrompt) => {
+                const planMessages = [
+                    { role: "system", content: systemPrompt },
+                    { role: "user", content: userPrompt },
+                ];
+                const response = await this.llmClient.chat(planMessages, []);
+                return response.choices[0]?.message?.content || "";
+            }, {
+                projectType: "typescript", // Could be detected
+            });
+            if (!plan) {
+                yield {
+                    type: "content",
+                    content: "Could not generate a plan. Processing as single request...\n\n",
+                };
+                // Fall back to normal processing - disable planning and retry
+                this.planningEnabled = false;
+                yield* this.processUserMessageStreamInternal(message);
+                this.planningEnabled = true;
+                return;
+            }
+            this.currentPlan = plan;
+            // Emit plan created event
+            this.emit("plan:created", { plan });
+            // Create TodoWrite items for phases (Claude Code-style progress)
+            if (PLANNER_CONFIG.SILENT_MODE) {
+                // Use TodoWrite to show phases as natural todo items
+                const todoItems = plan.phases.map((phase, index) => ({
+                    id: `phase-${index}`,
+                    content: phase.name,
+                    status: index === 0 ? "in_progress" : "pending",
+                    priority: phase.riskLevel === "high" ? "high" :
+                        phase.riskLevel === "low" ? "low" : "medium",
+                }));
+                try {
+                    await this.todoTool.createTodoList(todoItems);
+                }
+                catch (todoError) {
+                    // TodoWrite failure is non-critical, continue execution
+                    console.warn("TodoWrite create failed:", extractErrorMessage(todoError));
+                }
+            }
+            else {
+                // Display explicit plan summary
+                yield {
+                    type: "content",
+                    content: this.formatPlanSummary(plan),
+                };
+            }
+            // Execute phases one by one with progress updates
+            const phaseResults = [];
+            let totalTokensUsed = 0;
+            const planStartTime = Date.now();
+            for (let i = 0; i < plan.phases.length; i++) {
+                const phase = plan.phases[i];
+                plan.currentPhaseIndex = i;
+                if (PLANNER_CONFIG.SILENT_MODE) {
+                    // Update TodoWrite: mark current phase as in_progress
+                    try {
+                        await this.todoTool.updateTodoList([{
+                                id: `phase-${i}`,
+                                status: "in_progress",
+                            }]);
+                    }
+                    catch { /* TodoWrite update is non-critical */ }
+                }
+                else {
+                    // Show explicit phase starting banner
+                    yield {
+                        type: "content",
+                        content: `\n**⏳ Phase ${i + 1}/${plan.phases.length}: ${phase.name}**\n`,
+                    };
+                }
+                // Execute the phase
+                const context = {
+                    planId: plan.id,
+                    originalRequest: message,
+                    completedPhases: phaseResults.filter(r => r.success).map(r => r.phaseId),
+                };
+                const result = await this.executePhase(phase, context);
+                phaseResults.push(result);
+                totalTokensUsed += result.tokensUsed;
+                // Report phase result
+                if (result.success) {
+                    if (PLANNER_CONFIG.SILENT_MODE) {
+                        // Update TodoWrite: mark phase as completed
+                        try {
+                            await this.todoTool.updateTodoList([{
+                                    id: `phase-${i}`,
+                                    status: "completed",
+                                }]);
+                        }
+                        catch { /* TodoWrite update is non-critical */ }
+                    }
+                    else {
+                        yield {
+                            type: "content",
+                            content: `✓ Phase ${i + 1} completed (${Math.ceil(result.duration / 1000)}s)\n`,
+                        };
+                        if (result.filesModified.length > 0) {
+                            yield {
+                                type: "content",
+                                content: `  Files modified: ${result.filesModified.join(", ")}\n`,
+                            };
+                        }
+                    }
+                }
+                else {
+                    if (PLANNER_CONFIG.SILENT_MODE) {
+                        // Update TodoWrite: mark phase as failed (update content to show failure)
+                        try {
+                            await this.todoTool.updateTodoList([{
+                                    id: `phase-${i}`,
+                                    status: "completed", // Mark as done even if failed
+                                    content: `${phase.name} (failed)`,
+                                }]);
+                        }
+                        catch { /* TodoWrite update is non-critical */ }
+                    }
+                    else {
+                        yield {
+                            type: "content",
+                            content: `✕ Phase ${i + 1} failed: ${result.error}\n`,
+                        };
+                    }
+                    // Continue with next phase unless abort strategy
+                    if (phase.fallbackStrategy === "abort") {
+                        if (!PLANNER_CONFIG.SILENT_MODE) {
+                            yield {
+                                type: "content",
+                                content: `\n⚠️ Plan aborted due to phase failure.\n`,
+                            };
+                        }
+                        break;
+                    }
+                }
+            }
+            const totalDuration = Date.now() - planStartTime;
+            // Build final result
+            const successfulPhases = phaseResults.filter(r => r.success);
+            const failedPhases = phaseResults.filter(r => !r.success);
+            const allFilesModified = [...new Set(phaseResults.flatMap(r => r.filesModified))];
+            const summary = successfulPhases.length === phaseResults.length
+                ? `All ${phaseResults.length} phases completed successfully. ${allFilesModified.length} files modified.`
+                : `${successfulPhases.length}/${phaseResults.length} phases completed. ${failedPhases.length} failed.`;
+            const warnings = [];
+            for (const result of failedPhases) {
+                warnings.push(`Phase ${result.phaseId} failed: ${result.error || "Unknown error"}`);
+            }
+            const planResult = {
+                planId: plan.id,
+                success: phaseResults.every(r => r.success),
+                phaseResults,
+                totalDuration,
+                totalTokensUsed,
+                summary,
+                warnings,
+            };
+            // Report final results (silent mode shows minimal output)
+            if (!PLANNER_CONFIG.SILENT_MODE) {
+                yield {
+                    type: "content",
+                    content: this.formatPlanResult(planResult),
+                };
+            }
+            else {
+                // Brief completion message in silent mode
+                const successCount = phaseResults.filter(r => r.success).length;
+                if (successCount === phaseResults.length) {
+                    yield {
+                        type: "content",
+                        content: `\n✓ All ${phaseResults.length} tasks completed successfully.\n`,
+                    };
+                }
+                else {
+                    yield {
+                        type: "content",
+                        content: `\n⚠️ ${successCount}/${phaseResults.length} tasks completed. Check todo list for details.\n`,
+                    };
+                }
+            }
+            // Emit plan completed event
+            this.emit("plan:completed", { plan, result: planResult });
+            this.currentPlan = null;
+        }
+        catch (error) {
+            // Defensive error extraction to prevent nested failures
+            let errorMsg;
+            try {
+                errorMsg = extractErrorMessage(error);
+            }
+            catch {
+                errorMsg = String(error) || "Unknown error";
+            }
+            yield {
+                type: "content",
+                content: `\n⚠️ Plan execution error: ${errorMsg}\n`,
+            };
+            this.emit("plan:failed", { error: errorMsg });
+            this.currentPlan = null;
+        }
+    }
+    /**
+     * Internal streaming processor (used when planning falls back)
+     * Executes the core message processing loop without planning
+     */
+    async *processUserMessageStreamInternal(message) {
+        // Reset tool call tracking for new message
+        this.resetToolCallTracking();
+        // Prepare user message and get input tokens
+        const inputTokensRef = { value: this.prepareUserMessageForStreaming(message) };
+        yield {
+            type: "token_count",
+            tokenCount: inputTokensRef.value,
+        };
+        // Yield context warnings if needed
+        yield* this.yieldContextWarnings();
+        const maxToolRounds = this.maxToolRounds;
+        let toolRounds = 0;
+        const totalOutputTokensRef = { value: 0 };
+        const lastTokenUpdateRef = { value: 0 };
+        try {
+            // Agent loop - continue until no more tool calls or max rounds reached
+            while (toolRounds < maxToolRounds) {
+                // Check if operation was cancelled
+                if (this.isCancelled()) {
+                    yield* this.yieldCancellation();
+                    return;
+                }
+                // Load tools safely
+                const tools = await this.loadToolsSafely();
+                // Create chat stream
+                const stream = this.llmClient.chatStream(this.messages, tools, {
+                    searchOptions: this.isGrokModel() && this.shouldUseSearchFor(message)
+                        ? { search_parameters: { mode: "auto" } }
+                        : { search_parameters: { mode: "off" } }
+                });
+                // Process streaming chunks
+                const chunkGen = this.processStreamingChunks(stream, inputTokensRef.value, lastTokenUpdateRef, totalOutputTokensRef);
+                let streamResult;
+                for await (const chunk of chunkGen) {
+                    if ('accumulated' in chunk) {
+                        streamResult = chunk;
+                    }
+                    else {
+                        yield chunk;
+                    }
+                }
+                if (!streamResult) {
+                    continue;
+                }
+                // Add assistant message to history
+                this.addAssistantMessage(streamResult.accumulated);
+                // Handle tool calls if present
+                if (streamResult.accumulated.tool_calls?.length > 0) {
+                    toolRounds++;
+                    // Check for repetitive tool calls (loop detection)
+                    const hasRepetitiveCall = streamResult.accumulated.tool_calls.some((tc) => this.isRepetitiveToolCall(tc));
+                    if (hasRepetitiveCall) {
+                        yield {
+                            type: "content",
+                            content: "\n\n⚠️ Detected repetitive tool calls. Stopping to prevent infinite loop.\n",
+                        };
+                        break;
+                    }
+                    yield* this.executeToolCalls(streamResult.accumulated.tool_calls, streamResult.yielded, inputTokensRef, totalOutputTokensRef);
+                    // Continue loop to get next response
+                }
+                else {
+                    // No tool calls, we're done
+                    break;
+                }
+            }
+        }
+        catch (error) {
+            const errorMsg = extractErrorMessage(error);
+            yield {
+                type: "content",
+                content: `\n⚠️ Error processing message: ${errorMsg}\n`,
+            };
+        }
+        // Final token count
+        yield {
+            type: "token_count",
+            tokenCount: inputTokensRef.value + totalOutputTokensRef.value,
+        };
+        yield { type: "done" };
+    }
+    /**
+     * Format plan summary for display
+     */
+    formatPlanSummary(plan) {
+        let output = `**📋 Execution Plan Created**\n\n`;
+        output += `**Request:** ${plan.originalPrompt.slice(0, 100)}${plan.originalPrompt.length > 100 ? "..." : ""}\n\n`;
+        output += `**Phases (${plan.phases.length}):**\n`;
+        for (const phase of plan.phases) {
+            const riskIcon = phase.riskLevel === "high" ? "⚠️" : phase.riskLevel === "medium" ? "△" : "";
+            output += `  ${phase.index + 1}. ${phase.name} ${riskIcon}\n`;
+        }
+        output += `\n**Estimated Duration:** ~${Math.ceil(plan.estimatedDuration / 60000)} min\n\n`;
+        output += "---\n\n";
+        return output;
+    }
+    /**
+     * Format plan result for display
+     */
+    formatPlanResult(result) {
+        let output = "\n---\n\n**📋 Plan Execution Complete**\n\n";
+        const successful = result.phaseResults.filter((r) => r.success).length;
+        const failed = result.phaseResults.filter((r) => !r.success).length;
+        output += `**Results:** ${successful}/${result.phaseResults.length} phases successful`;
+        if (failed > 0) {
+            output += ` (${failed} failed)`;
+        }
+        output += "\n";
+        if (result.totalDuration) {
+            output += `**Duration:** ${Math.ceil(result.totalDuration / 1000)}s\n`;
+        }
+        if (result.totalTokensUsed) {
+            output += `**Tokens Used:** ${result.totalTokensUsed.toLocaleString()}\n`;
+        }
+        return output;
+    }
     async processUserMessage(message) {
         // Reset tool call tracking for new message
         this.resetToolCallTracking();
@@ -687,6 +1198,13 @@ export class LLMAgent extends EventEmitter {
     async *processUserMessageStream(message) {
         // Create new abort controller for this request
         this.abortController = new AbortController();
+        // Check if this is a complex request that should use multi-phase planning
+        if (this.shouldCreatePlan(message)) {
+            // Delegate to planning processor
+            yield* this.processWithPlanning(message);
+            yield { type: "done" };
+            return;
+        }
         // Reset tool call tracking for new message
         this.resetToolCallTracking();
         // Prepare user message and get input tokens
@@ -866,7 +1384,12 @@ export class LLMAgent extends EventEmitter {
                 case "str_replace_editor":
                     return await this.textEditor.strReplace(args.path, args.old_str, args.new_str, args.replace_all);
                 case "bash":
-                    return await this.bash.execute(args.command);
+                    return await this.bash.execute(args.command, {
+                        background: args.background,
+                        timeout: args.timeout,
+                    });
+                case "bash_output":
+                    return await this.bashOutput.execute(args.task_id, args.wait, args.timeout);
                 case "create_todo_list":
                     return await this.todoTool.createTodoList(args.todos);
                 case "update_todo_list":
@@ -963,6 +1486,19 @@ export class LLMAgent extends EventEmitter {
     async executeBashCommand(command) {
         return await this.bash.execute(command);
     }
+    /**
+     * Check if a bash command is currently executing
+     */
+    isBashExecuting() {
+        return this.bash.isExecuting();
+    }
+    /**
+     * Move currently running bash command to background
+     * Returns task ID if successful, null otherwise
+     */
+    moveBashToBackground() {
+        return this.bash.moveToBackground();
+    }
     getCurrentModel() {
         return this.llmClient.getCurrentModel();
     }