orquesta-cli 0.1.12

package/src/tools/types.ts

@@ -0,0 +1,231 @@
+/**
+ * Tool Types and Interfaces
+ *
+ * Type definitions for 6-category tool classification system
+ *
+ * Categories:
+ * 1. LLM Simple Tools - LLM calls via tool_call, no Sub-LLM
+ * 2. LLM Agent Tools - LLM calls via tool_call, uses Sub-LLM
+ * 3. System Simple Tools - Called by logic based on conditions, no Sub-LLM
+ * 4. System Agent Tools - Called by logic based on conditions, uses Sub-LLM
+ * 5. User Commands - User slash commands
+ * 6. MCP Tools - Model Context Protocol tools
+ */
+
+import { ToolDefinition } from '../types/index.js';
+import { LLMClient } from '../core/llm/llm-client.js';
+
+/**
+ * Tool categories for classification and registration
+ */
+export type ToolCategory =
+  | 'llm-simple'
+  | 'llm-agent'
+  | 'llm-planning'  // Tools exclusive to Planning LLM
+  | 'system-simple'
+  | 'system-agent'
+  | 'user-command'
+  | 'mcp';
+
+/**
+ * Tool execution result
+ */
+export interface ToolResult {
+  success: boolean;
+  result?: string;
+  error?: string;
+  metadata?: Record<string, unknown>;
+}
+
+/**
+ * Context passed to system tools
+ */
+export interface SystemContext {
+  userMessage: string;
+  messages: Array<{ role: string; content: string }>;
+  currentDirectory: string;
+  sessionId?: string;
+  metadata?: Record<string, unknown>;
+}
+
+/**
+ * 1. LLM Simple Tool Interface
+ * - LLM calls via tool_call
+ * - Does not use Sub-LLM
+ */
+export interface LLMSimpleTool {
+  /** Tool definition for LLM */
+  definition: ToolDefinition;
+  /** Execute the tool with given arguments */
+  execute: (args: Record<string, unknown>) => Promise<ToolResult>;
+  /** Categories this tool belongs to */
+  categories: ToolCategory[];
+  /** Optional description for registration */
+  description?: string;
+}
+
+/**
+ * 2. LLM Agent Tool Interface
+ * - LLM calls via tool_call
+ * - Uses Sub-LLM to perform complex tasks
+ */
+export interface LLMAgentTool {
+  /** Tool definition for LLM */
+  definition: ToolDefinition;
+  /** Execute the tool with given arguments and LLM client */
+  execute: (args: Record<string, unknown>, llmClient: LLMClient) => Promise<ToolResult>;
+  /** Categories this tool belongs to */
+  categories: ToolCategory[];
+  /** Flag indicating this tool requires Sub-LLM */
+  requiresSubLLM: true;
+  /** Optional description for registration */
+  description?: string;
+}
+
+/**
+ * 3. System Simple Tool Interface
+ * - Automatically called by logic based on conditions
+ * - Does not use Sub-LLM
+ */
+export interface SystemSimpleTool {
+  /** Unique tool name */
+  name: string;
+  /** Execute the tool with system context */
+  execute: (context: SystemContext) => Promise<ToolResult>;
+  /** Condition to trigger this tool automatically */
+  triggerCondition: (context: SystemContext) => boolean;
+  /** Categories this tool belongs to */
+  categories: ToolCategory[];
+  /** Optional description for registration */
+  description?: string;
+}
+
+/**
+ * 4. System Agent Tool Interface
+ * - Automatically called by logic based on conditions
+ * - Uses Sub-LLM to perform complex tasks
+ */
+export interface SystemAgentTool {
+  /** Unique tool name */
+  name: string;
+  /** Execute the tool with system context and LLM client */
+  execute: (context: SystemContext, llmClient: LLMClient) => Promise<ToolResult>;
+  /** Condition to trigger this tool automatically */
+  triggerCondition: (context: SystemContext) => boolean;
+  /** Categories this tool belongs to */
+  categories: ToolCategory[];
+  /** Flag indicating this tool requires Sub-LLM */
+  requiresSubLLM: true;
+  /** Optional description for registration */
+  description?: string;
+}
+
+/**
+ * 5. User Command Interface
+ * - User directly calls via slash commands
+ */
+export interface UserCommand {
+  /** Command name (e.g., '/help', '/settings') */
+  name: string;
+  /** Command aliases (e.g., '/quit' for '/exit') */
+  aliases?: string[];
+  /** Short description for help display */
+  description: string;
+  /** Execute the command */
+  execute: (args: string[], context: UserCommandContext) => Promise<UserCommandResult>;
+  /** Categories this command belongs to */
+  categories: ToolCategory[];
+}
+
+/**
+ * Context passed to user commands
+ */
+export interface UserCommandContext {
+  messages: Array<{ role: string; content: string }>;
+  setMessages: (messages: Array<{ role: string; content: string }>) => void;
+  exit: () => void;
+  // UI callbacks
+  onShowSessionBrowser?: () => void;
+  onShowSettings?: () => void;
+  onShowModelSelector?: () => void;
+}
+
+/**
+ * Result from user command execution
+ */
+export interface UserCommandResult {
+  handled: boolean;
+  shouldContinue: boolean;
+  message?: string;
+}
+
+/**
+ * 6. MCP Tool Interface
+ * - Model Context Protocol tools
+ * - Communicates with external servers
+ */
+export interface MCPTool {
+  /** Tool definition for MCP */
+  definition: ToolDefinition;
+  /** MCP server identifier */
+  serverName: string;
+  /** Execute the tool through MCP protocol */
+  execute: (args: Record<string, unknown>) => Promise<ToolResult>;
+  /** Categories this tool belongs to */
+  categories: ToolCategory[];
+  /** Optional description for registration */
+  description?: string;
+}
+
+/**
+ * Union type of all tool types
+ */
+export type AnyTool =
+  | LLMSimpleTool
+  | LLMAgentTool
+  | SystemSimpleTool
+  | SystemAgentTool
+  | UserCommand
+  | MCPTool;
+
+/**
+ * Type guard: Check if tool is LLM Simple Tool
+ */
+export function isLLMSimpleTool(tool: AnyTool): tool is LLMSimpleTool {
+  return 'definition' in tool && 'execute' in tool && !('requiresSubLLM' in tool) && !('serverName' in tool);
+}
+
+/**
+ * Type guard: Check if tool is LLM Agent Tool
+ */
+export function isLLMAgentTool(tool: AnyTool): tool is LLMAgentTool {
+  return 'definition' in tool && 'requiresSubLLM' in tool && tool.requiresSubLLM === true;
+}
+
+/**
+ * Type guard: Check if tool is System Simple Tool
+ */
+export function isSystemSimpleTool(tool: AnyTool): tool is SystemSimpleTool {
+  return 'triggerCondition' in tool && !('requiresSubLLM' in tool);
+}
+
+/**
+ * Type guard: Check if tool is System Agent Tool
+ */
+export function isSystemAgentTool(tool: AnyTool): tool is SystemAgentTool {
+  return 'triggerCondition' in tool && 'requiresSubLLM' in tool && tool.requiresSubLLM === true;
+}
+
+/**
+ * Type guard: Check if tool is User Command
+ */
+export function isUserCommand(tool: AnyTool): tool is UserCommand {
+  return 'name' in tool && 'aliases' in tool || ('name' in tool && !('definition' in tool) && !('triggerCondition' in tool));
+}
+
+/**
+ * Type guard: Check if tool is MCP Tool
+ */
+export function isMCPTool(tool: AnyTool): tool is MCPTool {
+  return 'serverName' in tool && 'definition' in tool;
+}

package/src/types/index.ts

@@ -0,0 +1,181 @@
+/**
+ * LOCAL-CLI Type Definitions
+ *
+ * TypeScript type definitions used throughout the project
+ */
+
+/**
+ * Endpoint configuration
+ */
+export interface EndpointConfig {
+  id: string;
+  name: string;
+  baseUrl: string;
+  apiKey?: string;
+  models: ModelInfo[];
+  healthCheckInterval?: number;
+  priority?: number;
+  fallbackTo?: string;
+  description?: string;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+/**
+ * Model information
+ */
+export interface ModelInfo {
+  id: string;
+  name: string;
+  maxTokens: number;
+  costPerMToken?: number;
+  enabled: boolean;
+  lastHealthCheck?: Date;
+  healthStatus?: 'healthy' | 'degraded' | 'unhealthy';
+}
+
+/**
+ * LLM message
+ */
+export interface Message {
+  role: 'system' | 'user' | 'assistant' | 'tool' | 'error';
+  content: string;
+  name?: string;
+  tool_calls?: ToolCall[];
+  tool_call_id?: string;
+}
+
+/**
+ * Tool Call
+ */
+export interface ToolCall {
+  id: string;
+  type: 'function';
+  function: {
+    name: string;
+    arguments: string;
+  };
+}
+
+/**
+ * LLM request options
+ */
+export interface LLMRequestOptions {
+  model: string;
+  messages: Message[];
+  temperature?: number;
+  max_tokens?: number;
+  stream?: boolean;
+  tools?: ToolDefinition[];
+  tool_choice?: 'auto' | 'none' | 'required' | { type: 'function'; function: { name: string } };
+}
+
+/**
+ * LLM Response
+ */
+export interface LLMResponse {
+  choices: {
+    message: {
+      role: 'assistant' | 'system' | 'user';
+      content: string;
+      tool_calls?: ToolCall[];
+    };
+    finish_reason: 'stop' | 'length' | 'tool_calls' | 'function_call';
+    index?: number;
+  }[];
+  usage?: {
+    prompt_tokens: number;
+    completion_tokens: number;
+    total_tokens: number;
+  };
+  model?: string;
+}
+
+/**
+ * Tool definition
+ */
+export interface ToolDefinition {
+  type: 'function';
+  function: {
+    name: string;
+    description: string;
+    parameters: {
+      type: 'object';
+      properties: Record<string, unknown>;
+      required?: string[];
+    };
+  };
+}
+
+/**
+ * Session memory
+ */
+export interface SessionMemory {
+  sessionId: string;
+  tags: string[];
+  messages: Message[];
+  memory: Record<string, unknown>;
+  metadata: {
+    createdAt: Date;
+    updatedAt: Date;
+    model: string;
+    totalTokens: number;
+    directories: string[];
+    includedFiles: string[];
+  };
+}
+
+/**
+ * Configuration file structure
+ */
+export interface OpenConfig {
+  version: string;
+  currentEndpoint?: string;
+  currentModel?: string;
+  endpoints: EndpointConfig[];
+  settings: {
+    autoApprove: boolean;
+    debugMode: boolean;
+    streamResponse: boolean;
+    autoSave: boolean;
+  };
+  /** Enabled optional tool group IDs (persisted across sessions) */
+  enabledTools?: string[];
+  /** User-defined safe environment variables to pass to subprocesses (security) */
+  safeEnvVars?: string[];
+  /** Orquesta cloud connection token */
+  orquestaToken?: string;
+  /** Preferred agent mode: 'local' | 'orquesta' | 'ask' */
+  preferredAgent?: 'local' | 'orquesta' | 'ask';
+}
+
+/**
+ * TODO Item type for Plan-and-Execute Architecture
+ * Simplified: title only, no description
+ */
+export interface TodoItem {
+  id: string;
+  title: string;
+  status: 'pending' | 'in_progress' | 'completed' | 'failed';
+  result?: string;
+  error?: string;
+}
+
+/**
+ * Planning result from Planning LLM
+ */
+export interface PlanningResult {
+  todos: TodoItem[];
+  estimatedTime?: string;
+  complexity: 'simple' | 'moderate' | 'complex';
+  /** Direct response when no planning is needed */
+  directResponse?: string;
+  /** Clarification messages from ask_to_user during planning (Q&A pairs) */
+  clarificationMessages?: Message[];
+}
+
+/**
+ * TODO status type
+ */
+export type TodoStatus = 'pending' | 'in_progress' | 'completed' | 'failed';
+

package/src/ui/PlanExecuteView.tsx

@@ -0,0 +1,119 @@
+/**
+ * Plan-Execute View
+ *
+ * Main UI for Plan-and-Execute workflow with real-time progress
+ */
+
+import React from 'react';
+import { Box, Text } from 'ink';
+import { TodoItem } from '../types/index.js';
+import {
+  TodoListView,
+  StatusBar,
+  ProgressBar,
+} from './components/index.js';
+
+export interface PlanExecuteViewProps {
+  todos: TodoItem[];
+  currentTodo?: TodoItem;
+  model?: string;
+  endpoint?: string;
+  onExit?: () => void;
+}
+
+export const PlanExecuteView: React.FC<PlanExecuteViewProps> = ({
+  todos,
+  currentTodo,
+  model,
+  endpoint,
+}) => {
+  const completedTodos = todos.filter(t => t.status === 'completed').length;
+  const totalTodos = todos.length;
+
+  return (
+    <Box flexDirection="column" padding={1}>
+      {/* Title */}
+      <Box marginBottom={1} justifyContent="center">
+        <Text bold color="magenta">
+          🎼 ══════ ORQUESTA CLI ══════ 🎼
+        </Text>
+      </Box>
+      <Box marginBottom={1} justifyContent="center">
+        <Text color="blue" dimColor>
+          Orchestrating AI-Powered Development
+        </Text>
+      </Box>
+
+      {/* Overall Progress */}
+      <Box marginBottom={1}>
+        <ProgressBar
+          current={completedTodos}
+          total={totalTodos}
+          label="Overall Progress"
+          width={50}
+          showPercentage
+        />
+      </Box>
+
+      {/* Two Column Layout */}
+      <Box gap={2}>
+        {/* Left Column - TODO List */}
+        <Box width="50%">
+          <TodoListView
+            todos={todos}
+            title="Task List"
+            showDescription={false}
+          />
+        </Box>
+
+        {/* Right Column - Current Task Status */}
+        <Box width="50%">
+          {currentTodo ? (
+            <Box
+              borderStyle="round"
+              borderColor="magenta"
+              padding={1}
+              flexDirection="column"
+            >
+              <Text bold color="magenta">♪ Current Task:</Text>
+              <Text>{currentTodo.title}</Text>
+              <Box marginTop={1}>
+                <Text color="gray">Status: </Text>
+                <Text color={currentTodo.status === 'in_progress' ? 'magenta' : 'green'}>
+                  {currentTodo.status}
+                </Text>
+              </Box>
+            </Box>
+          ) : (
+            <Box
+              borderStyle="round"
+              borderColor="green"
+              padding={1}
+              justifyContent="center"
+              alignItems="center"
+            >
+              <Text bold color="green">
+                🎉 All tasks completed!
+              </Text>
+            </Box>
+          )}
+        </Box>
+      </Box>
+
+      {/* Status Bar */}
+      <Box marginTop={1}>
+        <StatusBar
+          model={model}
+          endpoint={endpoint}
+          status={currentTodo ? (currentTodo.status === 'in_progress' ? 'executing' : 'idle') : 'idle'}
+          message={currentTodo ? `Working on: ${currentTodo.title}` : 'All tasks complete'}
+        />
+      </Box>
+
+      {/* Instructions */}
+      <Box marginTop={1} justifyContent="center">
+        <Text dimColor>Press Ctrl+C to exit</Text>
+      </Box>
+    </Box>
+  );
+};