@ebowwa/coder 0.7.64 → 0.7.66

package/packages/src/ecosystem/tools/index.ts

@@ -1852,6 +1852,175 @@ export const AnalyzeImageTool: ToolDefinition = {
   },
 };
 
+// ============================================
+// TEAMMATE COORDINATION TOOLS
+// ============================================
+
+/**
+ * Check for new messages from teammates
+ */
+const TeammateCheckMessagesTool: ToolDefinition = {
+  name: "teammate_check_messages",
+  description:
+    "Check for new messages from other teammates in your team. Returns pending messages and clears the inbox. Use this periodically when in teammate mode to receive tasks and coordination messages.",
+  input_schema: {
+    type: "object",
+    properties: {},
+  },
+  handler: async (_args, _context: ToolContext): Promise<ToolResult> => {
+    const { getTeammateRunner } = await import("../../teammates/runner.js");
+    const runner = getTeammateRunner();
+    if (!runner) {
+      return {
+        content: "Teammate mode is not active. Start with --teammate-mode flag.",
+        is_error: true,
+      };
+    }
+
+    const messages = runner.getPendingMessages();
+    if (messages.length === 0) {
+      return { content: "No pending messages." };
+    }
+
+    const formatted = messages
+      .map((m) => `[${m.type}] From: ${m.from}\n${m.content}`)
+      .join("\n\n---\n\n");
+
+    return { content: `Received ${messages.length} message(s):\n\n${formatted}` };
+  },
+};
+
+/**
+ * Send a direct message to another teammate
+ */
+const TeammateSendMessageTool: ToolDefinition = {
+  name: "teammate_send_message",
+  description:
+    "Send a direct message to a specific teammate or broadcast to all teammates. Use this for coordination, sharing results, or requesting help.",
+  input_schema: {
+    type: "object",
+    properties: {
+      to: {
+        type: "string",
+        description:
+          "Teammate ID to send to, or 'broadcast' to send to all teammates",
+      },
+      message: {
+        type: "string",
+        description: "The message content to send",
+      },
+    },
+    required: ["to", "message"],
+  },
+  handler: async (args, _context: ToolContext): Promise<ToolResult> => {
+    const { getTeammateRunner } = await import("../../teammates/runner.js");
+    const runner = getTeammateRunner();
+    if (!runner) {
+      return {
+        content: "Teammate mode is not active. Start with --teammate-mode flag.",
+        is_error: true,
+      };
+    }
+
+    const to = args.to as string;
+    const message = args.message as string;
+
+    if (to === "broadcast") {
+      runner.broadcast(message);
+      return { content: `Broadcast message sent to team.` };
+    } else {
+      runner.sendDirectMessage(to, message);
+      return { content: `Direct message sent to ${to}.` };
+    }
+  },
+};
+
+/**
+ * Report idle status to team
+ */
+const TeammateReportIdleTool: ToolDefinition = {
+  name: "teammate_report_idle",
+  description:
+    "Report that you are now idle and ready for new tasks. Use this when you complete your current work and are available for assignment.",
+  input_schema: {
+    type: "object",
+    properties: {
+      message: {
+        type: "string",
+        description: "Optional status message",
+      },
+    },
+  },
+  handler: async (args, _context: ToolContext): Promise<ToolResult> => {
+    const { getTeammateRunner } = await import("../../teammates/runner.js");
+    const runner = getTeammateRunner();
+    if (!runner) {
+      return {
+        content: "Teammate mode is not active. Start with --teammate-mode flag.",
+        is_error: true,
+      };
+    }
+
+    const message = args.message as string | undefined;
+    runner.updateStatus("idle");
+    runner.broadcast(message || "Now idle and ready for tasks.");
+    return { content: "Status updated to idle. Team notified." };
+  },
+};
+
+/**
+ * Get teammate status information
+ */
+const TeammateGetStatusTool: ToolDefinition = {
+  name: "teammate_get_status",
+  description:
+    "Get current teammate mode status including your info, team members, and inbox stats. Use this to check your state and team coordination.",
+  input_schema: {
+    type: "object",
+    properties: {},
+  },
+  handler: async (_args, _context: ToolContext): Promise<ToolResult> => {
+    const { getTeammateRunner } = await import("../../teammates/runner.js");
+    const runner = getTeammateRunner();
+    if (!runner) {
+      return {
+        content: "Teammate mode is not active. Start with --teammate-mode flag.",
+        is_error: true,
+      };
+    }
+
+    const teammate = runner.getTeammate();
+    const team = runner.getTeam();
+    const status = runner.getStatus();
+    const inbox = runner.getInboxStats();
+
+    const info = {
+      teammate: teammate
+        ? {
+            id: teammate.teammateId,
+            name: teammate.name,
+            color: teammate.color,
+          }
+        : null,
+      team: team
+        ? {
+            name: team.name,
+            memberCount: team.teammates.length,
+            members: team.teammates.map((t) => ({
+              id: t.teammateId,
+              name: t.name,
+              status: t.status,
+            })),
+          }
+        : null,
+      status,
+      inbox,
+    };
+
+    return { content: JSON.stringify(info, null, 2) };
+  },
+};
+
 export const builtInTools: ToolDefinition[] = [
   ReadTool,
   WriteTool,
@@ -1870,6 +2039,11 @@ export const builtInTools: ToolDefinition[] = [
   NotebookEditTool,
   AnalyzeImageTool,
   TempGlmVisionTool,
+  // Teammate coordination tools
+  TeammateCheckMessagesTool,
+  TeammateSendMessageTool,
+  TeammateReportIdleTool,
+  TeammateGetStatusTool,
 ];
 
 export function getToolByName(name: string): ToolDefinition | undefined {

package/packages/src/index.ts

@@ -71,6 +71,27 @@ export * from "./teammates/index.js";
 // Cognitive Security
 export * from "./core/cognitive-security/index.js";
 
+// Providers
+export {
+  PROVIDERS,
+  getProvider,
+  getProviderForModel,
+  resolveProvider,
+  isProviderHealthy,
+  getHealthyProviders,
+  getNextHealthyProvider,
+  recordProviderSuccess,
+  recordProviderFailure,
+  getProviderHealth,
+} from "./core/providers/index.js";
+export type {
+  ProviderName,
+  ProviderConfig,
+  ProviderHealth,
+  ResolvedProvider,
+  ProviderRoutingConfig,
+} from "./core/providers/index.js";
+
 // UI Components (exclude types that are already in types/index.js)
 export {
   Spinner,
@@ -112,9 +133,9 @@ export {
   summarizeMessages,
   summarizeWithLLM,
   getCompactionStats,
-} from "./core/context-compaction.js";
+} from "./core/context/index.js";
 export type {
   CompactionOptions,
   CompactionResult,
   LLMSummarizationOptions,
-} from "./core/context-compaction.js";
+} from "./core/context/index.js";

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

@@ -53,27 +53,24 @@ export {
   type ContextInfo,
 } from "./terminal/shared/status-line.js";
 
-// TUI Footer (from tui)
+// Interactive CLI (non-React, from interactive module)
 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";
+  InteractiveRunner,
+  runInteractiveMode,
+  MessageStoreImpl,
+  InputManagerImpl,
+  KeyEvents,
+  InputPriority,
+  type InteractiveRunnerProps,
+  type InteractiveState,
+  type UIMessage,
+  type MessageSubType,
+  type MessageStore,
+  type InputManager,
+  type InputHandler,
+  type InputHandlerOptions,
+  type NativeKeyEvent,
+} from "./terminal/cli/interactive/index.js";
 
 // ============================================
 // PROGRESS CALLBACK TYPES

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

@@ -7,14 +7,14 @@
 import ora, { type Ora } from "ora";
 import chalk from "chalk";
 
-// Import spinner frames from the single source of truth
+// Import spinner frames from the single source of truth (shared)
 import {
   spinnerFrames,
   dotSpinnerFrames,
   asciiSpinnerFrames,
   arrowSpinnerFrames,
   simpleDotFrames,
-} from "./terminal/tui/spinner.js";
+} from "./terminal/shared/spinner-frames.js";
 
 // Re-export for external use
 export {

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

@@ -0,0 +1,370 @@
+/**
+ * TUI Bridge Module
+ * Enables external control of coder via TUI Bridge MCP
+ *
+ * This module provides:
+ * 1. State export for external parsing
+ * 2. Command execution from external sources
+ * 3. Event emission for external listeners
+ * 4. Screen capture and export utilities
+ */
+
+import { EventEmitter } from "events";
+import type {
+  BridgeState,
+  BridgeEvent,
+  BridgeCommand,
+  BridgeCommandResult,
+  TUIBridgeConfig,
+  ParsedScreen,
+  ScreenBuffer,
+  ScreenCell,
+  UIElement,
+  UIElementType,
+  BridgeEventType,
+} from "./types.js";
+
+// Re-export screen-export utilities
+export {
+  DEFAULT_CELL,
+  parseANSIText,
+  stripANSI,
+  createScreenBuffer,
+  renderToScreenBuffer,
+  captureScreen,
+  detectUIElements,
+  exportToText,
+  exportToJSON,
+  exportToHTML,
+  exportToMarkdown,
+  exportScreen,
+  parseScreen,
+  createScreenExportAPI,
+  type ExportFormat,
+  type ExportOptions,
+  type ScreenExportAPI,
+} from "./screen-export.js";
+
+// Import for use in TUIBridge
+import {
+  createScreenBuffer as createBuffer,
+  parseANSIText,
+  renderToScreenBuffer,
+  detectUIElements,
+  exportScreen as doExport,
+  parseScreen,
+} from "./screen-export.js";
+import type { ExportFormat, ExportOptions } from "./screen-export.js";
+
+/**
+ * TUI Bridge singleton for external control
+ */
+export class TUIBridge extends EventEmitter {
+  private static instance: TUIBridge | null = null;
+  private config: TUIBridgeConfig;
+  private state: BridgeState | null = null;
+  private subscribers: Set<string> = new Set();
+  private commandQueue: Array<{ command: BridgeCommand; resolve: (result: BridgeCommandResult) => void }> = [];
+  private isProcessing: boolean = false;
+  private screenBuffer: ScreenBuffer | null = null;
+  private terminalDimensions: { width: number; height: number } = { width: 80, height: 24 };
+
+  private constructor(config: TUIBridgeConfig) {
+    super();
+    this.config = config;
+  }
+
+  /**
+   * Get singleton instance
+   */
+  static getInstance(config?: TUIBridgeConfig): TUIBridge | null {
+    if (!TUIBridge.instance && config) {
+      TUIBridge.instance = new TUIBridge(config);
+    }
+    return TUIBridge.instance;
+  }
+
+  /**
+   * Initialize bridge with config
+   */
+  static init(config: TUIBridgeConfig): TUIBridge {
+    if (!TUIBridge.instance) {
+      TUIBridge.instance = new TUIBridge(config);
+    }
+    return TUIBridge.instance;
+  }
+
+  /**
+   * Update internal state and emit event
+   */
+  updateState(newState: Partial<BridgeState>): void {
+    if (!this.state) {
+      return;
+    }
+    this.state = { ...this.state, ...newState, timestamp: Date.now() };
+    this.emitEvent("state_update", this.state);
+  }
+
+  /**
+   * Initialize state (called once at startup)
+   */
+  initState(initialState: BridgeState): void {
+    this.state = { ...initialState, timestamp: Date.now() };
+  }
+
+  /**
+   * Get current state
+   */
+  getState(): BridgeState | null {
+    return this.state ? { ...this.state } : null;
+  }
+
+  /**
+   * Emit event to subscribers
+   */
+  emitEvent<T>(type: BridgeEventType, payload: T): void {
+    const event: BridgeEvent<T> = {
+      type,
+      payload,
+      timestamp: Date.now(),
+    };
+
+    // Emit to local listeners
+    this.emit("event", event);
+
+    // Call config callback if provided
+    if (this.config.onEvent) {
+      this.config.onEvent(event as BridgeEvent);
+    }
+  }
+
+  /**
+   * Execute a command from external source
+   */
+  async executeCommand(command: BridgeCommand): Promise<BridgeCommandResult> {
+    return new Promise((resolve) => {
+      this.commandQueue.push({ command, resolve });
+      this.processQueue();
+    });
+  }
+
+  /**
+   * Process command queue
+   */
+  private async processQueue(): Promise<void> {
+    if (this.isProcessing || this.commandQueue.length === 0) {
+      return;
+    }
+
+    this.isProcessing = true;
+    const { command, resolve } = this.commandQueue.shift()!;
+
+    try {
+      const result = await this.handleCommand(command);
+      resolve(result);
+    } catch (error) {
+      resolve({
+        success: false,
+        error: error instanceof Error ? error.message : String(error),
+      });
+    } finally {
+      this.isProcessing = false;
+      this.processQueue();
+    }
+  }
+
+  /**
+   * Handle individual command
+   */
+  private async handleCommand(command: BridgeCommand): Promise<BridgeCommandResult> {
+    // Most commands are handled by the TUI component itself
+    // This just validates and queues them
+    switch (command.type) {
+      case "get_state":
+        return {
+          success: true,
+          data: this.getState(),
+        };
+
+      case "get_screen":
+        // Screen capture is handled by TUI Bridge MCP directly via tmux
+        return {
+          success: true,
+          data: {
+            note: "Screen capture is handled by TUI Bridge MCP via tmux. Use tui_capture tool.",
+            state: this.getState(),
+          },
+        };
+
+      case "get_screen":
+        // Screen capture is handled by TUI Bridge MCP directly via tmux
+        return {
+          success: true,
+          data: {
+            note: "Screen capture is handled by TUI Bridge MCP via tmux. Use tui_capture tool.",
+            state: this.getState(),
+          },
+        };
+
+      default:
+        // Queue command for TUI to handle
+        this.emitEvent("command_executed", command);
+        return {
+          success: true,
+          data: { queued: true, command },
+        };
+    }
+  }
+
+  /**
+   * Subscribe to events
+   */
+  subscribe(subscriberId: string): boolean {
+    this.subscribers.add(subscriberId);
+    return true;
+  }
+
+  /**
+   * Unsubscribe from events
+   */
+  unsubscribe(subscriberId: string): boolean {
+    return this.subscribers.delete(subscriberId);
+  }
+
+  /**
+   * Get subscriber count
+   */
+  getSubscriberCount(): number {
+    return this.subscribers.size;
+  }
+
+  /**
+   * Check if bridge is enabled
+   */
+  isEnabled(): boolean {
+    return this.config.enabled;
+  }
+
+  // ============================================
+  // SCREEN BUFFER API
+  // ============================================
+
+  /**
+   * Set terminal dimensions
+   */
+  setDimensions(width: number, height: number): void {
+    this.terminalDimensions = { width, height };
+  }
+
+  /**
+   * Get terminal dimensions
+   */
+  getDimensions(): { width: number; height: number } {
+    return { ...this.terminalDimensions };
+  }
+
+  /**
+   * Get screen buffer
+   * Returns the current screen buffer if available, or creates an empty one
+   */
+  getScreenBuffer(): ScreenBuffer {
+    if (this.screenBuffer) {
+      return this.screenBuffer;
+    }
+    return createBuffer(this.terminalDimensions.width, this.terminalDimensions.height);
+  }
+
+  /**
+   * Update screen buffer with raw terminal content
+   * @param rawContent - Raw terminal output with ANSI codes
+   */
+  updateScreenBuffer(rawContent: string): ScreenBuffer {
+    const chars = parseANSIText(rawContent);
+    this.screenBuffer = renderToScreenBuffer(
+      chars,
+      this.terminalDimensions.width,
+      this.terminalDimensions.height
+    );
+    return this.screenBuffer;
+  }
+
+  /**
+   * Export screen to specified format
+   * @param format - Export format (text, json, html, markdown)
+   * @param options - Export options
+   */
+  exportScreen(format: ExportFormat, options?: ExportOptions): string {
+    const buffer = this.getScreenBuffer();
+    return doExport(buffer, format, options);
+  }
+
+  /**
+   * Parse raw terminal content into a full ParsedScreen
+   * @param rawContent - Raw terminal output with ANSI codes
+   */
+  parseRawScreen(rawContent: string): ParsedScreen {
+    return parseScreen(
+      rawContent,
+      this.terminalDimensions.width,
+      this.terminalDimensions.height
+    );
+  }
+
+  /**
+   * Get detected UI elements from current screen buffer
+   */
+  getUIElements(): UIElement[] {
+    const buffer = this.getScreenBuffer();
+    return detectUIElements(buffer);
+  }
+
+  /**
+   * Clear screen buffer
+   */
+  clearScreenBuffer(): void {
+    this.screenBuffer = null;
+  }
+
+  /**
+   * Cleanup
+   */
+  destroy(): void {
+    this.removeAllListeners();
+    this.subscribers.clear();
+    this.commandQueue = [];
+    TUIBridge.instance = null;
+  }
+}
+
+// Re-export types
+export type {
+  BridgeState,
+  BridgeEvent,
+  BridgeCommand,
+  BridgeCommandResult,
+  TUIBridgeConfig,
+  ParsedScreen,
+  ScreenBuffer,
+  ScreenCell,
+  UIElement,
+  UIElementType,
+  BridgeEventType,
+};
+
+// Re-export IPC Server
+export {
+  IPCServer,
+  createIPCServer,
+  JSONRPCRequestSchema,
+  JSONRPCNotificationSchema,
+  IPCServerConfigSchema,
+  type JSONRPCRequest,
+  type JSONRPCSuccessResponse,
+  type JSONRPCErrorResponse,
+  type JSONRPCResponse,
+  type JSONRPCNotification,
+  type IPCServerConfig,
+  type IPCServerEventType,
+  type IPCServerEvent,
+  type ClientConnection,
+} from "./ipc.js";