@spader/dotllm 1.0.0 → 1.1.0

package/package.json

@@ -1,31 +1,31 @@
 {
   "name": "@spader/dotllm",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "A simple CLI to clone, manage, and link repositories for LLM reference",
   "type": "module",
-  "bin": {
-    "dotllm": "src/cli/index.ts"
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/tspader/dotllm"
   },
-  "scripts": {
-    "check": "bunx tsc --noEmit",
-    "prepublishOnly": "bun run check"
+  "publishConfig": {
+    "access": "public"
+  },
+  "bin": {
+    "dotllm": "src/cli/index.js"
   },
   "files": [
-    "src/**/*.ts",
+    "src/**/*.js",
     "README.md"
   ],
   "exports": {
-    "./cli": "./src/cli/index.ts",
-    "./cli/*": "./src/cli/*.ts",
-    "./core": "./src/core/index.ts",
-    "./core/*": "./src/core/*.ts"
+    "./cli": "./src/cli/index.js",
+    "./cli/*": "./src/cli/*.js",
+    "./core": "./src/core/index.js",
+    "./core/*": "./src/core/*.js"
   },
   "engines": {
     "bun": ">=1.1.0"
   },
-  "publishConfig": {
-    "access": "public"
-  },
   "keywords": [
     "cli",
     "bun",
@@ -39,9 +39,5 @@
     "picocolors": "^1.1.1",
     "yargs": "^17.7.2",
     "zod": "^4.3.6"
-  },
-  "devDependencies": {
-    "@types/bun": "latest",
-    "@types/yargs": "^17.0.33"
   }
 }

package/src/cli/commands/{add.ts → add.js}

@@ -1,177 +1,184 @@
+// @bun
+// src/cli/commands/add.ts
 import fs from "fs";
 import path from "path";
 import * as prompts from "@clack/prompts";
 import { z } from "zod";
-import { add } from "@spader/dotllm/core";
+import { add, Config } from "@spader/dotllm/core";
 import { defaultTheme as t } from "@spader/dotllm/cli/theme";
-import type { CommandDef } from "@spader/dotllm/cli/yargs";
-
-const RepoShape = z.object({
-  description: z.string().nullable().optional(),
+var RepoShape = z.object({
+  description: z.string().nullable().optional()
 });
-
-function isUrl(value: string): boolean {
-  return value.startsWith("http://") ||
-    value.startsWith("https://") ||
-    value.startsWith("git@") ||
-    value.startsWith("ssh://");
+function isUrl(value) {
+  return value.startsWith("http://") || value.startsWith("https://") || value.startsWith("git@") || value.startsWith("ssh://");
 }
-
-function stem(value: string): string {
+function stem(value) {
   const clean = value.trim().replace(/\/+$/, "");
-  if (clean.length === 0) return "";
-
+  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 (isUrl(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);
-  if (parsed.name.length > 0) return parsed.name;
+  if (parsed.name.length > 0)
+    return parsed.name;
   return base;
 }
-
-function github(uri: string): { owner: string; repo: string } | null {
+function github(uri) {
   const https = uri.match(/^https?:\/\/github\.com\/([^/]+)\/([^/]+?)(?:\.git)?\/?$/);
   if (https) {
-    return { owner: https[1]!, repo: https[2]! };
+    return { owner: https[1], repo: https[2] };
   }
-
   const ssh = uri.match(/^ssh:\/\/git@github\.com\/([^/]+)\/([^/]+?)(?:\.git)?\/?$/);
   if (ssh) {
-    return { owner: ssh[1]!, repo: ssh[2]! };
+    return { owner: ssh[1], repo: ssh[2] };
   }
-
   const scp = uri.match(/^git@github\.com:([^/]+)\/([^/]+?)(?:\.git)?$/);
   if (scp) {
-    return { owner: scp[1]!, repo: scp[2]! };
+    return { owner: scp[1], repo: scp[2] };
   }
-
   return null;
 }
-
-function gitName(uri: string): string {
+function gitName(uri) {
   const dir = path.resolve(uri);
-  if (!fs.existsSync(dir)) return "";
-  if (!fs.statSync(dir).isDirectory()) return "";
-
+  if (!fs.existsSync(dir))
+    return "";
+  if (!fs.statSync(dir).isDirectory())
+    return "";
   const proc = Bun.spawnSync(["git", "remote", "get-url", "origin"], {
     cwd: dir,
     stdout: "pipe",
-    stderr: "pipe",
+    stderr: "pipe"
   });
-  if (proc.exitCode !== 0) return "";
-
+  if (proc.exitCode !== 0)
+    return "";
   const out = proc.stdout.toString().trim();
-  if (out.length === 0) return "";
+  if (out.length === 0)
+    return "";
   return stem(out);
 }
-
-async function remoteDescription(uri: string): Promise<string> {
+async function remoteDescription(uri) {
   const repo = github(uri);
-  if (!repo) return "";
-
+  if (!repo)
+    return "";
   const url = `https://api.github.com/repos/${repo.owner}/${repo.repo}`;
   const response = await fetch(url, {
     headers: {
       accept: "application/vnd.github+json",
-      "user-agent": "dotllm",
-    },
+      "user-agent": "dotllm"
+    }
   });
-  if (!response.ok) return "";
-
+  if (!response.ok)
+    return "";
   const raw = await response.json();
   const result = RepoShape.safeParse(raw);
-  if (!result.success) return "";
+  if (!result.success)
+    return "";
   return result.data.description ?? "";
 }
-
-async function prefill(uri: string): Promise<{ name: string; description: string }> {
+async function prefill(uri) {
   const remote = isUrl(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(): Promise<void> {
+async function interactive(namePrefill, descPrefill) {
   const uri = await prompts.text({
-    message: "URL or local path to a git repo",
+    message: "URL or local path to a git repo"
   });
-  if (prompts.isCancel(uri)) return;
-
+  if (prompts.isCancel(uri))
+    return;
   const input = uri.trim();
   const seed = await prefill(input);
-
   const name = await prompts.text({
-    message: "Name (leave empty to auto-detect)",
-    defaultValue: seed.name,
+    message: "Name",
+    initialValue: namePrefill ?? seed.name
   });
-  if (prompts.isCancel(name)) return;
-
+  if (prompts.isCancel(name))
+    return;
   const description = await prompts.text({
     message: "Description",
-    defaultValue: seed.description,
+    initialValue: descPrefill ?? seed.description
   });
-  if (prompts.isCancel(description)) return;
-
+  if (prompts.isCancel(description))
+    return;
   await run(input, name || undefined, description || undefined);
 }
-
-async function run(uri: string, name?: string, description?: string): Promise<void> {
-  const spinner = prompts.spinner();
-  spinner.start(`Adding ${uri}`);
-
-  const result = await add(uri, name, description);
+function autoLink(name) {
+  const localFile = path.join(".llm", "dotllm.json");
+  if (!fs.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));
+  prompts.log.step(`linked ${t.primary(name)}`);
+}
+async function run(uri, name, description) {
+  const spinner2 = prompts.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) {
-    spinner.stop(t.error(result.error), 1);
+    spinner2.stop(t.error(result.error), 1);
     process.exit(1);
     return;
   }
-
-  spinner.stop(`${t.success("added")} ${t.primary(result.entry.name)} ${t.link(result.storePath)}`);
+  spinner2.stop(`${t.success("added")} ${t.primary(result.entry.name)} ${t.link(result.storePath)}`);
+  autoLink(result.entry.name);
 }
-
-export const command: CommandDef = {
+var command = {
   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",
-    },
+      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: "Name override (defaults to repo name from git)"
     },
     description: {
       alias: "d",
       type: "string",
-      description: "Description of the reference",
-    },
+      description: "Description of the reference"
+    }
   },
   handler: async (argv) => {
+    prompts.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();
+      await interactive(name, description);
       return;
     }
-
-    const name = typeof argv.name === "string" && argv.name.length > 0 ? argv.name : undefined;
-    const description = typeof argv.description === "string" ? argv.description : undefined;
     await run(uri, name, description);
-  },
+  }
+};
+export {
+  stem,
+  github,
+  command
 };

package/src/cli/commands/cd.js

@@ -0,0 +1,45 @@
+// @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
+};

package/src/cli/commands/index.js

@@ -0,0 +1,18 @@
+// @bun
+// src/cli/commands/index.ts
+import { command } from "@spader/dotllm/cli/commands/add";
+import { command as command2 } from "@spader/dotllm/cli/commands/remove";
+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";
+export {
+  command6 as which,
+  command5 as sync,
+  command2 as remove,
+  command3 as list,
+  command4 as link,
+  command7 as cd,
+  command as add
+};

package/src/cli/commands/link.js

@@ -0,0 +1,89 @@
+// @bun
+// src/cli/commands/link.ts
+import * as prompts from "@clack/prompts";
+import { Config, link, unlink, sync } from "@spader/dotllm/core";
+import { defaultTheme as t } from "@spader/dotllm/cli/theme";
+function printResult(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 (parts.length === 0)
+    return;
+  prompts.log.step(parts.join(", "));
+}
+var command = {
+  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) => {
+    prompts.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) {
+          prompts.log.error(t.error(result.error));
+          process.exit(1);
+          return;
+        }
+        prompts.log.step(`unlinked ${t.primary(name)}`);
+        return;
+      }
+      const global2 = Config.Global.read();
+      const repo = Config.Global.find(global2, name);
+      if (!repo) {
+        prompts.log.error(t.error(`No repo named "${name}" in registry`));
+        process.exit(1);
+        return;
+      }
+      const local2 = Config.Local.read();
+      Config.Local.write(Config.Local.add(local2, repo));
+      printResult(sync());
+      return;
+    }
+    const global = Config.Global.read();
+    if (global.repos.length === 0) {
+      console.log(t.dim("(no repos registered)"));
+      console.log(t.dim("use `dotllm add <path>` to register one"));
+      return;
+    }
+    const local = Config.Local.read();
+    const current = new Set(Object.keys(local.refs));
+    const selected = await prompts.multiselect({
+      message: "Select repos to link into .llm/reference/",
+      options: global.repos.map((r) => ({
+        value: r.name,
+        label: r.name,
+        hint: r.uri
+      })),
+      initialValues: global.repos.filter((r) => current.has(r.name)).map((r) => r.name),
+      required: false
+    });
+    if (prompts.isCancel(selected)) {
+      prompts.cancel("cancelled");
+      return;
+    }
+    const names = Array.isArray(selected) ? selected.filter((value) => typeof value === "string") : [];
+    printResult(link(names));
+  }
+};
+export {
+  command
+};

package/src/cli/commands/list.js

@@ -0,0 +1,42 @@
+// @bun
+// src/cli/commands/list.ts
+import * as prompts from "@clack/prompts";
+import { Config } from "@spader/dotllm/core";
+import { table } from "@spader/dotllm/cli/layout";
+import { defaultTheme as t } from "@spader/dotllm/cli/theme";
+var command = {
+  description: "List all registered repos",
+  summary: "Show the registry",
+  handler: () => {
+    prompts.intro("dotllm list");
+    const global = Config.Global.read();
+    if (global.repos.length === 0) {
+      console.log(t.dim("(no repos registered)"));
+      console.log(t.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) => t.primary(s),
+        (s) => s,
+        (s) => t.link(s),
+        (s) => s,
+        (s) => s.trim() === "yes" ? t.success(s) : s
+      ]
+    });
+  }
+};
+export {
+  command
+};

package/src/cli/commands/{remove.ts → remove.js}

@@ -1,28 +1,30 @@
-import { log } from "@clack/prompts";
+// @bun
+// src/cli/commands/remove.ts
+import * as prompts from "@clack/prompts";
 import { remove } from "@spader/dotllm/core";
 import { defaultTheme as t } from "@spader/dotllm/cli/theme";
-import type { CommandDef } from "@spader/dotllm/cli/yargs";
-
-export const command: CommandDef = {
+var command = {
   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,
-    },
+      required: true
+    }
   },
   handler: (argv) => {
+    prompts.intro("dotllm remove");
     const name = String(argv.name);
-
     const result = remove(name);
     if (!result.ok) {
-      log.error(t.error(result.error));
+      prompts.log.error(t.error(result.error));
       process.exit(1);
       return;
     }
-
-    log.step(`removed ${t.primary(name)}`);
-  },
+    prompts.log.step(`removed ${t.primary(name)}`);
+  }
+};
+export {
+  command
 };

package/src/cli/commands/sync.js

@@ -0,0 +1,45 @@
+// @bun
+// src/cli/commands/sync.ts
+import * as prompts from "@clack/prompts";
+import { pull, sync } from "@spader/dotllm/core";
+import { defaultTheme as t } from "@spader/dotllm/cli/theme";
+var command = {
+  description: "Re-create symlinks from .llm/dotllm.json",
+  summary: "Sync symlinks from local config",
+  handler: async () => {
+    prompts.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(t.dim("(no refs in local config)"));
+      console.log(t.dim("use `dotllm link` to select repos"));
+      return;
+    }
+    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(", "));
+    const refs = [...new Set([...result.unchanged, ...result.linked])];
+    if (refs.length === 0) {
+      return;
+    }
+    const spinner2 = prompts.spinner();
+    spinner2.start(`Pulling ${refs.length} linked repo${refs.length === 1 ? "" : "s"}`);
+    const pulled = await pull(refs);
+    if (pulled.failed.length > 0) {
+      spinner2.stop(t.error(`pull failed for ${pulled.failed.length} repo${pulled.failed.length === 1 ? "" : "s"}`), 1);
+      process.exit(1);
+      return;
+    }
+    spinner2.stop(`${t.success("pulled")} ${pulled.count} repo${pulled.count === 1 ? "" : "s"}`);
+  }
+};
+export {
+  command
+};

package/src/cli/commands/which.js

@@ -0,0 +1,30 @@
+// @bun
+// 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",
+  summary: "Show repo store path",
+  positionals: {
+    name: {
+      type: "string",
+      description: "Name 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`));
+      process.exit(1);
+      return;
+    }
+    console.log(path.join(Config.storeDir(), name));
+  }
+};
+export {
+  command
+};

package/src/cli/index.js

@@ -0,0 +1,30 @@
+#!/usr/bin/env bun
+// @bun
+
+// 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";
+var DotLlmCli;
+((DotLlmCli) => {
+  DotLlmCli.def = {
+    name: "dotllm",
+    description: "Manage git repo references symlinked into .llm/reference/",
+    commands: {
+      add,
+      remove,
+      list,
+      link,
+      sync,
+      which,
+      cd
+    }
+  };
+  function run() {
+    build(DotLlmCli.def).parse();
+  }
+  DotLlmCli.run = run;
+})(DotLlmCli ||= {});
+DotLlmCli.run();
+export {
+  DotLlmCli
+};