@spader/dotllm 1.3.1 → 1.3.3

package/src/core/sync.js

@@ -1,35 +1,246 @@
 // @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/sync.ts
+// src/core/config.ts
 import fs from "fs";
+import os from "os";
 import path from "path";
-import { Config } from "@spader/dotllm/core/config";
-async function pull(names) {
+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/sync.ts
+import fs2 from "fs";
+import path2 from "path";
+function shouldPull(storeDir, force) {
+  if (force)
+    return true;
+  const head = path2.join(storeDir, ".git", "HEAD");
+  const headStat = fs2.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 = fs2.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" };
+    const cwd = path2.join(Config.refDir(), name);
+    if (!fs2.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 = path2.join(Config.storeDir(), name);
+    const storeStat = fs2.lstatSync(storeDir, { throwIfNoEntry: false });
+    if (!storeStat || storeStat.isSymbolicLink()) {
+      return { kind: "skipped", name };
+    }
+    if (!fs2.existsSync(path2.join(storeDir, ".git"))) {
+      return { kind: "failed", name, error: "store directory is not a git repo" };
     }
-    const proc = Bun.spawn(["git", "pull", "--ff-only"], {
+    if (!shouldPull(storeDir, force)) {
+      return { kind: "skipped", name };
+    }
+    const fetch = Bun.spawn(["git", "fetch", "--depth=1", "origin", "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 [fetchCode, fetchOut, fetchErr] = await Promise.all([
+      fetch.exited,
+      new Response(fetch.stdout).text(),
+      new Response(fetch.stderr).text()
     ]);
-    const msg = `${out}
-${err}`.trim();
-    if (code !== 0) {
-      return { name, error: msg || "git pull failed" };
+    if (fetchCode !== 0) {
+      const msg = `${fetchOut}
+${fetchErr}`.trim();
+      return { kind: "failed", name, error: msg || "git fetch failed" };
     }
-    return null;
+    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 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();
@@ -39,30 +250,31 @@ function sync() {
     Config.Global.write(merged);
   }
   const refDir = Config.refDir();
-  fs.mkdirSync(refDir, { recursive: true });
-  fs.mkdirSync(Config.storeDir(), { recursive: true });
+  fs2.mkdirSync(refDir, { recursive: true });
+  fs2.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 fs.readdirSync(refDir)) {
+  for (const entry of fs2.readdirSync(refDir)) {
     if (wanted.has(entry))
       continue;
-    const target = path.join(refDir, entry);
-    const stat = fs.lstatSync(target);
+    const target = path2.join(refDir, entry);
+    const stat = fs2.lstatSync(target);
     if (stat.isSymbolicLink()) {
-      fs.unlinkSync(target);
+      fs2.unlinkSync(target);
       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 });
+    const store = path2.join(Config.storeDir(), name);
+    const storeBroken = repo.kind === "url" && fs2.existsSync(store) && !fs2.existsSync(path2.join(store, ".git"));
+    if (storeBroken) {
+      fs2.rmSync(store, { recursive: true, force: true });
     }
-    if (!fs.existsSync(store) && repo.kind === "url") {
-      const clone = Bun.spawnSync(["git", "clone", repo.uri, store], {
+    if (!fs2.existsSync(store) && repo.kind === "url") {
+      const clone = Bun.spawnSync(["git", "clone", "--depth=1", repo.uri, store], {
         stdout: "pipe",
         stderr: "pipe"
       });
@@ -71,32 +283,40 @@ function sync() {
         continue;
       }
     }
-    if (!fs.existsSync(store) && repo.kind === "file") {
-      if (!fs.existsSync(repo.uri)) {
+    if (!fs2.existsSync(store) && repo.kind === "file") {
+      if (!fs2.existsSync(repo.uri)) {
         missing.push(name);
         continue;
       }
-      if (!fs.statSync(repo.uri).isDirectory()) {
+      if (!fs2.statSync(repo.uri).isDirectory()) {
         missing.push(name);
         continue;
       }
-      fs.symlinkSync(repo.uri, store, "dir");
+      fs2.symlinkSync(repo.uri, store, "dir");
     }
-    if (!fs.existsSync(store)) {
+    if (!fs2.existsSync(store)) {
       missing.push(name);
       continue;
     }
-    const target = path.join(refDir, name);
-    if (fs.existsSync(target)) {
+    const target = path2.join(refDir, name);
+    if (fs2.existsSync(target)) {
       unchanged.push(name);
       continue;
     }
-    fs.symlinkSync(store, target, "dir");
+    fs2.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;
+});
+init_sync();
+
 export {
-  sync,
-  pull
+  pull,
+  sync
 };

package/src/core/unlink.js

@@ -1,23 +1,179 @@
 // @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/unlink.ts
+// src/core/config.ts
 import fs from "fs";
+import os from "os";
 import path from "path";
-import { Config } from "@spader/dotllm/core/config";
+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/unlink.ts
+import fs2 from "fs";
+import path2 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 = path.join(Config.refDir(), found.name);
-  if (fs.existsSync(target)) {
-    fs.unlinkSync(target);
+  const target = path2.join(Config.refDir(), found.name);
+  if (fs2.existsSync(target)) {
+    fs2.unlinkSync(target);
   }
   Config.Local.write(Config.Local.remove(local, found.name));
   return { ok: true };
 }
+var init_unlink = __esm(() => {
+  init_config();
+});
+init_unlink();
+
 export {
   unlink
 };