@ebowwa/coder 0.7.63 → 0.7.64

package/packages/src/index.ts

@@ -0,0 +1,120 @@
+/**
+ * Coder - AI-powered terminal coding assistant
+ * Main entry point
+ */
+
+// Types
+export * from "./types/index.js";
+
+// Core
+export {
+  createMessageStream,
+  calculateCost,
+  buildSystemPrompt,
+  buildCachedMessages,
+  calculateCacheMetrics,
+} from "./core/api-client.js";
+export type { StreamOptionsType as StreamOptions, StreamResultType as StreamResult } from "./core/api-client.js";
+export {
+  agentLoop,
+  formatCost,
+  formatMetrics,
+  formatCostBrief,
+  formatCacheMetrics,
+} from "./core/agent-loop.js";
+export type { AgentLoopOptions, AgentLoopResult } from "./core/agent-loop.js";
+
+// Permissions (types are re-exported via ./types/index.js)
+export {
+  PermissionManager,
+  assessRiskLevel,
+  generateDescription,
+  isReadOnlyTool,
+  isFileEditTool,
+  isSystemTool,
+  TOOL_CATEGORIES,
+} from "./core/permissions.js";
+
+// Session Store
+export {
+  SessionStore,
+  formatSessionSummary,
+  printSessionsList,
+} from "./core/session-store.js";
+export type {
+  SessionMetadata,
+  SessionMessage,
+  SessionToolUse,
+  SessionMetrics,
+  SessionContext,
+  SessionEntry,
+  SessionSummary,
+  LoadedSession,
+} from "./core/session-store.js";
+
+// Tools
+export * from "./ecosystem/tools/index.js";
+
+// MCP (renamed to avoid conflict with MCPClient type)
+export { MCPClientImpl } from "./interfaces/mcp/client.js";
+export { MCPClientImpl as MCPClient } from "./interfaces/mcp/client.js";
+
+// Hooks
+export * from "./ecosystem/hooks/index.js";
+
+// Skills
+export * from "./ecosystem/skills/index.js";
+
+// Teammates
+export * from "./teammates/index.js";
+
+// Cognitive Security
+export * from "./core/cognitive-security/index.js";
+
+// UI Components (exclude types that are already in types/index.js)
+export {
+  Spinner,
+  getSpinner,
+  resetSpinner,
+  defaultFrames,
+  dotFrames,
+  arrowFrames,
+  defaultTips,
+  toolTips,
+  streamingTips,
+  type SpinnerOptions,
+  type SpinnerColor,
+  type SpinnerState,
+  LoadingState,
+  getLoadingState,
+  setLoading,
+  stopLoading,
+  updateLoading,
+  startTool,
+  endTool,
+  type LoadingStateEvents,
+  type ProgressUpdate,
+  type ProgressCallback,
+  createProgressCallback,
+  formatElapsedTime,
+  formatLoadingMessage,
+} from "./interfaces/ui/index.js";
+
+// Native module (Rust)
+export * from "./native/index.js";
+
+// Context Compaction
+export {
+  estimateTokens,
+  estimateMessagesTokens,
+  compactMessages,
+  needsCompaction,
+  summarizeMessages,
+  summarizeWithLLM,
+  getCompactionStats,
+} from "./core/context-compaction.js";
+export type {
+  CompactionOptions,
+  CompactionResult,
+  LLMSummarizationOptions,
+} from "./core/context-compaction.js";

package/packages/src/interfaces/mcp/client.ts

@@ -0,0 +1,389 @@
+/**
+ * MCP Client - Model Context Protocol implementation
+ */
+
+import type {
+  MCPServerConfig,
+  MCPTool,
+  JSONRPCRequest,
+  JSONRPCResponse,
+  JSONRPCNotification,
+  JSONSchema,
+  ToolResult,
+} from "../../types/index.js";
+import { spawn, type ChildProcess } from "child_process";
+import WebSocket from "ws";
+
+export interface MCPClientOptions {
+  name: string;
+  config: MCPServerConfig;
+  onLog?: (message: string) => void;
+}
+
+export class MCPClientImpl {
+  // Alias for backwards compatibility
+  static readonly MCPClient = MCPClientImpl;
+  name: string;
+  config: MCPServerConfig;
+  connected = false;
+  tools: MCPTool[] = [];
+
+  private process: ChildProcess | null = null;
+  private websocket: WebSocket | null = null;
+  private requestId = 0;
+  private pendingRequests = new Map<
+    string | number,
+    {
+      resolve: (value: unknown) => void;
+      reject: (error: Error) => void;
+    }
+  >();
+  private buffer = "";
+  private onLog?: (message: string) => void;
+
+  constructor(options: MCPClientOptions) {
+    this.name = options.name;
+    this.config = options.config;
+    this.onLog = options.onLog;
+  }
+
+  async connect(): Promise<void> {
+    if (this.config.type === "stdio") {
+      await this.connectStdio();
+    } else if (this.config.type === "http" || this.config.type === "sse") {
+      await this.connectHttp();
+    } else if (this.config.type === "ws") {
+      await this.connectWebSocket();
+    }
+  }
+
+  private async connectStdio(): Promise<void> {
+    if (!this.config.command) {
+      throw new Error("No command specified for stdio transport");
+    }
+
+    this.log(`Starting stdio transport: ${this.config.command}`);
+
+    this.process = spawn(this.config.command, this.config.args || [], {
+      env: { ...process.env, ...this.config.env },
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+
+    this.process.stdout?.on("data", (data: Buffer) => {
+      this.handleData(data.toString());
+    });
+
+    this.process.stderr?.on("data", (data: Buffer) => {
+      this.log(`stderr: ${data.toString()}`);
+    });
+
+    this.process.on("error", (error: Error) => {
+      this.log(`Process error: ${error.message}`);
+    });
+
+    this.process.on("close", (code: number) => {
+      this.log(`Process closed with code ${code}`);
+      this.connected = false;
+    });
+
+    // Wait for process to start
+    await new Promise((resolve) => setTimeout(resolve, 100));
+
+    // Initialize connection
+    await this.initialize();
+  }
+
+  private async connectHttp(): Promise<void> {
+    if (!this.config.url) {
+      throw new Error("No URL specified for HTTP transport");
+    }
+
+    this.log(`Starting HTTP transport: ${this.config.url}`);
+
+    // For HTTP transport, we just validate the endpoint
+    try {
+      const response = await fetch(this.config.url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...this.config.headers,
+        },
+        body: JSON.stringify({
+          jsonrpc: "2.0",
+          id: 1,
+          method: "initialize",
+          params: {
+            protocolVersion: "2024-11-05",
+            capabilities: {},
+            clientInfo: {
+              name: "coder",
+              version: "0.1.0",
+            },
+          },
+        }),
+      });
+
+      if (!response.ok) {
+        throw new Error(`HTTP error: ${response.status}`);
+      }
+
+      const result = (await response.json()) as JSONRPCResponse;
+      this.connected = true;
+
+      // Get tools
+      await this.loadTools();
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      throw new Error(`Failed to connect to HTTP server: ${errorMessage}`);
+    }
+  }
+
+  private async connectWebSocket(): Promise<void> {
+    if (!this.config.url) {
+      throw new Error("No URL specified for WebSocket transport");
+    }
+
+    const url = this.config.url;
+    this.log(`Starting WebSocket transport: ${url}`);
+
+    return new Promise((resolve, reject) => {
+      const headers: Record<string, string> = {
+        ...this.config.headers,
+      };
+
+      const ws = new WebSocket(url, {
+        headers,
+        handshakeTimeout: this.config.timeout || 30000,
+      });
+
+      ws.on("open", () => {
+        this.log("WebSocket connection established");
+        this.websocket = ws;
+        this.connected = true;
+
+        // Initialize the MCP connection
+        this.initialize()
+          .then(() => resolve())
+          .catch((error) => {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            this.log(`Initialization failed: ${errorMessage}`);
+            reject(error);
+          });
+      });
+
+      ws.on("message", (data: WebSocket.RawData, isBinary: boolean) => {
+        const message = isBinary ? data.toString() : data.toString();
+        this.handleData(message);
+      });
+
+      ws.on("error", (error: Error) => {
+        this.log(`WebSocket error: ${error.message}`);
+        if (!this.connected) {
+          reject(new Error(`WebSocket connection failed: ${error.message}`));
+        }
+      });
+
+      ws.on("close", (code: number, reason: Buffer) => {
+        this.log(`WebSocket closed: code=${code}, reason=${reason.toString()}`);
+        this.connected = false;
+        this.websocket = null;
+
+        // Reject any pending requests
+        for (const [id, pending] of this.pendingRequests) {
+          this.pendingRequests.delete(id);
+          pending.reject(new Error(`WebSocket closed: ${reason.toString()}`));
+        }
+      });
+
+      ws.on("ping", () => {
+        ws.pong();
+      });
+    });
+  }
+
+  private async initialize(): Promise<void> {
+    const result = await this.request("initialize", {
+      protocolVersion: "2024-11-05",
+      capabilities: {
+        tools: {},
+        resources: {},
+        prompts: {},
+      },
+      clientInfo: {
+        name: "coder",
+        version: "0.1.0",
+      },
+    });
+
+    this.log(`Initialized with: ${JSON.stringify(result)}`);
+    this.connected = true;
+
+    // Send initialized notification
+    this.notify("notifications/initialized", {});
+
+    // Load tools
+    await this.loadTools();
+  }
+
+  private async loadTools(): Promise<void> {
+    try {
+      const result = (await this.request("tools/list", {})) as {
+        tools: Array<{
+          name: string;
+          description: string;
+          inputSchema: JSONSchema;
+        }>;
+      };
+
+      this.tools = result.tools.map((tool) => ({
+        name: tool.name,
+        description: tool.description,
+        inputSchema: tool.inputSchema,
+      }));
+
+      this.log(`Loaded ${this.tools.length} tools`);
+    } catch (error) {
+      this.log(`Failed to load tools: ${error}`);
+    }
+  }
+
+  async callTool(name: string, args: Record<string, unknown>): Promise<ToolResult> {
+    const result = (await this.request("tools/call", {
+      name,
+      arguments: args,
+    })) as { content: Array<{ type: string; text?: string }> };
+
+    const text = result.content
+      .filter((c) => c.type === "text")
+      .map((c) => c.text || "")
+      .join("\n");
+
+    return {
+      content: text,
+    };
+  }
+
+  async request(method: string, params: unknown): Promise<unknown> {
+    const id = ++this.requestId;
+
+    const request: JSONRPCRequest = {
+      jsonrpc: "2.0",
+      id,
+      method,
+      params,
+    };
+
+    return new Promise((resolve, reject) => {
+      this.pendingRequests.set(id, { resolve, reject });
+
+      const message = JSON.stringify(request);
+
+      // Send via WebSocket or stdio depending on transport type
+      if (this.websocket && this.websocket.readyState === WebSocket.OPEN) {
+        this.websocket.send(message);
+      } else if (this.process?.stdin?.writable) {
+        this.process.stdin.write(message + "\n");
+      } else {
+        this.pendingRequests.delete(id);
+        reject(new Error("No active connection to send request"));
+        return;
+      }
+
+      // Timeout
+      setTimeout(() => {
+        if (this.pendingRequests.has(id)) {
+          this.pendingRequests.delete(id);
+          reject(new Error(`Request timeout for ${method}`));
+        }
+      }, this.config.timeout || 120000);
+    });
+  }
+
+  notify(method: string, params: unknown): void {
+    const notification: JSONRPCNotification = {
+      jsonrpc: "2.0",
+      method,
+      params,
+    };
+
+    const message = JSON.stringify(notification);
+
+    // Send via WebSocket or stdio depending on transport type
+    if (this.websocket && this.websocket.readyState === WebSocket.OPEN) {
+      this.websocket.send(message);
+    } else if (this.process?.stdin?.writable) {
+      this.process.stdin.write(message + "\n");
+    }
+  }
+
+  private handleData(data: string): void {
+    this.buffer += data;
+
+    const lines = this.buffer.split("\n");
+    this.buffer = lines.pop() || "";
+
+    for (const line of lines) {
+      if (!line.trim()) continue;
+
+      try {
+        const response = JSON.parse(line) as JSONRPCResponse;
+
+        if (response.id !== undefined) {
+          const pending = this.pendingRequests.get(response.id);
+          if (pending) {
+            this.pendingRequests.delete(response.id);
+            if (response.error) {
+              pending.reject(new Error(response.error.message));
+            } else {
+              pending.resolve(response.result);
+            }
+          }
+        }
+      } catch (error) {
+        this.log(`Parse error: ${error}`);
+      }
+    }
+  }
+
+  async close(): Promise<void> {
+    if (this.websocket) {
+      this.websocket.close();
+      this.websocket = null;
+    }
+    if (this.process) {
+      this.process.kill();
+      this.process = null;
+    }
+    this.connected = false;
+  }
+
+  private log(message: string): void {
+    this.onLog?.(`[MCP:${this.name}] ${message}`);
+  }
+}
+
+/**
+ * Create MCP clients from config
+ */
+export async function createMCPClients(
+  servers: Record<string, MCPServerConfig>,
+  onLog?: (message: string) => void
+): Promise<Map<string, MCPClientImpl>> {
+  const clients = new Map<string, MCPClientImpl>();
+
+  for (const [name, config] of Object.entries(servers)) {
+    if (config.disabled) continue;
+
+    const client = new MCPClientImpl({ name, config, onLog });
+
+    try {
+      await client.connect();
+      clients.set(name, client);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      onLog?.(`[MCP:${name}] Failed to connect: ${errorMessage}`);
+    }
+  }
+
+  return clients;
+}

package/packages/src/interfaces/ui/index.ts

@@ -0,0 +1,161 @@
+/**
+ * UI Components for Coder CLI
+ */
+
+// Spinner
+export {
+  Spinner,
+  getSpinner,
+  resetSpinner,
+  defaultFrames,
+  dotFrames,
+  arrowFrames,
+  defaultTips,
+  toolTips,
+  streamingTips,
+  type SpinnerOptions,
+  type SpinnerColor,
+  type SpinnerState,
+} from "./spinner.js";
+
+// Loading State (from shared)
+export {
+  LoadingState,
+  getLoadingState,
+  setLoading,
+  stopLoading,
+  updateLoading,
+  startTool,
+  endTool,
+  type LoadingPhase,
+  type LoadingStateData,
+  type LoadingStateEvents,
+} from "./terminal/shared/loading-state.js";
+
+// Status Line (from shared)
+export {
+  VERSION,
+  BUILD_TIME,
+  renderStatusLine,
+  renderCompactStatusLine,
+  renderMinimalStatusLine,
+  renderFooterStatus,
+  renderAutoCompactWarning,
+  calculateContextInfo,
+  formatPermissionMode,
+  formatTokenCount,
+  formatContextPercent,
+  getContextWindow,
+  shouldShowAutoCompactWarning,
+  getModelDisplayName,
+  getPermissionModeDisplay,
+  type StatusLineOptions,
+  type ContextInfo,
+} from "./terminal/shared/status-line.js";
+
+// TUI Footer (from tui)
+export {
+  TUIFooter,
+  getTUIFooter,
+  enableTUIFooter,
+  disableTUIFooter,
+  renderTUIFooter,
+  clearTUIFooter,
+  ANSI,
+  type TUIFooterOptions,
+  type TUIFooterState,
+} from "./terminal/tui/tui-footer.js";
+
+// TUI App (Ink-based, from tui)
+export {
+  createTUIApp,
+  type TUIAppProps,
+  type TUIAppHandle,
+  type Message as TUIMessage,
+} from "./terminal/tui/tui-app.js";
+export { default as TUIApp } from "./terminal/tui/tui-app.js";
+
+// ============================================
+// PROGRESS CALLBACK TYPES
+// ============================================
+
+/**
+ * Progress update for tool execution
+ */
+export interface ProgressUpdate {
+  toolName: string;
+  status: "pending" | "running" | "complete" | "error";
+  message?: string;
+  progress?: number; // 0-100
+  timestamp: number;
+}
+
+/**
+ * Progress callback type for tool context
+ */
+export type ProgressCallback = (update: ProgressUpdate) => void;
+
+/**
+ * Create a progress callback for a specific tool
+ */
+export function createProgressCallback(
+  toolName: string,
+  onProgress?: (message: string) => void
+): ProgressCallback {
+  return (update: ProgressUpdate) => {
+    if (onProgress) {
+      const message = update.message || `${update.toolName}: ${update.status}`;
+      onProgress(message);
+    }
+  };
+}
+
+// ============================================
+// UTILITY FUNCTIONS
+// ============================================
+
+/**
+ * Format elapsed time for display
+ */
+export function formatElapsedTime(ms: number): string {
+  if (ms < 1000) {
+    return `${ms}ms`;
+  }
+
+  const seconds = Math.floor(ms / 1000);
+  if (seconds < 60) {
+    return `${seconds}s`;
+  }
+
+  const minutes = Math.floor(seconds / 60);
+  const remainingSeconds = seconds % 60;
+
+  if (minutes < 60) {
+    return `${minutes}m${remainingSeconds}s`;
+  }
+
+  const hours = Math.floor(minutes / 60);
+  const remainingMinutes = minutes % 60;
+  return `${hours}h${remainingMinutes}m`;
+}
+
+/**
+ * Format a loading message with optional phase
+ */
+export function formatLoadingMessage(
+  phase: string,
+  message?: string,
+  elapsedTime?: number
+): string {
+  let result = phase;
+
+  if (message) {
+    result = `${result}: ${message}`;
+  }
+
+  if (elapsedTime !== undefined && elapsedTime > 0) {
+    result = `${result} [${formatElapsedTime(elapsedTime)}]`;
+  }
+
+  return result;
+}