orquesta-cli 0.1.12 → 0.1.14

package/src/tools/llm/simple/simple-tool-executor.ts

@@ -1,279 +0,0 @@
-/**
- * Simple Tool Executor
- *
- * Execution and callback management for LLM Simple Tools
- * Module separated from file-tools.ts
- */
-
-import { ToolResult, isLLMSimpleTool } from '../../types.js';
-import { getStreamLogger } from '../../../utils/json-stream-logger.js';
-
-/**
- * Callback for tool execution events (reason display to user)
- */
-type ToolExecutionCallback = (toolName: string, reason: string, args: Record<string, unknown>) => void;
-let toolExecutionCallback: ToolExecutionCallback | null = null;
-
-/**
- * Callback for tool response events
- */
-type ToolResponseCallback = (toolName: string, success: boolean, result: string) => void;
-let toolResponseCallback: ToolResponseCallback | null = null;
-
-/**
- * Callback for plan created events
- */
-type PlanCreatedCallback = (todoTitles: string[]) => void;
-let planCreatedCallback: PlanCreatedCallback | null = null;
-
-/**
- * Callback for todo start events
- */
-type TodoStartCallback = (title: string) => void;
-let todoStartCallback: TodoStartCallback | null = null;
-
-/**
- * Callback for todo complete events
- */
-type TodoCompleteCallback = (title: string) => void;
-let todoCompleteCallback: TodoCompleteCallback | null = null;
-
-/**
- * Callback for todo fail events
- */
-type TodoFailCallback = (title: string) => void;
-let todoFailCallback: TodoFailCallback | null = null;
-
-/**
- * Callback for tool approval (Supervised Mode)
- * Returns: 'approve' | 'always' | { reject: true; comment: string }
- */
-export type ToolApprovalResult = 'approve' | 'always' | { reject: true; comment: string };
-type ToolApprovalCallback = (
-  toolName: string,
-  args: Record<string, unknown>,
-  reason?: string
-) => Promise<ToolApprovalResult>;
-let toolApprovalCallback: ToolApprovalCallback | null = null;
-
-/**
- * Callback for compact events
- */
-type CompactCallback = (originalCount: number, newCount: number) => void;
-let compactCallback: CompactCallback | null = null;
-
-/**
- * Callback for assistant response events (final LLM response)
- */
-type AssistantResponseCallback = (content: string) => void;
-let assistantResponseCallback: AssistantResponseCallback | null = null;
-
-/**
- * Callback for reasoning/thinking events (extended thinking from o1 models)
- */
-type ReasoningCallback = (content: string, isStreaming: boolean) => void;
-let reasoningCallback: ReasoningCallback | null = null;
-
-// ============================================
-// Callback Setters
-// ============================================
-
-export function setToolExecutionCallback(callback: ToolExecutionCallback | null): void {
-  toolExecutionCallback = callback;
-}
-
-export function setToolResponseCallback(callback: ToolResponseCallback | null): void {
-  toolResponseCallback = callback;
-}
-
-export function setPlanCreatedCallback(callback: PlanCreatedCallback | null): void {
-  planCreatedCallback = callback;
-}
-
-export function setTodoStartCallback(callback: TodoStartCallback | null): void {
-  todoStartCallback = callback;
-}
-
-export function setTodoCompleteCallback(callback: TodoCompleteCallback | null): void {
-  todoCompleteCallback = callback;
-}
-
-export function setTodoFailCallback(callback: TodoFailCallback | null): void {
-  todoFailCallback = callback;
-}
-
-export function setToolApprovalCallback(callback: ToolApprovalCallback | null): void {
-  toolApprovalCallback = callback;
-}
-
-export function setCompactCallback(callback: CompactCallback | null): void {
-  compactCallback = callback;
-}
-
-export function setAssistantResponseCallback(callback: AssistantResponseCallback | null): void {
-  assistantResponseCallback = callback;
-}
-
-export function setReasoningCallback(callback: ReasoningCallback | null): void {
-  reasoningCallback = callback;
-}
-
-// ============================================
-// Callback Getters & Emitters
-// ============================================
-
-export function getToolExecutionCallback(): ToolExecutionCallback | null {
-  return toolExecutionCallback;
-}
-
-export async function requestToolApproval(
-  toolName: string,
-  args: Record<string, unknown>,
-  reason?: string
-): Promise<ToolApprovalResult | null> {
-  if (!toolApprovalCallback) {
-    return null;
-  }
-  return toolApprovalCallback(toolName, args, reason);
-}
-
-export function emitPlanCreated(todoTitles: string[]): void {
-  if (planCreatedCallback) {
-    planCreatedCallback(todoTitles);
-  }
-}
-
-export function emitTodoStart(title: string): void {
-  if (todoStartCallback) {
-    todoStartCallback(title);
-  }
-}
-
-export function emitTodoComplete(title: string): void {
-  if (todoCompleteCallback) {
-    todoCompleteCallback(title);
-  }
-}
-
-export function emitTodoFail(title: string): void {
-  if (todoFailCallback) {
-    todoFailCallback(title);
-  }
-}
-
-export function emitCompact(originalCount: number, newCount: number): void {
-  if (compactCallback) {
-    compactCallback(originalCount, newCount);
-  }
-}
-
-export function emitAssistantResponse(content: string): void {
-  // Skip empty content to prevent blank lines in UI
-  if (assistantResponseCallback && content && content.trim()) {
-    // Filter out <think>...</think> tags (used by some models like DeepSeek)
-    // Extract thinking content and emit as reasoning, then remove from main content
-    const thinkRegex = /<think>([\s\S]*?)<\/think>/g;
-    let thinkingContent = '';
-    let match;
-    while ((match = thinkRegex.exec(content)) !== null) {
-      if (match[1] && match[1].trim()) {
-        thinkingContent += match[1].trim() + '\n';
-      }
-    }
-
-    // Emit thinking as reasoning if present
-    if (thinkingContent && reasoningCallback) {
-      reasoningCallback(thinkingContent.trim(), false);
-    }
-
-    // Remove <think> tags from content
-    const cleanedContent = content.replace(/<think>[\s\S]*?<\/think>/g, '').trim();
-
-    if (cleanedContent) {
-      assistantResponseCallback(cleanedContent);
-
-      // Log assistant response (for Ctrl+O LogBrowser chat category)
-      const streamLogger = getStreamLogger();
-      streamLogger?.logAssistantResponse(cleanedContent);
-    }
-  }
-}
-
-export function emitReasoning(content: string, isStreaming: boolean = false): void {
-  // Skip empty content to prevent blank lines in UI
-  if (reasoningCallback && content && content.trim()) {
-    reasoningCallback(content, isStreaming);
-  }
-}
-
-// ============================================
-// Tool Executor
-// ============================================
-
-/**
- * Execute a simple tool by name
- * Uses tool registry to find and execute tools
- */
-export async function executeSimpleTool(
-  toolName: string,
-  args: Record<string, unknown>
-): Promise<ToolResult> {
-  const startTime = Date.now();
-  const logger = getStreamLogger();
-
-  // Dynamic import to avoid circular dependency
-  const { toolRegistry } = await import('../../registry.js');
-  const tool = toolRegistry.get(toolName);
-
-  if (!tool || !isLLMSimpleTool(tool)) {
-    const error = `Unknown or not a simple tool: ${toolName}`;
-    // Log tool execution failure
-    logger?.logToolEnd(toolName, false, undefined, error, Date.now() - startTime);
-    return {
-      success: false,
-      error,
-    };
-  }
-
-  // Extract reason from args (not required for TODO tools)
-  const reason = args['reason'] as string | undefined;
-
-  // Log tool execution start
-  logger?.logToolStart(toolName, args, reason);
-
-  // Call the callback to notify UI about tool execution (pass all args)
-  // Skip for TODO tools which don't have reason parameter
-  if (toolExecutionCallback && reason) {
-    toolExecutionCallback(toolName, reason, args);
-  }
-
-  // Execute the tool
-  const result = await tool.execute(args);
-  const durationMs = Date.now() - startTime;
-
-  // Log tool execution end
-  logger?.logToolEnd(
-    toolName,
-    result.success,
-    result.success ? result.result : undefined,
-    result.success ? undefined : result.error,
-    durationMs
-  );
-
-  // Call the response callback to notify UI about tool result
-  // Skip response callback for TODO tools to avoid cluttering UI
-  const isTodoTool = ['update_todos', 'get_todo_list'].includes(toolName);
-  if (toolResponseCallback && !isTodoTool) {
-    const resultText = result.success
-      ? (result.result || '')
-      : (result.error || 'Unknown error');
-    toolResponseCallback(toolName, result.success, resultText);
-  }
-
-  return result;
-}
-
-/**
- * @deprecated Use executeSimpleTool instead
- */
-export const executeFileTool = executeSimpleTool;

package/src/tools/llm/simple/todo-tools.ts

@@ -1,207 +0,0 @@
-/**
- * TODO Management LLM Tools
- *
- * Tools that allow LLM to manage TODO lists
- * Claude Code approach: Replace entire list with write_todos
- */
-
-import { LLMSimpleTool, ToolResult, ToolCategory } from '../../types.js';
-import { ToolDefinition } from '../../../types/index.js';
-import { logger } from '../../../utils/logger.js';
-
-/**
- * TODO item (simplified: title + status only)
- */
-export interface TodoInput {
-  id: string;
-  title: string;
-  status: 'pending' | 'in_progress' | 'completed' | 'failed';
-}
-
-/**
- * TODO list replacement callback type
- * Receives and replaces entire list
- */
-export type TodoWriteCallback = (todos: TodoInput[]) => Promise<boolean>;
-
-// Global callback - set by orchestrator
-let todoWriteCallback: TodoWriteCallback | null = null;
-
-/**
- * Set the TODO write callback
- */
-export function setTodoWriteCallback(callback: TodoWriteCallback): void {
-  logger.flow('Setting TODO write callback');
-  todoWriteCallback = callback;
-}
-
-/**
- * Clear TODO callbacks
- */
-export function clearTodoCallbacks(): void {
-  logger.flow('Clearing TODO callbacks');
-  todoWriteCallback = null;
-}
-
-/**
- * write_todos Tool Definition
- * Replace entire TODO list (Claude Code approach)
- */
-const WRITE_TODOS_DEFINITION: ToolDefinition = {
-  type: 'function',
-  function: {
-    name: 'write_todos',
-    description: `Replace the entire TODO list with a new list.
-
-Use this to:
-- Update TODO statuses (change status field)
-- Add new TODOs (include in the array)
-- Remove TODOs (omit from the array)
-- Reorder TODOs (change array order)
-
-IMPORTANT: You must include ALL TODOs you want to keep. Any TODO not in the array will be removed.
-
-Example - Mark first task complete, second in progress:
-{
-  "todos": [
-    { "id": "1", "title": "Setup project", "status": "completed" },
-    { "id": "2", "title": "Implement feature", "status": "in_progress" },
-    { "id": "3", "title": "Write tests", "status": "pending" }
-  ]
-}
-
-Example - Add a new task:
-{
-  "todos": [
-    { "id": "1", "title": "Existing task", "status": "completed" },
-    { "id": "2", "title": "New task I just added", "status": "pending" }
-  ]
-}`,
-    parameters: {
-      type: 'object',
-      properties: {
-        todos: {
-          type: 'array',
-          description: 'The complete TODO list (replaces existing list)',
-          items: {
-            type: 'object',
-            properties: {
-              id: {
-                type: 'string',
-                description: 'Unique ID for the TODO',
-              },
-              title: {
-                type: 'string',
-                description: 'Short title describing the task',
-              },
-              status: {
-                type: 'string',
-                enum: ['pending', 'in_progress', 'completed', 'failed'],
-                description: 'Current status of the TODO',
-              },
-            },
-            required: ['id', 'title', 'status'],
-          },
-        },
-      },
-      required: ['todos'],
-    },
-  },
-};
-
-/**
- * write_todos Tool Implementation
- */
-async function executeWriteTodos(args: Record<string, unknown>): Promise<ToolResult> {
-  logger.enter('executeWriteTodos', args);
-
-  const todos = args['todos'] as TodoInput[];
-
-  if (!todos || !Array.isArray(todos)) {
-    logger.warn('Missing or invalid todos array');
-    return {
-      success: false,
-      error: 'Missing required parameter: todos array is required',
-    };
-  }
-
-  if (!todoWriteCallback) {
-    logger.warn('TODO write callback not set');
-    return {
-      success: false,
-      error: 'TODO management is not available in current context',
-    };
-  }
-
-  // Validate each todo
-  for (const todo of todos) {
-    if (!todo.id || !todo.title || !todo.status) {
-      return {
-        success: false,
-        error: `Invalid TODO item: each item must have id, title, and status`,
-      };
-    }
-    if (!['pending', 'in_progress', 'completed', 'failed'].includes(todo.status)) {
-      return {
-        success: false,
-        error: `Invalid status "${todo.status}" for TODO "${todo.id}"`,
-      };
-    }
-  }
-
-  try {
-    logger.flow(`Writing ${todos.length} TODOs`);
-    const success = await todoWriteCallback(todos);
-
-    if (success) {
-      const completed = todos.filter(t => t.status === 'completed').length;
-      const inProgress = todos.filter(t => t.status === 'in_progress').length;
-      const pending = todos.filter(t => t.status === 'pending').length;
-      const failed = todos.filter(t => t.status === 'failed').length;
-
-      const summary = `TODO list updated (${todos.length} items): ${completed} completed, ${inProgress} in progress, ${pending} pending, ${failed} failed`;
-
-      logger.exit('executeWriteTodos', { success: true, count: todos.length });
-      return {
-        success: true,
-        result: summary,
-        metadata: { todoCount: todos.length, completed, inProgress, pending, failed },
-      };
-    } else {
-      return {
-        success: false,
-        error: 'Failed to update TODO list',
-      };
-    }
-  } catch (error) {
-    logger.error('Error writing TODOs', error as Error);
-    return {
-      success: false,
-      error: `Error writing TODOs: ${error instanceof Error ? error.message : 'Unknown error'}`,
-    };
-  }
-}
-
-/**
- * LLM Simple Tool: write_todos
- */
-export const WriteTodosTool: LLMSimpleTool = {
-  definition: WRITE_TODOS_DEFINITION,
-  execute: executeWriteTodos,
-  categories: ['llm-simple'] as ToolCategory[],
-  description: 'Write/replace entire TODO list',
-};
-
-/**
- * All TODO Tools
- */
-export const TODO_TOOLS = [WriteTodosTool];
-
-/**
- * Get TODO tool definitions for LLM
- */
-export function getTodoToolDefinitions(): ToolDefinition[] {
-  return TODO_TOOLS.map(tool => tool.definition);
-}
-
-export default TODO_TOOLS;