zero-ai-cli 1.0.0

package/packages/core/src/orchestrator/protocol.ts

@@ -0,0 +1,140 @@
+/**
+ * ZERO Orchestrator IPC Protocol
+ * Adapted from: pi (earendil-works) - AGPL-3.0
+ *
+ * Inter-process communication protocol for multi-agent orchestration.
+ * Enables spawning, managing, and communicating with agent instances.
+ */
+
+export interface SpawnRequest {
+  type: "spawn";
+  cwd: string;
+  label?: string;
+  provider?: string;
+  model?: string;
+  agentId?: string;
+}
+
+export interface ListRequest {
+  type: "list";
+}
+
+export interface StopRequest {
+  type: "stop";
+  instanceId: string;
+}
+
+export interface StatusRequest {
+  type: "status";
+  instanceId: string;
+}
+
+export interface RpcRequest {
+  type: "rpc";
+  instanceId: string;
+  command: RpcCommand;
+}
+
+export interface RpcStreamRequest {
+  type: "rpc_stream";
+  instanceId: string;
+}
+
+export interface RequestMap {
+  spawn: SpawnRequest;
+  list: ListRequest;
+  stop: StopRequest;
+  status: StatusRequest;
+  rpc: RpcRequest;
+  rpc_stream: RpcStreamRequest;
+}
+
+export type OrchestratorRequest = RequestMap[keyof RequestMap];
+
+export type InstanceStatus = "starting" | "running" | "stopped" | "error";
+
+export interface InstanceSummary {
+  id: string;
+  status: InstanceStatus;
+  cwd: string;
+  label?: string;
+  sessionId?: string;
+  agentId?: string;
+  model?: string;
+  createdAt: number;
+}
+
+export interface ResponseBase {
+  ok: boolean;
+  error?: string;
+}
+
+export interface SpawnResponse extends ResponseBase {
+  type: "spawn_result";
+  instance?: InstanceSummary;
+}
+
+export interface ListResponse extends ResponseBase {
+  type: "list_result";
+  instances?: InstanceSummary[];
+}
+
+export interface StopResponse extends ResponseBase {
+  type: "stop_result";
+  instanceId?: string;
+}
+
+export interface StatusResponse extends ResponseBase {
+  type: "status_result";
+  instance?: InstanceSummary;
+}
+
+export interface RpcResponse {
+  type: "rpc_result";
+  data: unknown;
+}
+
+export interface RpcBridgeResponse extends ResponseBase {
+  type: "rpc_result";
+  response: RpcResponse;
+}
+
+export interface RpcReadyResponse extends ResponseBase {
+  type: "rpc_ready";
+  instance?: InstanceSummary;
+}
+
+export interface ErrorResponse extends ResponseBase {
+  type: "error";
+  ok: false;
+  error: string;
+}
+
+export interface ResponseMap {
+  spawn: SpawnResponse;
+  list: ListResponse;
+  stop: StopResponse;
+  status: StatusResponse;
+  rpc: RpcBridgeResponse;
+  rpc_stream: RpcReadyResponse;
+}
+
+export type OrchestratorResponse = ResponseMap[keyof ResponseMap] | ErrorResponse;
+
+export type RpcCommand =
+  | { type: "chat"; message: string }
+  | { type: "abort" }
+  | { type: "get_messages" }
+  | { type: "get_state" };
+
+export function encodeMessage(message: OrchestratorRequest | OrchestratorResponse): string {
+  return `${JSON.stringify(message)}\n`;
+}
+
+export function parseRequestLine(line: string): OrchestratorRequest {
+  return JSON.parse(line) as OrchestratorRequest;
+}
+
+export function parseResponseLine(line: string): OrchestratorResponse {
+  return JSON.parse(line) as OrchestratorResponse;
+}

package/packages/core/src/orchestrator/server.ts

@@ -0,0 +1,319 @@
+/**
+ * ZERO Orchestrator Server
+ * Adapted from: pi (earendil-works) - AGPL-3.0
+ *
+ * IPC server for managing multiple agent instances.
+ */
+
+import { createConnection, createServer, type Server } from "node:net";
+import * as path from "node:path";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import type {
+  OrchestratorRequest,
+  OrchestratorResponse,
+  InstanceSummary,
+  InstanceStatus,
+  SpawnRequest,
+  ListRequest,
+  StopRequest,
+  StatusRequest,
+  RpcRequest,
+  ErrorResponse,
+  SpawnResponse,
+  ListResponse,
+  StopResponse,
+  StatusResponse,
+  RpcBridgeResponse,
+  RpcReadyResponse,
+  RpcCommand,
+} from "./protocol.js";
+import { encodeMessage, parseRequestLine } from "./protocol.js";
+
+interface AgentInstance {
+  id: string;
+  status: InstanceStatus;
+  cwd: string;
+  label?: string;
+  sessionId?: string;
+  agentId?: string;
+  model?: string;
+  createdAt: number;
+  messages: Array<{ role: string; content: string; timestamp: number }>;
+}
+
+export class OrchestratorServer {
+  private server?: Server;
+  private instances = new Map<string, AgentInstance>();
+  private socketPath: string;
+
+  constructor(socketPath?: string) {
+    this.socketPath = socketPath || path.join(os.tmpdir(), `zero-orchestrator-${process.pid}.sock`);
+  }
+
+  async start(): Promise<void> {
+    // Remove stale socket
+    try {
+      if (fs.existsSync(this.socketPath)) {
+        fs.unlinkSync(this.socketPath);
+      }
+    } catch {}
+
+    return new Promise((resolve, reject) => {
+      this.server = createServer((socket) => {
+        let buffer = "";
+
+        socket.on("data", async (chunk: Buffer | string) => {
+          buffer += chunk.toString();
+          const newlineIndex = buffer.indexOf("\n");
+          if (newlineIndex === -1) return;
+
+          const line = buffer.slice(0, newlineIndex).trim();
+          buffer = buffer.slice(newlineIndex + 1);
+          if (!line) return;
+
+          try {
+            const request = parseRequestLine(line);
+            const response = await this.handleRequest(request);
+            socket.write(encodeMessage(response));
+          } catch (error) {
+            const errorResponse: ErrorResponse = {
+              type: "error",
+              ok: false,
+              error: error instanceof Error ? error.message : String(error),
+            };
+            socket.write(encodeMessage(errorResponse));
+          }
+        });
+
+        socket.on("error", () => {});
+      });
+
+      this.server.listen(this.socketPath, () => resolve());
+      this.server.on("error", reject);
+    });
+  }
+
+  async stop(): Promise<void> {
+    return new Promise((resolve) => {
+      if (this.server) {
+        this.server.close(() => {
+          try { fs.unlinkSync(this.socketPath); } catch {}
+          resolve();
+        });
+      } else {
+        resolve();
+      }
+    });
+  }
+
+  private async handleRequest(request: OrchestratorRequest): Promise<OrchestratorResponse> {
+    switch (request.type) {
+      case "spawn": return this.handleSpawn(request);
+      case "list": return this.handleList();
+      case "stop": return this.handleStop(request);
+      case "status": return this.handleStatus(request);
+      case "rpc": return this.handleRpc(request);
+      default:
+        return { type: "error", ok: false, error: `Unknown request type: ${(request as any).type}` };
+    }
+  }
+
+  private async handleSpawn(request: SpawnRequest): Promise<SpawnResponse> {
+    const id = `instance_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+    const instance: AgentInstance = {
+      id,
+      status: "running",
+      cwd: request.cwd || process.cwd(),
+      label: request.label,
+      agentId: request.agentId || "coder",
+      model: request.model || "default",
+      createdAt: Date.now(),
+      messages: [],
+    };
+
+    this.instances.set(id, instance);
+
+    return {
+      type: "spawn_result",
+      ok: true,
+      instance: {
+        id: instance.id,
+        status: instance.status,
+        cwd: instance.cwd,
+        label: instance.label,
+        agentId: instance.agentId,
+        model: instance.model,
+        createdAt: instance.createdAt,
+      },
+    };
+  }
+
+  private async handleList(): Promise<ListResponse> {
+    const instances: InstanceSummary[] = Array.from(this.instances.values()).map((i) => ({
+      id: i.id,
+      status: i.status,
+      cwd: i.cwd,
+      label: i.label,
+      agentId: i.agentId,
+      model: i.model,
+      createdAt: i.createdAt,
+    }));
+
+    return { type: "list_result", ok: true, instances };
+  }
+
+  private async handleStop(request: StopRequest): Promise<StopResponse> {
+    const instance = this.instances.get(request.instanceId);
+    if (!instance) {
+      return { type: "stop_result", ok: false, error: `Instance ${request.instanceId} not found` };
+    }
+
+    instance.status = "stopped";
+    this.instances.delete(request.instanceId);
+
+    return { type: "stop_result", ok: true, instanceId: request.instanceId };
+  }
+
+  private async handleStatus(request: StatusRequest): Promise<StatusResponse> {
+    const instance = this.instances.get(request.instanceId);
+    if (!instance) {
+      return { type: "status_result", ok: false, error: `Instance ${request.instanceId} not found` };
+    }
+
+    return {
+      type: "status_result",
+      ok: true,
+      instance: {
+        id: instance.id,
+        status: instance.status,
+        cwd: instance.cwd,
+        label: instance.label,
+        agentId: instance.agentId,
+        model: instance.model,
+        createdAt: instance.createdAt,
+      },
+    };
+  }
+
+  private async handleRpc(request: RpcRequest): Promise<RpcBridgeResponse> {
+    const instance = this.instances.get(request.instanceId);
+    if (!instance) {
+      return { type: "rpc_result", ok: false, error: `Instance ${request.instanceId} not found`, response: { type: "rpc_result", data: null } };
+    }
+
+    // Handle RPC commands
+    switch (request.command.type) {
+      case "chat":
+        instance.messages.push({
+          role: "user",
+          content: request.command.message,
+          timestamp: Date.now(),
+        });
+        return {
+          type: "rpc_result",
+          ok: true,
+          response: { type: "rpc_result", data: { queued: true } },
+        };
+
+      case "get_messages":
+        return {
+          type: "rpc_result",
+          ok: true,
+          response: { type: "rpc_result", data: instance.messages },
+        };
+
+      case "get_state":
+        return {
+          type: "rpc_result",
+          ok: true,
+          response: { type: "rpc_result", data: { status: instance.status, messageCount: instance.messages.length } },
+        };
+
+      default:
+        return { type: "rpc_result", ok: false, error: "Unknown RPC command", response: { type: "rpc_result", data: null } };
+    }
+  }
+
+  getSocketPath(): string {
+    return this.socketPath;
+  }
+}
+
+/**
+ * IPC Client for connecting to orchestrator
+ */
+export class OrchestratorClient {
+  private socket?: ReturnType<typeof createConnection>;
+  private buffer = "";
+  private responseHandlers = new Map<string, (response: OrchestratorResponse) => void>();
+
+  constructor(private socketPath: string) {}
+
+  async connect(): Promise<void> {
+    return new Promise((resolve, reject) => {
+      this.socket = createConnection(this.socketPath, () => resolve());
+      this.socket.on("error", reject);
+      this.socket.on("data", (chunk: Buffer) => {
+        this.buffer += chunk.toString();
+        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 OrchestratorResponse;
+            // Broadcast to all handlers
+            for (const handler of this.responseHandlers.values()) {
+              handler(response);
+            }
+          } catch {}
+        }
+      });
+    });
+  }
+
+  async send(request: OrchestratorRequest): Promise<OrchestratorResponse> {
+    return new Promise((resolve) => {
+      const id = Math.random().toString(36).slice(2);
+      this.responseHandlers.set(id, (response) => {
+        this.responseHandlers.delete(id);
+        resolve(response);
+      });
+
+      this.socket?.write(encodeMessage(request));
+
+      // Timeout fallback
+      setTimeout(() => {
+        if (this.responseHandlers.has(id)) {
+          this.responseHandlers.delete(id);
+          resolve({ type: "error", ok: false, error: "Timeout" });
+        }
+      }, 30000);
+    });
+  }
+
+  async spawn(request: Omit<SpawnRequest, "type">): Promise<SpawnResponse> {
+    return (await this.send({ ...request, type: "spawn" })) as SpawnResponse;
+  }
+
+  async list(): Promise<ListResponse> {
+    return (await this.send({ type: "list" })) as ListResponse;
+  }
+
+  async stop(instanceId: string): Promise<StopResponse> {
+    return (await this.send({ type: "stop", instanceId })) as StopResponse;
+  }
+
+  async status(instanceId: string): Promise<StatusResponse> {
+    return (await this.send({ type: "status", instanceId })) as StatusResponse;
+  }
+
+  async rpc(instanceId: string, command: RpcCommand): Promise<RpcBridgeResponse> {
+    return (await this.send({ type: "rpc", instanceId, command })) as RpcBridgeResponse;
+  }
+
+  disconnect(): void {
+    this.socket?.end();
+  }
+}

package/packages/core/src/output/index.ts

@@ -0,0 +1,164 @@
+/**
+ * ZERO Output Formatting
+ * Adapted from: qwen-code (Alibaba) - MIT
+ *
+ * Output formatting for JSON, streaming, and markdown responses.
+ */
+
+import type { Message, TokenUsage, AgentResult } from "../types.js";
+
+// ============================================================================
+// JSON Output Formatter
+// ============================================================================
+
+export interface JSONOutput {
+  version: string;
+  timestamp: string;
+  result: {
+    success: boolean;
+    messages: Array<{
+      role: string;
+      content: string;
+      timestamp: number;
+    }>;
+    usage: TokenUsage;
+    duration: number;
+    error?: string;
+  };
+}
+
+export function formatJSON(result: AgentResult): JSONOutput {
+  return {
+    version: "1.0",
+    timestamp: new Date().toISOString(),
+    result: {
+      success: result.success,
+      messages: result.messages.map((m) => ({
+        role: m.role,
+        content: m.content
+          .filter((c) => c.type === "text")
+          .map((c) => (c as any).text)
+          .join(""),
+        timestamp: m.timestamp,
+      })),
+      usage: result.tokenUsage,
+      duration: result.duration,
+      error: result.error,
+    },
+  };
+}
+
+// ============================================================================
+// Streaming Output Formatter
+// ============================================================================
+
+export interface StreamEvent {
+  type: "text" | "tool_call" | "tool_result" | "error" | "done";
+  data: unknown;
+  timestamp: number;
+}
+
+export function createStreamFormatter(): {
+  format: (event: StreamEvent) => string;
+} {
+  return {
+    format: (event: StreamEvent) => {
+      return JSON.stringify(event) + "\n";
+    },
+  };
+}
+
+// ============================================================================
+// Markdown Output Formatter
+// ============================================================================
+
+export function formatMarkdown(result: AgentResult): string {
+  const lines: string[] = [];
+
+  lines.push("# ZERO Agent Result");
+  lines.push("");
+  lines.push(`**Status:** ${result.success ? "✅ Success" : "❌ Failed"}`);
+  lines.push(`**Duration:** ${(result.duration / 1000).toFixed(1)}s`);
+  lines.push(`**Tokens:** ${result.tokenUsage.inputTokens} input / ${result.tokenUsage.outputTokens} output`);
+  lines.push("");
+
+  if (result.error) {
+    lines.push(`**Error:** ${result.error}`);
+    lines.push("");
+  }
+
+  lines.push("## Messages");
+  lines.push("");
+
+  for (const msg of result.messages) {
+    if (msg.role === "user") {
+      lines.push(`### 👤 User`);
+    } else if (msg.role === "assistant") {
+      lines.push(`### 🤖 Assistant`);
+    } else if (msg.role === "tool") {
+      lines.push(`### 🔧 Tool Result`);
+    } else {
+      lines.push(`### ${msg.role}`);
+    }
+
+    for (const content of msg.content) {
+      if (content.type === "text") {
+        lines.push(content.text);
+      } else if (content.type === "tool_call") {
+        lines.push(`\`\`\`tool\n${content.name}(${JSON.stringify(content.arguments, null, 2)})\n\`\`\``);
+      } else if (content.type === "tool_result") {
+        lines.push(`\`\`\`result\n${typeof content.result === "string" ? content.result : JSON.stringify(content.result, null, 2)}\n\`\`\``);
+      }
+    }
+
+    lines.push("");
+  }
+
+  return lines.join("\n");
+}
+
+// ============================================================================
+// Plain Text Formatter
+// ============================================================================
+
+export function formatPlainText(result: AgentResult): string {
+  const lines: string[] = [];
+
+  for (const msg of result.messages) {
+    if (msg.role === "assistant") {
+      for (const content of msg.content) {
+        if (content.type === "text") {
+          lines.push(content.text);
+        }
+      }
+    }
+  }
+
+  return lines.join("\n");
+}
+
+// ============================================================================
+// Cost Calculator
+// ============================================================================
+
+const MODEL_COSTS: Record<string, { input: number; output: number }> = {
+  "gpt-4o": { input: 0.000005, output: 0.000015 },
+  "gpt-4o-mini": { input: 0.00000015, output: 0.0000006 },
+  "claude-sonnet-4-20250514": { input: 0.000003, output: 0.000015 },
+  "claude-3-5-haiku-20241022": { input: 0.000001, output: 0.000005 },
+  "gemini-2.5-pro": { input: 0.00000125, output: 0.00001 },
+  "gemini-2.5-flash": { input: 0.00000015, output: 0.0000006 },
+  "deepseek-v4-pro": { input: 0.00000027, output: 0.0000011 },
+  "grok-4.5": { input: 0.000003, output: 0.000015 },
+};
+
+export function calculateCost(model: string, usage: TokenUsage): number {
+  const costs = MODEL_COSTS[model] || { input: 0.000005, output: 0.000015 };
+  return (usage.inputTokens * costs.input) + (usage.outputTokens * costs.output);
+}
+
+export function formatCost(cost: number): string {
+  if (cost < 0.001) return `$${cost.toFixed(6)}`;
+  if (cost < 1) return `$${cost.toFixed(4)}`;
+  return `$${cost.toFixed(2)}`;
+}