ada-agent 0.1.0

package/src/client/compaction.ts

@@ -0,0 +1,86 @@
+// Context management (pi-style compaction). When the transcript grows large, summarize the
+// older turns into one compact summary and keep the recent ones, so a session can run forever.
+// The summary is produced by the same model via the backend. Token sizing is a chars/4 estimate
+// (no tokenizer dependency) — accurate enough to decide *when* to compact.
+
+import type OpenAI from "openai";
+
+type Msg = OpenAI.Chat.Completions.ChatCompletionMessageParam;
+
+// Cap on the text fed to the summarizer, so the summary call itself can't overflow the context.
+const SUMMARY_INPUT_MAX = 30_000;
+
+export function estimateTokens(messages: Msg[]): number {
+  let chars = 0;
+  for (const m of messages) chars += JSON.stringify(m).length;
+  return Math.ceil(chars / 4); // ponytail: chars/4 heuristic, not a real tokenizer — fine for a threshold
+}
+
+export function isContextOverflowError(e: unknown): boolean {
+  const s = (e instanceof Error ? e.message : String(e)).toLowerCase();
+  return /context|max(imum)?[ _-]*tokens?|too long|exceeds|context[_ ]length|reduce the length|prompt is too/.test(s);
+}
+
+/** Pure: split messages into { system, toSummarize, tail } at a clean turn boundary, or null when
+ *  there isn't enough to compact. `tail` always starts at a user message, so a tool_call/tool_result
+ *  pair is never split across the cut. */
+export function planCut(
+  messages: Msg[],
+  keepLast = 6,
+): { system: Msg | null; toSummarize: Msg[]; tail: Msg[] } | null {
+  const system = messages[0]?.role === "system" ? messages[0]! : null;
+  const body = system ? messages.slice(1) : messages;
+  if (body.length <= keepLast + 1) return null;
+
+  let cut = body.length - keepLast;
+  while (cut > 0 && body[cut]?.role !== "user") cut--; // snap the tail start back to a user message
+  if (cut <= 0) return null;
+
+  return { system, toSummarize: body.slice(0, cut), tail: body.slice(cut) };
+}
+
+function serialize(messages: Msg[]): string {
+  const parts: string[] = [];
+  for (const m of messages) {
+    let text = typeof m.content === "string" ? m.content : Array.isArray(m.content) ? "(non-text content)" : "";
+    const calls = (m as { tool_calls?: Array<{ function?: { name?: string; arguments?: string } }> }).tool_calls;
+    if (calls) text += calls.map((c) => `\n[calls ${c.function?.name}(${c.function?.arguments ?? ""})]`).join("");
+    parts.push(`${m.role}: ${text}`.trim());
+  }
+  let out = parts.join("\n\n");
+  if (out.length > SUMMARY_INPUT_MAX) out = `[…older messages omitted…]\n\n${out.slice(-SUMMARY_INPUT_MAX)}`;
+  return out;
+}
+
+/** Summarize the older messages and return a compacted transcript: [system, summary, ...tail]. */
+export async function compact(
+  client: OpenAI,
+  model: string,
+  messages: Msg[],
+  keepLast = 6,
+): Promise<{ messages: Msg[]; summary: string } | null> {
+  const plan = planCut(messages, keepLast);
+  if (!plan) return null;
+
+  // Stream the summary (works for every adapter — anthropic always streams, openai-compat too).
+  const stream = await client.chat.completions.create({
+    model,
+    stream: true,
+    messages: [
+      {
+        role: "system",
+        content:
+          "You compress a coding agent's conversation into a concise summary so the task can continue. " +
+          "Preserve: the user's goal, key decisions, files created/edited (with paths), important command " +
+          "results, and remaining TODOs. Be terse and factual. Output only the summary.",
+      },
+      { role: "user", content: `${serialize(plan.toSummarize)}\n\n---\nSummarize the conversation above.` },
+    ],
+  });
+  let summary = "";
+  for await (const chunk of stream) summary += chunk.choices[0]?.delta?.content ?? "";
+  summary = summary.trim() || "(summary unavailable)";
+
+  const summaryMsg: Msg = { role: "user", content: `[Summary of earlier conversation in this session]\n${summary}` };
+  return { messages: [...(plan.system ? [plan.system] : []), summaryMsg, ...plan.tail], summary };
+}

package/src/client/extensions.ts

@@ -0,0 +1,83 @@
+// Extensions: JS/TS in .ada/extensions/ (project) or ~/.ada/extensions/ (global). An entry can be
+// a file (foo.ts) or a directory (package.json "main", else index.{ts,js,mjs}) — so `ada add`
+// can clone/install whole packages. Each default-exports { name?, tools?, onStart? }.
+
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { registerTool, type Tool } from "./tools.ts";
+import { addHook, type ToolHooks } from "./hooks.ts";
+
+export interface Command {
+  name: string;
+  description?: string;
+  run(args: string): string | void | Promise<string | void>;
+}
+
+export interface Extension {
+  name?: string;
+  tools?: Tool[];
+  hooks?: ToolHooks;
+  commands?: Command[];
+  onStart?: () => void | Promise<void>;
+}
+
+const commands = new Map<string, Command>();
+export function getCommands(): Map<string, Command> {
+  return commands;
+}
+
+function extDirs(includeProject: boolean): string[] {
+  const global = resolve(homedir(), ".ada", "extensions");
+  return includeProject ? [resolve(process.cwd(), ".ada", "extensions"), global] : [global];
+}
+
+/** Resolve an entry (file or directory) to an importable module URL, or null. */
+function entryUrl(full: string): string | null {
+  try {
+    if (statSync(full).isDirectory()) {
+      const pkg = join(full, "package.json");
+      if (existsSync(pkg)) {
+        const main = (JSON.parse(readFileSync(pkg, "utf8")) as { main?: string }).main;
+        if (main && existsSync(join(full, main))) return pathToFileURL(join(full, main)).href;
+      }
+      for (const idx of ["index.ts", "index.js", "index.mjs"]) {
+        if (existsSync(join(full, idx))) return pathToFileURL(join(full, idx)).href;
+      }
+      return null;
+    }
+    return /\.(ts|js|mjs)$/.test(full) ? pathToFileURL(full).href : null;
+  } catch {
+    return null;
+  }
+}
+
+export async function loadExtensions(includeProject: boolean): Promise<string[]> {
+  const loaded: string[] = [];
+  for (const dir of extDirs(includeProject)) {
+    if (!existsSync(dir)) continue;
+    let entries: string[];
+    try {
+      entries = readdirSync(dir);
+    } catch {
+      continue;
+    }
+    for (const e of entries) {
+      const url = entryUrl(join(dir, e));
+      if (!url) continue;
+      try {
+        const ext = ((await import(url)) as { default?: Extension }).default;
+        if (!ext) continue;
+        for (const t of ext.tools ?? []) registerTool(t);
+        if (ext.hooks) addHook(ext.hooks);
+        for (const c of ext.commands ?? []) commands.set(c.name, c);
+        await ext.onStart?.();
+        loaded.push(ext.name ?? e);
+      } catch (err) {
+        console.error(`extension ${e} failed: ${err instanceof Error ? err.message : err}`);
+      }
+    }
+  }
+  return loaded;
+}

package/src/client/hooks.ts

@@ -0,0 +1,40 @@
+// Extension hook registry: transform user input, and intercept tool calls (deny / rewrite args /
+// post-process results). Extensions register a ToolHooks object; the agent runs them in order.
+
+import type { ToolResult } from "./tools.ts";
+
+export interface ToolHooks {
+  onUserMessage?(text: string): string | undefined | Promise<string | undefined>;
+  beforeTool?(
+    name: string,
+    args: Record<string, unknown>,
+  ): { deny?: string; args?: Record<string, unknown> } | void | Promise<{ deny?: string; args?: Record<string, unknown> } | void>;
+  afterTool?(name: string, args: Record<string, unknown>, result: ToolResult): ToolResult | undefined | Promise<ToolResult | undefined>;
+}
+
+const hooks: ToolHooks[] = [];
+
+export function addHook(h: ToolHooks): void {
+  hooks.push(h);
+}
+
+export async function transformInput(text: string): Promise<string> {
+  for (const h of hooks) if (h.onUserMessage) text = (await h.onUserMessage(text)) ?? text;
+  return text;
+}
+
+export async function beforeTool(name: string, args: Record<string, unknown>): Promise<{ deny?: string; args: Record<string, unknown> }> {
+  let cur = args;
+  for (const h of hooks) {
+    if (!h.beforeTool) continue;
+    const r = await h.beforeTool(name, cur);
+    if (r?.deny) return { deny: r.deny, args: cur };
+    if (r?.args) cur = r.args;
+  }
+  return { args: cur };
+}
+
+export async function afterTool(name: string, args: Record<string, unknown>, result: ToolResult): Promise<ToolResult> {
+  for (const h of hooks) if (h.afterTool) result = (await h.afterTool(name, args, result)) ?? result;
+  return result;
+}

package/src/client/image.ts

@@ -0,0 +1,26 @@
+// Load an image file into a data URL for multimodal messages (OpenAI image_url format).
+
+import { existsSync, readFileSync } from "node:fs";
+import { extname, resolve } from "node:path";
+
+const MIME: Record<string, string> = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".bmp": "image/bmp",
+};
+
+export function loadImage(path: string): { dataUrl: string; bytes: number; name: string } | null {
+  const abs = resolve(process.cwd(), path);
+  if (!existsSync(abs)) return null;
+  const mime = MIME[extname(abs).toLowerCase()];
+  if (!mime) return null;
+  try {
+    const buf = readFileSync(abs);
+    return { dataUrl: `data:${mime};base64,${buf.toString("base64")}`, bytes: buf.length, name: path };
+  } catch {
+    return null;
+  }
+}

package/src/client/mcp.ts

@@ -0,0 +1,276 @@
+// Minimal MCP client (stdio, JSON-RPC 2.0). Reads .ada/mcp.json, spawns each server, lists its
+// tools, and registers them as ada tools (prefixed `<server>__<tool>`, gated behind approval).
+// Config: { "servers": { "fs": { "command": "npx", "args": ["-y", "@modelcontextprotocol/server-filesystem", "."] } } }
+
+import { type ChildProcess, spawn } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { registerTool } from "./tools.ts";
+
+interface RpcClient {
+  call(method: string, params?: unknown): Promise<Record<string, unknown>>;
+  notify(method: string, params?: unknown): void;
+}
+
+function makeClient(proc: ChildProcess): RpcClient {
+  let nextId = 1;
+  const pending = new Map<number, { resolve: (v: Record<string, unknown>) => void; reject: (e: Error) => void }>();
+  let buf = "";
+  proc.stdout?.on("data", (d: Buffer) => {
+    buf += d.toString("utf8");
+    let nl: number;
+    while ((nl = buf.indexOf("\n")) >= 0) {
+      const line = buf.slice(0, nl).trim();
+      buf = buf.slice(nl + 1);
+      if (!line) continue;
+      try {
+        const msg = JSON.parse(line) as { id?: number; result?: Record<string, unknown>; error?: { message?: string } };
+        if (msg.id != null && pending.has(msg.id)) {
+          const p = pending.get(msg.id)!;
+          pending.delete(msg.id);
+          if (msg.error) p.reject(new Error(msg.error.message ?? "rpc error"));
+          else p.resolve(msg.result ?? {});
+        }
+      } catch {
+        /* servers sometimes log non-JSON to stdout — ignore */
+      }
+    }
+  });
+  const send = (obj: unknown): void => void proc.stdin?.write(`${JSON.stringify(obj)}\n`);
+  return {
+    call(method, params) {
+      const id = nextId++;
+      return new Promise((res, rej) => {
+        pending.set(id, { resolve: res, reject: rej });
+        send({ jsonrpc: "2.0", id, method, params });
+      });
+    },
+    notify(method, params) {
+      send({ jsonrpc: "2.0", method, params });
+    },
+  };
+}
+
+// Streamable-HTTP MCP client: POST JSON-RPC, read a JSON or SSE response.
+// ponytail: request/response only — no server-initiated notifications, no stream resumability.
+function makeHttpClient(url: string, headers: Record<string, string>): RpcClient {
+  let nextId = 1;
+  let sessionId: string | undefined;
+  const post = (body: unknown): Promise<Response> =>
+    fetch(url, {
+      method: "POST",
+      headers: { "content-type": "application/json", accept: "application/json, text/event-stream", ...(sessionId ? { "mcp-session-id": sessionId } : {}), ...headers },
+      body: JSON.stringify(body),
+    });
+  const take = (msg: { result?: Record<string, unknown>; error?: { message?: string } }): Record<string, unknown> => {
+    if (msg.error) throw new Error(msg.error.message ?? "rpc error");
+    return msg.result ?? {};
+  };
+  const readResult = async (res: Response, id: number): Promise<Record<string, unknown>> => {
+    const sid = res.headers.get("mcp-session-id");
+    if (sid) sessionId = sid;
+    if (!(res.headers.get("content-type") ?? "").includes("text/event-stream")) return take((await res.json()) as Parameters<typeof take>[0]);
+    const reader = res.body!.getReader();
+    const dec = new TextDecoder();
+    let buf = "";
+    let data = "";
+    for (;;) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buf += dec.decode(value, { stream: true });
+      let nl: number;
+      while ((nl = buf.indexOf("\n")) >= 0) {
+        let line = buf.slice(0, nl);
+        buf = buf.slice(nl + 1);
+        if (line.endsWith("\r")) line = line.slice(0, -1);
+        if (line.startsWith("data:")) {
+          data += line.slice(5).replace(/^ /, "");
+        } else if (line === "" && data) {
+          let msg: { id?: number; result?: Record<string, unknown>; error?: { message?: string } } | undefined;
+          try {
+            msg = JSON.parse(data) as typeof msg;
+          } catch {
+            msg = undefined;
+          }
+          data = "";
+          if (msg && msg.id === id) {
+            await reader.cancel();
+            return take(msg);
+          }
+        }
+      }
+    }
+    throw new Error("stream ended without a matching response");
+  };
+  return {
+    async call(method, params) {
+      const id = nextId++;
+      const res = await post({ jsonrpc: "2.0", id, method, params });
+      if (!res.ok) throw new Error(`http ${res.status}`);
+      return readResult(res, id);
+    },
+    notify(method, params) {
+      void post({ jsonrpc: "2.0", method, params }).catch(() => {});
+    },
+  };
+}
+
+interface McpServerDef {
+  command?: string;
+  args?: string[];
+  env?: Record<string, string>;
+  url?: string; // remote MCP server (Streamable HTTP) instead of a local stdio command
+  headers?: Record<string, string>;
+}
+
+export async function loadMcpServers(includeProject: boolean): Promise<string[]> {
+  if (!includeProject) return []; // MCP servers run code — trusted projects only
+  const cfgPath = resolve(process.cwd(), ".ada", "mcp.json");
+  if (!existsSync(cfgPath)) return [];
+  let cfg: { servers?: Record<string, McpServerDef> };
+  try {
+    cfg = JSON.parse(readFileSync(cfgPath, "utf8"));
+  } catch {
+    return [];
+  }
+  const loaded: string[] = [];
+  for (const [name, def] of Object.entries(cfg.servers ?? {})) {
+    try {
+      let rpc: RpcClient;
+      if (def.url) {
+        rpc = makeHttpClient(def.url, def.headers ?? {});
+      } else if (def.command) {
+        rpc = makeClient(spawn(def.command, def.args ?? [], { env: { ...process.env, ...def.env }, stdio: ["pipe", "pipe", "ignore"] }));
+      } else {
+        console.error(`mcp ${name}: needs a "command" (stdio) or "url" (http)`);
+        continue;
+      }
+      await rpc.call("initialize", { protocolVersion: "2024-11-05", capabilities: {}, clientInfo: { name: "ada", version: "0.0.1" } });
+      rpc.notify("notifications/initialized");
+      const list = await rpc.call("tools/list", {});
+      const mcpTools = (list.tools as Array<Record<string, unknown>>) ?? [];
+      for (const t of mcpTools) {
+        const toolName = String(t.name);
+        registerTool({
+          name: `${name}__${toolName}`,
+          description: String(t.description ?? `${name} tool ${toolName}`),
+          parameters: (t.inputSchema as Record<string, unknown>) ?? { type: "object", properties: {} },
+          needsApproval: true,
+          async run(args) {
+            try {
+              const res = await rpc.call("tools/call", { name: toolName, arguments: args });
+              const content = (res.content as Array<Record<string, unknown>>) ?? [];
+              const text = content.map((c) => (c.text != null ? String(c.text) : JSON.stringify(c))).join("\n");
+              return { output: text || "(no content)", isError: !!res.isError };
+            } catch (e) {
+              return { output: String(e), isError: true };
+            }
+          },
+        });
+      }
+      // Resources (optional): expose a read_resource tool listing the server's resource URIs.
+      try {
+        const rl = await rpc.call("resources/list", {});
+        const resources = (rl.resources as Array<{ uri: string; name?: string }>) ?? [];
+        if (resources.length) {
+          registerTool({
+            name: `${name}__read_resource`,
+            description: `Read a resource from ${name}. Available URIs: ${resources.slice(0, 30).map((r) => (r.name ? `${r.uri} (${r.name})` : r.uri)).join("; ")}`,
+            parameters: { type: "object", properties: { uri: { type: "string" } }, required: ["uri"], additionalProperties: false },
+            needsApproval: true,
+            async run(args) {
+              try {
+                const res = await rpc.call("resources/read", { uri: String(args.uri) });
+                const contents = (res.contents as Array<{ text?: string; blob?: string }>) ?? [];
+                return { output: contents.map((c) => c.text ?? (c.blob ? "[binary content]" : "")).join("\n") || "(empty)" };
+              } catch (e) {
+                return { output: String(e), isError: true };
+              }
+            },
+          });
+          loaded.push(`${name} (+${resources.length} resources)`);
+        }
+      } catch {
+        /* server doesn't support resources */
+      }
+      loaded.push(`${name} (${mcpTools.length} tools)`);
+    } catch (e) {
+      console.error(`mcp ${name} failed: ${e instanceof Error ? e.message : e}`);
+    }
+  }
+  return loaded;
+}
+
+// ---- connector catalog + .ada/mcp.json management (`ada mcp …`) ----
+
+// A curated set of popular MCP connectors. `ada mcp add <name>` drops the entry into .ada/mcp.json.
+// ponytail: package names track the public MCP servers — adjust an entry if an upstream renames.
+export const CATALOG: Record<string, { description: string; server: McpServerDef }> = {
+  filesystem: { description: "Local filesystem read/write", server: { command: "npx", args: ["-y", "@modelcontextprotocol/server-filesystem", "."] } },
+  github: { description: "GitHub repos, issues, PRs", server: { command: "npx", args: ["-y", "@modelcontextprotocol/server-github"], env: { GITHUB_PERSONAL_ACCESS_TOKEN: "" } } },
+  git: { description: "Local git repository operations", server: { command: "npx", args: ["-y", "@modelcontextprotocol/server-git", "--repository", "."] } },
+  postgres: { description: "Postgres (read-only SQL)", server: { command: "npx", args: ["-y", "@modelcontextprotocol/server-postgres", "postgresql://localhost/postgres"] } },
+  sqlite: { description: "SQLite database", server: { command: "npx", args: ["-y", "mcp-server-sqlite", "--db-path", "./db.sqlite"] } },
+  fetch: { description: "Fetch and convert web pages", server: { command: "npx", args: ["-y", "@modelcontextprotocol/server-fetch"] } },
+  "brave-search": { description: "Web search via Brave", server: { command: "npx", args: ["-y", "@modelcontextprotocol/server-brave-search"], env: { BRAVE_API_KEY: "" } } },
+  puppeteer: { description: "Browser automation (Puppeteer)", server: { command: "npx", args: ["-y", "@modelcontextprotocol/server-puppeteer"] } },
+  slack: { description: "Slack channels and messages", server: { command: "npx", args: ["-y", "@modelcontextprotocol/server-slack"], env: { SLACK_BOT_TOKEN: "", SLACK_TEAM_ID: "" } } },
+  memory: { description: "Persistent knowledge-graph memory", server: { command: "npx", args: ["-y", "@modelcontextprotocol/server-memory"] } },
+  sentry: { description: "Sentry issues and events", server: { command: "npx", args: ["-y", "@modelcontextprotocol/server-sentry"], env: { SENTRY_AUTH_TOKEN: "" } } },
+};
+
+function configPath(): string {
+  return resolve(process.cwd(), ".ada", "mcp.json");
+}
+
+function readConfig(): { servers: Record<string, McpServerDef> } {
+  const p = configPath();
+  if (!existsSync(p)) return { servers: {} };
+  try {
+    const c = JSON.parse(readFileSync(p, "utf8")) as { servers?: Record<string, McpServerDef> };
+    return { servers: c.servers ?? {} };
+  } catch {
+    return { servers: {} };
+  }
+}
+
+function writeConfig(cfg: { servers: Record<string, McpServerDef> }): void {
+  const p = configPath();
+  mkdirSync(dirname(p), { recursive: true });
+  writeFileSync(p, `${JSON.stringify(cfg, null, 2)}\n`);
+}
+
+/** Add a catalog connector to .ada/mcp.json. Returns the env vars the user still needs to set. */
+export function addConnector(name: string): { ok: boolean; envVars: string[]; error?: string } {
+  const entry = CATALOG[name];
+  if (!entry) return { ok: false, envVars: [], error: `unknown connector "${name}" — run \`ada mcp\` to list the catalog` };
+  const cfg = readConfig();
+  cfg.servers[name] = entry.server;
+  writeConfig(cfg);
+  return { ok: true, envVars: Object.keys(entry.server.env ?? {}) };
+}
+
+/** Remove a connector from .ada/mcp.json. */
+export function removeConnector(name: string): boolean {
+  const cfg = readConfig();
+  if (!cfg.servers[name]) return false;
+  delete cfg.servers[name];
+  writeConfig(cfg);
+  return true;
+}
+
+/** Names of the servers currently configured in .ada/mcp.json. */
+export function configuredServers(): string[] {
+  return Object.keys(readConfig().servers);
+}
+
+/** The catalog annotated with whether each connector is already in .ada/mcp.json. */
+export function listConnectors(): { name: string; description: string; configured: boolean; needsEnv: string[] }[] {
+  const cfg = readConfig();
+  return Object.entries(CATALOG).map(([name, e]) => ({
+    name,
+    description: e.description,
+    configured: !!cfg.servers[name],
+    needsEnv: Object.keys(e.server.env ?? {}),
+  }));
+}

package/src/client/models-dev.ts

@@ -0,0 +1,52 @@
+// models.dev catalog — model metadata (context limits, pricing, capabilities). Prefetched once at
+// startup and cached for an hour; reads are synchronous from the in-memory cache. Offline-safe:
+// if the fetch fails, the cache stays empty and callers fall back to their own tables.
+
+interface Info {
+  context?: number;
+  output?: number;
+  inputCost?: number; // $ per 1M input tokens
+  outputCost?: number; // $ per 1M output tokens
+  reasoning?: boolean;
+}
+
+const cache = new Map<string, Info>();
+let fetchedAt = 0;
+
+/** Fetch and cache the models.dev catalog (no-op if fetched within the last hour). */
+export async function prefetch(): Promise<void> {
+  if (cache.size && Date.now() - fetchedAt < 3_600_000) return;
+  try {
+    const res = await fetch("https://models.dev/api.json", { signal: AbortSignal.timeout(10_000) });
+    if (!res.ok) return;
+    const data = (await res.json()) as Record<string, { models?: Record<string, { limit?: { context?: number; output?: number }; cost?: { input?: number; output?: number }; reasoning?: boolean }> }>;
+    cache.clear();
+    for (const prov of Object.values(data)) {
+      for (const [id, m] of Object.entries(prov.models ?? {})) {
+        cache.set(id, { context: m.limit?.context, output: m.limit?.output, inputCost: m.cost?.input, outputCost: m.cost?.output, reasoning: m.reasoning });
+      }
+    }
+    fetchedAt = Date.now();
+  } catch {
+    /* offline — keep whatever's cached */
+  }
+}
+
+function lookup(modelId: string): Info | null {
+  return cache.get(modelId) ?? cache.get(modelId.split("/").pop() ?? "") ?? cache.get(modelId.split(":")[0] ?? "") ?? null;
+}
+
+/** [inputCostPer1M, outputCostPer1M] from models.dev, or null. */
+export function priceOf(modelId: string): [number, number] | null {
+  const i = lookup(modelId);
+  return i && i.inputCost != null && i.outputCost != null ? [i.inputCost, i.outputCost] : null;
+}
+
+/** Context-window limit (tokens) from models.dev, or null. */
+export function contextOf(modelId: string): number | null {
+  return lookup(modelId)?.context ?? null;
+}
+
+export function catalogSize(): number {
+  return cache.size;
+}

package/src/client/pkg.ts

@@ -0,0 +1,41 @@
+// Extension package manager: `ada add <git-url | npm-package>` installs into .ada/extensions/
+// as a directory the extension loader can import.
+
+import { spawnSync } from "node:child_process";
+import { mkdirSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const EXT = resolve(process.cwd(), ".ada", "extensions");
+
+export function addExtension(spec: string): void {
+  mkdirSync(EXT, { recursive: true });
+
+  if (spec.includes("://") || spec.startsWith("git@")) {
+    const name = (spec.split("/").pop() ?? "ext").replace(/\.git$/, "");
+    const r = spawnSync("git", ["clone", "--depth", "1", spec, join(EXT, name)], { stdio: "inherit" });
+    if (r.status !== 0) throw new Error("git clone failed");
+    console.log(`installed extension ${name} → .ada/extensions/${name}`);
+    return;
+  }
+
+  // npm package: install into a self-contained dir + a re-export entry the loader imports.
+  const pkgName = spec.replace(/@[^@/]+$/, ""); // drop a trailing @version
+  const name = pkgName.replace(/^@/, "").replace(/\//g, "-");
+  const dir = join(EXT, name);
+  mkdirSync(dir, { recursive: true });
+  const r = spawnSync("npm", ["install", spec, "--prefix", dir], { stdio: "inherit", shell: process.platform === "win32" });
+  if (r.status !== 0) throw new Error("npm install failed");
+  writeFileSync(join(dir, "index.mjs"), `export { default } from ${JSON.stringify(pkgName)};\n`);
+  console.log(`installed extension ${name} (${pkgName}) → .ada/extensions/${name}`);
+}
+
+/** Self-update: ada runs from source, so update = git pull in the repo root. */
+export function selfUpdate(): void {
+  const root = resolve(dirname(fileURLToPath(import.meta.url)), "..", ".."); // src/client/pkg.ts → repo root
+  const r = spawnSync("git", ["-C", root, "pull", "--ff-only"], { stdio: "inherit" });
+  if (r.status !== 0) {
+    console.error("self-update failed (is this a git checkout?)");
+    process.exit(1);
+  }
+}