orquesta-cli 0.1.13 → 0.1.14

package/src/ui/hooks/useInputHistory.ts

@@ -1,89 +0,0 @@
-/**
- * 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

@@ -1,339 +0,0 @@
-/**
- * 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

@@ -1,10 +0,0 @@
-/**
- * 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

@@ -1,36 +0,0 @@
-#!/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

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