@spader/dotllm 1.3.1 → 1.3.3

package/src/cli/layout.js

@@ -1,8 +1,24 @@
 // @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`;
+}
+var gray = (value) => rgb(value, value, value);
+var defaultTheme = {
+  primary: rgb(114, 161, 136),
+  link: rgb(114, 140, 212),
+  header: gray(128),
+  command: rgb(114, 161, 136),
+  arg: rgb(161, 212, 212),
+  option: rgb(212, 212, 161),
+  type: gray(128),
+  description: (value) => value,
+  dim: gray(128),
+  error: rgb(212, 114, 114),
+  success: rgb(114, 212, 136)
+};
 
 // src/cli/layout.ts
-import { defaultTheme as theme } from "@spader/dotllm/cli/theme";
 var ANSI_RE = /\x1b\[[0-9;]*m/g;
 function clean(value) {
   return value.replace(/[\t\n]/g, " ").replace(ANSI_RE, "");
@@ -101,7 +117,7 @@ function table(headers, columns, options = {}) {
   const available = Math.max(0, maxWidth - gap * (count - 1) - 1);
   const widths = fitWidths(natural, available, options.flex ?? [], options.noTruncate ?? []);
   const header = headers.map((title, col) => truncateMiddle(clean(title), widths[col] ?? 0).padEnd(widths[col] ?? 0)).join("  ");
-  process.stdout.write(`${theme.dim(header)}
+  process.stdout.write(`${defaultTheme.dim(header)}
 `);
   for (let row = 0;row < visibleRows; row++) {
     const cells = [];
@@ -118,7 +134,7 @@ function table(headers, columns, options = {}) {
 `);
   }
   if (rows > visibleRows) {
-    process.stdout.write(`${theme.dim("(...truncated)")}
+    process.stdout.write(`${defaultTheme.dim("(...truncated)")}
 `);
   }
 }
@@ -142,6 +158,6 @@ function cols(rows, colorFns) {
   }
 }
 export {
-  table,
-  cols
+  cols,
+  table
 };

package/src/cli/prompt.js

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

package/src/cli/theme.js

@@ -1,6 +1,4 @@
 // @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,12 +1,169 @@
 // @bun
-var __require = import.meta.require;
-
 // src/cli/yargs.ts
 import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
 import pc from "picocolors";
-import { cols } from "@spader/dotllm/cli/layout";
-import { defaultTheme } from "@spader/dotllm/cli/theme";
+
+// src/cli/theme.ts
+function rgb(r, g, b) {
+  return (value) => `\x1B[38;2;${r};${g};${b}m${value}\x1B[39m`;
+}
+var gray = (value) => rgb(value, value, value);
+var defaultTheme = {
+  primary: rgb(114, 161, 136),
+  link: rgb(114, 140, 212),
+  header: gray(128),
+  command: rgb(114, 161, 136),
+  arg: rgb(161, 212, 212),
+  option: rgb(212, 212, 161),
+  type: gray(128),
+  description: (value) => value,
+  dim: gray(128),
+  error: rgb(212, 114, 114),
+  success: rgb(114, 212, 136)
+};
+
+// src/cli/layout.ts
+var ANSI_RE = /\x1b\[[0-9;]*m/g;
+function clean(value) {
+  return value.replace(/[\t\n]/g, " ").replace(ANSI_RE, "");
+}
+function truncateMiddle(value, width) {
+  if (width <= 0)
+    return "";
+  if (value.length <= width)
+    return value;
+  if (width <= 3)
+    return value.slice(0, width);
+  const tail = Math.floor((width - 3) / 2);
+  const head = width - 3 - tail;
+  return `${value.slice(0, head)}...${value.slice(value.length - tail)}`;
+}
+function truncateStart(value, width) {
+  if (width <= 0)
+    return "";
+  if (value.length <= width)
+    return value;
+  if (width <= 3)
+    return "...".slice(0, width);
+  return `...${value.slice(value.length - (width - 3))}`;
+}
+function truncateEnd(value, width) {
+  if (width <= 0)
+    return "";
+  if (value.length <= width)
+    return value;
+  if (width <= 3)
+    return "...".slice(0, width);
+  return `${value.slice(0, width - 3)}...`;
+}
+function truncate(value, width, mode) {
+  if (mode === "start")
+    return truncateStart(value, width);
+  if (mode === "end")
+    return truncateEnd(value, width);
+  return truncateMiddle(value, width);
+}
+function fitWidths(natural, available, flex, noTruncate) {
+  const widths = [...natural];
+  const totalNatural = natural.reduce((sum, width) => sum + width, 0);
+  if (totalNatural <= available) {
+    return widths;
+  }
+  let fixedWidth = 0;
+  const dynamic = [];
+  for (let index = 0;index < widths.length; index++) {
+    if (noTruncate[index] || flex[index] === 0) {
+      fixedWidth += widths[index] ?? 0;
+      continue;
+    }
+    dynamic.push({ index, weight: flex[index] ?? 1 });
+  }
+  const remaining = Math.max(0, available - fixedWidth);
+  if (dynamic.length === 0) {
+    return widths;
+  }
+  const totalWeight = dynamic.reduce((sum, item) => sum + item.weight, 0);
+  let used = 0;
+  for (const item of dynamic) {
+    const share = Math.floor(remaining * item.weight / totalWeight);
+    const width = Math.max(1, share);
+    widths[item.index] = width;
+    used += width;
+  }
+  let extra = remaining - used;
+  let cursor = 0;
+  while (extra > 0) {
+    const item = dynamic[cursor % dynamic.length];
+    widths[item.index] = (widths[item.index] ?? 0) + 1;
+    extra--;
+    cursor++;
+  }
+  return widths;
+}
+function table(headers, columns, options = {}) {
+  if (headers.length === 0)
+    return;
+  const count = headers.length;
+  const gap = 2;
+  const rows = columns.reduce((max, column) => Math.max(max, column.length), 0);
+  const visibleRows = Math.min(rows, options.maxRows ?? rows);
+  const natural = [];
+  for (let col = 0;col < count; col++) {
+    const headerWidth = clean(headers[col] ?? "").length;
+    let width = headerWidth;
+    for (let row = 0;row < visibleRows; row++) {
+      const value = clean(columns[col]?.[row] ?? "");
+      width = Math.max(width, value.length);
+    }
+    natural[col] = width;
+  }
+  const maxWidth = options.maxWidth ?? (process.stdout.columns == null ? 120 : process.stdout.columns);
+  const available = Math.max(0, maxWidth - gap * (count - 1) - 1);
+  const widths = fitWidths(natural, available, options.flex ?? [], options.noTruncate ?? []);
+  const header = headers.map((title, col) => truncateMiddle(clean(title), widths[col] ?? 0).padEnd(widths[col] ?? 0)).join("  ");
+  process.stdout.write(`${defaultTheme.dim(header)}
+`);
+  for (let row = 0;row < visibleRows; row++) {
+    const cells = [];
+    for (let col = 0;col < count; col++) {
+      const width = widths[col] ?? 0;
+      const source = clean(columns[col]?.[row] ?? "");
+      const mode = options.truncate?.[col] ?? "middle";
+      const value = options.noTruncate?.[col] ? source : truncate(source, width, mode);
+      const padded = width > 0 ? value.padEnd(width) : value;
+      const formatted = options.format?.[col]?.(padded, row, col) ?? padded;
+      cells.push(formatted);
+    }
+    process.stdout.write(`${cells.join("  ")}
+`);
+  }
+  if (rows > visibleRows) {
+    process.stdout.write(`${defaultTheme.dim("(...truncated)")}
+`);
+  }
+}
+function cols(rows, colorFns) {
+  if (rows.length === 0)
+    return;
+  const widths = rows[0].map((_, col) => {
+    let width = 0;
+    for (const row of rows) {
+      width = Math.max(width, clean(row[col] ?? "").length);
+    }
+    return width;
+  });
+  for (const row of rows) {
+    const line = row.map((value, col) => {
+      const padded = clean(value).padEnd(widths[col] ?? 0);
+      return colorFns?.[col]?.(padded) ?? padded;
+    }).join(" ");
+    process.stdout.write(`${line}
+`);
+  }
+}
+
+// src/cli/yargs.ts
 function usage(def, path, t) {
   const parts = [];
   const last = path.length - 1;
@@ -173,6 +330,6 @@ function build(def) {
   return y;
 }
 export {
-  help,
-  build
+  build,
+  help
 };

package/src/core/add.js

@@ -1,10 +1,161 @@
 // @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/add.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/add.ts
+import fs2 from "fs";
+import path2 from "path";
 function isUrl(value) {
   return value.startsWith("http://") || value.startsWith("https://") || value.startsWith("git@") || value.startsWith("ssh://");
 }
@@ -33,10 +184,10 @@ async function add(uri, name, description) {
 async function cloneUrl(url, name, description) {
   const resolved = name ?? nameFromUrl(url);
   const store = Config.storeDir();
-  fs.mkdirSync(store, { recursive: true });
-  const target = path.join(store, resolved);
-  if (!fs.existsSync(target)) {
-    const proc = Bun.spawn(["git", "clone", url, target], {
+  fs2.mkdirSync(store, { recursive: true });
+  const target = path2.join(store, resolved);
+  if (!fs2.existsSync(target)) {
+    const proc = Bun.spawn(["git", "clone", "--depth=1", url, target], {
       stdout: "pipe",
       stderr: "pipe"
     });
@@ -52,25 +203,30 @@ async function cloneUrl(url, name, description) {
   return { ok: true, entry, storePath: target };
 }
 function linkLocal(raw, name, description) {
-  const resolved = path.resolve(raw);
-  if (!fs.existsSync(resolved)) {
+  const resolved = path2.resolve(raw);
+  if (!fs2.existsSync(resolved)) {
     return { ok: false, error: `Path does not exist: ${resolved}` };
   }
-  if (!fs.statSync(resolved).isDirectory()) {
+  if (!fs2.statSync(resolved).isDirectory()) {
     return { ok: false, error: `Not a directory: ${resolved}` };
   }
   const store = Config.storeDir();
-  fs.mkdirSync(store, { recursive: true });
-  const finalName = name ?? nameFromGitRemote(resolved) ?? path.basename(resolved);
-  const target = path.join(store, finalName);
-  if (!fs.existsSync(target)) {
-    fs.symlinkSync(resolved, target, "dir");
+  fs2.mkdirSync(store, { recursive: true });
+  const finalName = name ?? nameFromGitRemote(resolved) ?? path2.basename(resolved);
+  const target = path2.join(store, finalName);
+  if (!fs2.existsSync(target)) {
+    fs2.symlinkSync(resolved, target, "dir");
   }
   const entry = { kind: "file", name: finalName, uri: resolved, description };
   const global = Config.Global.read();
   Config.Global.write(Config.Global.add(global, entry));
   return { ok: true, entry, storePath: target };
 }
+var init_add = __esm(() => {
+  init_config();
+});
+init_add();
+
 export {
   add
 };