zero-ai-cli 1.0.0

package/packages/core/src/routing/model-router.ts

@@ -0,0 +1,160 @@
+/**
+ * ZERO Model Router Service
+ * Adapted from: gemini-cli (Google) - Apache 2.0
+ *
+ * A centralized service for making intelligent model routing decisions.
+ * Supports multiple routing strategies with fallback chains.
+ */
+
+import type { Message } from "../types.js";
+
+export interface RoutingDecision {
+  model: string;
+  metadata: {
+    source: string;
+    latencyMs: number;
+    reasoning: string;
+    error?: string;
+  };
+}
+
+export interface RoutingContext {
+  history: readonly Message[];
+  request: string;
+  signal: AbortSignal;
+  requestedModel?: string;
+}
+
+export interface RoutingStrategy {
+  readonly name: string;
+  route(context: RoutingContext): Promise<RoutingDecision | null>;
+}
+
+export interface TerminalStrategy extends RoutingStrategy {
+  route(context: RoutingContext): Promise<RoutingDecision>;
+}
+
+/**
+ * Default routing strategy that always returns the configured model
+ */
+export class DefaultStrategy implements TerminalStrategy {
+  readonly name = "default";
+
+  constructor(private defaultModel: string) {}
+
+  async route(context: RoutingContext): Promise<RoutingDecision> {
+    return {
+      model: context.requestedModel || this.defaultModel,
+      metadata: {
+        source: "default",
+        latencyMs: 0,
+        reasoning: "Default model selection",
+      },
+    };
+  }
+}
+
+/**
+ * Override strategy that forces a specific model
+ */
+export class OverrideStrategy implements RoutingStrategy {
+  readonly name = "override";
+
+  constructor(private overrideModel?: string) {}
+
+  async route(context: RoutingContext): Promise<RoutingDecision | null> {
+    if (!this.overrideModel) return null;
+
+    return {
+      model: this.overrideModel,
+      metadata: {
+        source: "override",
+        latencyMs: 0,
+        reasoning: `Override model: ${this.overrideModel}`,
+      },
+    };
+  }
+}
+
+/**
+ * Composite strategy that chains multiple strategies
+ */
+export class CompositeStrategy implements TerminalStrategy {
+  readonly name = "composite";
+
+  constructor(
+    private strategies: (RoutingStrategy | TerminalStrategy)[],
+    private fallbackModel: string
+  ) {}
+
+  async route(context: RoutingContext): Promise<RoutingDecision> {
+    const startTime = Date.now();
+
+    for (const strategy of this.strategies) {
+      try {
+        const decision = await strategy.route(context);
+        if (decision) {
+          return {
+            ...decision,
+            metadata: {
+              ...decision.metadata,
+              latencyMs: Date.now() - startTime,
+            },
+          };
+        }
+      } catch (error) {
+        // Continue to next strategy
+      }
+    }
+
+    // Fallback
+    return {
+      model: this.fallbackModel,
+      metadata: {
+        source: "composite-fallback",
+        latencyMs: Date.now() - startTime,
+        reasoning: "All strategies declined, using fallback",
+      },
+    };
+  }
+}
+
+/**
+ * Main Model Router Service
+ */
+export class ModelRouterService {
+  private strategy: TerminalStrategy;
+
+  constructor(
+    private defaultModel: string,
+    private strategies: RoutingStrategy[] = []
+  ) {
+    const allStrategies: (RoutingStrategy | TerminalStrategy)[] = [
+      ...strategies,
+      new DefaultStrategy(defaultModel),
+    ];
+
+    this.strategy = new CompositeStrategy(allStrategies, defaultModel);
+  }
+
+  async route(context: RoutingContext): Promise<RoutingDecision> {
+    const startTime = Date.now();
+    let decision: RoutingDecision;
+
+    try {
+      decision = await this.strategy.route(context);
+    } catch (error) {
+      decision = {
+        model: this.defaultModel,
+        metadata: {
+          source: "router-exception",
+          latencyMs: Date.now() - startTime,
+          reasoning: "Exception during routing, using default",
+          error: error instanceof Error ? error.message : String(error),
+        },
+      };
+    }
+
+    return decision;
+  }
+}

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

@@ -0,0 +1,232 @@
+/**
+ * ZERO HTTP API Server
+ * Adapted from: opencode (SST) - MIT
+ *
+ * REST API server for programmatic access to ZERO.
+ * Supports SSE (Server-Sent Events) for streaming.
+ */
+
+import * as http from "node:http";
+import type { AddressInfo } from "node:net";
+import type { AgentResult, SessionConfig } from "../types.js";
+
+export interface ServerOptions {
+  port?: number;
+  host?: string;
+  cors?: boolean;
+  apiKey?: string;
+}
+
+export interface RouteHandler {
+  (req: http.IncomingMessage, res: http.ServerResponse, params: Record<string, string>): Promise<void>;
+}
+
+export class ZeroServer {
+  private server?: http.Server;
+  private routes = new Map<string, { method: string; handler: RouteHandler }>();
+  private options: ServerOptions;
+
+  constructor(options: ServerOptions = {}) {
+    this.options = {
+      port: options.port || 3700,
+      host: options.host || "localhost",
+      cors: options.cors !== false,
+      apiKey: options.apiKey,
+    };
+  }
+
+  /**
+   * Register a route
+   */
+  route(method: string, path: string, handler: RouteHandler): void {
+    this.routes.set(`${method}:${path}`, { method, handler });
+  }
+
+  /**
+   * Start the server
+   */
+  async start(): Promise<{ host: string; port: number }> {
+    return new Promise((resolve, reject) => {
+      this.server = http.createServer(async (req, res) => {
+        // CORS
+        if (this.options.cors) {
+          res.setHeader("Access-Control-Allow-Origin", "*");
+          res.setHeader("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS");
+          res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
+          if (req.method === "OPTIONS") {
+            res.writeHead(204);
+            res.end();
+            return;
+          }
+        }
+
+        // Auth
+        if (this.options.apiKey) {
+          const auth = req.headers.authorization;
+          if (!auth || auth !== `Bearer ${this.options.apiKey}`) {
+            res.writeHead(401, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "Unauthorized" }));
+            return;
+          }
+        }
+
+        // Route matching
+        const url = new URL(req.url || "/", `http://${req.headers.host}`);
+        const routeKey = `${req.method}:${url.pathname}`;
+        const route = this.routes.get(routeKey);
+
+        if (route) {
+          try {
+            await route.handler(req, res, {});
+          } catch (error) {
+            res.writeHead(500, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: error instanceof Error ? error.message : String(error) }));
+          }
+        } else {
+          // Try parameterized routes
+          let matched = false;
+          for (const [key, { handler }] of this.routes) {
+            const [method, pattern] = key.split(":");
+            if (method !== req.method) continue;
+
+            const params = this.matchRoute(pattern, url.pathname);
+            if (params) {
+              try {
+                await handler(req, res, params);
+              } catch (error) {
+                res.writeHead(500, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: error instanceof Error ? error.message : String(error) }));
+              }
+              matched = true;
+              break;
+            }
+          }
+
+          if (!matched) {
+            res.writeHead(404, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "Not found" }));
+          }
+        }
+      });
+
+      this.server.listen(this.options.port, this.options.host, () => {
+        const addr = this.server!.address() as AddressInfo;
+        resolve({ host: addr.address, port: addr.port });
+      });
+
+      this.server.on("error", reject);
+    });
+  }
+
+  /**
+   * Stop the server
+   */
+  async stop(): Promise<void> {
+    return new Promise((resolve) => {
+      if (this.server) {
+        this.server.close(() => resolve());
+      } else {
+        resolve();
+      }
+    });
+  }
+
+  /**
+   * Send SSE (Server-Sent Events) stream
+   */
+  static sendSSE(res: http.ServerResponse, event: string, data: unknown): void {
+    res.write(`event: ${event}\n`);
+    res.write(`data: ${JSON.stringify(data)}\n\n`);
+  }
+
+  /**
+   * Send JSON response
+   */
+  static sendJSON(res: http.ServerResponse, data: unknown, status = 200): void {
+    res.writeHead(status, { "Content-Type": "application/json" });
+    res.end(JSON.stringify(data));
+  }
+
+  /**
+   * Read request body as JSON
+   */
+  static async readBody<T = unknown>(req: http.IncomingMessage): Promise<T> {
+    return new Promise((resolve, reject) => {
+      let body = "";
+      req.on("data", (chunk) => { body += chunk; });
+      req.on("end", () => {
+        try {
+          resolve(body ? JSON.parse(body) : {});
+        } catch (error) {
+          reject(new Error("Invalid JSON body"));
+        }
+      });
+      req.on("error", reject);
+    });
+  }
+
+  private matchRoute(pattern: string, pathname: string): Record<string, string> | null {
+    const patternParts = pattern.split("/");
+    const pathParts = pathname.split("/");
+
+    if (patternParts.length !== pathParts.length) return null;
+
+    const params: Record<string, string> = {};
+    for (let i = 0; i < patternParts.length; i++) {
+      if (patternParts[i].startsWith(":")) {
+        params[patternParts[i].slice(1)] = pathParts[i];
+      } else if (patternParts[i] !== pathParts[i]) {
+        return null;
+      }
+    }
+
+    return params;
+  }
+}
+
+/**
+ * Create a pre-configured ZERO API server
+ */
+export function createAPIServer(options?: ServerOptions): ZeroServer {
+  const server = new ZeroServer(options);
+
+  // Health check
+  server.route("GET", "/health", async (_, res) => {
+    ZeroServer.sendJSON(res, { status: "ok", version: "1.0.0", uptime: process.uptime() });
+  });
+
+  // List agents
+  server.route("GET", "/agents", async (_, res) => {
+    ZeroServer.sendJSON(res, {
+      agents: [
+        { id: "coder", name: "Coder", description: "Primary coding agent" },
+        { id: "reviewer", name: "Reviewer", description: "Code review specialist" },
+        { id: "researcher", name: "Researcher", description: "Documentation research" },
+      ],
+    });
+  });
+
+  // List tools
+  server.route("GET", "/tools", async (_, res) => {
+    ZeroServer.sendJSON(res, {
+      tools: [
+        "read_file", "write_file", "edit_file", "list_directory",
+        "search_files", "search_code", "execute_shell",
+        "git_status", "git_diff", "git_commit",
+        "web_fetch", "web_search", "lint", "repo_map",
+      ],
+    });
+  });
+
+  // List providers
+  server.route("GET", "/providers", async (_, res) => {
+    ZeroServer.sendJSON(res, {
+      providers: [
+        "openai", "anthropic", "google", "ollama", "custom",
+        "deepseek", "grok", "openrouter", "together", "fireworks",
+      ],
+    });
+  });
+
+  return server;
+}

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

@@ -0,0 +1,174 @@
+/**
+ * ZERO Session Manager
+ * Manages conversation sessions with persistence
+ *
+ * Sources:
+ * - opencode: session management with SQLite
+ * - crush: session state management
+ * - gemini-cli: context window management
+ */
+
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import type { Session, SessionConfig, Message, TokenUsage } from "../types.js";
+
+export interface SessionManagerOptions {
+  storagePath: string;
+  defaultConfig: Partial<SessionConfig>;
+}
+
+export class SessionManager {
+  private sessions = new Map<string, Session>();
+  private storagePath: string;
+  private defaultConfig: Partial<SessionConfig>;
+
+  constructor(options: SessionManagerOptions) {
+    this.storagePath = options.storagePath;
+    this.defaultConfig = options.defaultConfig;
+  }
+
+  /**
+   * Create a new session
+   */
+  async create(name?: string, configOverrides?: Partial<SessionConfig>): Promise<Session> {
+    const id = `session_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+    const now = Date.now();
+
+    const session: Session = {
+      id,
+      name: name || `Session ${this.sessions.size + 1}`,
+      createdAt: now,
+      updatedAt: now,
+      messages: [],
+      config: {
+        provider: configOverrides?.provider || this.defaultConfig.provider || "openai",
+        model: configOverrides?.model || this.defaultConfig.model || "gpt-4o",
+        systemPrompt: configOverrides?.systemPrompt || this.defaultConfig.systemPrompt || "",
+        workingDirectory: configOverrides?.workingDirectory || this.defaultConfig.workingDirectory || process.cwd(),
+        permissions: configOverrides?.permissions || this.defaultConfig.permissions || {
+          fileRead: "allow",
+          fileWrite: "ask",
+          shellExecution: "ask",
+          networkAccess: "ask",
+          mcpAccess: "allow",
+        },
+        tools: configOverrides?.tools || this.defaultConfig.tools || [],
+        mcpServers: configOverrides?.mcpServers || this.defaultConfig.mcpServers || [],
+      },
+      state: {
+        status: "idle",
+        tokenUsage: { inputTokens: 0, outputTokens: 0 },
+      },
+    };
+
+    this.sessions.set(id, session);
+    await this.save(session);
+    return session;
+  }
+
+  /**
+   * Get an existing session
+   */
+  get(id: string): Session | undefined {
+    return this.sessions.get(id);
+  }
+
+  /**
+   * List all sessions
+   */
+  list(): Session[] {
+    return Array.from(this.sessions.values()).sort((a, b) => b.updatedAt - a.updatedAt);
+  }
+
+  /**
+   * Add a message to a session
+   */
+  async addMessage(sessionId: string, message: Message): Promise<void> {
+    const session = this.sessions.get(sessionId);
+    if (!session) throw new Error(`Session "${sessionId}" not found`);
+
+    session.messages.push(message);
+    session.updatedAt = Date.now();
+    await this.save(session);
+  }
+
+  /**
+   * Update session state
+   */
+  async updateState(sessionId: string, updates: Partial<Session["state"]>): Promise<void> {
+    const session = this.sessions.get(sessionId);
+    if (!session) throw new Error(`Session "${sessionId}" not found`);
+
+    Object.assign(session.state, updates);
+    session.updatedAt = Date.now();
+    await this.save(session);
+  }
+
+  /**
+   * Delete a session
+   */
+  async delete(id: string): Promise<void> {
+    this.sessions.delete(id);
+    try {
+      await fs.unlink(path.join(this.storagePath, `${id}.json`));
+    } catch {}
+  }
+
+  /**
+   * Load sessions from storage
+   */
+  async loadAll(): Promise<void> {
+    try {
+      await fs.mkdir(this.storagePath, { recursive: true });
+      const files = await fs.readdir(this.storagePath);
+
+      for (const file of files) {
+        if (file.endsWith(".json")) {
+          try {
+            const data = await fs.readFile(path.join(this.storagePath, file), "utf-8");
+            const session = JSON.parse(data) as Session;
+            this.sessions.set(session.id, session);
+          } catch {}
+        }
+      }
+    } catch {}
+  }
+
+  /**
+   * Save session to storage
+   */
+  private async save(session: Session): Promise<void> {
+    await fs.mkdir(this.storagePath, { recursive: true });
+    await fs.writeFile(
+      path.join(this.storagePath, `${session.id}.json`),
+      JSON.stringify(session, null, 2)
+    );
+  }
+
+  /**
+   * Get session statistics
+   */
+  getStats(sessionId: string): {
+    messageCount: number;
+    totalTokens: TokenUsage;
+    duration: number;
+    toolsUsed: string[];
+  } {
+    const session = this.sessions.get(sessionId);
+    if (!session) throw new Error(`Session "${sessionId}" not found`);
+
+    const toolsUsed = new Set<string>();
+    for (const msg of session.messages) {
+      for (const content of msg.content) {
+        if (content.type === "tool_call") toolsUsed.add(content.name);
+      }
+    }
+
+    return {
+      messageCount: session.messages.length,
+      totalTokens: session.state.tokenUsage,
+      duration: session.updatedAt - session.createdAt,
+      toolsUsed: Array.from(toolsUsed),
+    };
+  }
+}