orquesta-cli 0.1.12

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

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

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