@spader/dotllm 1.0.0 → 1.2.0

package/src/cli/layout.js

@@ -0,0 +1,145 @@
+// @bun
+// 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, "");
+}
+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(`${theme.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(`${theme.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}
+`);
+  }
+}
+export {
+  table,
+  cols
+};

package/src/cli/prompt.js

@@ -0,0 +1,23 @@
+// @bun
+// src/cli/prompt.ts
+import * as prompts from "@clack/prompts";
+var Prompt;
+((Prompt) => {
+  function sync(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 (result.missing.length > 0)
+      parts.push(`${result.missing.length} missing`);
+    if (parts.length > 0)
+      prompts.log.step(parts.join(", "));
+  }
+  Prompt.sync = sync;
+})(Prompt ||= {});
+export {
+  Prompt
+};

package/src/cli/theme.js

@@ -0,0 +1,22 @@
+// @bun
+// 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)
+};
+export {
+  defaultTheme
+};

package/src/cli/{yargs.ts → yargs.js}

@@ -1,121 +1,69 @@
+// @bun
+// 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 { type Theme, defaultTheme } from "@spader/dotllm/cli/theme";
-
-export type OptionDef = {
-  alias?: string;
-  type: "string" | "number" | "boolean" | "array";
-  description: string;
-  required?: boolean;
-  default?: unknown;
-};
-
-export type Options = Record<string, OptionDef>;
-
-export type PositionalDef = {
-  type: "string" | "number";
-  description: string;
-  required?: boolean;
-  default?: unknown;
-};
-
-export type Positionals = Record<string, PositionalDef>;
-
-export type CommandDef = {
-  description: string;
-  summary?: string;
-  hidden?: boolean;
-  positionals?: Positionals;
-  options?: Options;
-  commands?: Record<string, CommandDef>;
-  handler?: (argv: Record<string, unknown>) => void | Promise<void>;
-};
-
-export type CliDef = {
-  name: string;
-  description: string;
-  options?: Options;
-  commands: Record<string, CommandDef>;
-};
-
-function usage(def: CommandDef | CliDef, path: string[], t: Theme): string {
-  const parts: string[] = [];
+import { defaultTheme } from "@spader/dotllm/cli/theme";
+function usage(def, path, t) {
+  const parts = [];
   const last = path.length - 1;
-  for (let i = 0; i < path.length; i++) {
+  for (let i = 0;i < path.length; i++) {
     const fmt = t.command;
-    parts.push(i === last ? fmt(path[i]!) : path[i]!);
+    parts.push(i === last ? fmt(path[i]) : path[i]);
   }
-
   if ("positionals" in def && def.positionals) {
     for (const [k, v] of Object.entries(def.positionals)) {
       const name = t.arg(`$${k}`);
       parts.push(v.required ? name : `[${name}]`);
     }
   }
-
   if (def.options && Object.keys(def.options).length > 0) {
     parts.push(t.dim("[options]"));
   }
-
-  if (
-    "commands" in def &&
-    def.commands &&
-    Object.keys(def.commands).length > 0
-  ) {
+  if ("commands" in def && def.commands && Object.keys(def.commands).length > 0) {
     parts.push(t.arg("$command"));
   }
-
   return parts.join(" ");
 }
-
-export function help(
-  def: CommandDef | CliDef,
-  name: string,
-  path: string[] = [],
-  t: Theme = defaultTheme,
-): void {
+function help(def, name, path = [], t = defaultTheme) {
   let prev = false;
-
   if (def.description) {
     console.log(t.description(def.description));
     prev = true;
   }
-
-  if (prev) console.log("");
+  if (prev)
+    console.log("");
   console.log(t.header("usage:"));
   console.log(`  ${usage(def, [name, ...path], t)}`);
   prev = true;
-
   const pos = "positionals" in def ? def.positionals : undefined;
   if (pos && Object.keys(pos).length > 0) {
-    if (prev) console.log("");
+    if (prev)
+      console.log("");
     console.log(t.header("arguments"));
     prev = true;
-
-    const rows: string[][] = [];
+    const rows = [];
     for (const [k, v] of Object.entries(pos)) {
       let desc = v.description;
       if (v.default !== undefined)
         desc += ` ${t.dim(`(default: ${v.default})`)}`;
-      if (v.required) desc += ` ${t.dim("(required)")}`;
+      if (v.required)
+        desc += ` ${t.dim("(required)")}`;
       rows.push([`  ${k}`, v.type, desc]);
     }
     cols(rows, [t.arg, t.type, t.description]);
   }
-
-  const opts: Record<string, OptionDef> = {
-    ...(def.options ?? {}),
-    help: { alias: "h", type: "boolean", description: "Show help" },
+  const opts = {
+    ...def.options ?? {},
+    help: { alias: "h", type: "boolean", description: "Show help" }
   };
-
   if (Object.keys(opts).length > 0) {
-    if (prev) console.log("");
+    if (prev)
+      console.log("");
     console.log(t.header("options"));
     prev = true;
-
-    const rows: string[][] = [];
+    const rows = [];
     for (const [k, v] of Object.entries(opts)) {
       const short = v.alias ? `-${v.alias}, ` : "    ";
       let desc = v.description;
@@ -126,35 +74,31 @@ export function help(
     }
     cols(rows, [t.option, t.type, t.description]);
   }
-
   const cmds = "commands" in def ? def.commands : undefined;
   if (cmds && Object.keys(cmds).length > 0) {
-    if (prev) console.log("");
+    if (prev)
+      console.log("");
     console.log(t.header("commands"));
-
-    const rows: string[][] = [];
-    const rowCmdFmt: ((s: string) => string)[] = [];
+    const rows = [];
+    const rowCmdFmt = [];
     for (const [k, v] of Object.entries(cmds)) {
-      if (v.hidden) continue;
+      if (v.hidden)
+        continue;
       const args = v.positionals ? Object.keys(v.positionals).join(" ") : "";
       rows.push([`  ${k}`, args, v.summary ?? v.description]);
       rowCmdFmt.push(t.command);
     }
     let ri = 0;
-    cols(rows, [(s) => rowCmdFmt[ri++]!(s), t.arg, t.description]);
+    cols(rows, [(s) => rowCmdFmt[ri++](s), t.arg, t.description]);
   }
 }
-
-function fail(def: CommandDef | CliDef, name: string, path: string[] = []) {
-  return (msg: string | null): void => {
+function fail(def, name, path = []) {
+  return (msg) => {
     if (process.argv.includes("--help") || process.argv.includes("-h")) {
       help(def, name, path);
       process.exit(0);
     }
-    if (
-      msg?.includes("You must specify") ||
-      msg?.includes("Not enough non-option arguments")
-    ) {
+    if (msg?.includes("You must specify") || msg?.includes("Not enough non-option arguments")) {
       help(def, name, path);
       process.exit(1);
     }
@@ -162,10 +106,9 @@ function fail(def: CommandDef | CliDef, name: string, path: string[] = []) {
     process.exit(1);
   };
 }
-
-function check(def: CommandDef | CliDef, name: string, path: string[] = []) {
-  return (argv: Record<string, unknown>): boolean => {
-    const args = argv as Record<string, unknown> & { _: unknown[]; help?: boolean };
+function check(def, name, path = []) {
+  return (argv) => {
+    const args = argv;
     if (args.help && args._.length === path.length) {
       help(def, name, path);
       process.exit(0);
@@ -173,24 +116,17 @@ function check(def: CommandDef | CliDef, name: string, path: string[] = []) {
     return true;
   };
 }
-
-function configure(
-  y: ReturnType<typeof yargs>,
-  def: CommandDef | CliDef,
-  root: string,
-  path: string[],
-): void {
+function configure(y, def, root, path) {
   if ("positionals" in def && def.positionals) {
     for (const [k, v] of Object.entries(def.positionals)) {
       y.positional(k, {
         type: v.type,
         describe: v.description,
         demandOption: v.required,
-        default: v.default,
+        default: v.default
       });
     }
   }
-
   if (def.options) {
     for (const [k, v] of Object.entries(def.options)) {
       y.option(k, {
@@ -198,48 +134,34 @@ function configure(
         type: v.type,
         describe: v.description,
         demandOption: v.required,
-        default: v.default,
+        default: v.default
       });
     }
   }
-
   if ("commands" in def && def.commands) {
     for (const [k, v] of Object.entries(def.commands)) {
       command(y, k, v, root, path);
     }
     y.demandCommand(1, "You must specify a command");
   }
-
-  y.help(false)
-    .option("help", { alias: "h", type: "boolean", describe: "Show help" })
-    .check(check(def, root, path))
-    .fail(fail(def, root, path));
+  y.help(false).option("help", { alias: "h", type: "boolean", describe: "Show help" }).check(check(def, root, path)).fail(fail(def, root, path));
 }
-
-function command(
-  y: ReturnType<typeof yargs>,
-  name: string,
-  def: CommandDef,
-  root: string,
-  path: string[],
-): void {
+function command(y, name, def, root, path) {
   let cmd = name;
   if (def.positionals) {
     for (const [k, v] of Object.entries(def.positionals)) {
       cmd += v.required ? ` <${k}>` : ` [${k}]`;
     }
   }
-  y.command(
-    cmd,
-    def.description,
-    (inner: ReturnType<typeof yargs>) => configure(inner, def, root, [...path, name]),
-    def.handler as (argv: Record<string, unknown>) => void,
-  );
+  y.command(cmd, def.description, (inner) => configure(inner, def, root, [...path, name]), def.handler);
 }
-
-export function build(def: CliDef): ReturnType<typeof yargs> {
+function build(def) {
   const y = yargs(hideBin(process.argv)).scriptName(def.name);
   configure(y, def, def.name, []);
   y.strict();
   return y;
 }
+export {
+  help,
+  build
+};

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

@@ -1,100 +1,74 @@
+// @bun
+// src/core/add.ts
 import fs from "fs";
 import path from "path";
-import { Config, type RepoEntry } from "@spader/dotllm/core/config";
-
-function isUrl(value: string): boolean {
-  return value.startsWith("http://") ||
-    value.startsWith("https://") ||
-    value.startsWith("git@") ||
-    value.startsWith("ssh://");
+import { Config } from "@spader/dotllm/core/config";
+function isUrl(value) {
+  return value.startsWith("http://") || value.startsWith("https://") || value.startsWith("git@") || value.startsWith("ssh://");
 }
-
-function nameFromGitRemote(dir: string): string | null {
+function nameFromGitRemote(dir) {
   const result = Bun.spawnSync(["git", "remote", "get-url", "origin"], {
     cwd: dir,
     stdout: "pipe",
-    stderr: "pipe",
+    stderr: "pipe"
   });
-  if (result.exitCode !== 0) return null;
+  if (result.exitCode !== 0)
+    return null;
   const url = result.stdout.toString().trim();
   return nameFromUrl(url);
 }
-
-function nameFromUrl(url: string): string {
+function nameFromUrl(url) {
   const base = url.split("/").pop() ?? url;
   return base.replace(/\.git$/, "");
 }
-
-export type AddResult = {
-  ok: true;
-  entry: RepoEntry;
-  storePath: string;
-} | {
-  ok: false;
-  error: string;
-};
-
-export async function add(uri: string, name?: string, description?: string): Promise<AddResult> {
+async function add(uri, name, description) {
   const desc = description ?? "";
-
   if (isUrl(uri)) {
     return cloneUrl(uri, name, desc);
   }
-
   return linkLocal(uri, name, desc);
 }
-
-async function cloneUrl(url: string, name: string | undefined, description: string): Promise<AddResult> {
+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], {
       stdout: "pipe",
-      stderr: "pipe",
+      stderr: "pipe"
     });
     const code = await proc.exited;
-
     if (code !== 0) {
       const msg = await new Response(proc.stderr).text();
       return { ok: false, error: `git clone failed: ${msg.trim()}` };
     }
   }
-
-  const entry: RepoEntry = { kind: "url", name: resolved, uri: url, description };
+  const entry = { kind: "url", name: resolved, uri: url, description };
   const global = Config.Global.read();
   Config.Global.write(Config.Global.add(global, entry));
-
   return { ok: true, entry, storePath: target };
 }
-
-function linkLocal(raw: string, name: string | undefined, description: string): AddResult {
+function linkLocal(raw, name, description) {
   const resolved = path.resolve(raw);
-
   if (!fs.existsSync(resolved)) {
     return { ok: false, error: `Path does not exist: ${resolved}` };
   }
-
   if (!fs.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");
   }
-
-  const entry: RepoEntry = { kind: "file", name: finalName, uri: resolved, description };
+  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 };
 }
+export {
+  add
+};