@spader/dotllm 1.0.0 → 1.2.0

package/src/core/config.js

@@ -0,0 +1,112 @@
+// @bun
+// src/core/config.ts
+import fs from "fs";
+import path from "path";
+import { z } from "zod";
+var LOCAL_DIR = ".llm";
+var LOCAL_FILE = path.join(LOCAL_DIR, "dotllm.json");
+var REF_DIR = path.join(LOCAL_DIR, "reference");
+function home() {
+  return path.join(process.env.HOME ?? "", ".local", "share", "dotllm");
+}
+var RepoEntry = z.object({
+  kind: z.enum(["url", "file"]),
+  name: z.string(),
+  uri: z.string(),
+  description: z.string()
+});
+var GlobalShape = z.object({
+  repos: z.array(RepoEntry)
+});
+var LocalShape = z.object({
+  refs: z.record(z.string(), RepoEntry)
+});
+var Config;
+((Config) => {
+  function storeDir() {
+    return path.join(home(), "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) {
+      return config.repos.find((r) => r.name === name);
+    }
+    Global.find = find;
+    function add(config, entry) {
+      const filtered = config.repos.filter((r) => r.name !== entry.name);
+      return { repos: [...filtered, entry] };
+    }
+    Global.add = add;
+    function remove(config, name) {
+      return { repos: config.repos.filter((r) => r.name !== name) };
+    }
+    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 has(config, name) {
+      return Object.prototype.hasOwnProperty.call(config.refs, name);
+    }
+    Local.has = has;
+    function add(config, repo) {
+      return { refs: { ...config.refs, [repo.name]: repo } };
+    }
+    Local.add = add;
+    function remove(config, name) {
+      const refs = Object.fromEntries(Object.entries(config.refs).filter(([key]) => key !== name));
+      return { refs };
+    }
+    Local.remove = remove;
+  })(Local = Config.Local ||= {});
+})(Config ||= {});
+function readJson(filepath) {
+  if (!fs.existsSync(filepath))
+    return null;
+  const raw = fs.readFileSync(filepath, "utf-8");
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+export {
+  Config
+};

package/src/core/index.js

@@ -0,0 +1,17 @@
+// @bun
+// src/core/index.ts
+import { Config } from "@spader/dotllm/core/config";
+import { add } from "@spader/dotllm/core/add";
+import { remove } from "@spader/dotllm/core/remove";
+import { link } from "@spader/dotllm/core/link";
+import { unlink } from "@spader/dotllm/core/unlink";
+import { pull, sync } from "@spader/dotllm/core/sync";
+export {
+  unlink,
+  sync,
+  remove,
+  pull,
+  link,
+  add,
+  Config
+};

package/src/core/link.js

@@ -0,0 +1,18 @@
+// @bun
+// src/core/link.ts
+import { Config } from "@spader/dotllm/core/config";
+import { sync } from "@spader/dotllm/core/sync";
+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 [name, repo];
+  }).filter((row) => row !== null);
+  Config.Local.write({ refs: Object.fromEntries(rows) });
+  return sync();
+}
+export {
+  link
+};

package/src/core/{remove.ts → remove.js}

@@ -1,22 +1,14 @@
+// @bun
+// src/core/remove.ts
 import fs from "fs";
 import path from "path";
 import { Config } from "@spader/dotllm/core/config";
-
-export type RemoveResult = {
-  ok: true;
-} | {
-  ok: false;
-  error: string;
-};
-
-export function remove(name: string): RemoveResult {
+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 = path.join(Config.storeDir(), name);
   if (fs.existsSync(target)) {
     const stat = fs.lstatSync(target);
@@ -27,7 +19,9 @@ export function remove(name: string): RemoveResult {
       fs.rmSync(target, { recursive: true, force: true });
     }
   }
-
   Config.Global.write(Config.Global.remove(global, name));
   return { ok: true };
 }
+export {
+  remove
+};

package/src/core/{sync.ts → sync.js}

@@ -1,85 +1,52 @@
+// @bun
+// src/core/sync.ts
 import fs from "fs";
 import path from "path";
 import { Config } from "@spader/dotllm/core/config";
-
-export type SyncResult = {
-  linked: string[];
-  removed: string[];
-  missing: string[];
-  unchanged: string[];
-};
-
-type PullState = {
-  name: string;
-  error: string;
-} | null;
-
-export type PullError = {
-  name: string;
-  error: string;
-};
-
-export type PullResult = {
-  count: number;
-  failed: PullError[];
-};
-
-export async function pull(names: string[]): Promise<PullResult> {
-  const states = await Promise.all(
-    names.map(async (name): Promise<PullState> => {
-      const cwd = path.join(Config.refDir(), name);
-      if (!fs.existsSync(cwd)) {
-        return { name, error: "reference directory missing" };
-      }
-
-      const proc = Bun.spawn(["git", "pull", "--ff-only"], {
-        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 msg = `${out}\n${err}`.trim();
-
-      if (code !== 0) {
-        return { name, error: msg || "git pull failed" };
-      }
-
-      return null;
-    }),
-  );
-
-  const failed = states.filter((state): state is PullError => state !== null);
-
+async function pull(names) {
+  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" };
+    }
+    const proc = Bun.spawn(["git", "pull", "--ff-only"], {
+      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 msg = `${out}
+${err}`.trim();
+    if (code !== 0) {
+      return { name, error: msg || "git pull failed" };
+    }
+    return null;
+  }));
+  const failed = states.filter((state) => state !== null);
   return { count: names.length, failed };
 }
-
-export function sync(): SyncResult {
+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,
-  );
+  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();
   fs.mkdirSync(refDir, { recursive: true });
   fs.mkdirSync(Config.storeDir(), { recursive: true });
-
-  const linked: string[] = [];
-  const removed: string[] = [];
-  const missing: string[] = [];
-  const unchanged: string[] = [];
-
+  const linked = [];
+  const removed = [];
+  const missing = [];
+  const unchanged = [];
   const wanted = new Set(Object.keys(local.refs));
   for (const entry of fs.readdirSync(refDir)) {
-    if (wanted.has(entry)) continue;
+    if (wanted.has(entry))
+      continue;
     const target = path.join(refDir, entry);
     const stat = fs.lstatSync(target);
     if (stat.isSymbolicLink()) {
@@ -87,24 +54,21 @@ export function sync(): SyncResult {
       removed.push(entry);
     }
   }
-
   for (const [name, repo] of Object.entries(local.refs)) {
     const store = path.join(Config.storeDir(), name);
     if (!fs.existsSync(store)) {
       fs.rmSync(store, { recursive: true, force: true });
     }
-
     if (!fs.existsSync(store) && repo.kind === "url") {
       const clone = Bun.spawnSync(["git", "clone", repo.uri, store], {
         stdout: "pipe",
-        stderr: "pipe",
+        stderr: "pipe"
       });
       if (clone.exitCode !== 0) {
         missing.push(name);
         continue;
       }
     }
-
     if (!fs.existsSync(store) && repo.kind === "file") {
       if (!fs.existsSync(repo.uri)) {
         missing.push(name);
@@ -116,21 +80,21 @@ export function sync(): SyncResult {
       }
       fs.symlinkSync(repo.uri, store, "dir");
     }
-
     if (!fs.existsSync(store)) {
       missing.push(name);
       continue;
     }
-
     const target = path.join(refDir, name);
     if (fs.existsSync(target)) {
       unchanged.push(name);
       continue;
     }
-
     fs.symlinkSync(store, target, "dir");
     linked.push(name);
   }
-
   return { linked, removed, missing, unchanged };
 }
+export {
+  sync,
+  pull
+};

package/src/core/{unlink.ts → unlink.js}

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

package/src/cli/commands/index.ts

@@ -1,5 +0,0 @@
-export { command as add } from "@spader/dotllm/cli/commands/add";
-export { command as remove } from "@spader/dotllm/cli/commands/remove";
-export { command as list } from "@spader/dotllm/cli/commands/list";
-export { command as link } from "@spader/dotllm/cli/commands/link";
-export { command as sync } from "@spader/dotllm/cli/commands/sync";

package/src/cli/commands/link.ts

@@ -1,54 +0,0 @@
-import * as prompts from "@clack/prompts";
-import { Config, link, type SyncResult } from "@spader/dotllm/core";
-import { defaultTheme as t } from "@spader/dotllm/cli/theme";
-import type { CommandDef } from "@spader/dotllm/cli/yargs";
-
-function printResult(result: SyncResult): void {
-  for (const name of result.removed) {
-    prompts.log.step(`unlinked ${t.primary(name)} -> ${t.link(`.llm/reference/${name}`)}`);
-  }
-  for (const name of result.linked) {
-    prompts.log.step(`linked ${t.primary(name)} -> ${t.link(`.llm/reference/${name}`)}`);
-  }
-}
-
-export const command: CommandDef = {
-  description: "Interactively select repos to symlink into .llm/reference/",
-  summary: "Select and link references",
-  handler: async () => {
-    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): value is string => typeof value === "string")
-      : [];
-
-    printResult(link(names));
-  },
-};

package/src/cli/commands/list.ts

@@ -1,44 +0,0 @@
-import { Config } from "@spader/dotllm/core";
-import { table } from "@spader/dotllm/cli/layout";
-import { defaultTheme as t } from "@spader/dotllm/cli/theme";
-import type { CommandDef } from "@spader/dotllm/cli/yargs";
-
-export const command: CommandDef = {
-  description: "List all registered repos",
-  summary: "Show the registry",
-  handler: () => {
-    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,
-        ],
-      },
-    );
-  },
-};

package/src/cli/index.ts

@@ -1,24 +0,0 @@
-#!/usr/bin/env bun
-
-import { build, type CliDef } from "@spader/dotllm/cli/yargs";
-import { add, remove, list, link, sync } from "@spader/dotllm/cli/commands/index";
-
-export namespace DotLlmCli {
-  export const def: CliDef = {
-    name: "dotllm",
-    description: "Manage git repo references symlinked into .llm/reference/",
-    commands: {
-      add,
-      remove,
-      list,
-      link,
-      sync,
-    },
-  };
-
-  export function run(): void {
-    build(def).parse();
-  }
-}
-
-DotLlmCli.run();