orquesta-cli 0.1.12 → 0.1.14

package/src/orchestration/plan-executor.ts

@@ -1,652 +0,0 @@
-/**
- * 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();