@spader/dotllm 1.3.0 → 1.3.2

package/package.json

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

package/src/cli/commands/add.js

@@ -1,4 +1,6 @@
 // @bun
+var __require = import.meta.require;
+
 // src/cli/commands/add.ts
 import fs from "fs";
 import path from "path";

package/src/cli/commands/completions.js

@@ -0,0 +1,216 @@
+// @bun
+var __require = import.meta.require;
+
+// src/cli/commands/completions.ts
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { Config } from "@spader/dotllm/core";
+import { defaultTheme as t } from "@spader/dotllm/cli/theme";
+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 path.join(path.dirname(Config.storeDir()), `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 = os.homedir();
+  switch (shell) {
+    case "bash": {
+      const bashrc = path.join(home, ".bashrc");
+      if (fs.existsSync(bashrc))
+        return bashrc;
+      return path.join(home, ".bash_profile");
+    }
+    case "zsh":
+      return path.join(home, ".zshrc");
+    case "fish":
+      return path.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(t.dim("Shell completions are not supported on Windows."));
+      return;
+    }
+    const shell = detectShell();
+    const rc = rcPath(shell);
+    if (!rc) {
+      console.error(t.error(`Could not determine rc file for shell: "${shell}"`));
+      process.exit(1);
+      return;
+    }
+    const script = shellScript(shell);
+    if (!script) {
+      console.error(t.error(`Unknown shell: "${shell}"`));
+      process.exit(1);
+      return;
+    }
+    const cached = completionFile(shell);
+    fs.mkdirSync(path.dirname(cached), { recursive: true });
+    fs.writeFileSync(cached, script + `
+`);
+    const existing = fs.existsSync(rc) ? fs.readFileSync(rc, "utf-8") : "";
+    if (existing.includes(CANARY)) {
+      console.log(t.dim(`Updated ${cached}`));
+      console.log(t.dim(`Already sourced from ${rc}`));
+      return;
+    }
+    fs.appendFileSync(rc, hookSnippet(shell));
+    console.log(`Installed completions in ${t.link(rc)}`);
+    console.log(t.dim(`Restart your shell or run: source ${rc}`));
+  }
+};
+var command = {
+  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(t.dim("Shell completions are not supported on Windows."));
+      return;
+    }
+    if (argv.names) {
+      const { Config: Config2 } = await import("@spader/dotllm/core");
+      const global = Config2.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(t.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";
+}
+export {
+  command
+};

package/src/cli/commands/index.js

@@ -1,4 +1,6 @@
 // @bun
+var __require = import.meta.require;
+
 // src/cli/commands/index.ts
 import { command } from "@spader/dotllm/cli/commands/add";
 import { command as command2 } from "@spader/dotllm/cli/commands/remove";
@@ -6,13 +8,13 @@ import { command as command3 } from "@spader/dotllm/cli/commands/list";
 import { command as command4 } from "@spader/dotllm/cli/commands/link";
 import { command as command5 } from "@spader/dotllm/cli/commands/sync";
 import { command as command6 } from "@spader/dotllm/cli/commands/which";
-import { command as command7 } from "@spader/dotllm/cli/commands/cd";
+import { command as command7 } from "@spader/dotllm/cli/commands/completions";
 export {
   command6 as which,
   command5 as sync,
   command2 as remove,
   command3 as list,
   command4 as link,
-  command7 as cd,
+  command7 as completions,
   command as add
 };

package/src/cli/commands/link.js

@@ -1,4 +1,6 @@
 // @bun
+var __require = import.meta.require;
+
 // src/cli/commands/link.ts
 import * as prompts from "@clack/prompts";
 import { Config, link, unlink, sync } from "@spader/dotllm/core";

package/src/cli/commands/list.js

@@ -1,4 +1,6 @@
 // @bun
+var __require = import.meta.require;
+
 // src/cli/commands/list.ts
 import * as prompts from "@clack/prompts";
 import { Config } from "@spader/dotllm/core";

package/src/cli/commands/remove.js

@@ -1,4 +1,6 @@
 // @bun
+var __require = import.meta.require;
+
 // src/cli/commands/remove.ts
 import * as prompts from "@clack/prompts";
 import { remove } from "@spader/dotllm/core";

package/src/cli/commands/sync.js

@@ -1,4 +1,6 @@
 // @bun
+var __require = import.meta.require;
+
 // src/cli/commands/sync.ts
 import * as prompts from "@clack/prompts";
 import { pull, sync } from "@spader/dotllm/core";
@@ -7,7 +9,14 @@ import { Prompt } from "@spader/dotllm/cli/prompt";
 var command = {
   description: "Re-create symlinks from .llm/dotllm.json",
   summary: "Sync symlinks from local config",
-  handler: async () => {
+  options: {
+    force: {
+      alias: "f",
+      type: "boolean",
+      description: "Pull all repos regardless of recent access"
+    }
+  },
+  handler: async (argv) => {
     prompts.intro("dotllm sync");
     const result = sync();
     if (result.linked.length === 0 && result.removed.length === 0 && result.missing.length === 0 && result.unchanged.length === 0) {
@@ -20,15 +29,21 @@ var command = {
     if (refs.length === 0) {
       return;
     }
+    const force = argv.force === true;
     const spinner2 = prompts.spinner();
-    spinner2.start(`Pulling ${refs.length} linked repo${refs.length === 1 ? "" : "s"}`);
-    const pulled = await pull(refs);
+    spinner2.start(`Checking ${refs.length} linked repo${refs.length === 1 ? "" : "s"}`);
+    const pulled = await pull(refs, { force });
     if (pulled.failed.length > 0) {
       spinner2.stop(t.error(`pull failed for ${pulled.failed.length} repo${pulled.failed.length === 1 ? "" : "s"}`));
       process.exit(1);
       return;
     }
-    spinner2.stop(`${t.success("pulled")} ${pulled.count} repo${pulled.count === 1 ? "" : "s"}`);
+    const parts = [];
+    if (pulled.pulled.length > 0)
+      parts.push(`${t.success("pulled")} ${pulled.pulled.length}`);
+    if (pulled.skipped.length > 0)
+      parts.push(t.dim(`${pulled.skipped.length} skipped`));
+    spinner2.stop(parts.length > 0 ? parts.join(" ") : t.dim("nothing to pull"));
   }
 };
 export {

package/src/cli/commands/which.js

@@ -1,28 +1,42 @@
 // @bun
+var __require = import.meta.require;
+
 // src/cli/commands/which.ts
 import path from "path";
 import { Config } from "@spader/dotllm/core";
 import { defaultTheme as t } from "@spader/dotllm/cli/theme";
 var command = {
-  description: "Print the absolute path to a repo in the store",
+  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 of the repo",
+      description: "Name (or prefix) of the repo",
       required: true
     }
   },
   handler: (argv) => {
     const name = String(argv.name);
     const global = Config.Global.read();
-    const repo = Config.Global.find(global, name);
-    if (!repo) {
-      console.error(t.error(`No repo named "${name}" in registry`));
+    const exact = Config.Global.find(global, name);
+    if (exact) {
+      console.log(path.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(t.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(t.error(`Ambiguous prefix "${name}": ${names.join(", ")}`));
       process.exit(1);
       return;
     }
-    console.log(path.join(Config.storeDir(), name));
+    console.log(path.join(Config.storeDir(), matches[0].name));
   }
 };
 export {

package/src/cli/index.js

@@ -1,9 +1,10 @@
 #!/usr/bin/env bun
 // @bun
+var __require = import.meta.require;
 
 // src/cli/index.ts
 import { build } from "@spader/dotllm/cli/yargs";
-import { add, remove, list, link, sync, which, cd } from "@spader/dotllm/cli/commands/index";
+import { add, remove, list, link, sync, which, completions } from "@spader/dotllm/cli/commands/index";
 var DotLlmCli;
 ((DotLlmCli) => {
   async function run() {
@@ -20,7 +21,7 @@ var DotLlmCli;
         link,
         sync,
         which,
-        cd
+        completions
       }
     };
     build(def).parse();

package/src/cli/layout.js

@@ -1,4 +1,6 @@
 // @bun
+var __require = import.meta.require;
+
 // src/cli/layout.ts
 import { defaultTheme as theme } from "@spader/dotllm/cli/theme";
 var ANSI_RE = /\x1b\[[0-9;]*m/g;

package/src/cli/prompt.js

@@ -1,4 +1,6 @@
 // @bun
+var __require = import.meta.require;
+
 // src/cli/prompt.ts
 import * as prompts from "@clack/prompts";
 var Prompt;

package/src/cli/theme.js

@@ -1,4 +1,6 @@
 // @bun
+var __require = import.meta.require;
+
 // src/cli/theme.ts
 function rgb(r, g, b) {
   return (value) => `\x1B[38;2;${r};${g};${b}m${value}\x1B[39m`;

package/src/cli/yargs.js

@@ -1,4 +1,6 @@
 // @bun
+var __require = import.meta.require;
+
 // src/cli/yargs.ts
 import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
@@ -145,7 +147,10 @@ function configure(y, def, root, path) {
     for (const [k, v] of Object.entries(def.commands)) {
       command(y, k, v, root, path);
     }
-    y.demandCommand(1, "You must specify a command");
+    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) {

package/src/core/add.js

@@ -1,4 +1,6 @@
 // @bun
+var __require = import.meta.require;
+
 // src/core/add.ts
 import fs from "fs";
 import path from "path";
@@ -34,7 +36,7 @@ async function cloneUrl(url, name, description) {
   fs.mkdirSync(store, { recursive: true });
   const target = path.join(store, resolved);
   if (!fs.existsSync(target)) {
-    const proc = Bun.spawn(["git", "clone", url, target], {
+    const proc = Bun.spawn(["git", "clone", "--depth=1", url, target], {
       stdout: "pipe",
       stderr: "pipe"
     });

package/src/core/config.js

@@ -1,4 +1,6 @@
 // @bun
+var __require = import.meta.require;
+
 // src/core/config.ts
 import fs from "fs";
 import os from "os";
@@ -56,16 +58,19 @@ var Config;
     }
     Global.write = write;
     function find(config, name) {
-      return config.repos.find((r) => r.name === name);
+      const lower = name.toLowerCase();
+      return config.repos.find((r) => r.name.toLowerCase() === lower);
     }
     Global.find = find;
     function add(config, entry) {
-      const filtered = config.repos.filter((r) => r.name !== entry.name);
+      const lower = entry.name.toLowerCase();
+      const filtered = config.repos.filter((r) => r.name.toLowerCase() !== lower);
       return { repos: [...filtered, entry] };
     }
     Global.add = add;
     function remove(config, name) {
-      return { repos: config.repos.filter((r) => r.name !== name) };
+      const lower = name.toLowerCase();
+      return { repos: config.repos.filter((r) => r.name.toLowerCase() !== lower) };
     }
     Global.remove = remove;
   })(Global = Config.Global ||= {});
@@ -87,16 +92,29 @@ var Config;
 `);
     }
     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 Object.prototype.hasOwnProperty.call(config.refs, name);
+      return find(config, name) !== undefined;
     }
     Local.has = has;
     function add(config, repo) {
-      return { refs: { ...config.refs, [repo.name]: 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 refs = Object.fromEntries(Object.entries(config.refs).filter(([key]) => key !== name));
+      const lower = name.toLowerCase();
+      const refs = Object.fromEntries(Object.entries(config.refs).filter(([key]) => key.toLowerCase() !== lower));
       return { refs };
     }
     Local.remove = remove;

package/src/core/index.js

@@ -1,4 +1,6 @@
 // @bun
+var __require = import.meta.require;
+
 // src/core/index.ts
 import { Config } from "@spader/dotllm/core/config";
 import { add } from "@spader/dotllm/core/add";

package/src/core/link.js

@@ -1,4 +1,6 @@
 // @bun
+var __require = import.meta.require;
+
 // src/core/link.ts
 import { Config } from "@spader/dotllm/core/config";
 import { sync } from "@spader/dotllm/core/sync";
@@ -8,7 +10,7 @@ function link(names) {
     const repo = Config.Global.find(global, name);
     if (!repo)
       return null;
-    return [name, repo];
+    return [repo.name, repo];
   }).filter((row) => row !== null);
   Config.Local.write({ refs: Object.fromEntries(rows) });
   return sync();

package/src/core/remove.js

@@ -1,4 +1,6 @@
 // @bun
+var __require = import.meta.require;
+
 // src/core/remove.ts
 import fs from "fs";
 import path from "path";
@@ -9,7 +11,7 @@ function remove(name) {
   if (!found) {
     return { ok: false, error: `No repo named "${name}" in registry` };
   }
-  const target = path.join(Config.storeDir(), name);
+  const target = path.join(Config.storeDir(), found.name);
   if (fs.existsSync(target)) {
     const stat = fs.lstatSync(target);
     if (stat.isSymbolicLink()) {
@@ -19,7 +21,7 @@ function remove(name) {
       fs.rmSync(target, { recursive: true, force: true });
     }
   }
-  Config.Global.write(Config.Global.remove(global, name));
+  Config.Global.write(Config.Global.remove(global, found.name));
   return { ok: true };
 }
 export {

package/src/core/sync.js

@@ -1,33 +1,97 @@
 // @bun
+var __require = import.meta.require;
+
 // src/core/sync.ts
 import fs from "fs";
 import path from "path";
 import { Config } from "@spader/dotllm/core/config";
-async function pull(names) {
+var FRESH_MS = 24 * 60 * 60 * 1000;
+var STALE_MS = 7 * FRESH_MS;
+function shouldPull(storeDir, force) {
+  if (force)
+    return true;
+  const head = path.join(storeDir, ".git", "HEAD");
+  const headStat = fs.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 = fs.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 = path.join(Config.refDir(), name);
     if (!fs.existsSync(cwd)) {
-      return { name, error: "reference directory missing" };
+      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 = path.join(Config.storeDir(), name);
+    const storeStat = fs.lstatSync(storeDir, { throwIfNoEntry: false });
+    if (!storeStat || storeStat.isSymbolicLink()) {
+      return { kind: "skipped", name };
+    }
+    if (!fs.existsSync(path.join(storeDir, ".git"))) {
+      return { kind: "failed", name, error: "store directory is not a git repo" };
+    }
+    if (!shouldPull(storeDir, force)) {
+      return { kind: "skipped", name };
+    }
+    const fetch = Bun.spawn(["git", "fetch", "--depth=1", "origin", "HEAD"], {
+      cwd,
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const [fetchCode, fetchOut, fetchErr] = await Promise.all([
+      fetch.exited,
+      new Response(fetch.stdout).text(),
+      new Response(fetch.stderr).text()
+    ]);
+    if (fetchCode !== 0) {
+      const msg = `${fetchOut}
+${fetchErr}`.trim();
+      return { kind: "failed", name, error: msg || "git fetch failed" };
     }
-    const proc = Bun.spawn(["git", "pull", "--ff-only"], {
+    const reset = Bun.spawn(["git", "reset", "--hard", "FETCH_HEAD"], {
       cwd,
       stdout: "pipe",
       stderr: "pipe"
     });
-    const [code, out, err] = await Promise.all([
-      proc.exited,
-      new Response(proc.stdout).text(),
-      new Response(proc.stderr).text()
+    const [resetCode, resetOut, resetErr] = await Promise.all([
+      reset.exited,
+      new Response(reset.stdout).text(),
+      new Response(reset.stderr).text()
     ]);
-    const msg = `${out}
-${err}`.trim();
-    if (code !== 0) {
-      return { name, error: msg || "git pull failed" };
+    if (resetCode !== 0) {
+      const msg = `${resetOut}
+${resetErr}`.trim();
+      return { kind: "failed", name, error: msg || "git reset failed" };
     }
-    return null;
+    return { kind: "ok" };
   }));
-  const failed = states.filter((state) => state !== null);
-  return { count: names.length, failed };
+  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();
@@ -56,11 +120,12 @@ function sync() {
   }
   for (const [name, repo] of Object.entries(local.refs)) {
     const store = path.join(Config.storeDir(), name);
-    if (!fs.existsSync(store)) {
+    const storeBroken = repo.kind === "url" && fs.existsSync(store) && !fs.existsSync(path.join(store, ".git"));
+    if (storeBroken) {
       fs.rmSync(store, { recursive: true, force: true });
     }
     if (!fs.existsSync(store) && repo.kind === "url") {
-      const clone = Bun.spawnSync(["git", "clone", repo.uri, store], {
+      const clone = Bun.spawnSync(["git", "clone", "--depth=1", repo.uri, store], {
         stdout: "pipe",
         stderr: "pipe"
       });

package/src/core/unlink.js

@@ -1,18 +1,21 @@
 // @bun
+var __require = import.meta.require;
+
 // src/core/unlink.ts
 import fs from "fs";
 import path from "path";
 import { Config } from "@spader/dotllm/core/config";
 function unlink(name) {
   const local = Config.Local.read();
-  if (!Config.Local.has(local, name)) {
+  const found = Config.Local.find(local, name);
+  if (!found) {
     return { ok: false, error: `"${name}" is not linked in local config` };
   }
-  const target = path.join(Config.refDir(), name);
+  const target = path.join(Config.refDir(), found.name);
   if (fs.existsSync(target)) {
     fs.unlinkSync(target);
   }
-  Config.Local.write(Config.Local.remove(local, name));
+  Config.Local.write(Config.Local.remove(local, found.name));
   return { ok: true };
 }
 export {

package/src/cli/commands/cd.js

@@ -1,45 +0,0 @@
-// @bun
-// src/cli/commands/cd.ts
-import path from "path";
-import fs from "fs";
-import { Config } from "@spader/dotllm/core";
-import { defaultTheme as t } from "@spader/dotllm/cli/theme";
-var command = {
-  description: "Open a subshell in a repo's store directory",
-  summary: "cd into a repo",
-  positionals: {
-    name: {
-      type: "string",
-      description: "Name of the repo",
-      required: true
-    }
-  },
-  handler: async (argv) => {
-    const name = String(argv.name);
-    const global = Config.Global.read();
-    const repo = Config.Global.find(global, name);
-    if (!repo) {
-      console.error(t.error(`No repo named "${name}" in registry`));
-      process.exit(1);
-      return;
-    }
-    const dir = path.join(Config.storeDir(), name);
-    if (!fs.existsSync(dir)) {
-      console.error(t.error(`Store path does not exist: ${dir}`));
-      process.exit(1);
-      return;
-    }
-    const shell = process.env.SHELL ?? "/bin/sh";
-    const proc = Bun.spawn([shell], {
-      cwd: dir,
-      stdin: "inherit",
-      stdout: "inherit",
-      stderr: "inherit"
-    });
-    const code = await proc.exited;
-    process.exit(code);
-  }
-};
-export {
-  command
-};