orquesta-cli 0.1.12

package/src/orchestration/plan-executor.ts

@@ -0,0 +1,652 @@
+/**
+ * Plan Executor
+ *
+ * Core business logic for Plan & Execute workflow
+ * Contains pure logic without React dependencies
+ *
+ * All execution is planning-based (Direct Mode removed)
+ */
+
+import { Message, TodoItem } from '../types/index.js';
+import { LLMClient } from '../core/llm/llm-client.js';
+import { PlanningLLM } from '../agents/planner/index.js';
+import { sessionManager } from '../core/session/session-manager.js';
+import {
+  CompactManager,
+  CompactResult,
+  contextTracker,
+  buildCompactedMessages,
+} from '../core/compact/index.js';
+import { configManager } from '../core/config/config-manager.js';
+import {
+  setTodoWriteCallback,
+  clearTodoCallbacks,
+  TodoInput,
+} from '../tools/llm/simple/todo-tools.js';
+import {
+  setGetTodosCallback,
+  setFinalResponseCallback,
+  clearFinalResponseCallbacks,
+} from '../tools/llm/simple/final-response-tool.js';
+import {
+  setDocsSearchLLMClientGetter,
+  clearDocsSearchLLMClientGetter,
+} from '../tools/llm/simple/docs-search-agent-tool.js';
+import {
+  emitPlanCreated,
+  emitTodoStart,
+  emitTodoComplete,
+  emitTodoFail,
+  emitCompact,
+  emitAssistantResponse,
+} from '../tools/llm/simple/file-tools.js';
+import { toolRegistry } from '../tools/registry.js';
+import { PLAN_EXECUTE_SYSTEM_PROMPT as PLAN_PROMPT } from '../prompts/system/plan-execute.js';
+import { GIT_COMMIT_RULES } from '../prompts/shared/git-rules.js';
+import { logger } from '../utils/logger.js';
+import { getStreamLogger } from '../utils/json-stream-logger.js';
+import { detectGitRepo } from '../utils/git-utils.js';
+
+import type { StateCallbacks } from './types.js';
+import { formatErrorMessage, buildTodoContext, findActiveTodo, getTodoStats } from './utils.js';
+
+/**
+ * Build system prompt with conditional Git rules
+ * Git rules are only added when .git folder exists in working directory
+ */
+function buildSystemPrompt(): string {
+  const isGitRepo = detectGitRepo();
+  if (isGitRepo) {
+    return `${PLAN_PROMPT}\n\n${GIT_COMMIT_RULES}`;
+  }
+  return PLAN_PROMPT;
+}
+
+/**
+ * Plan Executor
+ *
+ * Execute all requests based on planning
+ * chatCompletionWithTools handles tool loop internally, no external loop needed
+ */
+export class PlanExecutor {
+  private currentLLMClient: LLMClient | null = null;
+
+  constructor() {
+    // No configuration needed - chatCompletionWithTools handles the loop internally
+  }
+
+  /**
+   * Plan Mode execution (TODO-based execution)
+   * Performs Planning and Docs Search Decision in parallel
+   */
+  async executePlanMode(
+    userMessage: string,
+    llmClient: LLMClient,
+    messages: Message[],
+    isInterruptedRef: { current: boolean },
+    callbacks: StateCallbacks
+  ): Promise<void> {
+    const planningStartTime = Date.now();
+    const streamLogger = getStreamLogger();
+
+    logger.enter('PlanExecutor.executePlanMode', { messageLength: userMessage.length });
+
+    // Log user input (for Ctrl+O LogBrowser chat category)
+    streamLogger?.logUserInput(userMessage);
+
+    // Log planning start
+    streamLogger?.logPlanningStart(userMessage, {
+      messageCount: messages.length,
+      model: configManager.getCurrentModel()?.name,
+    });
+
+    // Store LLM client for docs search agent tool
+    this.currentLLMClient = llmClient;
+    setDocsSearchLLMClientGetter(() => this.currentLLMClient);
+
+    // Reset state - clear previous TODOs when starting new planning
+    isInterruptedRef.current = false;
+    callbacks.setIsInterrupted(false);
+    callbacks.setTodos([]);  // Clear previous TODOs at start
+    callbacks.setExecutionPhase('planning');
+    callbacks.setCurrentActivity('Planning tasks');
+
+    // Local TODO state
+    let currentTodos: TodoItem[] = [];
+
+    try {
+      if (isInterruptedRef.current) {
+        throw new Error('INTERRUPTED');
+      }
+
+      let currentMessages = messages;
+
+      // 1. Generate TODO list with parallel docs search decision
+      callbacks.setCurrentActivity('Thinking');
+      const planningLLM = new PlanningLLM(llmClient);
+
+      // Connect ask-user callback for planning phase clarification
+      if (callbacks.askUser) {
+        planningLLM.setAskUserCallback(callbacks.askUser);
+      }
+
+      const planResult = await planningLLM.generateTODOListWithDocsDecision(userMessage, currentMessages);
+
+      // Add clarification messages to history (ask_to_user Q&A from planning phase)
+      if (planResult.clarificationMessages?.length) {
+        currentMessages = [...currentMessages, ...planResult.clarificationMessages];
+        callbacks.setMessages([...currentMessages]);
+        logger.flow('Added planning clarification messages to history', {
+          count: planResult.clarificationMessages.length,
+        });
+      }
+
+      // Check for direct response (no planning needed)
+      if (planResult.directResponse) {
+        logger.flow('Direct response - no execution needed');
+
+        // Log planning end (direct response)
+        streamLogger?.logPlanningEnd(0, [], true, Date.now() - planningStartTime);
+
+        // Check if last message is already the same user request (avoid duplicate)
+        const lastMsg = currentMessages[currentMessages.length - 1];
+        const needsUserMessage = !(lastMsg?.role === 'user' && lastMsg?.content === userMessage);
+        const updatedMessages: Message[] = needsUserMessage
+          ? [
+              ...currentMessages,
+              { role: 'user' as const, content: userMessage },
+              { role: 'assistant' as const, content: planResult.directResponse }
+            ]
+          : [
+              ...currentMessages,
+              { role: 'assistant' as const, content: planResult.directResponse }
+            ];
+        // Emit to UI log
+        emitAssistantResponse(planResult.directResponse);
+        // Update messages state
+        callbacks.setMessages([...updatedMessages]);
+        sessionManager.autoSaveCurrentSession(updatedMessages);
+        callbacks.setExecutionPhase('idle');
+        logger.exit('PlanExecutor.executePlanMode', { directResponse: true });
+        return;
+      }
+
+      currentTodos = planResult.todos;
+
+      // Log planning end (TODOs created)
+      streamLogger?.logPlanningEnd(
+        currentTodos.length,
+        currentTodos.map(t => ({ id: t.id, title: t.title, status: t.status })),
+        false,
+        Date.now() - planningStartTime
+      );
+
+      logger.vars(
+        { name: 'todoCount', value: currentTodos.length },
+        { name: 'docsSearchNeeded', value: planResult.docsSearchNeeded }
+      );
+
+      // Update UI with TODOs
+      callbacks.setTodos(currentTodos);
+      emitPlanCreated(currentTodos.map(t => t.title));
+
+      const planMessage = planResult.docsSearchNeeded
+        ? `📋 Created ${currentTodos.length} tasks (including docs search). Starting execution...`
+        : `📋 Created ${currentTodos.length} tasks. Starting execution...`;
+      // Check if last message is already the same user request (avoid duplicate)
+      const lastMsgForPlan = currentMessages[currentMessages.length - 1];
+      const needsUserMessageForPlan = !(lastMsgForPlan?.role === 'user' && lastMsgForPlan?.content === userMessage);
+      currentMessages = needsUserMessageForPlan
+        ? [
+            ...currentMessages,
+            { role: 'user' as const, content: userMessage },
+            { role: 'assistant' as const, content: planMessage }
+          ]
+        : [
+            ...currentMessages,
+            { role: 'assistant' as const, content: planMessage }
+          ];
+      callbacks.setMessages(currentMessages);
+
+      // 2. Setup TODO callbacks
+      this.setupTodoCallbacks(currentTodos, callbacks, (updated) => {
+        currentTodos = updated;
+      });
+
+      // 3. Execute (single call - chatCompletionWithTools handles loop internally)
+      callbacks.setExecutionPhase('executing');
+      const tools = toolRegistry.getLLMToolDefinitions();
+
+      // Prepare system message (with conditional Git rules if .git exists)
+      const hasSystemMessage = currentMessages.some(m => m.role === 'system');
+      if (!hasSystemMessage) {
+        currentMessages = [
+          { role: 'system' as const, content: buildSystemPrompt() },
+          ...currentMessages
+        ];
+      }
+
+      if (isInterruptedRef.current) {
+        throw new Error('INTERRUPTED');
+      }
+
+      // Update activity
+      const activeTodo = findActiveTodo(currentTodos);
+      callbacks.setCurrentActivity(activeTodo?.title || 'Working on tasks');
+
+      // Build TODO context and inject into last user message
+      const todoContext = buildTodoContext(currentTodos);
+      const lastUserMsgIndex = currentMessages.map(m => m.role).lastIndexOf('user');
+      const messagesForLLM = lastUserMsgIndex >= 0
+        ? currentMessages.map((m, i) =>
+            i === lastUserMsgIndex
+              ? { ...m, content: m.content + todoContext }
+              : m
+          )
+        : [...currentMessages, { role: 'user' as const, content: `Execute the TODO list.${todoContext}` }];
+
+      // Single LLM call - continues internally until finish_reason: stop
+      // Pass pending message callbacks for mid-execution user input injection
+      const result = await llmClient.chatCompletionWithTools(messagesForLLM, tools, {
+        getPendingMessage: callbacks.getPendingMessage,
+        clearPendingMessage: callbacks.clearPendingMessage,
+      });
+
+      // Update messages (without TODO context)
+      const newMessages = result.allMessages.slice(currentMessages.length);
+      currentMessages = [...currentMessages, ...newMessages];
+      callbacks.setMessages([...currentMessages]);
+      sessionManager.autoSaveCurrentSession(currentMessages);
+
+      // Check for auto-compact after completion
+      await this.checkAndPerformAutoCompact(
+        llmClient,
+        currentMessages,
+        currentTodos,
+        callbacks,
+        (updated) => { currentMessages = updated; }
+      );
+
+      // 4. Completion - LLM's final response is already in currentMessages
+      const stats = getTodoStats(currentTodos);
+      sessionManager.autoSaveCurrentSession(currentMessages);
+
+      logger.exit('PlanExecutor.executePlanMode', { success: true, ...stats });
+    } catch (error) {
+      if (error instanceof Error && error.message === 'INTERRUPTED') {
+        logger.flow('Plan mode interrupted by user');
+        callbacks.setMessages((prev: Message[]) => {
+          const updatedMessages: Message[] = [
+            ...prev,
+            { role: 'assistant' as const, content: '⚠️ Execution interrupted.' }
+          ];
+          sessionManager.autoSaveCurrentSession(updatedMessages);
+          return updatedMessages;
+        });
+        return;
+      }
+
+      logger.error('Plan mode execution failed', error as Error);
+      const errorMessage = formatErrorMessage(error);
+
+      callbacks.setMessages((prev: Message[]) => {
+        const updatedMessages: Message[] = [
+          ...prev,
+          { role: 'assistant' as const, content: `Execution error:\n\n${errorMessage}` }
+        ];
+        sessionManager.autoSaveCurrentSession(updatedMessages);
+        return updatedMessages;
+      });
+    } finally {
+      callbacks.setExecutionPhase('idle');
+      clearTodoCallbacks();
+      clearFinalResponseCallbacks();
+      clearDocsSearchLLMClientGetter();
+      this.currentLLMClient = null;
+    }
+  }
+
+  /**
+   * Resume TODO execution
+   */
+  async resumeTodoExecution(
+    userMessage: string,
+    llmClient: LLMClient,
+    messages: Message[],
+    todos: TodoItem[],
+    isInterruptedRef: { current: boolean },
+    callbacks: StateCallbacks
+  ): Promise<void> {
+    logger.enter('PlanExecutor.resumeTodoExecution', { messageLength: userMessage.length, todoCount: todos.length });
+
+    // Log user input (for Ctrl+O LogBrowser chat category)
+    const streamLogger = getStreamLogger();
+    streamLogger?.logUserInput(userMessage);
+
+    // Store LLM client for docs search agent tool
+    this.currentLLMClient = llmClient;
+    setDocsSearchLLMClientGetter(() => this.currentLLMClient);
+
+    // Reset state
+    isInterruptedRef.current = false;
+    callbacks.setIsInterrupted(false);
+    callbacks.setExecutionPhase('executing');
+    callbacks.setCurrentActivity('Resuming execution');
+
+    let currentTodos = [...todos];
+
+    try {
+      // Add user message
+      let currentMessages: Message[] = [
+        ...messages,
+        { role: 'user' as const, content: userMessage }
+      ];
+      callbacks.setMessages(currentMessages);
+
+      // Setup TODO callbacks
+      this.setupTodoCallbacks(currentTodos, callbacks, (updated) => {
+        currentTodos = updated;
+      });
+
+      // Get tools from registry
+      const tools = toolRegistry.getLLMToolDefinitions();
+
+      // Ensure system message (with conditional Git rules if .git exists)
+      const hasSystemMessage = currentMessages.some(m => m.role === 'system');
+      if (!hasSystemMessage) {
+        currentMessages = [
+          { role: 'system' as const, content: buildSystemPrompt() },
+          ...currentMessages
+        ];
+      }
+
+      if (isInterruptedRef.current) {
+        throw new Error('INTERRUPTED');
+      }
+
+      const activeTodo = findActiveTodo(currentTodos);
+      callbacks.setCurrentActivity(activeTodo?.title || 'Working on tasks');
+
+      // Build TODO context
+      const todoContext = buildTodoContext(currentTodos);
+
+      // Create messages with TODO context
+      const lastUserMsgIndex = currentMessages.map(m => m.role).lastIndexOf('user');
+      const messagesForLLM = lastUserMsgIndex >= 0
+        ? currentMessages.map((m, i) =>
+            i === lastUserMsgIndex
+              ? { ...m, content: m.content + todoContext }
+              : m
+          )
+        : [...currentMessages, { role: 'user' as const, content: `Resume the TODO list.${todoContext}` }];
+
+      // Single LLM call - continues internally until finish_reason: stop
+      // Pass pending message callbacks for mid-execution user input injection
+      const result = await llmClient.chatCompletionWithTools(messagesForLLM, tools, {
+        getPendingMessage: callbacks.getPendingMessage,
+        clearPendingMessage: callbacks.clearPendingMessage,
+      });
+
+      // Update messages
+      const newMessages = result.allMessages.slice(currentMessages.length);
+      currentMessages = [...currentMessages, ...newMessages];
+      callbacks.setMessages([...currentMessages]);
+      sessionManager.autoSaveCurrentSession(currentMessages);
+
+      // Check for auto-compact
+      await this.checkAndPerformAutoCompact(
+        llmClient,
+        currentMessages,
+        currentTodos,
+        callbacks,
+        (updated) => { currentMessages = updated; }
+      );
+
+      // Completion - LLM's final response is already in currentMessages
+      sessionManager.autoSaveCurrentSession(currentMessages);
+
+      logger.exit('PlanExecutor.resumeTodoExecution', { success: true });
+    } catch (error) {
+      if (error instanceof Error && error.message === 'INTERRUPTED') {
+        logger.flow('Resume interrupted by user');
+        return;
+      }
+
+      logger.error('Resume execution failed', error as Error);
+      callbacks.setMessages((prev: Message[]) => [...prev, {
+        role: 'assistant' as const,
+        content: `Execution error:\n\n${error instanceof Error ? error.message : 'Unknown error'}`
+      }]);
+    } finally {
+      callbacks.setExecutionPhase('idle');
+      clearTodoCallbacks();
+      clearFinalResponseCallbacks();
+      clearDocsSearchLLMClientGetter();
+      this.currentLLMClient = null;
+    }
+  }
+
+  /**
+   * Auto Mode execution (direct execution based on planning)
+   * Classification logic removed - all requests handled via Plan Mode
+   */
+  async executeAutoMode(
+    userMessage: string,
+    llmClient: LLMClient,
+    messages: Message[],
+    _todos: TodoItem[],
+    isInterruptedRef: { current: boolean },
+    callbacks: StateCallbacks
+  ): Promise<void> {
+    logger.enter('PlanExecutor.executeAutoMode', { messageLength: userMessage.length });
+
+    // All requests are now handled via Plan Mode
+    // Classification and Direct Mode have been removed
+    await this.executePlanMode(userMessage, llmClient, messages, isInterruptedRef, callbacks);
+
+    logger.exit('PlanExecutor.executeAutoMode');
+  }
+
+  /**
+   * Perform conversation compaction
+   */
+  async performCompact(
+    llmClient: LLMClient,
+    messages: Message[],
+    todos: TodoItem[],
+    callbacks: StateCallbacks
+  ): Promise<CompactResult> {
+    logger.enter('PlanExecutor.performCompact', { messageCount: messages.length });
+    callbacks.setExecutionPhase('compacting');
+    callbacks.setCurrentActivity('Compacting conversation');
+
+    try {
+      const compactManager = new CompactManager(llmClient);
+
+      const result = await compactManager.compact(messages, {
+        todos,
+        workingDirectory: process.cwd(),
+        currentModel: configManager.getCurrentModel()?.name,
+        recentFiles: contextTracker.getRecentFiles(),
+      });
+
+      if (result.success && result.compactedSummary) {
+        const lastTwoMessages = messages.slice(-2);
+
+        const compactedBase = buildCompactedMessages(result.compactedSummary, {
+          workingDirectory: process.cwd(),
+        });
+
+        const finalMessages = [...compactedBase, ...lastTwoMessages];
+
+        // Estimate token count for compacted messages (for UI display)
+        const totalContent = finalMessages
+          .map(m => typeof m.content === 'string' ? m.content : JSON.stringify(m.content))
+          .join('');
+        const estimatedTokens = contextTracker.estimateTokens(totalContent);
+
+        callbacks.setMessages(finalMessages);
+        contextTracker.reset(estimatedTokens);
+        sessionManager.autoSaveCurrentSession(finalMessages);
+
+        emitCompact(result.originalMessageCount, finalMessages.length);
+
+        logger.flow('Compact completed successfully', { preservedMessages: 2 });
+
+        // Return with compactedMessages for caller to use
+        logger.exit('PlanExecutor.performCompact', { success: true });
+        return {
+          ...result,
+          compactedMessages: finalMessages,
+        };
+      }
+
+      logger.exit('PlanExecutor.performCompact', { success: result.success });
+      return result;
+
+    } catch (error) {
+      logger.error('Compact failed', error as Error);
+      return {
+        success: false,
+        originalMessageCount: messages.length,
+        newMessageCount: messages.length,
+        error: error instanceof Error ? error.message : 'Unknown error',
+      };
+    } finally {
+      callbacks.setExecutionPhase('idle');
+      callbacks.setCurrentActivity('Idle');
+    }
+  }
+
+  /**
+   * Check if auto-compaction is needed
+   */
+  shouldAutoCompact(): boolean {
+    const model = configManager.getCurrentModel();
+    const maxTokens = model?.maxTokens || 128000;
+    return contextTracker.shouldTriggerAutoCompact(maxTokens);
+  }
+
+  /**
+   * Return context remaining percentage
+   */
+  getContextRemainingPercent(): number {
+    const model = configManager.getCurrentModel();
+    const maxTokens = model?.maxTokens || 128000;
+    const usage = contextTracker.getContextUsage(maxTokens);
+    return usage.remainingPercentage;
+  }
+
+  /**
+   * Return context usage information
+   */
+  getContextUsageInfo(): { tokens: number; percent: number } {
+    const model = configManager.getCurrentModel();
+    const maxTokens = model?.maxTokens || 128000;
+    const usage = contextTracker.getContextUsage(maxTokens);
+    return {
+      tokens: usage.currentTokens,
+      percent: usage.usagePercentage,
+    };
+  }
+
+  /**
+   * Setup TODO callbacks (internal helper)
+   * write_todos: Replace entire list approach
+   * final_response: Deliver final response (requires all TODOs completed)
+   */
+  private setupTodoCallbacks(
+    currentTodos: TodoItem[],
+    callbacks: StateCallbacks,
+    updateLocalTodos: (todos: TodoItem[]) => void
+  ): void {
+    // Mutable reference for getTodos callback
+    let todosRef = currentTodos;
+
+    // write_todos callback: Replace entire list
+    setTodoWriteCallback(async (newTodos: TodoInput[]) => {
+      // Find status changes for UI events
+      const oldStatusMap = new Map(todosRef.map(t => [t.id, t.status]));
+
+      // Convert to TodoItem format
+      const updatedTodos: TodoItem[] = newTodos.map(t => ({
+        id: t.id,
+        title: t.title,
+        status: t.status,
+      }));
+
+      // Emit events for status changes
+      for (const todo of updatedTodos) {
+        const oldStatus = oldStatusMap.get(todo.id);
+        if (oldStatus !== todo.status) {
+          if (todo.status === 'completed') {
+            emitTodoComplete(todo.title);
+          } else if (todo.status === 'failed') {
+            emitTodoFail(todo.title);
+          } else if (todo.status === 'in_progress') {
+            emitTodoStart(todo.title);
+          }
+        }
+      }
+
+      // Update both local ref and external state
+      todosRef = updatedTodos;
+      updateLocalTodos(updatedTodos);
+      callbacks.setTodos([...updatedTodos]);
+
+      return true;
+    });
+
+    // getTodos callback for final_response tool
+    setGetTodosCallback(() => todosRef);
+
+    // finalResponse callback - emit as assistant response
+    setFinalResponseCallback((message: string) => {
+      emitAssistantResponse(message);
+    });
+  }
+
+  /**
+   * Check and perform auto-compaction (internal helper)
+   */
+  private async checkAndPerformAutoCompact(
+    llmClient: LLMClient,
+    currentMessages: Message[],
+    currentTodos: TodoItem[],
+    callbacks: StateCallbacks,
+    updateLocalMessages: (messages: Message[]) => void
+  ): Promise<void> {
+    const model = configManager.getCurrentModel();
+    const maxTokens = model?.maxTokens || 128000;
+
+    if (contextTracker.shouldTriggerAutoCompact(maxTokens)) {
+      logger.flow('Auto-compact triggered during execution');
+      callbacks.setExecutionPhase('compacting');
+      callbacks.setCurrentActivity('Compacting context');
+
+      const compactManager = new CompactManager(llmClient);
+      const compactResult = await compactManager.compact(currentMessages, {
+        todos: currentTodos,
+        workingDirectory: process.cwd(),
+      });
+
+      if (compactResult.success && compactResult.compactedSummary) {
+        const lastTwoMessages = currentMessages.slice(-2);
+        const newMessages = [
+          ...buildCompactedMessages(compactResult.compactedSummary, {
+            workingDirectory: process.cwd(),
+          }),
+          ...lastTwoMessages,
+        ];
+        updateLocalMessages(newMessages);
+        callbacks.setMessages([...newMessages]);
+        emitCompact(compactResult.originalMessageCount, compactResult.newMessageCount);
+      }
+
+      callbacks.setExecutionPhase('executing');
+    }
+  }
+}
+
+// Singleton instance (optional use)
+export const planExecutor = new PlanExecutor();