@spader/dotllm 1.3.2 → 1.3.4

package/README.md

@@ -39,3 +39,15 @@ Check in `.llm/dotllm.json`. Then, on a fresh clone, link the repositories to yo
 ```bash
 dotllm sync
 ```
+
+# configuration
+The registry lives at `~/.local/share/dotllm/dotllm.json` (`%LOCALAPPDATA%\dotllm\dotllm.json` on Windows). Set `store` to keep the repositories somewhere else, e.g. another drive
+
+```json
+{
+  "store": "/mnt/big/llm",
+  "repos": []
+}
+```
+
+`~` is expanded, and a relative path resolves against the config directory. Existing repositories are not moved; either move them yourself or `dotllm sync` to re-clone.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spader/dotllm",
-  "version": "1.3.2",
+  "version": "1.3.4",
   "description": "A simple CLI to clone, manage, and link repositories for LLM reference",
   "type": "module",
   "repository": {

package/src/cli/commands/add.js

@@ -1,20 +1,527 @@
 // @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/cli/commands/add.ts
+// src/core/config.ts
 import fs from "fs";
+import os from "os";
 import path from "path";
-import * as prompts from "@clack/prompts";
 import { z } from "zod";
-import { add, Config, sync } from "@spader/dotllm/core";
-import { defaultTheme as t } from "@spader/dotllm/cli/theme";
-import { Prompt } from "@spader/dotllm/cli/prompt";
-var RepoShape = z.object({
-  description: z.string().nullable().optional()
+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);
+    const stat = fs4.lstatSync(target, { throwIfNoEntry: false });
+    if (stat && !stat.isSymbolicLink()) {
+      unchanged.push(name);
+      continue;
+    }
+    if (stat && fs4.readlinkSync(target) === store) {
+      unchanged.push(name);
+      continue;
+    }
+    if (stat) {
+      fs4.unlinkSync(target);
+    }
+    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.lstatSync(target, { throwIfNoEntry: false })) {
+    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/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/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/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)
@@ -24,14 +531,14 @@ function stem(value) {
     const seg = raw.split("/").filter(Boolean).pop() ?? raw;
     return seg.replace(/\.git$/, "");
   }
-  if (isUrl(clean)) {
+  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 = path.basename(clean);
-  const parsed = path.parse(base);
+  const base = path6.basename(clean);
+  const parsed = path6.parse(base);
   if (parsed.name.length > 0)
     return parsed.name;
   return base;
@@ -74,10 +581,10 @@ async function apiDescription(url, accept) {
   return result.data.description ?? "";
 }
 function gitName(uri) {
-  const dir = path.resolve(uri);
-  if (!fs.existsSync(dir))
+  const dir = path6.resolve(uri);
+  if (!fs6.existsSync(dir))
     return "";
-  if (!fs.statSync(dir).isDirectory())
+  if (!fs6.statSync(dir).isDirectory())
     return "";
   const proc = Bun.spawnSync(["git", "remote", "get-url", "origin"], {
     cwd: dir,
@@ -105,37 +612,37 @@ async function remoteDescription(uri) {
   return "";
 }
 async function prefill(uri) {
-  const remote = isUrl(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 prompts.text({
+  const uri = await prompts2.text({
     message: "URL or local path to a git repo"
   });
-  if (prompts.isCancel(uri))
+  if (prompts2.isCancel(uri))
     return;
   const input = uri.trim();
   const seed = await prefill(input);
-  const name = await prompts.text({
+  const name = await prompts2.text({
     message: "Name",
     initialValue: namePrefill ?? seed.name
   });
-  if (prompts.isCancel(name))
+  if (prompts2.isCancel(name))
     return;
-  const description = await prompts.text({
+  const description = await prompts2.text({
     message: "Description",
     initialValue: descPrefill ?? seed.description
   });
-  if (prompts.isCancel(description))
+  if (prompts2.isCancel(description))
     return;
   await run(input, name || undefined, description || undefined);
 }
 function autoLink(name) {
-  const localFile = path.join(".llm", "dotllm.json");
-  if (!fs.existsSync(localFile))
+  const localFile = path6.join(".llm", "dotllm.json");
+  if (!fs6.existsSync(localFile))
     return;
   const local = Config.Local.read();
   if (Config.Local.has(local, name))
@@ -148,7 +655,7 @@ function autoLink(name) {
   Prompt.sync(sync());
 }
 async function run(uri, name, description) {
-  const spinner2 = prompts.spinner();
+  const spinner2 = prompts2.spinner();
   spinner2.start(`Adding ${uri}`);
   const needSeed = !name || !description;
   const seed = needSeed ? await prefill(uri) : { name: "", description: "" };
@@ -156,11 +663,11 @@ async function run(uri, name, description) {
   const desc = description ?? seed.description;
   const result = await add(uri, resolved || undefined, desc || undefined);
   if (!result.ok) {
-    spinner2.stop(t.error(result.error));
+    spinner2.stop(defaultTheme.error(result.error));
     process.exit(1);
     return;
   }
-  spinner2.stop(`${t.success("added")} ${t.primary(result.entry.name)} ${t.link(result.storePath)}`);
+  spinner2.stop(`${defaultTheme.success("added")} ${defaultTheme.primary(result.entry.name)} ${defaultTheme.link(result.storePath)}`);
   autoLink(result.entry.name);
 }
 var command = {
@@ -185,7 +692,7 @@ var command = {
     }
   },
   handler: async (argv) => {
-    prompts.intro("dotllm add");
+    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;
@@ -197,8 +704,8 @@ var command = {
   }
 };
 export {
-  stem,
-  github,
+  codeberg,
   command,
-  codeberg
+  github,
+  stem
 };