ada-agent 0.1.0

package/src/client/platform.ts

@@ -0,0 +1,94 @@
+// Cross-platform niceties: detect WSL / tmux / Termux and read the OS clipboard accordingly.
+
+import { spawnSync } from "node:child_process";
+import { existsSync, readFileSync, rmSync, statSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+export interface PlatformInfo {
+  os: NodeJS.Platform;
+  wsl: boolean;
+  tmux: boolean;
+  termux: boolean;
+}
+
+export function platformInfo(): PlatformInfo {
+  let wsl = false;
+  try {
+    wsl = process.platform === "linux" && existsSync("/proc/version") && /microsoft/i.test(readFileSync("/proc/version", "utf8"));
+  } catch {
+    /* ignore */
+  }
+  return {
+    os: process.platform,
+    wsl,
+    tmux: !!process.env.TMUX,
+    termux: !!process.env.TERMUX_VERSION || (process.env.PREFIX ?? "").includes("com.termux"),
+  };
+}
+
+/** Read text from the OS clipboard (best-effort; tries the right tool for the platform). */
+export function readClipboard(): string {
+  const p = platformInfo();
+  const tries: Array<[string, string[]]> =
+    p.os === "win32" || p.wsl
+      ? [["powershell.exe", ["-NoProfile", "-Command", "Get-Clipboard"]]]
+      : p.os === "darwin"
+        ? [["pbpaste", []]]
+        : p.termux
+          ? [["termux-clipboard-get", []]]
+          : [
+              ["wl-paste", []],
+              ["xclip", ["-selection", "clipboard", "-o"]],
+              ["xsel", ["-b"]],
+            ];
+  for (const [cmd, args] of tries) {
+    try {
+      const r = spawnSync(cmd, args, { encoding: "utf8" });
+      if (r.status === 0 && r.stdout) return r.stdout.replace(/\r\n/g, "\n").replace(/\n$/, "");
+    } catch {
+      /* try the next tool */
+    }
+  }
+  return "";
+}
+
+/** Best-effort desktop notification (+ terminal bell); ignores failures. */
+export function notify(title: string, body: string): void {
+  process.stdout.write("\x07"); // bell
+  const p = platformInfo();
+  try {
+    if (p.os === "darwin") spawnSync("osascript", ["-e", `display notification ${JSON.stringify(body)} with title ${JSON.stringify(title)}`]);
+    else if (p.termux) spawnSync("termux-notification", ["-t", title, "-c", body]);
+    else if (p.os === "linux") spawnSync("notify-send", [title, body]);
+  } catch {
+    /* ignore — the bell already fired */
+  }
+}
+
+/** Read an image from the OS clipboard as a PNG data URL (best-effort), or null. */
+export function readClipboardImage(): string | null {
+  const p = platformInfo();
+  const tmp = join(tmpdir(), `ada-clip-${Date.now()}-${Math.floor(Math.random() * 1e6)}.png`);
+  try {
+    if (p.os === "win32" || p.wsl) {
+      const ps = `Add-Type -AssemblyName System.Windows.Forms,System.Drawing; $i=[System.Windows.Forms.Clipboard]::GetImage(); if($i){ $i.Save('${tmp}'); 'OK' } else { 'NONE' }`;
+      const r = spawnSync("powershell.exe", ["-NoProfile", "-Command", ps], { encoding: "utf8" });
+      if (!r.stdout || !r.stdout.includes("OK")) return null;
+    } else if (p.os === "darwin") {
+      if (spawnSync("pngpaste", [tmp]).status !== 0) return null;
+    } else {
+      spawnSync("sh", ["-c", `wl-paste --type image/png > '${tmp}' 2>/dev/null || xclip -selection clipboard -t image/png -o > '${tmp}' 2>/dev/null`]);
+    }
+    if (!existsSync(tmp) || statSync(tmp).size === 0) return null;
+    return `data:image/png;base64,${readFileSync(tmp).toString("base64")}`;
+  } catch {
+    return null;
+  } finally {
+    try {
+      rmSync(tmp, { force: true });
+    } catch {
+      /* ignore */
+    }
+  }
+}

package/src/client/prompts.ts

@@ -0,0 +1,47 @@
+// User prompt templates ("/commands"). Markdown files in .ada/prompts/ (project) or
+// ~/.ada/prompts/ (global) become slash commands: a file `review.md` → `/review <args>`.
+// Substitutions: $ARGUMENTS (everything after the command), $1, $2, … (whitespace-split args).
+
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, join, resolve } from "node:path";
+
+function dirs(includeProject: boolean): string[] {
+  const global = resolve(homedir(), ".ada", "prompts");
+  return includeProject ? [resolve(process.cwd(), ".ada", "prompts"), global] : [global];
+}
+
+export function loadPrompts(includeProject = true): Map<string, string> {
+  const out = new Map<string, string>();
+  for (const dir of dirs(includeProject)) {
+    if (!existsSync(dir)) continue;
+    let names: string[];
+    try {
+      names = readdirSync(dir);
+    } catch {
+      continue;
+    }
+    for (const f of names) {
+      if (!f.endsWith(".md")) continue;
+      const name = basename(f, ".md");
+      if (out.has(name)) continue; // project dir wins over global
+      try {
+        out.set(name, readFileSync(join(dir, f), "utf8"));
+      } catch {
+        /* ignore */
+      }
+    }
+  }
+  return out;
+}
+
+/** If `input` is `/<name> args` and a template exists, return the expanded text; else null. */
+export function expandPrompt(prompts: Map<string, string>, input: string): string | null {
+  if (!input.startsWith("/")) return null;
+  const name = input.slice(1).split(/\s+/)[0] ?? "";
+  const tmpl = prompts.get(name);
+  if (!tmpl) return null;
+  const argline = input.slice(1 + name.length).trim();
+  const parts = argline ? argline.split(/\s+/) : [];
+  return tmpl.replace(/\$ARGUMENTS/g, argline).replace(/\$(\d+)/g, (_, n) => parts[Number(n) - 1] ?? "");
+}

package/src/client/render.ts

@@ -0,0 +1,138 @@
+// Terminal rendering: colored edit diffs + a streaming markdown styler with light,
+// dependency-free syntax highlighting. Colors come from a theme (ADA_THEME=dark|light).
+
+const ESC = "\x1b[";
+const wrap = (code: string) => (s: string) => `${ESC}${code}m${s}${ESC}0m`;
+export const red = wrap("31");
+export const green = wrap("32");
+export const yellow = wrap("33");
+export const cyan = wrap("36");
+export const dim = wrap("2");
+export const bold = wrap("1");
+const magenta = wrap("35");
+const blue = wrap("34");
+
+interface Theme {
+  heading: (s: string) => string;
+  bullet: (s: string) => string;
+  inlineCode: (s: string) => string;
+  keyword: (s: string) => string;
+  str: (s: string) => string;
+  comment: (s: string) => string;
+  num: (s: string) => string;
+  meta: (s: string) => string;
+  add: (s: string) => string;
+  del: (s: string) => string;
+}
+
+const THEMES: Record<string, Theme> = {
+  dark: { heading: bold, bullet: yellow, inlineCode: cyan, keyword: magenta, str: green, comment: dim, num: yellow, meta: dim, add: green, del: red },
+  light: { heading: bold, bullet: blue, inlineCode: blue, keyword: magenta, str: green, comment: dim, num: yellow, meta: dim, add: green, del: red },
+};
+
+export const theme: Theme = THEMES[process.env.ADA_THEME ?? "dark"] ?? THEMES.dark!;
+
+// A small, language-agnostic keyword set — enough to make most code blocks readable.
+const KEYWORDS = new Set(
+  ("const let var function return if else for while class new import export from async await try catch finally throw " +
+    "typeof instanceof of in do switch case break continue default extends implements interface type enum namespace " +
+    "public private protected static readonly void null undefined true false this super yield " +
+    "def lambda elif fn pub use struct impl match mut self None True False and or not is with as pass raise " +
+    "package func go defer chan map range select")
+    .split(" "),
+);
+
+/** Index of a line comment (`//` or `#`) not inside a string, or -1. */
+function commentStart(line: string): number {
+  let q = "";
+  for (let i = 0; i < line.length; i++) {
+    const c = line[i]!;
+    if (q) {
+      if (c === q && line[i - 1] !== "\\") q = "";
+      continue;
+    }
+    if (c === '"' || c === "'" || c === "`") {
+      q = c;
+      continue;
+    }
+    if (c === "/" && line[i + 1] === "/") return i;
+    if (c === "#") return i;
+  }
+  return -1;
+}
+
+/** Heuristic syntax highlight for a single code line: strings, numbers, keywords, comments. */
+export function highlight(line: string): string {
+  const ci = commentStart(line);
+  const code = ci >= 0 ? line.slice(0, ci) : line;
+  const comment = ci >= 0 ? line.slice(ci) : "";
+  const colored = code.replace(
+    /("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|`(?:[^`\\]|\\.)*`)|(\b\d+(?:\.\d+)?\b)|(\b[A-Za-z_]\w*\b)/g,
+    (m, str, num, word) => {
+      if (str) return theme.str(str);
+      if (num) return theme.num(num);
+      if (word && KEYWORDS.has(word)) return theme.keyword(word);
+      return m;
+    },
+  );
+  return colored + (comment ? theme.comment(comment) : "");
+}
+
+/** A colored diff for an exact edit (old_text → new_text), trimming shared head/tail lines
+ *  so only the changed region is shown. */
+export function renderEditDiff(path: string, oldText: string, newText: string): string {
+  const a = oldText.split("\n");
+  const b = newText.split("\n");
+  let pre = 0;
+  while (pre < a.length && pre < b.length && a[pre] === b[pre]) pre++;
+  let suf = 0;
+  while (suf < a.length - pre && suf < b.length - pre && a[a.length - 1 - suf] === b[b.length - 1 - suf]) suf++;
+
+  const out: string[] = [theme.meta(path)];
+  for (const l of a.slice(pre, a.length - suf)) out.push(theme.del(`- ${l}`));
+  for (const l of b.slice(pre, b.length - suf)) out.push(theme.add(`+ ${l}`));
+  return out.map((l) => `  ${l}`).join("\n");
+}
+
+/** Styles streamed assistant text line-by-line (markdown). Feed deltas to push(); it returns
+ *  the styled, already-completed lines to print and buffers the in-progress line until its
+ *  newline arrives. Call end() once the stream finishes to flush the last partial line. */
+export class MarkdownStreamer {
+  private buf = "";
+  private inCode = false;
+
+  push(text: string): string {
+    this.buf += text;
+    let out = "";
+    let nl: number;
+    while ((nl = this.buf.indexOf("\n")) >= 0) {
+      out += `${this.styleLine(this.buf.slice(0, nl))}\n`;
+      this.buf = this.buf.slice(nl + 1);
+    }
+    return out;
+  }
+
+  end(): string {
+    if (!this.buf) return "";
+    const out = this.styleLine(this.buf);
+    this.buf = "";
+    return out;
+  }
+
+  private styleLine(line: string): string {
+    if (/^\s*```/.test(line)) {
+      this.inCode = !this.inCode;
+      return theme.meta(line);
+    }
+    if (this.inCode) return highlight(line);
+    const heading = line.match(/^#{1,6}\s+(.*)$/);
+    if (heading) return theme.heading(heading[1]!);
+    const bullet = line.match(/^(\s*)[-*]\s+(.*)$/);
+    if (bullet) return `${bullet[1]}${theme.bullet("•")} ${this.inline(bullet[2]!)}`;
+    return this.inline(line);
+  }
+
+  private inline(s: string): string {
+    return s.replace(/\*\*([^*]+)\*\*/g, (_, m) => bold(m)).replace(/`([^`]+)`/g, (_, m) => theme.inlineCode(m));
+  }
+}

package/src/client/session.ts

@@ -0,0 +1,107 @@
+// Append-only JSONL session store under .ada/sessions/. One OpenAI message per line.
+
+import { appendFileSync, existsSync, mkdirSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { join, resolve } from "node:path";
+
+const DIR = resolve(process.cwd(), ".ada", "sessions");
+
+export type StoredMessage = Record<string, unknown>;
+
+function ensureDir(): void {
+  mkdirSync(DIR, { recursive: true });
+}
+
+function newId(): string {
+  return `${new Date().toISOString().replace(/[:.]/g, "-")}-${Math.random().toString(16).slice(2, 6)}`;
+}
+
+export interface SessionMeta {
+  file: string;
+  mtime: number;
+  title: string;
+  parent?: string; // file this branch was forked from
+}
+
+export class Session {
+  readonly file: string;
+
+  private constructor(file: string) {
+    this.file = file;
+  }
+
+  static create(): Session {
+    ensureDir();
+    return new Session(join(DIR, `${newId()}.jsonl`));
+  }
+
+  static open(file: string): Session {
+    return new Session(file);
+  }
+
+  static latest(): Session | null {
+    const metas = list();
+    return metas[0] ? Session.open(metas[0].file) : null;
+  }
+
+  /** Branch: a new session seeded with `messages`, recording its parent for /tree. */
+  static fork(parentFile: string, messages: unknown[]): Session {
+    ensureDir();
+    const s = new Session(join(DIR, `${newId()}.jsonl`));
+    s.append({ __meta: { parent: parentFile, branchedAt: messages.length } });
+    for (const m of messages) s.append(m);
+    return s;
+  }
+
+  append(msg: unknown): void {
+    try {
+      ensureDir();
+      appendFileSync(this.file, `${JSON.stringify(msg)}\n`, "utf8");
+    } catch {
+      /* persistence is best-effort; never crash the agent over it */
+    }
+  }
+
+  load(): StoredMessage[] {
+    if (!existsSync(this.file)) return [];
+    return readFileSync(this.file, "utf8")
+      .split("\n")
+      .filter((l) => l.trim())
+      .map((l) => {
+        try {
+          return JSON.parse(l) as StoredMessage;
+        } catch {
+          return null;
+        }
+      })
+      .filter((m): m is StoredMessage => m !== null && !("__meta" in m));
+  }
+}
+
+export function list(): SessionMeta[] {
+  ensureDir();
+  const out: SessionMeta[] = [];
+  for (const f of readdirSync(DIR)) {
+    if (!f.endsWith(".jsonl")) continue;
+    const file = join(DIR, f);
+    let title = "(empty)";
+    let parent: string | undefined;
+    try {
+      for (const l of readFileSync(file, "utf8").split("\n")) {
+        if (!l.trim()) continue;
+        const m = JSON.parse(l) as StoredMessage;
+        if (m.__meta) {
+          parent = (m.__meta as { parent?: string }).parent;
+          continue;
+        }
+        if (m.role === "user" && typeof m.content === "string") {
+          title = m.content.slice(0, 60);
+          break;
+        }
+      }
+    } catch {
+      /* ignore unreadable session */
+    }
+    out.push({ file, mtime: statSync(file).mtimeMs, title, parent });
+  }
+  return out.sort((a, b) => b.mtime - a.mtime);
+}

package/src/client/settings.ts

@@ -0,0 +1,86 @@
+// Layered settings: global (~/.ada/settings.json) merged with project (.ada/settings.json),
+// project winning. Also the project-trust list — project files are only loaded for trusted dirs.
+
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+
+export type PermAction = "allow" | "ask" | "deny";
+export interface PermRule {
+  tool?: string; // glob over the tool name (e.g. "bash", "web_*"); omit = any tool
+  pattern?: string; // glob/substring over the call summary (args); omit = any
+  action: PermAction;
+}
+
+export interface Settings {
+  model?: string;
+  reasoning?: "low" | "medium" | "high";
+  autoApprove?: boolean;
+  compactAt?: number;
+  trustedDirs?: string[];
+  keybindings?: { interrupt?: string };
+  protectedPaths?: string[];
+  confirmDestructive?: boolean;
+  permissions?: PermRule[]; // per-tool allow/ask/deny rules; last match wins
+  agents?: Record<string, { description?: string; prompt?: string; permissions?: PermRule[] }>; // named agent profiles
+}
+
+const GLOBAL = join(homedir(), ".ada", "settings.json");
+const PROJECT = resolve(process.cwd(), ".ada", "settings.json");
+
+function readJson(p: string): Settings {
+  try {
+    return JSON.parse(readFileSync(p, "utf8")) as Settings;
+  } catch {
+    return {};
+  }
+}
+
+function writeGlobal(s: Settings): void {
+  try {
+    mkdirSync(dirname(GLOBAL), { recursive: true });
+    writeFileSync(GLOBAL, JSON.stringify(s, null, 2), "utf8");
+  } catch {
+    /* best-effort */
+  }
+}
+
+/** Global settings, with project settings merged in (project overrides) when trusted. */
+export function loadSettings(includeProject: boolean): Settings {
+  const g = readJson(GLOBAL);
+  return includeProject ? { ...g, ...readJson(PROJECT) } : g;
+}
+
+export function isTrusted(dir: string): boolean {
+  return (readJson(GLOBAL).trustedDirs ?? []).includes(dir);
+}
+
+function globMatch(pat: string, s: string): boolean {
+  const re = new RegExp(`^${pat.split("*").map((p) => p.replace(/[.+?^${}()|[\]\\]/g, "\\$&")).join(".*")}$`, "i");
+  return re.test(s);
+}
+
+// A named agent's permission rules override the configured ones while it's active.
+let activeAgentPerms: PermRule[] | null = null;
+export function setActiveAgentPermissions(rules: PermRule[] | null): void {
+  activeAgentPerms = rules;
+}
+
+/** Evaluate the configured permission rules for a tool call. null = no matching rule (use defaults). */
+export function permissionFor(toolName: string, summary: string): PermAction | null {
+  const rules = activeAgentPerms ?? loadSettings(isTrusted(process.cwd())).permissions ?? [];
+  let result: PermAction | null = null;
+  for (const r of rules) {
+    const toolOk = !r.tool || r.tool === toolName || globMatch(r.tool, toolName);
+    const patOk = !r.pattern || summary.toLowerCase().includes(r.pattern.toLowerCase()) || globMatch(r.pattern, summary);
+    if (toolOk && patOk) result = r.action; // last match wins
+  }
+  return result;
+}
+
+export function addTrust(dir: string): void {
+  const g = readJson(GLOBAL);
+  const dirs = new Set(g.trustedDirs ?? []);
+  dirs.add(dir);
+  writeGlobal({ ...g, trustedDirs: [...dirs] });
+}

package/src/client/skill-router.ts

@@ -0,0 +1,79 @@
+// Skill routing: rank skills by relevance to a free-text request, so ada can surface the right
+// skill proactively (or via the find_skill tool) instead of the model browsing the whole catalog.
+//
+// ponytail: this is a lexical TF-IDF-ish ranker (idf-weighted token overlap, name-boosted, with a
+// shared-prefix match so plurals/derivations line up — "docker" ↔ "dockerfile", "migrate" ↔
+// "migration"). No embedding model or dependency. A real embedding scorer can replace `rankSkills`
+// later if synonym matching (e.g. "containerize" → dockerize) becomes worth a model round-trip.
+
+export interface RankItem {
+  name: string;
+  description: string;
+  category?: string;
+}
+
+const STOP = new Set(
+  "a an and are as at be build by can create do for from how in into is it make of on or set the this to up use using with without your you".split(" "),
+);
+
+export function tokenize(s: string): string[] {
+  return s
+    .toLowerCase()
+    .split(/[^a-z0-9]+/)
+    .filter((t) => t.length > 1 && !STOP.has(t));
+}
+
+/** Two tokens match if equal or they share a 4+ char prefix (a cheap stand-in for stemming). */
+function matches(a: string, b: string): boolean {
+  if (a === b) return true;
+  const m = Math.min(a.length, b.length);
+  let i = 0;
+  while (i < m && a[i] === b[i]) i++;
+  return i >= 4;
+}
+
+/** Top-n skills most relevant to `query`, scored by idf-weighted token overlap (name-boosted). */
+export function rankSkills(query: string, items: RankItem[], n = 5): { name: string; description: string; score: number }[] {
+  const q = [...new Set(tokenize(query))];
+  if (!q.length || !items.length) return [];
+  const docs = items.map((it) => ({
+    name: tokenize(it.name),
+    all: tokenize(`${it.name} ${it.description} ${it.category ?? ""}`),
+  }));
+  const N = items.length;
+  const idf = (qt: string): number => {
+    let df = 0;
+    for (const d of docs) if (d.all.some((dt) => matches(qt, dt))) df++;
+    return Math.log(1 + N / (1 + df));
+  };
+  const weight = new Map(q.map((qt) => [qt, idf(qt)]));
+  const scored = items.map((it, i) => {
+    let s = 0;
+    for (const qt of q) {
+      if (docs[i].all.some((dt) => matches(qt, dt))) {
+        s += weight.get(qt)! * (docs[i].name.some((dt) => matches(qt, dt)) ? 2.5 : 1);
+      }
+    }
+    return { name: it.name, description: it.description, score: s };
+  });
+  return scored
+    .filter((x) => x.score > 0)
+    .sort((a, b) => b.score - a.score)
+    .slice(0, n);
+}
+
+/**
+ * The single clearly-dominant skill for a query, or null when the match is weak/ambiguous.
+ * Three gates, all required: a score floor, dominance over the runner-up, and — crucially — an
+ * EXACT whole-token overlap with the skill NAME. That last gate is the precision guard against
+ * lexical false positives: "make a powerpoint" prefix-matches "low-power" and even dominates, but
+ * "powerpoint" never equals the name token "power", so it's correctly rejected.
+ */
+export function confidentSkill(query: string, items: RankItem[]): string | null {
+  const ranked = rankSkills(query, items, 2);
+  const top = ranked[0];
+  if (!top || top.score < 4) return null;
+  if (ranked[1] && top.score < ranked[1].score * 1.3) return null; // reject ties/near-ties; the name-exact gate below is the real precision guard
+  const q = new Set(tokenize(query));
+  return tokenize(top.name).some((t) => q.has(t)) ? top.name : null;
+}