orquesta-cli 0.1.12

package/src/ui/hooks/useInputHistory.ts

@@ -0,0 +1,89 @@
+/**
+ * useInputHistory Hook
+ *
+ * Manages input history navigation with Up/Down arrow keys (bash-style)
+ * History is session-only (resets on restart)
+ */
+
+import { useState, useCallback, useRef } from 'react';
+
+export interface InputHistoryState {
+  input: string;
+  setInput: (value: string) => void;
+  handleHistoryPrev: () => void;
+  handleHistoryNext: () => void;
+  addToHistory: (value: string) => void;
+}
+
+export function useInputHistory(): InputHistoryState {
+  const [input, setInputInternal] = useState('');
+  const [history, setHistory] = useState<string[]>([]);
+  const [historyIndex, setHistoryIndex] = useState(-1);
+  const savedInputRef = useRef('');
+
+  const setInput = useCallback((value: string) => {
+    setInputInternal(value);
+  }, []);
+
+  const handleHistoryPrev = useCallback(() => {
+    if (history.length === 0) return;
+
+    if (historyIndex === -1) {
+      // Save current input before browsing history
+      savedInputRef.current = input;
+      const newIndex = history.length - 1;
+      const historyItem = history[newIndex];
+      if (historyItem !== undefined) {
+        setHistoryIndex(newIndex);
+        setInputInternal(historyItem);
+      }
+    } else if (historyIndex > 0) {
+      const newIndex = historyIndex - 1;
+      const historyItem = history[newIndex];
+      if (historyItem !== undefined) {
+        setHistoryIndex(newIndex);
+        setInputInternal(historyItem);
+      }
+    }
+  }, [input, history, historyIndex]);
+
+  const handleHistoryNext = useCallback(() => {
+    if (historyIndex === -1) return;
+
+    if (historyIndex < history.length - 1) {
+      const newIndex = historyIndex + 1;
+      const historyItem = history[newIndex];
+      if (historyItem !== undefined) {
+        setHistoryIndex(newIndex);
+        setInputInternal(historyItem);
+      }
+    } else {
+      // Reached the end, restore saved input
+      setHistoryIndex(-1);
+      setInputInternal(savedInputRef.current);
+    }
+  }, [history, historyIndex]);
+
+  const addToHistory = useCallback((value: string) => {
+    const trimmed = value.trim();
+    if (!trimmed) return;
+
+    // Skip duplicates
+    setHistory(prev => {
+      if (prev.length > 0 && prev[prev.length - 1] === trimmed) {
+        return prev;
+      }
+      return [...prev, trimmed];
+    });
+    setHistoryIndex(-1);
+    savedInputRef.current = '';
+  }, []);
+
+  return {
+    input,
+    setInput,
+    handleHistoryPrev,
+    handleHistoryNext,
+    addToHistory,
+  };
+}

package/src/ui/hooks/usePlanExecution.ts

@@ -0,0 +1,339 @@
+/**
+ * usePlanExecution Hook
+ *
+ * Plan & Execute state management React Hook
+ * Business logic handled in orchestration/plan-executor.ts
+ */
+
+import { useState, useCallback, useEffect, useRef, useMemo } from 'react';
+import { Message, TodoItem } from '../../types/index.js';
+import { LLMClient } from '../../core/llm/llm-client.js';
+import { logger } from '../../utils/logger.js';
+import {
+  setTodoWriteCallback,
+  clearTodoCallbacks,
+  TodoInput,
+} from '../../tools/llm/simple/todo-tools.js';
+import {
+  setAskUserCallback,
+  clearAskUserCallback,
+  type AskUserRequest,
+  type AskUserResponse,
+} from '../../tools/llm/simple/ask-user-tool.js';
+import { CompactResult } from '../../core/compact/index.js';
+
+import {
+  ExecutionPhase,
+  PlanExecutionState,
+  AskUserState,
+  PlanExecutionActions,
+  PlanExecutor,
+  StateCallbacks,
+} from '../../orchestration/index.js';
+
+// Re-export types for backward compatibility
+export type { ExecutionPhase, PlanExecutionState, AskUserState, PlanExecutionActions };
+
+/**
+ * External callbacks for pending message handling
+ */
+export interface PendingMessageCallbacks {
+  getPendingMessage?: () => string | null;
+  clearPendingMessage?: () => void;
+}
+
+export function usePlanExecution(pendingMessageCallbacks?: PendingMessageCallbacks): PlanExecutionState & AskUserState & PlanExecutionActions {
+  logger.enter('usePlanExecution');
+
+  // State
+  const [todos, setTodos] = useState<TodoItem[]>([]);
+  const [currentTodoId, setCurrentTodoId] = useState<string | undefined>();
+  const [executionPhase, setExecutionPhase] = useState<ExecutionPhase>('idle');
+  const [isInterrupted, setIsInterrupted] = useState(false);
+  const [currentActivity, setCurrentActivity] = useState<string>('Idle');
+
+  // Ask-user state
+  const [askUserRequest, setAskUserRequest] = useState<AskUserRequest | null>(null);
+  const [askUserResolver, setAskUserResolver] = useState<{
+    resolve: (response: AskUserResponse) => void;
+  } | null>(null);
+
+  // Refs
+  const isInterruptedRef = useRef(false);
+  const isPlanModeActiveRef = useRef(false);
+  const todosRef = useRef<TodoItem[]>([]);
+
+  // Memoized executor instance
+  const executor = useMemo(() => new PlanExecutor(), []);
+
+  // State callbacks for executor
+  const stateCallbacks: StateCallbacks = useMemo(() => ({
+    setTodos,
+    setCurrentTodoId,
+    setExecutionPhase,
+    setIsInterrupted: (interrupted: boolean) => {
+      setIsInterrupted(interrupted);
+      isInterruptedRef.current = interrupted;
+    },
+    setCurrentActivity,
+    setMessages: () => {}, // Will be provided per-call
+    setAskUserRequest,
+    // Planning LLM ask-user callback (Promise-based)
+    askUser: async (request) => {
+      return new Promise((resolve) => {
+        setAskUserRequest(request);
+        setAskUserResolver({ resolve });
+      });
+    },
+    // Pending message callbacks for mid-execution user input injection
+    getPendingMessage: pendingMessageCallbacks?.getPendingMessage,
+    clearPendingMessage: pendingMessageCallbacks?.clearPendingMessage,
+  }), [pendingMessageCallbacks]);
+
+  // Keep todosRef in sync with todos state
+  useEffect(() => {
+    todosRef.current = todos;
+  }, [todos]);
+
+  // Setup TODO tool callbacks (only when NOT in plan mode)
+  // Note: Using todosRef instead of todos in dependency to avoid cleanup issues during plan mode
+  useEffect(() => {
+    if (isPlanModeActiveRef.current) {
+      logger.flow('Skipping TODO callback setup - plan mode is active');
+      return;
+    }
+
+    logger.flow('Setting up TODO tool callbacks');
+
+    // write_todos callback: Replace entire list
+    const writeCallback = async (newTodos: TodoInput[]): Promise<boolean> => {
+      logger.enter('todoWriteCallback', { todoCount: newTodos.length });
+
+      // Convert to TodoItem format
+      const updatedTodos: TodoItem[] = newTodos.map(t => ({
+        id: t.id,
+        title: t.title,
+        status: t.status,
+      }));
+
+      setTodos(updatedTodos);
+
+      // Update currentTodoId based on in_progress item
+      const inProgressTodo = updatedTodos.find(t => t.status === 'in_progress');
+      setCurrentTodoId(inProgressTodo?.id);
+
+      logger.exit('todoWriteCallback', { success: true });
+      return true;
+    };
+
+    setTodoWriteCallback(writeCallback);
+
+    return () => {
+      logger.flow('Cleaning up TODO tool callbacks');
+      clearTodoCallbacks();
+    };
+  }, [executionPhase]); // Re-run when execution phase changes to restore callbacks after plan execution
+
+  // Setup ask-user callback
+  useEffect(() => {
+    logger.flow('Setting up ask-user callback');
+
+    const askCallback = async (request: AskUserRequest): Promise<AskUserResponse> => {
+      logger.enter('askUserCallback', { question: request.question });
+
+      return new Promise((resolve) => {
+        setAskUserRequest(request);
+        setAskUserResolver({ resolve });
+      });
+    };
+
+    setAskUserCallback(askCallback);
+
+    return () => {
+      logger.flow('Cleaning up ask-user callback');
+      clearAskUserCallback();
+    };
+  }, []);
+
+  // Handle TODO update
+  const handleTodoUpdate = useCallback((todo: TodoItem) => {
+    logger.enter('handleTodoUpdate', { todoId: todo.id, status: todo.status });
+
+    setTodos(prev => prev.map(t => t.id === todo.id ? todo : t));
+    if (todo.status === 'in_progress') {
+      setCurrentTodoId(todo.id);
+    } else if (todo.status === 'completed' || todo.status === 'failed') {
+      setCurrentTodoId(prev => prev === todo.id ? undefined : prev);
+    }
+
+    logger.exit('handleTodoUpdate');
+  }, []);
+
+  // Handle ask-user response
+  const handleAskUserResponse = useCallback((response: AskUserResponse) => {
+    logger.enter('handleAskUserResponse', { selectedOption: response.selectedOption, isOther: response.isOther });
+
+    if (askUserResolver) {
+      askUserResolver.resolve(response);
+      setAskUserResolver(null);
+    }
+    setAskUserRequest(null);
+
+    logger.exit('handleAskUserResponse');
+  }, [askUserResolver]);
+
+  // Handle interrupt (ESC key)
+  const handleInterrupt = useCallback((): 'paused' | 'stopped' | 'none' => {
+    logger.enter('handleInterrupt', { executionPhase, isInterrupted });
+
+    const hasPendingTodos = todos.some(t => t.status === 'pending' || t.status === 'in_progress');
+
+    if (isInterrupted && (executionPhase !== 'idle' || hasPendingTodos)) {
+      logger.flow('Second ESC - stopping execution completely');
+
+      setTodos([]);
+      setExecutionPhase('idle');
+      setCurrentTodoId(undefined);
+      setCurrentActivity('Idle');
+      setIsInterrupted(false);
+      isInterruptedRef.current = false;
+
+      logger.debug('Execution stopped completely, all todos cleared');
+      logger.exit('handleInterrupt', { result: 'stopped' });
+      return 'stopped';
+    }
+
+    if (executionPhase !== 'idle' || hasPendingTodos) {
+      logger.flow('First ESC - pausing execution');
+      setIsInterrupted(true);
+      isInterruptedRef.current = true;
+      setCurrentActivity('Paused');
+
+      logger.debug('Execution paused (can resume or press ESC again to stop)');
+      logger.exit('handleInterrupt', { result: 'paused' });
+      return 'paused';
+    }
+
+    logger.exit('handleInterrupt', { result: 'none' });
+    return 'none';
+  }, [executionPhase, isInterrupted, todos]);
+
+  // executeDirectMode removed - all requests now use Plan Mode
+
+  // Execute Plan Mode
+  const executePlanMode = useCallback(async (
+    userMessage: string,
+    llmClient: LLMClient,
+    messages: Message[],
+    setMessages: React.Dispatch<React.SetStateAction<Message[]>>
+  ) => {
+    isPlanModeActiveRef.current = true;
+    const callbacks: StateCallbacks = {
+      ...stateCallbacks,
+      setMessages: setMessages as StateCallbacks['setMessages'],
+    };
+    try {
+      await executor.executePlanMode(userMessage, llmClient, messages, isInterruptedRef, callbacks);
+    } finally {
+      isPlanModeActiveRef.current = false;
+    }
+  }, [executor, stateCallbacks]);
+
+  // Resume TODO Execution
+  const resumeTodoExecution = useCallback(async (
+    userMessage: string,
+    llmClient: LLMClient,
+    messages: Message[],
+    setMessages: React.Dispatch<React.SetStateAction<Message[]>>
+  ) => {
+    isPlanModeActiveRef.current = true;
+    const callbacks: StateCallbacks = {
+      ...stateCallbacks,
+      setMessages: setMessages as StateCallbacks['setMessages'],
+    };
+    try {
+      await executor.resumeTodoExecution(userMessage, llmClient, messages, todos, isInterruptedRef, callbacks);
+    } finally {
+      isPlanModeActiveRef.current = false;
+    }
+  }, [executor, stateCallbacks, todos]);
+
+  // Execute Auto Mode
+  const executeAutoMode = useCallback(async (
+    userMessage: string,
+    llmClient: LLMClient,
+    messages: Message[],
+    setMessages: React.Dispatch<React.SetStateAction<Message[]>>
+  ) => {
+    isPlanModeActiveRef.current = true;
+    const callbacks: StateCallbacks = {
+      ...stateCallbacks,
+      setMessages: setMessages as StateCallbacks['setMessages'],
+    };
+    try {
+      await executor.executeAutoMode(userMessage, llmClient, messages, todos, isInterruptedRef, callbacks);
+    } finally {
+      isPlanModeActiveRef.current = false;
+    }
+  }, [executor, stateCallbacks, todos]);
+
+  // Perform Compact
+  const performCompact = useCallback(async (
+    llmClient: LLMClient,
+    messages: Message[],
+    setMessages: React.Dispatch<React.SetStateAction<Message[]>>
+  ): Promise<CompactResult> => {
+    const callbacks: StateCallbacks = {
+      ...stateCallbacks,
+      setMessages: setMessages as StateCallbacks['setMessages'],
+    };
+    return executor.performCompact(llmClient, messages, todos, callbacks);
+  }, [executor, stateCallbacks, todos]);
+
+  // Utility methods
+  const shouldAutoCompact = useCallback((): boolean => {
+    return executor.shouldAutoCompact();
+  }, [executor]);
+
+  const getContextRemainingPercent = useCallback((): number => {
+    return executor.getContextRemainingPercent();
+  }, [executor]);
+
+  const getContextUsageInfo = useCallback((): { tokens: number; percent: number } => {
+    return executor.getContextUsageInfo();
+  }, [executor]);
+
+  // Reset interrupt flag when execution completes
+  useEffect(() => {
+    if (executionPhase === 'idle' && isInterrupted) {
+      const hasPendingTodos = todos.some(t => t.status === 'pending' || t.status === 'in_progress');
+      if (!hasPendingTodos) {
+        setIsInterrupted(false);
+        isInterruptedRef.current = false;
+      }
+    }
+  }, [executionPhase, isInterrupted, todos]);
+
+  logger.exit('usePlanExecution');
+
+  return {
+    todos,
+    currentTodoId,
+    executionPhase,
+    isInterrupted,
+    currentActivity,
+    askUserRequest,
+    setTodos,
+    handleTodoUpdate,
+    handleAskUserResponse,
+    handleInterrupt,
+    executeAutoMode,
+    executePlanMode,
+    resumeTodoExecution,
+    // executeDirectMode removed - all requests now use Plan Mode
+    performCompact,
+    shouldAutoCompact,
+    getContextRemainingPercent,
+    getContextUsageInfo,
+  };
+}

package/src/ui/index.ts

@@ -0,0 +1,10 @@
+/**
+ * UI Components Export
+ */
+
+export { PlanExecuteApp } from './components/PlanExecuteApp.js';
+export { ProgressBar } from './components/ProgressBar.js';
+export { TodoListView } from './components/TodoListView.js';
+export { StatusBar } from './components/StatusBar.js';
+export { PlanExecuteView } from './PlanExecuteView.js';
+export { TodoPanel, TodoStatusBar } from './TodoPanel.js';

package/src/ui/ink-entry.tsx

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+/**
+ * Ink UI Entry Point
+ *
+ * Direct execution of Ink UI with ESM
+ */
+
+import React from 'react';
+import { render } from 'ink';
+import { PlanExecuteApp } from './components/PlanExecuteApp.js';
+import { createLLMClient } from '../core/llm/llm-client.js';
+import { configManager } from '../core/config/config-manager.js';
+import { initializeOptionalTools } from '../tools/registry.js';
+import { logger } from '../utils/logger.js';
+
+// Async initialization
+(async () => {
+  try {
+    // Initialize ConfigManager
+    await configManager.initialize();
+
+    // Load saved optional tool states (e.g., browser tools, Office tools)
+    await initializeOptionalTools();
+
+    // Create LLM Client
+    const llmClient = createLLMClient();
+    const modelInfo = llmClient.getModelInfo();
+
+    // Render Ink UI (PlanExecuteApp supports both direct and plan-execute modes)
+    // exitOnCtrlC: false - Ctrl+C is handled manually in PlanExecuteApp for smart behavior
+    render(<PlanExecuteApp llmClient={llmClient} modelInfo={modelInfo} />, { exitOnCtrlC: false });
+  } catch (error) {
+    logger.error('Ink UI initialization failed', error);
+    process.exit(1);
+  }
+})();

package/src/utils/env-filter.ts

@@ -0,0 +1,164 @@
+/**
+ * Environment Variable Filter
+ *
+ * Filters sensitive environment variables before passing to subprocesses
+ * to prevent credential leakage to LLM-executed commands.
+ */
+
+/**
+ * Whitelist of safe environment variables that can be passed to subprocesses
+ */
+const SAFE_ENV_VARS = new Set([
+  // System paths
+  'PATH',
+  'HOME',
+  'HOMEPATH',
+  'HOMEDRIVE',
+  'USERPROFILE',
+  'TMPDIR',
+  'TEMP',
+  'TMP',
+
+  // Terminal and shell
+  'TERM',
+  'SHELL',
+  'SHLVL',
+  'PWD',
+  'OLDPWD',
+  'LANG',
+  'LANGUAGE',
+  'LC_ALL',
+  'LC_CTYPE',
+
+  // Display
+  'DISPLAY',
+  'COLORTERM',
+  'TERM_PROGRAM',
+
+  // User info (non-sensitive)
+  'USER',
+  'USERNAME',
+  'LOGNAME',
+
+  // Node/npm (but not tokens)
+  'NODE_ENV',
+  'NODE_PATH',
+
+  // System info
+  'OS',
+  'PROCESSOR_ARCHITECTURE',
+  'PROCESSOR_IDENTIFIER',
+  'NUMBER_OF_PROCESSORS',
+
+  // WSL
+  'WSL_DISTRO_NAME',
+  'WSL_INTEROP',
+  'WSLENV',
+]);
+
+/**
+ * Patterns for environment variable names that should NEVER be passed
+ * (even if not explicitly filtered)
+ */
+const SENSITIVE_PATTERNS = [
+  /^API[_-]?KEY/i,
+  /^.*[_-]API[_-]?KEY$/i,
+  /^TOKEN$/i,
+  /^.*[_-]TOKEN$/i,
+  /^SECRET/i,
+  /^.*[_-]SECRET$/i,
+  /^PASSWORD/i,
+  /^.*[_-]PASSWORD$/i,
+  /^.*[_-]PASS$/i,
+  /^AUTH/i,
+  /^CREDENTIAL/i,
+  /^ANTHROPIC/i,
+  /^OPENAI/i,
+  /^SUPABASE/i,
+  /^DATABASE/i,
+  /^DB[_-]/i,
+  /^POSTGRES/i,
+  /^MYSQL/i,
+  /^MONGO/i,
+  /^REDIS/i,
+  /^AWS/i,
+  /^AZURE/i,
+  /^GCP/i,
+  /^GOOGLE/i,
+  /^GITHUB/i,
+  /^GITLAB/i,
+  /^NPM[_-]TOKEN/i,
+  /^VERCEL/i,
+  /^NETLIFY/i,
+  /^ENCRYPTION/i,
+  /^PRIVATE[_-]KEY/i,
+  /^SESSION/i,
+  /^JWT/i,
+  /^BEARER/i,
+];
+
+/**
+ * Filter environment variables to only include safe ones
+ *
+ * @param env - Full environment object (typically process.env)
+ * @param additionalSafeVars - Additional env var names to consider safe (from user config)
+ * @param explicitVars - Explicitly provided env vars (from LLM/user) - these bypass filtering
+ * @returns Filtered environment object with only safe variables
+ */
+export function filterSafeEnv(
+  env: NodeJS.ProcessEnv = process.env,
+  additionalSafeVars: string[] = [],
+  explicitVars: Record<string, string> = {}
+): NodeJS.ProcessEnv {
+  const filtered: NodeJS.ProcessEnv = {};
+
+  // Add additional safe vars to the whitelist for this call
+  const extendedSafeVars = new Set([...SAFE_ENV_VARS, ...additionalSafeVars]);
+
+  for (const [key, value] of Object.entries(env)) {
+    // Skip if value is undefined
+    if (value === undefined) {
+      continue;
+    }
+
+    // Check if key matches sensitive patterns (unless explicitly allowed by user config)
+    const isSensitive = SENSITIVE_PATTERNS.some(pattern => pattern.test(key));
+    const isUserAllowed = additionalSafeVars.includes(key);
+
+    if (isSensitive && !isUserAllowed) {
+      continue; // Skip sensitive vars unless user explicitly allowed them
+    }
+
+    // Only include if in whitelist (base or user-extended)
+    if (extendedSafeVars.has(key)) {
+      filtered[key] = value;
+    }
+  }
+
+  // Merge explicit vars (these bypass all filtering - LLM/user explicitly set them)
+  return { ...filtered, ...explicitVars };
+}
+
+/**
+ * Get a list of filtered-out environment variable names (for logging/debugging)
+ * Does NOT return values, only keys.
+ */
+export function getFilteredEnvKeys(env: NodeJS.ProcessEnv = process.env): string[] {
+  const filtered = filterSafeEnv(env);
+  const allKeys = Object.keys(env);
+  return allKeys.filter(key => !(key in filtered));
+}
+
+/**
+ * Check if an environment variable would be filtered
+ */
+export function isEnvVarSafe(key: string): boolean {
+  // Check sensitive patterns
+  const isSensitive = SENSITIVE_PATTERNS.some(pattern => pattern.test(key));
+  if (isSensitive) {
+    return false;
+  }
+
+  // Check whitelist
+  return SAFE_ENV_VARS.has(key);
+}