@fastino-ai/pioneer-cli 0.2.10 → 0.3.0

package/src/chat/index.ts

@@ -1,7 +0,0 @@
-/**
- * Chat module exports
- */
-
-export { ChatApp } from "./ChatApp.js";
-export type { ChatAppProps } from "./ChatApp.js";
-

package/src/client/ToolExecutor.ts

@@ -1,175 +0,0 @@
-/**
- * ToolExecutor - Executes CLI tools locally
- *
- * When the MLE Agent calls a CLI tool (bash, read_file, etc.), this executor
- * runs it on the user's machine and returns the result.
- */
-
-import { createBashTool } from "../tools/bash.js";
-import {
-  createReadFileTool,
-  createWriteFileTool,
-  createEditFileTool,
-  createListDirTool,
-  createSearchFilesTool,
-} from "../tools/filesystem.js";
-import type { Tool, ToolResult } from "../tools/types.js";
-
-export interface ToolExecutorOptions {
-  workingDirectory?: string;
-  allowedPaths?: string[];
-  maxFileSize?: number;
-  bashTimeout?: number;
-}
-
-export class ToolExecutor {
-  private tools: Map<string, Tool> = new Map();
-  private workingDirectory: string;
-
-  constructor(options: ToolExecutorOptions = {}) {
-    this.workingDirectory = options.workingDirectory || process.cwd();
-
-    const fsOptions = {
-      basePath: this.workingDirectory,
-      allowedPaths: options.allowedPaths,
-      maxFileSize: options.maxFileSize || 1024 * 1024, // 1MB default
-    };
-
-    const bashOptions = {
-      cwd: this.workingDirectory,
-      timeout: options.bashTimeout || 60000, // 60s default
-    };
-
-    // Register all CLI tools
-    this.registerTool(createBashTool(bashOptions));
-    this.registerTool(createReadFileTool(fsOptions));
-    this.registerTool(createWriteFileTool(fsOptions));
-    this.registerTool(createEditFileTool(fsOptions));
-    this.registerTool(createListDirTool(fsOptions));
-    this.registerTool(createSearchFilesTool(fsOptions));
-  }
-
-  private registerTool(tool: Tool): void {
-    this.tools.set(tool.name, tool);
-  }
-
-  /**
-   * Execute a tool by name with the given arguments.
-   * Returns the output string on success, throws on error.
-   */
-  async execute(toolName: string, args: Record<string, unknown>): Promise<string> {
-    const tool = this.tools.get(toolName);
-
-    if (!tool) {
-      throw new Error(`Unknown tool: ${toolName}. Available tools: ${this.getToolNames().join(", ")}`);
-    }
-
-    // Map argument names if needed (server uses different names)
-    const mappedArgs = this.mapArguments(toolName, args);
-
-    const result = await tool.execute(mappedArgs);
-
-    if (!result.success) {
-      throw new Error(result.error || `Tool ${toolName} failed`);
-    }
-
-    return result.output;
-  }
-
-  /**
-   * Map server argument names to local tool argument names.
-   * The server uses slightly different naming conventions.
-   */
-  private mapArguments(toolName: string, args: Record<string, unknown>): Record<string, unknown> {
-    const mapped = { ...args };
-
-    switch (toolName) {
-      case "read_file":
-        // Server: file_path, start_line, end_line
-        // Local: path, start_line, end_line
-        if ("file_path" in args) {
-          mapped.path = args.file_path;
-          delete mapped.file_path;
-        }
-        break;
-
-      case "write_file":
-        // Server: file_path, content
-        // Local: path, content
-        if ("file_path" in args) {
-          mapped.path = args.file_path;
-          delete mapped.file_path;
-        }
-        break;
-
-      case "edit_file":
-        // Server: file_path, old_text, new_text
-        // Local: path, old_text, new_text
-        if ("file_path" in args) {
-          mapped.path = args.file_path;
-          delete mapped.file_path;
-        }
-        break;
-
-      case "list_directory":
-        // Both use: path, recursive, max_depth
-        break;
-
-      case "search_files":
-        // Server: path, pattern, search_content, max_results
-        // Local: path, pattern, type
-        if (args.search_content) {
-          mapped.type = "content";
-        } else {
-          mapped.type = "filename";
-        }
-        delete mapped.search_content;
-        delete mapped.max_results;
-        break;
-
-      case "bash":
-        // Both use: command, workdir
-        break;
-    }
-
-    return mapped;
-  }
-
-  /**
-   * Get list of available tool names.
-   */
-  getToolNames(): string[] {
-    return Array.from(this.tools.keys());
-  }
-
-  /**
-   * Get a tool by name.
-   */
-  getTool(name: string): Tool | undefined {
-    return this.tools.get(name);
-  }
-
-  /**
-   * Check if a tool exists.
-   */
-  hasTool(name: string): boolean {
-    return this.tools.has(name);
-  }
-
-  /**
-   * Get working directory.
-   */
-  getWorkingDirectory(): string {
-    return this.workingDirectory;
-  }
-
-  /**
-   * Set working directory for bash commands.
-   */
-  setWorkingDirectory(dir: string): void {
-    this.workingDirectory = dir;
-
-    // Recreate bash tool with new working directory
-    this.registerTool(createBashTool({ cwd: dir }));
-  }
-}

package/src/client/WebSocketClient.ts

@@ -1,379 +0,0 @@
-/**
- * WebSocket client for Pioneer MLE Agent
- *
- * Connects to the /mle-agent/ws endpoint for bidirectional communication.
- * Handles tool_call messages by executing tools locally and sending results back.
- */
-
-import WebSocket from "ws";
-import { getApiKey, getBaseUrl, getWsUrl } from "../config.js";
-
-export interface WebSocketMessage {
-  type: string;
-  [key: string]: unknown;
-}
-
-export interface ToolCallRequest {
-  call_id: string;
-  tool: string;
-  args: Record<string, unknown>;
-}
-
-/**
- * Message format for conversation history.
- * Matches the format sent by the backend on done event.
- */
-export interface HistoryMessage {
-  role: "user" | "assistant" | "tool";
-  content: string;
-  tool_calls?: Array<{
-    id: string;
-    name: string;
-    args: Record<string, unknown>;
-  }>;
-  tool_call_id?: string;
-}
-
-export interface WebSocketClientCallbacks {
-  onStream?: (content: string) => void;
-  onToolStart?: (name: string, callId: string, args: Record<string, unknown>) => void;
-  onToolResult?: (name: string, callId: string, result: unknown) => void;
-  onToolError?: (name: string, callId: string, error: string) => void;
-  onToolCall?: (call: ToolCallRequest) => Promise<string>;
-  onAssistantMessage?: (content: string) => void;
-  onError?: (error: Error) => void;
-  onDone?: (messages?: HistoryMessage[], sessionId?: string) => void;
-}
-
-export interface ChatOptions {
-  history?: HistoryMessage[];
-  fileReferences?: string[];
-  config?: { model?: string };
-}
-
-type ConnectionState = "disconnected" | "connecting" | "connected";
-
-export class WebSocketClient {
-  private ws: WebSocket | null = null;
-  private wsUrl: string;
-  private apiKey: string | undefined;
-  private callbacks: WebSocketClientCallbacks = {};
-  private state: ConnectionState = "disconnected";
-  private messageResolvers: Map<string, (value: void) => void> = new Map();
-  private donePromise: Promise<void> | null = null;
-  private doneResolver: (() => void) | null = null;
-  private doneCalled: boolean = false;  // Prevent duplicate onDone calls
-
-  constructor() {
-    this.wsUrl = getWsUrl();
-    this.apiKey = getApiKey();
-  }
-
-  async connect(): Promise<void> {
-    if (this.state === "connected") return;
-    if (this.state === "connecting") {
-      // Wait for existing connection attempt
-      return new Promise((resolve) => {
-        const checkState = setInterval(() => {
-          if (this.state === "connected") {
-            clearInterval(checkState);
-            resolve();
-          }
-        }, 100);
-      });
-    }
-
-    this.state = "connecting";
-
-    // Build WebSocket options with X-API-Key header for authentication
-    const wsOptions: WebSocket.ClientOptions = {};
-    if (this.apiKey) {
-      wsOptions.headers = {
-        "X-API-Key": this.apiKey,
-      };
-    }
-
-    return new Promise((resolve, reject) => {
-      this.ws = new WebSocket(this.wsUrl, wsOptions);
-
-      this.ws.on("open", () => {
-        this.state = "connected";
-        // Send auth explicitly as a defensive fallback when header auth is not
-        // propagated by proxy layers (some environments only support
-        // first-message auth for WS).
-        if (this.apiKey) {
-          this.ws?.send(JSON.stringify({ type: "auth", api_key: this.apiKey }));
-        }
-        resolve();
-      });
-
-      this.ws.on("error", (err: Error | { message?: string; error?: Error }) => {
-        this.state = "disconnected";
-        // Extract meaningful error message from ErrorEvent or Error
-        const errorMessage = err instanceof Error
-          ? err.message
-          : (err as { message?: string; error?: Error }).message
-            || (err as { error?: Error }).error?.message
-            || "WebSocket connection failed";
-        reject(new Error(errorMessage));
-      });
-
-      this.ws.on("close", () => {
-        this.state = "disconnected";
-        // Only call onDone if not already called (prevents duplicate)
-        if (!this.doneCalled) {
-          this.doneCalled = true;
-          this.callbacks.onDone?.(undefined, undefined);
-        }
-        if (this.doneResolver) {
-          this.doneResolver();
-          this.doneResolver = null;
-        }
-      });
-
-      this.ws.on("message", async (data: WebSocket.RawData) => {
-        try {
-          const message = JSON.parse(data.toString()) as WebSocketMessage;
-          await this.handleMessage(message);
-        } catch (err: unknown) {
-          console.error("Failed to parse WebSocket message:", err);
-        }
-      });
-    });
-  }
-
-  private async handleMessage(message: WebSocketMessage): Promise<void> {
-    switch (message.type) {
-      case "auth_required":
-        if (this.apiKey) {
-          this.send({ type: "auth", api_key: this.apiKey });
-        }
-        break;
-
-      case "auth_success":
-        break;
-
-      case "stream":
-        this.callbacks.onStream?.(message.content as string);
-        break;
-
-      case "tool_start":
-        this.callbacks.onToolStart?.(
-          message.name as string,
-          message.call_id as string,
-          message.args as Record<string, unknown>
-        );
-        break;
-
-      case "tool_call":
-        // Server is asking client to execute a tool locally
-        if (this.callbacks.onToolCall) {
-          const call: ToolCallRequest = {
-            call_id: message.call_id as string,
-            tool: message.tool as string,
-            args: message.args as Record<string, unknown>,
-          };
-
-          try {
-            const result = await this.callbacks.onToolCall(call);
-            this.sendToolResult(call.call_id, result);
-          } catch (error) {
-            const errorMsg = error instanceof Error ? error.message : String(error);
-            this.sendToolResult(call.call_id, null, errorMsg);
-          }
-        } else {
-          // No tool executor configured, send error
-          this.sendToolResult(
-            message.call_id as string,
-            null,
-            "No tool executor configured on client"
-          );
-        }
-        break;
-
-      case "tool_result":
-        this.callbacks.onToolResult?.(
-          message.name as string,
-          message.call_id as string,
-          message.result
-        );
-        break;
-
-      case "tool_error":
-        this.callbacks.onToolError?.(
-          message.name as string,
-          message.call_id as string,
-          message.error as string
-        );
-        break;
-
-      case "assistant_message":
-        this.callbacks.onAssistantMessage?.(message.content as string);
-        break;
-
-      case "error":
-        this.callbacks.onError?.(new Error(message.message as string));
-        break;
-
-      case "done":
-        // Only call onDone once (prevents duplicate with ws.onclose)
-        if (!this.doneCalled) {
-          this.doneCalled = true;
-          // Pass the message history if provided by the backend
-          const messages = message.messages as HistoryMessage[] | undefined;
-          const sessionId = typeof message.session_id === "string" ? message.session_id : undefined;
-          console.log(
-            "[DEBUG] Done event received, messages:",
-            messages?.length,
-            "roles:",
-            messages?.map((m) => m.role),
-            "sessionId:",
-            sessionId
-          );
-          this.callbacks.onDone?.(messages, sessionId);
-        }
-        if (this.doneResolver) {
-          this.doneResolver();
-          this.doneResolver = null;
-        }
-        break;
-
-      case "ping":
-        this.send({ type: "pong" });
-        break;
-
-      case "budget_warning":
-        // Could add a callback for this if needed
-        console.warn("Budget warning:", message.warnings);
-        break;
-    }
-  }
-
-  private send(message: WebSocketMessage): void {
-    if (this.ws?.readyState === WebSocket.OPEN) {
-      this.ws.send(JSON.stringify(message));
-    }
-  }
-
-  private sendToolResult(callId: string, result: string | null, error?: string): void {
-    this.send({
-      type: "tool_result",
-      call_id: callId,
-      result: result || "",
-      ...(error && { error }),
-    });
-  }
-
-  /**
-   * Send a chat message and wait for completion.
-   * The onToolCall callback will be invoked for client-side tool execution.
-   */
-  async chat(
-    message: string,
-    callbacks: WebSocketClientCallbacks,
-    options: ChatOptions = {}
-  ): Promise<void> {
-    if (this.state !== "connected") {
-      await this.connect();
-    }
-
-    this.callbacks = callbacks;
-    this.doneCalled = false;  // Reset for new chat
-
-    // Create promise that resolves when "done" is received
-    this.donePromise = new Promise((resolve) => {
-      this.doneResolver = resolve;
-    });
-
-    // Send chat message
-    this.send({
-      type: "chat",
-      message,
-      client_type: "cli",
-      history: options.history || [],
-      file_references: options.fileReferences || [],
-      config: options.config,
-    });
-
-    // Wait for completion
-    await this.donePromise;
-  }
-
-  /**
-   * Disconnect from the WebSocket server.
-   */
-  disconnect(): void {
-    if (this.ws) {
-      this.ws.close();
-      this.ws = null;
-    }
-    this.state = "disconnected";
-  }
-
-  /**
-   * Check if currently connected.
-   */
-  isConnected(): boolean {
-    return this.state === "connected";
-  }
-
-  /**
-   * Get the REST API base URL (for display purposes).
-   */
-  getRestApiUrl(): string {
-    return getBaseUrl();
-  }
-
-  /**
-   * Get the WebSocket URL (for display purposes).
-   */
-  getWebSocketUrl(): string {
-    return this.wsUrl;
-  }
-
-  /**
-   * Check server health via HTTP (WebSocket doesn't have health check).
-   */
-  async health(): Promise<boolean> {
-    try {
-      const httpUrl = getBaseUrl();
-
-      const headers: Record<string, string> = {
-        "Content-Type": "application/json",
-      };
-
-      if (this.apiKey) {
-        headers["X-API-Key"] = this.apiKey;
-      }
-
-      const response = await fetch(`${httpUrl}/health`, { headers });
-      return response.ok;
-    } catch {
-      return false;
-    }
-  }
-
-  /**
-   * List available tools from the server.
-   */
-  async listTools(): Promise<Array<{ name: string; description: string }>> {
-    const httpUrl = getBaseUrl();
-    const url = `${httpUrl}/mle-agent/tools?client_type=cli`;
-
-    const headers: Record<string, string> = {
-      "Content-Type": "application/json",
-    };
-
-    if (this.apiKey) {
-      headers["X-API-Key"] = this.apiKey;
-    }
-
-    const response = await fetch(url, { headers });
-    if (!response.ok) {
-      throw new Error(`Failed to list tools: ${response.status}`);
-    }
-
-    const data = await response.json();
-    return data.tools || [];
-  }
-}

package/src/client/index.ts

@@ -1,2 +0,0 @@
-export { WebSocketClient } from "./WebSocketClient.js";
-export { ToolExecutor } from "./ToolExecutor.js";