@spader/dotllm 1.3.2 → 1.3.3

package/src/cli/index.js

@@ -1,10 +1,1438 @@
 #!/usr/bin/env bun
 // @bun
-var __require = import.meta.require;
+var __esm = (fn, res, err) => () => {
+  if (fn)
+    try {
+      res = fn(fn = 0);
+    } catch (e) {
+      err = [e];
+    }
+  if (err)
+    throw err[0];
+  return res;
+};
 
+// src/core/config.ts
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { z } from "zod";
+function readJson(filepath) {
+  if (!fs.existsSync(filepath))
+    return null;
+  const raw = fs.readFileSync(filepath, "utf-8");
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+var LOCAL_DIR = ".llm", LOCAL_FILE, REF_DIR, RepoEntry, GlobalShape, LocalShape, Config;
+var init_config = __esm(() => {
+  LOCAL_FILE = path.join(LOCAL_DIR, "dotllm.json");
+  REF_DIR = path.join(LOCAL_DIR, "reference");
+  RepoEntry = z.object({
+    kind: z.enum(["url", "file"]),
+    name: z.string(),
+    uri: z.string(),
+    description: z.string()
+  });
+  GlobalShape = z.object({
+    store: z.string().optional(),
+    repos: z.array(RepoEntry)
+  });
+  LocalShape = z.object({
+    refs: z.record(z.string(), RepoEntry)
+  });
+  ((Config) => {
+    function home() {
+      if (process.platform === "win32") {
+        const appData = process.env.LOCALAPPDATA ?? path.join(os.homedir(), "AppData", "Local");
+        return path.join(appData, "dotllm");
+      }
+      return path.join(process.env.HOME ?? os.homedir(), ".local", "share", "dotllm");
+    }
+    Config.home = home;
+    function storeDir() {
+      const store = Global.read().store;
+      if (!store)
+        return path.join(home(), "store");
+      return expand(store);
+    }
+    Config.storeDir = storeDir;
+    function refDir() {
+      return REF_DIR;
+    }
+    Config.refDir = refDir;
+    let Global;
+    ((Global) => {
+      function read() {
+        const raw = readJson(path.join(home(), "dotllm.json"));
+        if (!raw)
+          return { repos: [] };
+        const result = GlobalShape.safeParse(raw);
+        if (!result.success)
+          return { repos: [] };
+        return result.data;
+      }
+      Global.read = read;
+      function write(config) {
+        const dir = home();
+        fs.mkdirSync(dir, { recursive: true });
+        fs.writeFileSync(path.join(dir, "dotllm.json"), JSON.stringify(config, null, 2) + `
+`);
+      }
+      Global.write = write;
+      function find(config, name) {
+        const lower = name.toLowerCase();
+        return config.repos.find((r) => r.name.toLowerCase() === lower);
+      }
+      Global.find = find;
+      function add(config, entry) {
+        const lower = entry.name.toLowerCase();
+        const filtered = config.repos.filter((r) => r.name.toLowerCase() !== lower);
+        return { ...config, repos: [...filtered, entry] };
+      }
+      Global.add = add;
+      function remove(config, name) {
+        const lower = name.toLowerCase();
+        return { ...config, repos: config.repos.filter((r) => r.name.toLowerCase() !== lower) };
+      }
+      Global.remove = remove;
+    })(Global = Config.Global ||= {});
+    let Local;
+    ((Local) => {
+      function read() {
+        const raw = readJson(LOCAL_FILE);
+        if (!raw)
+          return { refs: {} };
+        const result = LocalShape.safeParse(raw);
+        if (!result.success)
+          return { refs: {} };
+        return result.data;
+      }
+      Local.read = read;
+      function write(config) {
+        fs.mkdirSync(LOCAL_DIR, { recursive: true });
+        fs.writeFileSync(LOCAL_FILE, JSON.stringify(config, null, 2) + `
+`);
+      }
+      Local.write = write;
+      function find(config, name) {
+        const lower = name.toLowerCase();
+        for (const [key, value] of Object.entries(config.refs)) {
+          if (key.toLowerCase() === lower)
+            return value;
+        }
+        return;
+      }
+      Local.find = find;
+      function has(config, name) {
+        return find(config, name) !== undefined;
+      }
+      Local.has = has;
+      function add(config, repo) {
+        const lower = repo.name.toLowerCase();
+        const refs = Object.fromEntries(Object.entries(config.refs).filter(([key]) => key.toLowerCase() !== lower));
+        refs[repo.name] = repo;
+        return { refs };
+      }
+      Local.add = add;
+      function remove(config, name) {
+        const lower = name.toLowerCase();
+        const refs = Object.fromEntries(Object.entries(config.refs).filter(([key]) => key.toLowerCase() !== lower));
+        return { refs };
+      }
+      Local.remove = remove;
+    })(Local = Config.Local ||= {});
+    function expand(dir) {
+      const tilde = dir === "~" || dir.startsWith("~/") || dir.startsWith("~\\");
+      if (!tilde)
+        return path.resolve(home(), dir);
+      return path.join(os.homedir(), dir.slice(1));
+    }
+  })(Config ||= {});
+});
+
+// src/core/add.ts
+import fs2 from "fs";
+import path2 from "path";
+function isUrl(value) {
+  return value.startsWith("http://") || value.startsWith("https://") || value.startsWith("git@") || value.startsWith("ssh://");
+}
+function nameFromGitRemote(dir) {
+  const result = Bun.spawnSync(["git", "remote", "get-url", "origin"], {
+    cwd: dir,
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  if (result.exitCode !== 0)
+    return null;
+  const url = result.stdout.toString().trim();
+  return nameFromUrl(url);
+}
+function nameFromUrl(url) {
+  const base = url.split("/").pop() ?? url;
+  return base.replace(/\.git$/, "");
+}
+async function add(uri, name, description) {
+  const desc = description ?? "";
+  if (isUrl(uri)) {
+    return cloneUrl(uri, name, desc);
+  }
+  return linkLocal(uri, name, desc);
+}
+async function cloneUrl(url, name, description) {
+  const resolved = name ?? nameFromUrl(url);
+  const store = Config.storeDir();
+  fs2.mkdirSync(store, { recursive: true });
+  const target = path2.join(store, resolved);
+  if (!fs2.existsSync(target)) {
+    const proc = Bun.spawn(["git", "clone", "--depth=1", url, target], {
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const code = await proc.exited;
+    if (code !== 0) {
+      const msg = await new Response(proc.stderr).text();
+      return { ok: false, error: `git clone failed: ${msg.trim()}` };
+    }
+  }
+  const entry = { kind: "url", name: resolved, uri: url, description };
+  const global = Config.Global.read();
+  Config.Global.write(Config.Global.add(global, entry));
+  return { ok: true, entry, storePath: target };
+}
+function linkLocal(raw, name, description) {
+  const resolved = path2.resolve(raw);
+  if (!fs2.existsSync(resolved)) {
+    return { ok: false, error: `Path does not exist: ${resolved}` };
+  }
+  if (!fs2.statSync(resolved).isDirectory()) {
+    return { ok: false, error: `Not a directory: ${resolved}` };
+  }
+  const store = Config.storeDir();
+  fs2.mkdirSync(store, { recursive: true });
+  const finalName = name ?? nameFromGitRemote(resolved) ?? path2.basename(resolved);
+  const target = path2.join(store, finalName);
+  if (!fs2.existsSync(target)) {
+    fs2.symlinkSync(resolved, target, "dir");
+  }
+  const entry = { kind: "file", name: finalName, uri: resolved, description };
+  const global = Config.Global.read();
+  Config.Global.write(Config.Global.add(global, entry));
+  return { ok: true, entry, storePath: target };
+}
+var init_add = __esm(() => {
+  init_config();
+});
+
+// src/core/remove.ts
+import fs3 from "fs";
+import path3 from "path";
+function remove(name) {
+  const global = Config.Global.read();
+  const found = Config.Global.find(global, name);
+  if (!found) {
+    return { ok: false, error: `No repo named "${name}" in registry` };
+  }
+  const target = path3.join(Config.storeDir(), found.name);
+  if (fs3.existsSync(target)) {
+    const stat = fs3.lstatSync(target);
+    if (stat.isSymbolicLink()) {
+      fs3.unlinkSync(target);
+    }
+    if (stat.isDirectory()) {
+      fs3.rmSync(target, { recursive: true, force: true });
+    }
+  }
+  Config.Global.write(Config.Global.remove(global, found.name));
+  return { ok: true };
+}
+var init_remove = __esm(() => {
+  init_config();
+});
+
+// src/core/sync.ts
+import fs4 from "fs";
+import path4 from "path";
+function shouldPull(storeDir, force) {
+  if (force)
+    return true;
+  const head = path4.join(storeDir, ".git", "HEAD");
+  const headStat = fs4.statSync(head, { throwIfNoEntry: false });
+  if (!headStat)
+    return true;
+  const age = Date.now() - headStat.mtimeMs;
+  if (age < FRESH_MS)
+    return false;
+  if (age > STALE_MS)
+    return true;
+  const dirStat = fs4.statSync(storeDir, { throwIfNoEntry: false });
+  if (!dirStat)
+    return true;
+  return dirStat.atimeMs > headStat.mtimeMs;
+}
+async function pull(names, options = {}) {
+  const force = options.force === true;
+  const global = Config.Global.read();
+  const states = await Promise.all(names.map(async (name) => {
+    const cwd = path4.join(Config.refDir(), name);
+    if (!fs4.existsSync(cwd)) {
+      return { kind: "failed", name, error: "reference directory missing" };
+    }
+    const repo = Config.Global.find(global, name);
+    if (repo && repo.kind === "file") {
+      return { kind: "skipped", name };
+    }
+    const storeDir = path4.join(Config.storeDir(), name);
+    const storeStat = fs4.lstatSync(storeDir, { throwIfNoEntry: false });
+    if (!storeStat || storeStat.isSymbolicLink()) {
+      return { kind: "skipped", name };
+    }
+    if (!fs4.existsSync(path4.join(storeDir, ".git"))) {
+      return { kind: "failed", name, error: "store directory is not a git repo" };
+    }
+    if (!shouldPull(storeDir, force)) {
+      return { kind: "skipped", name };
+    }
+    const fetch2 = Bun.spawn(["git", "fetch", "--depth=1", "origin", "HEAD"], {
+      cwd,
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const [fetchCode, fetchOut, fetchErr] = await Promise.all([
+      fetch2.exited,
+      new Response(fetch2.stdout).text(),
+      new Response(fetch2.stderr).text()
+    ]);
+    if (fetchCode !== 0) {
+      const msg = `${fetchOut}
+${fetchErr}`.trim();
+      return { kind: "failed", name, error: msg || "git fetch failed" };
+    }
+    const reset = Bun.spawn(["git", "reset", "--hard", "FETCH_HEAD"], {
+      cwd,
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const [resetCode, resetOut, resetErr] = await Promise.all([
+      reset.exited,
+      new Response(reset.stdout).text(),
+      new Response(reset.stderr).text()
+    ]);
+    if (resetCode !== 0) {
+      const msg = `${resetOut}
+${resetErr}`.trim();
+      return { kind: "failed", name, error: msg || "git reset failed" };
+    }
+    return { kind: "ok" };
+  }));
+  const pulled = [];
+  const skipped = [];
+  const failed = [];
+  for (let i = 0;i < states.length; i++) {
+    const state = states[i];
+    if (state.kind === "ok")
+      pulled.push(names[i]);
+    if (state.kind === "skipped")
+      skipped.push(state.name);
+    if (state.kind === "failed")
+      failed.push({ name: state.name, error: state.error });
+  }
+  return { count: names.length, pulled, skipped, failed };
+}
+function sync() {
+  const local = Config.Local.read();
+  const global = Config.Global.read();
+  const merged = Object.values(local.refs).reduce((config, repo) => Config.Global.add(config, repo), global);
+  if (Object.keys(local.refs).length > 0) {
+    Config.Global.write(merged);
+  }
+  const refDir = Config.refDir();
+  fs4.mkdirSync(refDir, { recursive: true });
+  fs4.mkdirSync(Config.storeDir(), { recursive: true });
+  const linked = [];
+  const removed = [];
+  const missing = [];
+  const unchanged = [];
+  const wanted = new Set(Object.keys(local.refs));
+  for (const entry of fs4.readdirSync(refDir)) {
+    if (wanted.has(entry))
+      continue;
+    const target = path4.join(refDir, entry);
+    const stat = fs4.lstatSync(target);
+    if (stat.isSymbolicLink()) {
+      fs4.unlinkSync(target);
+      removed.push(entry);
+    }
+  }
+  for (const [name, repo] of Object.entries(local.refs)) {
+    const store = path4.join(Config.storeDir(), name);
+    const storeBroken = repo.kind === "url" && fs4.existsSync(store) && !fs4.existsSync(path4.join(store, ".git"));
+    if (storeBroken) {
+      fs4.rmSync(store, { recursive: true, force: true });
+    }
+    if (!fs4.existsSync(store) && repo.kind === "url") {
+      const clone = Bun.spawnSync(["git", "clone", "--depth=1", repo.uri, store], {
+        stdout: "pipe",
+        stderr: "pipe"
+      });
+      if (clone.exitCode !== 0) {
+        missing.push(name);
+        continue;
+      }
+    }
+    if (!fs4.existsSync(store) && repo.kind === "file") {
+      if (!fs4.existsSync(repo.uri)) {
+        missing.push(name);
+        continue;
+      }
+      if (!fs4.statSync(repo.uri).isDirectory()) {
+        missing.push(name);
+        continue;
+      }
+      fs4.symlinkSync(repo.uri, store, "dir");
+    }
+    if (!fs4.existsSync(store)) {
+      missing.push(name);
+      continue;
+    }
+    const target = path4.join(refDir, name);
+    if (fs4.existsSync(target)) {
+      unchanged.push(name);
+      continue;
+    }
+    fs4.symlinkSync(store, target, "dir");
+    linked.push(name);
+  }
+  return { linked, removed, missing, unchanged };
+}
+var FRESH_MS, STALE_MS;
+var init_sync = __esm(() => {
+  init_config();
+  FRESH_MS = 24 * 60 * 60 * 1000;
+  STALE_MS = 7 * FRESH_MS;
+});
+
+// src/core/link.ts
+function link(names) {
+  const global = Config.Global.read();
+  const rows = names.map((name) => {
+    const repo = Config.Global.find(global, name);
+    if (!repo)
+      return null;
+    return [repo.name, repo];
+  }).filter((row) => row !== null);
+  Config.Local.write({ refs: Object.fromEntries(rows) });
+  return sync();
+}
+var init_link = __esm(() => {
+  init_config();
+  init_sync();
+});
+
+// src/core/unlink.ts
+import fs5 from "fs";
+import path5 from "path";
+function unlink(name) {
+  const local = Config.Local.read();
+  const found = Config.Local.find(local, name);
+  if (!found) {
+    return { ok: false, error: `"${name}" is not linked in local config` };
+  }
+  const target = path5.join(Config.refDir(), found.name);
+  if (fs5.existsSync(target)) {
+    fs5.unlinkSync(target);
+  }
+  Config.Local.write(Config.Local.remove(local, found.name));
+  return { ok: true };
+}
+var init_unlink = __esm(() => {
+  init_config();
+});
+
+// src/core/index.ts
+var init_core = __esm(() => {
+  init_config();
+  init_add();
+  init_remove();
+  init_link();
+  init_unlink();
+  init_sync();
+});
+
+// src/cli/yargs.ts
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+import pc from "picocolors";
+
+// src/cli/theme.ts
+function rgb(r, g, b) {
+  return (value) => `\x1B[38;2;${r};${g};${b}m${value}\x1B[39m`;
+}
+var gray = (value) => rgb(value, value, value);
+var defaultTheme = {
+  primary: rgb(114, 161, 136),
+  link: rgb(114, 140, 212),
+  header: gray(128),
+  command: rgb(114, 161, 136),
+  arg: rgb(161, 212, 212),
+  option: rgb(212, 212, 161),
+  type: gray(128),
+  description: (value) => value,
+  dim: gray(128),
+  error: rgb(212, 114, 114),
+  success: rgb(114, 212, 136)
+};
+
+// src/cli/layout.ts
+var ANSI_RE = /\x1b\[[0-9;]*m/g;
+function clean(value) {
+  return value.replace(/[\t\n]/g, " ").replace(ANSI_RE, "");
+}
+function truncateMiddle(value, width) {
+  if (width <= 0)
+    return "";
+  if (value.length <= width)
+    return value;
+  if (width <= 3)
+    return value.slice(0, width);
+  const tail = Math.floor((width - 3) / 2);
+  const head = width - 3 - tail;
+  return `${value.slice(0, head)}...${value.slice(value.length - tail)}`;
+}
+function truncateStart(value, width) {
+  if (width <= 0)
+    return "";
+  if (value.length <= width)
+    return value;
+  if (width <= 3)
+    return "...".slice(0, width);
+  return `...${value.slice(value.length - (width - 3))}`;
+}
+function truncateEnd(value, width) {
+  if (width <= 0)
+    return "";
+  if (value.length <= width)
+    return value;
+  if (width <= 3)
+    return "...".slice(0, width);
+  return `${value.slice(0, width - 3)}...`;
+}
+function truncate(value, width, mode) {
+  if (mode === "start")
+    return truncateStart(value, width);
+  if (mode === "end")
+    return truncateEnd(value, width);
+  return truncateMiddle(value, width);
+}
+function fitWidths(natural, available, flex, noTruncate) {
+  const widths = [...natural];
+  const totalNatural = natural.reduce((sum, width) => sum + width, 0);
+  if (totalNatural <= available) {
+    return widths;
+  }
+  let fixedWidth = 0;
+  const dynamic = [];
+  for (let index = 0;index < widths.length; index++) {
+    if (noTruncate[index] || flex[index] === 0) {
+      fixedWidth += widths[index] ?? 0;
+      continue;
+    }
+    dynamic.push({ index, weight: flex[index] ?? 1 });
+  }
+  const remaining = Math.max(0, available - fixedWidth);
+  if (dynamic.length === 0) {
+    return widths;
+  }
+  const totalWeight = dynamic.reduce((sum, item) => sum + item.weight, 0);
+  let used = 0;
+  for (const item of dynamic) {
+    const share = Math.floor(remaining * item.weight / totalWeight);
+    const width = Math.max(1, share);
+    widths[item.index] = width;
+    used += width;
+  }
+  let extra = remaining - used;
+  let cursor = 0;
+  while (extra > 0) {
+    const item = dynamic[cursor % dynamic.length];
+    widths[item.index] = (widths[item.index] ?? 0) + 1;
+    extra--;
+    cursor++;
+  }
+  return widths;
+}
+function table(headers, columns, options = {}) {
+  if (headers.length === 0)
+    return;
+  const count = headers.length;
+  const gap = 2;
+  const rows = columns.reduce((max, column) => Math.max(max, column.length), 0);
+  const visibleRows = Math.min(rows, options.maxRows ?? rows);
+  const natural = [];
+  for (let col = 0;col < count; col++) {
+    const headerWidth = clean(headers[col] ?? "").length;
+    let width = headerWidth;
+    for (let row = 0;row < visibleRows; row++) {
+      const value = clean(columns[col]?.[row] ?? "");
+      width = Math.max(width, value.length);
+    }
+    natural[col] = width;
+  }
+  const maxWidth = options.maxWidth ?? (process.stdout.columns == null ? 120 : process.stdout.columns);
+  const available = Math.max(0, maxWidth - gap * (count - 1) - 1);
+  const widths = fitWidths(natural, available, options.flex ?? [], options.noTruncate ?? []);
+  const header = headers.map((title, col) => truncateMiddle(clean(title), widths[col] ?? 0).padEnd(widths[col] ?? 0)).join("  ");
+  process.stdout.write(`${defaultTheme.dim(header)}
+`);
+  for (let row = 0;row < visibleRows; row++) {
+    const cells = [];
+    for (let col = 0;col < count; col++) {
+      const width = widths[col] ?? 0;
+      const source = clean(columns[col]?.[row] ?? "");
+      const mode = options.truncate?.[col] ?? "middle";
+      const value = options.noTruncate?.[col] ? source : truncate(source, width, mode);
+      const padded = width > 0 ? value.padEnd(width) : value;
+      const formatted = options.format?.[col]?.(padded, row, col) ?? padded;
+      cells.push(formatted);
+    }
+    process.stdout.write(`${cells.join("  ")}
+`);
+  }
+  if (rows > visibleRows) {
+    process.stdout.write(`${defaultTheme.dim("(...truncated)")}
+`);
+  }
+}
+function cols(rows, colorFns) {
+  if (rows.length === 0)
+    return;
+  const widths = rows[0].map((_, col) => {
+    let width = 0;
+    for (const row of rows) {
+      width = Math.max(width, clean(row[col] ?? "").length);
+    }
+    return width;
+  });
+  for (const row of rows) {
+    const line = row.map((value, col) => {
+      const padded = clean(value).padEnd(widths[col] ?? 0);
+      return colorFns?.[col]?.(padded) ?? padded;
+    }).join(" ");
+    process.stdout.write(`${line}
+`);
+  }
+}
+
+// src/cli/yargs.ts
+function usage(def, path, t) {
+  const parts = [];
+  const last = path.length - 1;
+  for (let i = 0;i < path.length; i++) {
+    const fmt = t.command;
+    parts.push(i === last ? fmt(path[i]) : path[i]);
+  }
+  if ("positionals" in def && def.positionals) {
+    for (const [k, v] of Object.entries(def.positionals)) {
+      const name = t.arg(`$${k}`);
+      parts.push(v.required ? name : `[${name}]`);
+    }
+  }
+  if (def.options && Object.keys(def.options).length > 0) {
+    parts.push(t.dim("[options]"));
+  }
+  if ("commands" in def && def.commands && Object.keys(def.commands).length > 0) {
+    parts.push(t.arg("$command"));
+  }
+  return parts.join(" ");
+}
+function help(def, name, path = [], t = defaultTheme) {
+  let prev = false;
+  if (def.description) {
+    console.log(t.description(def.description));
+    prev = true;
+  }
+  if (prev)
+    console.log("");
+  console.log(t.header("usage:"));
+  console.log(`  ${usage(def, [name, ...path], t)}`);
+  prev = true;
+  const pos = "positionals" in def ? def.positionals : undefined;
+  if (pos && Object.keys(pos).length > 0) {
+    if (prev)
+      console.log("");
+    console.log(t.header("arguments"));
+    prev = true;
+    const rows = [];
+    for (const [k, v] of Object.entries(pos)) {
+      let desc = v.description;
+      if (v.default !== undefined)
+        desc += ` ${t.dim(`(default: ${v.default})`)}`;
+      if (v.required)
+        desc += ` ${t.dim("(required)")}`;
+      rows.push([`  ${k}`, v.type, desc]);
+    }
+    cols(rows, [t.arg, t.type, t.description]);
+  }
+  const opts = {
+    ...def.options ?? {},
+    help: { alias: "h", type: "boolean", description: "Show help" }
+  };
+  if ("version" in def && def.version) {
+    opts.version = { alias: "v", type: "boolean", description: "Show version" };
+  }
+  if (Object.keys(opts).length > 0) {
+    if (prev)
+      console.log("");
+    console.log(t.header("options"));
+    prev = true;
+    const rows = [];
+    for (const [k, v] of Object.entries(opts)) {
+      const short = v.alias ? `-${v.alias}, ` : "    ";
+      let desc = v.description;
+      if (v.default !== undefined && v.type !== "boolean") {
+        desc += ` ${t.dim(`(default: ${v.default})`)}`;
+      }
+      rows.push([`  ${short}--${k}`, v.type, desc]);
+    }
+    cols(rows, [t.option, t.type, t.description]);
+  }
+  const cmds = "commands" in def ? def.commands : undefined;
+  if (cmds && Object.keys(cmds).length > 0) {
+    if (prev)
+      console.log("");
+    console.log(t.header("commands"));
+    const rows = [];
+    const rowCmdFmt = [];
+    for (const [k, v] of Object.entries(cmds)) {
+      if (v.hidden)
+        continue;
+      const args = v.positionals ? Object.keys(v.positionals).join(" ") : "";
+      rows.push([`  ${k}`, args, v.summary ?? v.description]);
+      rowCmdFmt.push(t.command);
+    }
+    let ri = 0;
+    cols(rows, [(s) => rowCmdFmt[ri++](s), t.arg, t.description]);
+  }
+}
+function fail(def, name, path = []) {
+  return (msg) => {
+    if (process.argv.includes("--help") || process.argv.includes("-h")) {
+      help(def, name, path);
+      process.exit(0);
+    }
+    if (msg?.includes("You must specify") || msg?.includes("Not enough non-option arguments")) {
+      help(def, name, path);
+      process.exit(1);
+    }
+    console.error(pc.red(msg ?? "Unknown error"));
+    process.exit(1);
+  };
+}
+function check(def, name, path = []) {
+  return (argv) => {
+    const args = argv;
+    if (args.help && args._.length === path.length) {
+      help(def, name, path);
+      process.exit(0);
+    }
+    return true;
+  };
+}
+function configure(y, def, root, path) {
+  if ("positionals" in def && def.positionals) {
+    for (const [k, v] of Object.entries(def.positionals)) {
+      y.positional(k, {
+        type: v.type,
+        describe: v.description,
+        demandOption: v.required,
+        default: v.default
+      });
+    }
+  }
+  if (def.options) {
+    for (const [k, v] of Object.entries(def.options)) {
+      y.option(k, {
+        alias: v.alias,
+        type: v.type,
+        describe: v.description,
+        demandOption: v.required,
+        default: v.default
+      });
+    }
+  }
+  if ("commands" in def && def.commands) {
+    for (const [k, v] of Object.entries(def.commands)) {
+      command(y, k, v, root, path);
+    }
+    const hasHandler = "handler" in def && typeof def.handler === "function";
+    if (!hasHandler) {
+      y.demandCommand(1, "You must specify a command");
+    }
+  }
+  y.help(false).option("help", { alias: "h", type: "boolean", describe: "Show help" }).check(check(def, root, path)).fail(fail(def, root, path));
+  if (path.length === 0 && "version" in def && def.version) {
+    y.version(def.version).alias("version", "v");
+  }
+}
+function command(y, name, def, root, path) {
+  let cmd = name;
+  if (def.positionals) {
+    for (const [k, v] of Object.entries(def.positionals)) {
+      cmd += v.required ? ` <${k}>` : ` [${k}]`;
+    }
+  }
+  y.command(cmd, def.description, (inner) => configure(inner, def, root, [...path, name]), def.handler);
+}
+function build(def) {
+  const y = yargs(hideBin(process.argv)).scriptName(def.name);
+  configure(y, def, def.name, []);
+  y.strict();
+  return y;
+}
+
+// src/cli/commands/add.ts
+init_core();
+import fs6 from "fs";
+import path6 from "path";
+import * as prompts2 from "@clack/prompts";
+import { z as z2 } from "zod";
+
+// src/cli/prompt.ts
+import * as prompts from "@clack/prompts";
+var Prompt;
+((Prompt) => {
+  function sync(result) {
+    const parts = [];
+    if (result.linked.length > 0)
+      parts.push(`${result.linked.length} added`);
+    if (result.removed.length > 0)
+      parts.push(`${result.removed.length} removed`);
+    if (result.unchanged.length > 0)
+      parts.push(`${result.unchanged.length} unchanged`);
+    if (result.missing.length > 0)
+      parts.push(`${result.missing.length} missing`);
+    if (parts.length > 0)
+      prompts.log.step(parts.join(", "));
+  }
+  Prompt.sync = sync;
+})(Prompt ||= {});
+
+// src/cli/commands/add.ts
+var RepoShape = z2.object({
+  description: z2.string().nullable().optional()
+});
+function isUrl2(value) {
+  return value.startsWith("http://") || value.startsWith("https://") || value.startsWith("git@") || value.startsWith("ssh://");
+}
+function stem(value) {
+  const clean = value.trim().replace(/\/+$/, "");
+  if (clean.length === 0)
+    return "";
+  if (clean.startsWith("git@")) {
+    const raw = clean.split(":").slice(1).join(":");
+    const seg = raw.split("/").filter(Boolean).pop() ?? raw;
+    return seg.replace(/\.git$/, "");
+  }
+  if (isUrl2(clean)) {
+    const seg = clean.split("/").filter(Boolean).pop() ?? clean;
+    const raw = seg.split("?")[0] ?? seg;
+    const full = raw.split("#")[0] ?? raw;
+    return full.replace(/\.git$/, "");
+  }
+  const base = path6.basename(clean);
+  const parsed = path6.parse(base);
+  if (parsed.name.length > 0)
+    return parsed.name;
+  return base;
+}
+function github(uri) {
+  return hosted(uri, "github.com");
+}
+function codeberg(uri) {
+  return hosted(uri, "codeberg.org");
+}
+function hosted(uri, host) {
+  const escaped = host.replace(/\./g, "\\.");
+  const https = uri.match(new RegExp(`^https?:\\/\\/${escaped}\\/([^/]+)\\/([^/]+?)(?:\\.git)?\\/?$`));
+  if (https) {
+    return { owner: https[1], repo: https[2] };
+  }
+  const ssh = uri.match(new RegExp(`^ssh:\\/\\/git@${escaped}\\/([^/]+)\\/([^/]+?)(?:\\.git)?\\/?$`));
+  if (ssh) {
+    return { owner: ssh[1], repo: ssh[2] };
+  }
+  const scp = uri.match(new RegExp(`^git@${escaped}:([^/]+)\\/([^/]+?)(?:\\.git)?$`));
+  if (scp) {
+    return { owner: scp[1], repo: scp[2] };
+  }
+  return null;
+}
+async function apiDescription(url, accept) {
+  const response = await fetch(url, {
+    headers: {
+      accept,
+      "user-agent": "dotllm"
+    }
+  });
+  if (!response.ok)
+    return "";
+  const raw = await response.json();
+  const result = RepoShape.safeParse(raw);
+  if (!result.success)
+    return "";
+  return result.data.description ?? "";
+}
+function gitName(uri) {
+  const dir = path6.resolve(uri);
+  if (!fs6.existsSync(dir))
+    return "";
+  if (!fs6.statSync(dir).isDirectory())
+    return "";
+  const proc = Bun.spawnSync(["git", "remote", "get-url", "origin"], {
+    cwd: dir,
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  if (proc.exitCode !== 0)
+    return "";
+  const out = proc.stdout.toString().trim();
+  if (out.length === 0)
+    return "";
+  return stem(out);
+}
+async function remoteDescription(uri) {
+  const gh = github(uri);
+  if (gh) {
+    const url = `https://api.github.com/repos/${gh.owner}/${gh.repo}`;
+    return apiDescription(url, "application/vnd.github+json");
+  }
+  const cb = codeberg(uri);
+  if (cb) {
+    const url = `https://codeberg.org/api/v1/repos/${cb.owner}/${cb.repo}`;
+    return apiDescription(url, "application/json");
+  }
+  return "";
+}
+async function prefill(uri) {
+  const remote = isUrl2(uri);
+  const git = remote ? "" : gitName(uri);
+  const name = git.length > 0 ? git : stem(uri);
+  const description = remote ? await remoteDescription(uri) : "";
+  return { name, description };
+}
+async function interactive(namePrefill, descPrefill) {
+  const uri = await prompts2.text({
+    message: "URL or local path to a git repo"
+  });
+  if (prompts2.isCancel(uri))
+    return;
+  const input = uri.trim();
+  const seed = await prefill(input);
+  const name = await prompts2.text({
+    message: "Name",
+    initialValue: namePrefill ?? seed.name
+  });
+  if (prompts2.isCancel(name))
+    return;
+  const description = await prompts2.text({
+    message: "Description",
+    initialValue: descPrefill ?? seed.description
+  });
+  if (prompts2.isCancel(description))
+    return;
+  await run(input, name || undefined, description || undefined);
+}
+function autoLink(name) {
+  const localFile = path6.join(".llm", "dotllm.json");
+  if (!fs6.existsSync(localFile))
+    return;
+  const local = Config.Local.read();
+  if (Config.Local.has(local, name))
+    return;
+  const global = Config.Global.read();
+  const repo = Config.Global.find(global, name);
+  if (!repo)
+    return;
+  Config.Local.write(Config.Local.add(local, repo));
+  Prompt.sync(sync());
+}
+async function run(uri, name, description) {
+  const spinner2 = prompts2.spinner();
+  spinner2.start(`Adding ${uri}`);
+  const needSeed = !name || !description;
+  const seed = needSeed ? await prefill(uri) : { name: "", description: "" };
+  const resolved = name ?? seed.name;
+  const desc = description ?? seed.description;
+  const result = await add(uri, resolved || undefined, desc || undefined);
+  if (!result.ok) {
+    spinner2.stop(defaultTheme.error(result.error));
+    process.exit(1);
+    return;
+  }
+  spinner2.stop(`${defaultTheme.success("added")} ${defaultTheme.primary(result.entry.name)} ${defaultTheme.link(result.storePath)}`);
+  autoLink(result.entry.name);
+}
+var command2 = {
+  description: "Register a git repo as a reference",
+  summary: "Add a repo to the registry",
+  positionals: {
+    uri: {
+      type: "string",
+      description: "URL or local path to a git repo"
+    }
+  },
+  options: {
+    name: {
+      alias: "n",
+      type: "string",
+      description: "Name override (defaults to repo name from git)"
+    },
+    description: {
+      alias: "d",
+      type: "string",
+      description: "Description of the reference"
+    }
+  },
+  handler: async (argv) => {
+    prompts2.intro("dotllm add");
+    const uri = typeof argv.uri === "string" && argv.uri.length > 0 ? argv.uri : undefined;
+    const name = typeof argv.name === "string" && argv.name.length > 0 ? argv.name : undefined;
+    const description = typeof argv.description === "string" && argv.description.length > 0 ? argv.description : undefined;
+    if (!uri) {
+      await interactive(name, description);
+      return;
+    }
+    await run(uri, name, description);
+  }
+};
+// src/cli/commands/remove.ts
+init_core();
+import * as prompts3 from "@clack/prompts";
+var command3 = {
+  description: "Remove a repo from the registry",
+  summary: "Remove a registered repo",
+  positionals: {
+    name: {
+      type: "string",
+      description: "Name of the reference to remove",
+      required: true
+    }
+  },
+  handler: (argv) => {
+    prompts3.intro("dotllm remove");
+    const name = String(argv.name);
+    const result = remove(name);
+    if (!result.ok) {
+      prompts3.log.error(defaultTheme.error(result.error));
+      process.exit(1);
+      return;
+    }
+    prompts3.log.step(`removed ${defaultTheme.primary(name)}`);
+  }
+};
+// src/cli/commands/list.ts
+init_core();
+import * as prompts4 from "@clack/prompts";
+var command4 = {
+  description: "List all registered repos",
+  summary: "Show the registry",
+  handler: () => {
+    prompts4.intro("dotllm list");
+    const global = Config.Global.read();
+    if (global.repos.length === 0) {
+      console.log(defaultTheme.dim("(no repos registered)"));
+      console.log(defaultTheme.dim("use `dotllm add <path>` to register one"));
+      return;
+    }
+    const local = Config.Local.read();
+    const linked = new Set(Object.keys(local.refs));
+    table(["name", "kind", "uri", "description", "linked"], [
+      global.repos.map((r) => r.name),
+      global.repos.map((r) => r.kind),
+      global.repos.map((r) => r.uri),
+      global.repos.map((r) => r.description),
+      global.repos.map((r) => linked.has(r.name) ? "yes" : "no")
+    ], {
+      flex: [0, 0, 1, 1, 0],
+      noTruncate: [true, true, false, false, true],
+      truncate: ["end", "end", "start", "end", "end"],
+      format: [
+        (s) => defaultTheme.primary(s),
+        (s) => s,
+        (s) => defaultTheme.link(s),
+        (s) => s,
+        (s) => s.trim() === "yes" ? defaultTheme.success(s) : s
+      ]
+    });
+  }
+};
+// src/cli/commands/link.ts
+init_core();
+import * as prompts5 from "@clack/prompts";
+var command5 = {
+  description: "Interactively pick repos to link into .llm/reference/, or add/remove one by name",
+  summary: "Link references",
+  positionals: {
+    name: {
+      type: "string",
+      description: "Name of the repo to link, or omit for interactive"
+    }
+  },
+  options: {
+    remove: {
+      alias: "r",
+      type: "boolean",
+      description: "Remove the link instead of adding it"
+    }
+  },
+  handler: async (argv) => {
+    prompts5.intro("dotllm link");
+    const name = typeof argv.name === "string" && argv.name.length > 0 ? argv.name : undefined;
+    const shouldRemove = argv.remove === true;
+    if (name) {
+      if (shouldRemove) {
+        const result = unlink(name);
+        if (!result.ok) {
+          prompts5.log.error(defaultTheme.error(result.error));
+          process.exit(1);
+          return;
+        }
+        prompts5.log.step(`unlinked ${defaultTheme.primary(name)}`);
+        return;
+      }
+      const global = Config.Global.read();
+      const repo = Config.Global.find(global, name);
+      if (!repo) {
+        prompts5.log.error(defaultTheme.error(`No repo named "${name}" in registry`));
+        process.exit(1);
+        return;
+      }
+      const local = Config.Local.read();
+      Config.Local.write(Config.Local.add(local, repo));
+      Prompt.sync(sync());
+      return;
+    }
+    const global = Config.Global.read();
+    if (global.repos.length === 0) {
+      console.log(defaultTheme.dim("(no repos registered)"));
+      console.log(defaultTheme.dim("use `dotllm add <path>` to register one"));
+      return;
+    }
+    const local = Config.Local.read();
+    const current = new Set(Object.keys(local.refs));
+    const repos = [...global.repos].sort((a, b) => a.name.localeCompare(b.name));
+    const initialValues = repos.filter((r) => current.has(r.name)).map((r) => r.name).sort((a, b) => b.localeCompare(a));
+    const selected = await prompts5.autocompleteMultiselect({
+      message: "Select repos to link into .llm/reference/",
+      options: repos.map((r) => ({
+        value: r.name,
+        label: r.name,
+        hint: r.uri
+      })),
+      initialValues,
+      required: false
+    });
+    if (prompts5.isCancel(selected)) {
+      prompts5.cancel("cancelled");
+      return;
+    }
+    const names = Array.isArray(selected) ? selected.filter((value) => typeof value === "string") : [];
+    Prompt.sync(link(names));
+  }
+};
+// src/cli/commands/sync.ts
+init_core();
+import * as prompts6 from "@clack/prompts";
+var command6 = {
+  description: "Re-create symlinks from .llm/dotllm.json",
+  summary: "Sync symlinks from local config",
+  options: {
+    force: {
+      alias: "f",
+      type: "boolean",
+      description: "Pull all repos regardless of recent access"
+    }
+  },
+  handler: async (argv) => {
+    prompts6.intro("dotllm sync");
+    const result = sync();
+    if (result.linked.length === 0 && result.removed.length === 0 && result.missing.length === 0 && result.unchanged.length === 0) {
+      console.log(defaultTheme.dim("(no refs in local config)"));
+      console.log(defaultTheme.dim("use `dotllm link` to select repos"));
+      return;
+    }
+    Prompt.sync(result);
+    const refs = [...new Set([...result.unchanged, ...result.linked])];
+    if (refs.length === 0) {
+      return;
+    }
+    const force = argv.force === true;
+    const spinner = prompts6.spinner();
+    spinner.start(`Checking ${refs.length} linked repo${refs.length === 1 ? "" : "s"}`);
+    const pulled = await pull(refs, { force });
+    if (pulled.failed.length > 0) {
+      spinner.stop(defaultTheme.error(`pull failed for ${pulled.failed.length} repo${pulled.failed.length === 1 ? "" : "s"}`));
+      process.exit(1);
+      return;
+    }
+    const parts = [];
+    if (pulled.pulled.length > 0)
+      parts.push(`${defaultTheme.success("pulled")} ${pulled.pulled.length}`);
+    if (pulled.skipped.length > 0)
+      parts.push(defaultTheme.dim(`${pulled.skipped.length} skipped`));
+    spinner.stop(parts.length > 0 ? parts.join(" ") : defaultTheme.dim("nothing to pull"));
+  }
+};
+// src/cli/commands/which.ts
+init_core();
+import path7 from "path";
+var command7 = {
+  description: "Print the absolute path to a repo in the store (prefix match, shortest wins)",
+  summary: "Show repo store path",
+  positionals: {
+    name: {
+      type: "string",
+      description: "Name (or prefix) of the repo",
+      required: true
+    }
+  },
+  handler: (argv) => {
+    const name = String(argv.name);
+    const global = Config.Global.read();
+    const exact = Config.Global.find(global, name);
+    if (exact) {
+      console.log(path7.join(Config.storeDir(), exact.name));
+      return;
+    }
+    const lower = name.toLowerCase();
+    const matches = global.repos.filter((r) => r.name.toLowerCase().startsWith(lower)).sort((a, b) => a.name.length - b.name.length);
+    if (matches.length === 0) {
+      console.error(defaultTheme.error(`No repo matching "${name}" in registry`));
+      process.exit(1);
+      return;
+    }
+    if (matches.length > 1 && matches[0].name.length === matches[1].name.length) {
+      const names = matches.filter((m) => m.name.length === matches[0].name.length).map((m) => m.name);
+      console.error(defaultTheme.error(`Ambiguous prefix "${name}": ${names.join(", ")}`));
+      process.exit(1);
+      return;
+    }
+    console.log(path7.join(Config.storeDir(), matches[0].name));
+  }
+};
+// src/cli/commands/completions.ts
+init_core();
+import fs7 from "fs";
+import os2 from "os";
+import path8 from "path";
+var BASH = `_dotllm() {
+  local cur="\${COMP_WORDS[COMP_CWORD]}"
+
+  if [[ \${COMP_CWORD} -eq 1 ]]; then
+    COMPREPLY=( $(compgen -W "add remove list link sync which completions" -- "\${cur}") )
+    return
+  fi
+
+  case "\${COMP_WORDS[1]}" in
+    which|link)
+      local repos
+      repos=$(dotllm completions --names 2>/dev/null)
+      COMPREPLY=( $(compgen -W "\${repos}" -- "\${cur}") )
+      ;;
+  esac
+}
+
+complete -F _dotllm dotllm`;
+var ZSH = `#compdef dotllm
+
+_dotllm() {
+  local -a commands
+  commands=(
+    'add:Register a new repo'
+    'remove:Remove a repo from the registry'
+    'list:Show the registry'
+    'link:Link references'
+    'sync:Sync linked repos'
+    'which:Show repo store path'
+    'completions:Output shell completions'
+  )
+
+  _arguments -C '1:command:->cmd' '*::arg:->args'
+
+  case "$state" in
+    cmd)
+      _describe 'command' commands
+      ;;
+    args)
+      case "\${words[1]}" in
+        which|link)
+          local -a repos
+          repos=(\${(f)"$(dotllm completions --names 2>/dev/null)"})
+          _describe 'repo' repos
+          ;;
+      esac
+      ;;
+  esac
+}
+
+_dotllm`;
+var FISH = `complete -c dotllm -f
+complete -c dotllm -n "__fish_use_subcommand" -a add -d "Register a new repo"
+complete -c dotllm -n "__fish_use_subcommand" -a remove -d "Remove a repo from the registry"
+complete -c dotllm -n "__fish_use_subcommand" -a list -d "Show the registry"
+complete -c dotllm -n "__fish_use_subcommand" -a link -d "Link references"
+complete -c dotllm -n "__fish_use_subcommand" -a sync -d "Sync linked repos"
+complete -c dotllm -n "__fish_use_subcommand" -a which -d "Show repo store path"
+complete -c dotllm -n "__fish_use_subcommand" -a completions -d "Output shell completions"
+complete -c dotllm -n "__fish_seen_subcommand_from which link" -a "(dotllm completions --names 2>/dev/null)"`;
+var CANARY = "@dotllm_completions";
+function completionFile(shell) {
+  return path8.join(Config.home(), `completions.${shell}`);
+}
+function hookSnippet(shell) {
+  const file = completionFile(shell);
+  switch (shell) {
+    case "bash":
+      return `
+# ${CANARY}
+# Installed by the dotllm CLI
+[ -f "${file}" ] && source "${file}"
+`;
+    case "zsh":
+      return `
+# ${CANARY}
+# Installed by the dotllm CLI
+[ -f "${file}" ] && source "${file}"
+`;
+    case "fish":
+      return `
+# ${CANARY}
+# Installed by the dotllm CLI
+test -f "${file}"; and source "${file}"
+`;
+    default:
+      return "";
+  }
+}
+function rcPath(shell) {
+  const home = os2.homedir();
+  switch (shell) {
+    case "bash": {
+      const bashrc = path8.join(home, ".bashrc");
+      if (fs7.existsSync(bashrc))
+        return bashrc;
+      return path8.join(home, ".bash_profile");
+    }
+    case "zsh":
+      return path8.join(home, ".zshrc");
+    case "fish":
+      return path8.join(home, ".config", "fish", "config.fish");
+  }
+}
+var install = {
+  description: "Add completions to your shell rc file",
+  summary: "Install completions",
+  handler: async (argv) => {
+    if (process.platform === "win32") {
+      console.log(defaultTheme.dim("Shell completions are not supported on Windows."));
+      return;
+    }
+    const shell = detectShell();
+    const rc = rcPath(shell);
+    if (!rc) {
+      console.error(defaultTheme.error(`Could not determine rc file for shell: "${shell}"`));
+      process.exit(1);
+      return;
+    }
+    const script = shellScript(shell);
+    if (!script) {
+      console.error(defaultTheme.error(`Unknown shell: "${shell}"`));
+      process.exit(1);
+      return;
+    }
+    const cached = completionFile(shell);
+    fs7.mkdirSync(path8.dirname(cached), { recursive: true });
+    fs7.writeFileSync(cached, script + `
+`);
+    const existing = fs7.existsSync(rc) ? fs7.readFileSync(rc, "utf-8") : "";
+    if (existing.includes(CANARY)) {
+      console.log(defaultTheme.dim(`Updated ${cached}`));
+      console.log(defaultTheme.dim(`Already sourced from ${rc}`));
+      return;
+    }
+    fs7.appendFileSync(rc, hookSnippet(shell));
+    console.log(`Installed completions in ${defaultTheme.link(rc)}`);
+    console.log(defaultTheme.dim(`Restart your shell or run: source ${rc}`));
+  }
+};
+var command8 = {
+  description: "Output shell completion script for bash, zsh, or fish",
+  summary: "Shell completions",
+  options: {
+    shell: {
+      alias: "s",
+      type: "string",
+      description: "Shell type: bash, zsh, or fish"
+    },
+    names: {
+      type: "boolean",
+      description: "Print repo names (used internally by completions)"
+    }
+  },
+  commands: {
+    install
+  },
+  handler: async (argv) => {
+    if (process.platform === "win32") {
+      console.log(defaultTheme.dim("Shell completions are not supported on Windows."));
+      return;
+    }
+    if (argv.names) {
+      await Promise.resolve().then(() => init_core());
+      const global = Config.Global.read();
+      for (const r of global.repos)
+        console.log(r.name);
+      return;
+    }
+    const shell = typeof argv.shell === "string" && argv.shell.length > 0 ? argv.shell : detectShell();
+    switch (shell) {
+      case "bash":
+        console.log(BASH);
+        break;
+      case "zsh":
+        console.log(ZSH);
+        break;
+      case "fish":
+        console.log(FISH);
+        break;
+      default:
+        console.error(defaultTheme.error(`Unknown shell: "${shell}". Use bash, zsh, or fish.`));
+        process.exit(1);
+    }
+  }
+};
+function shellScript(shell) {
+  switch (shell) {
+    case "bash":
+      return BASH;
+    case "zsh":
+      return ZSH;
+    case "fish":
+      return FISH;
+  }
+}
+function detectShell() {
+  const login = process.env.SHELL ?? "";
+  if (login.endsWith("/fish"))
+    return "fish";
+  if (login.endsWith("/zsh"))
+    return "zsh";
+  return "bash";
+}
 // src/cli/index.ts
-import { build } from "@spader/dotllm/cli/yargs";
-import { add, remove, list, link, sync, which, completions } from "@spader/dotllm/cli/commands/index";
 var DotLlmCli;
 ((DotLlmCli) => {
   async function run() {
@@ -15,13 +1443,13 @@ var DotLlmCli;
       description: "Manage git repo references symlinked into .llm/reference/",
       version,
       commands: {
-        add,
-        remove,
-        list,
-        link,
-        sync,
-        which,
-        completions
+        add: command2,
+        remove: command3,
+        list: command4,
+        link: command5,
+        sync: command6,
+        which: command7,
+        completions: command8
       }
     };
     build(def).parse();