@spader/dotllm 1.3.1 → 1.3.2

package/package.json

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

package/src/cli/commands/sync.js

@@ -9,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) {
@@ -22,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/core/add.js

@@ -36,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/sync.js

@@ -5,31 +5,93 @@ var __require = import.meta.require;
 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();
@@ -58,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"
       });