@spader/spall-cli 1.0.0

package/dist/src/shared/index.js

@@ -0,0 +1,1164 @@
+// @bun
+var __require = import.meta.require;
+
+// src/shared/theme.ts
+var colorEnabled = true;
+function setColorEnabled(enabled) {
+  colorEnabled = enabled;
+}
+function wrap(fn) {
+  return (s) => colorEnabled ? fn(s) : s;
+}
+function rgb(r, g, b) {
+  return wrap((s) => `\x1B[38;2;${r};${g};${b}m${s}\x1B[39m`);
+}
+function dim(s) {
+  if (!colorEnabled)
+    return s;
+  return gray(128)(s);
+}
+var gray = (n) => rgb(n, n, n);
+var primary = rgb(114, 161, 136);
+var option = rgb(212, 212, 161);
+var code = rgb(212, 212, 161);
+var path = rgb(114, 161, 136);
+var guide = rgb(162, 125, 111);
+var search = (s) => {
+  const prefix = s?.prefix ?? "";
+  const suffix = s?.suffix ?? "";
+  const base = `${prefix}search${suffix}`;
+  return colorEnabled ? guide(base) : base;
+};
+var defaultTheme = {
+  primary,
+  code,
+  path,
+  guide,
+  header: dim,
+  command: primary,
+  arg: rgb(161, 212, 212),
+  option,
+  type: dim,
+  description: (s) => s,
+  dim,
+  search
+};
+
+// src/shared/layout.ts
+var CLEAR = "\x1B[K";
+var ANSI_RE = /\x1b\[[0-9;]*m/g;
+function stripAnsi(s) {
+  return s.replace(ANSI_RE, "");
+}
+function truncateMiddle(s, max) {
+  if (max <= 0)
+    return "";
+  if (s.length <= max)
+    return s;
+  if (max <= 3)
+    return s.slice(0, max);
+  const half = max - 3 >> 1;
+  return s.slice(0, half + (max - 3 & 1)) + "..." + s.slice(-half);
+}
+function truncateStart(s, max) {
+  if (max <= 0)
+    return "";
+  if (s.length <= max)
+    return s;
+  if (max <= 3)
+    return "...".slice(0, max);
+  return "..." + s.slice(-(max - 3));
+}
+function truncateEnd(s, max) {
+  if (max <= 0)
+    return "";
+  if (s.length <= max)
+    return s;
+  if (max <= 3)
+    return "...".slice(0, max);
+  return s.slice(0, max - 3) + "...";
+}
+function cleanEscapes(s) {
+  return s.replace(/[\t\n]/g, " ");
+}
+function displayText(s) {
+  return cleanEscapes(stripAnsi(s));
+}
+function displayLen(s) {
+  return displayText(s).length;
+}
+function table(headers, columns, opts) {
+  const numCols = headers.length;
+  const gap = 2;
+  if (numCols === 0)
+    return;
+  const flex = opts?.flex ?? [];
+  const noTruncate = opts?.noTruncate ?? [];
+  const min = opts?.min ?? [];
+  const truncate = opts?.truncate ?? [];
+  const format = opts?.format ?? [];
+  const termWidth = opts?.maxWidth ?? process.stdout.columns;
+  const maxWidth = termWidth - 3;
+  const numRows = columns.reduce((m, c) => Math.max(m, c.length), 0);
+  const maxRows = opts?.maxRows ?? numRows;
+  const visibleRows = Math.min(numRows, maxRows);
+  const natural = [];
+  for (let i = 0;i < numCols; i++) {
+    const col = columns[i] ?? [];
+    const headerLen = displayText(headers[i] ?? "").length;
+    let maxCellLen = 0;
+    for (let r = 0;r < visibleRows; r++) {
+      const len = displayText(col[r] ?? "").length;
+      if (len > maxCellLen)
+        maxCellLen = len;
+    }
+    natural[i] = Math.max(headerLen, maxCellLen);
+  }
+  const widths = [...natural];
+  if (maxWidth != null && Number.isFinite(maxWidth) && maxWidth > 0 && (opts?.flex != null || opts?.noTruncate != null || opts?.min != null || opts?.truncate != null || opts?.maxWidth != null)) {
+    const totalGap = gap * (numCols - 1);
+    const available = Math.max(0, maxWidth - totalGap);
+    const totalNatural = natural.reduce((a, b) => a + b, 0);
+    if (totalNatural <= available) {} else {
+      let fixed = 0;
+      let totalWeight = 0;
+      const flexCols = [];
+      for (let i = 0;i < numCols; i++) {
+        const isFixed = noTruncate[i] === true || flex[i] === 0;
+        if (isFixed) {
+          widths[i] = natural[i];
+          fixed += widths[i];
+        } else {
+          const weight = flex[i] ?? 1;
+          totalWeight += weight;
+          flexCols.push({ i, weight });
+        }
+      }
+      const remaining = Math.max(0, available - fixed);
+      if (flexCols.length > 0) {
+        const mins = flexCols.map(({ i }) => Math.max(0, min[i] ?? 0));
+        const minSum = mins.reduce((a, b) => a + b, 0);
+        const baseMins = minSum > 0 && remaining < minSum ? mins.map((m) => Math.floor(m * remaining / minSum)) : mins;
+        const usedByMins = baseMins.reduce((a, b) => a + b, 0);
+        const extraSpace = Math.max(0, remaining - usedByMins);
+        if (totalWeight <= 0 || extraSpace === 0) {
+          for (let idx = 0;idx < flexCols.length; idx++) {
+            widths[flexCols[idx].i] = baseMins[idx];
+          }
+        } else {
+          const alloc = flexCols.map(({ i, weight }, idx) => {
+            const exact = extraSpace * weight / totalWeight;
+            const base = Math.floor(exact);
+            return {
+              i,
+              base: baseMins[idx] + base,
+              frac: exact - base,
+              weight,
+              natural: natural[i],
+              capped: false
+            };
+          });
+          let changed = true;
+          while (changed) {
+            changed = false;
+            let surplus = 0;
+            let uncappedWeight = 0;
+            for (const a of alloc) {
+              if (!a.capped && a.base > a.natural) {
+                surplus += a.base - a.natural;
+                a.base = a.natural;
+                a.capped = true;
+                changed = true;
+              }
+              if (!a.capped)
+                uncappedWeight += a.weight;
+            }
+            if (surplus > 0 && uncappedWeight > 0) {
+              for (const a of alloc) {
+                if (!a.capped) {
+                  const share = Math.floor(surplus * a.weight / uncappedWeight);
+                  a.base += share;
+                }
+              }
+            }
+          }
+          let used = alloc.reduce((s, a) => s + a.base, 0);
+          let extra = Math.max(0, available - fixed - used);
+          alloc.sort((a, b) => b.frac - a.frac || a.i - b.i);
+          for (let k = 0;k < alloc.length && extra > 0; k++) {
+            if (!alloc[k].capped || alloc[k].base < alloc[k].natural) {
+              alloc[k].base += 1;
+              extra--;
+            }
+          }
+          for (const a of alloc)
+            widths[a.i] = a.base;
+        }
+      }
+    }
+  }
+  const header = headers.map((h, i) => {
+    const w = widths[i] ?? 0;
+    const cell = truncateMiddle(displayText(h), w);
+    return w > 0 ? cell.padEnd(w) : cell;
+  }).join("  ");
+  console.log(defaultTheme.dim(header));
+  for (let row = 0;row < visibleRows; row++) {
+    const parts = [];
+    for (let i = 0;i < numCols; i++) {
+      const w = widths[i] ?? 0;
+      const col = columns[i] ?? [];
+      const raw = col[row] ?? "";
+      const cell = displayText(raw);
+      if (noTruncate[i]) {
+        const padded2 = w > 0 ? cell.padEnd(w) : cell;
+        parts.push(format[i] ? format[i](padded2, row, i) : padded2);
+        continue;
+      }
+      const mode = truncate[i] ?? "middle";
+      const truncated = mode === "start" ? truncateStart(cell, w) : mode === "end" ? truncateEnd(cell, w) : truncateMiddle(cell, w);
+      const padded = w > 0 ? truncated.padEnd(w) : truncated;
+      parts.push(format[i] ? format[i](padded, row, i) : padded);
+    }
+    const line = parts.join("  ");
+    console.log(line);
+  }
+  if (numRows > maxRows) {
+    console.log(defaultTheme.dim("(...truncated)"));
+  }
+}
+function cols(rows, colorFns) {
+  if (rows.length === 0)
+    return;
+  const widths = rows[0].map((_, i) => Math.max(...rows.map((r) => r[i].length)));
+  for (const row of rows) {
+    const line = row.map((c, i) => {
+      const padded = c.padEnd(widths[i]);
+      return colorFns?.[i] ? colorFns[i](padded) : padded;
+    });
+    console.log(line.join(" "));
+  }
+}
+// src/shared/display.ts
+function formatPath(s) {
+  const bodyLen = s.trimEnd().length;
+  const body = s.slice(0, bodyLen);
+  const pad = s.slice(bodyLen);
+  const slash = body.lastIndexOf("/");
+  if (slash === -1)
+    return defaultTheme.primary(body) + pad;
+  return defaultTheme.dim(body.slice(0, slash + 1)) + defaultTheme.primary(body.slice(slash + 1)) + pad;
+}
+function highlightSnippet(s) {
+  const parts = s.split(/[\x01\x02]/);
+  let result = "";
+  let inside = false;
+  for (const part of parts) {
+    result += inside ? defaultTheme.code(part) : part;
+    inside = !inside;
+  }
+  return result;
+}
+function makePathTreeNode(name) {
+  return { name, children: new Map };
+}
+function buildPathTree(items, path2, initLeaf, addToLeaf) {
+  const root = makePathTreeNode("");
+  for (const item of items) {
+    const parts = path2(item).split("/");
+    let current = root;
+    for (const part of parts) {
+      let child = current.children.get(part);
+      if (!child) {
+        child = makePathTreeNode(part);
+        current.children.set(part, child);
+      }
+      current = child;
+    }
+    current.leaf ??= initLeaf();
+    addToLeaf(current.leaf, item);
+  }
+  return root;
+}
+function sortedChildren(node) {
+  const entries = Array.from(node.children.entries());
+  entries.sort((a, b) => {
+    const aDir = a[1].children.size > 0;
+    const bDir = b[1].children.size > 0;
+    if (aDir !== bDir)
+      return aDir ? -1 : 1;
+    return a[0].localeCompare(b[0]);
+  });
+  return entries;
+}
+function displayResults(items, opts) {
+  if (items.length === 0) {
+    console.log(defaultTheme.dim(opts.empty ?? "(no results)"));
+    return;
+  }
+  if (opts.output === "json") {
+    console.log(JSON.stringify(items, null, 2));
+    return;
+  }
+  if (opts.output === "tree") {
+    displayTree(items, opts);
+    return;
+  }
+  if (opts.output === "list") {
+    displayList(items, opts);
+    return;
+  }
+  const columns = [
+    {
+      header: "path",
+      value: opts.path,
+      flex: 1,
+      truncate: "start",
+      format: formatPath
+    },
+    {
+      header: "id",
+      value: opts.id,
+      flex: 0,
+      noTruncate: true,
+      format: (s) => defaultTheme.code(s)
+    },
+    ...opts.extraColumns ?? [],
+    {
+      header: "preview",
+      value: opts.preview,
+      flex: 2,
+      min: 3,
+      truncate: "end",
+      format: opts.previewFormat
+    }
+  ];
+  const termRows = process.stdout.rows ?? 24;
+  const maxRows = opts.showAll ? Infinity : Math.max(1, termRows - 4);
+  table(columns.map((c) => c.header), columns.map((c) => items.map((item) => c.value(item))), {
+    flex: columns.map((c) => c.flex ?? 1),
+    noTruncate: columns.map((c) => c.noTruncate ?? false),
+    min: columns.map((c) => c.min ?? 0),
+    truncate: columns.map((c) => c.truncate ?? "middle"),
+    format: columns.map((c) => c.format ? (s, row, col) => c.format(s, row, col) : undefined),
+    maxRows
+  });
+}
+function displayTree(items, opts) {
+  const termRows = process.stdout.rows ?? 24;
+  const maxRows = opts.showAll ? Infinity : Math.max(1, termRows - 3);
+  const truncated = items.length > maxRows;
+  const visible = truncated ? items.slice(0, maxRows) : items;
+  const root = buildPathTree(visible, (item) => opts.path(item), () => [], (leaf, item) => {
+    leaf.push(item);
+  });
+  const MAX_PER_LEAF = 3;
+  const termWidth = process.stdout.columns ?? 80;
+  const showAll = opts.showAll ?? false;
+  function printNode(node, indent) {
+    for (const [name, child] of sortedChildren(node)) {
+      if (child.children.size > 0) {
+        console.log(`${defaultTheme.dim(indent)}${defaultTheme.dim(name + "/")}`);
+        printNode(child, indent + "  ");
+      } else {
+        const toShow = showAll ? child.leaf ?? [] : (child.leaf ?? []).slice(0, MAX_PER_LEAF);
+        for (let i = 0;i < toShow.length; i++) {
+          const item = toShow[i];
+          const index = toShow.length > 1 || (child.leaf?.length ?? 0) > 1 ? `[${i + 1}/${child.leaf?.length ?? 0}] ` : "";
+          const left = `${indent}${index}${name}`;
+          const leftStyled = defaultTheme.dim(indent + index) + defaultTheme.primary(name);
+          const content = cleanEscapes(opts.preview(item));
+          const contentBudget = termWidth - displayLen(left) - 1;
+          const preview = contentBudget > 0 ? truncateMiddle(content, contentBudget) : "";
+          console.log(preview ? `${leftStyled} ${preview}` : leftStyled);
+        }
+        if (!showAll && (child.leaf?.length ?? 0) > MAX_PER_LEAF) {
+          const remaining = (child.leaf?.length ?? 0) - MAX_PER_LEAF;
+          console.log(`${defaultTheme.dim(indent)}  ${defaultTheme.dim(`( ... ${remaining} more note${remaining > 1 ? "s" : ""} )`)}`);
+        }
+      }
+    }
+  }
+  printNode(root, "");
+  if (truncated)
+    console.log(defaultTheme.dim("..."));
+}
+function displayList(items, opts) {
+  const termRows = process.stdout.rows ?? 24;
+  const maxItems = opts.showAll ? items.length : Math.max(1, termRows - 3);
+  for (let i = 0;i < Math.min(items.length, maxItems); i++) {
+    const item = items[i];
+    if (items.length > 1) {
+      console.log(defaultTheme.command(opts.path(item)));
+    }
+    console.log(opts.preview(item));
+    if (i < Math.min(items.length, maxItems) - 1)
+      console.log("");
+  }
+  if (items.length > maxItems && !opts.showAll) {
+    const remaining = items.length - maxItems;
+    console.log(defaultTheme.dim(`( ... ${remaining} more note${remaining > 1 ? "s" : ""} )`));
+  }
+}
+function printQueryId(queryId) {
+  console.log("");
+  console.log(`Your query ID is ${queryId}`);
+}
+function scoreBucket(score) {
+  if (score >= 0.9)
+    return "perfect";
+  if (score >= 0.85)
+    return "very high";
+  if (score >= 0.75)
+    return "high";
+  if (score >= 0.6)
+    return "medium";
+  return "low";
+}
+function truncatePreview(s, maxChars = 200) {
+  const collapsed = s.replace(/\s+/g, " ").trim();
+  if (collapsed.length <= maxChars)
+    return collapsed;
+  return collapsed.slice(0, maxChars - 3) + "...";
+}
+function displayLlmSearch(items, opts) {
+  if (items.length === 0) {
+    console.log(opts.empty ?? "(no results)");
+    printQueryId(opts.queryId);
+    return;
+  }
+  for (let i = 0;i < items.length; i++) {
+    const item = items[i];
+    const path2 = opts.path(item);
+    const id = opts.id(item);
+    const bucket = scoreBucket(opts.score(item));
+    const preview = truncatePreview(opts.preview(item));
+    console.log(`[${bucket}] (id: ${id}) ${path2}`);
+    console.log(preview);
+    if (i < items.length - 1)
+      console.log("");
+  }
+  printQueryId(opts.queryId);
+}
+function displayLlmFetch(items, opts) {
+  if (items.length === 0) {
+    console.log(opts.empty ?? "(no notes found)");
+    return;
+  }
+  for (let i = 0;i < items.length; i++) {
+    const item = items[i];
+    const path2 = opts.path(item);
+    const id = opts.id(item);
+    const content = opts.content(item);
+    console.log(`${path2} (id: ${id})`);
+    console.log(content);
+    if (i < items.length - 1)
+      console.log();
+  }
+}
+function displayPathTree(paths, opts) {
+  if (paths.length === 0) {
+    console.log(defaultTheme.dim(opts?.empty ?? "(no notes)"));
+    return;
+  }
+  const root = buildPathTree(paths, (p) => p, () => ({ count: 0 }), (leaf) => {
+    leaf.count++;
+  });
+  const showFiles = opts?.showAll ?? false;
+  function printNode(node, indent) {
+    const sorted = sortedChildren(node);
+    const dirs = [];
+    const files = [];
+    for (const entry of sorted) {
+      if (entry[1].children.size > 0)
+        dirs.push(entry);
+      else
+        files.push(entry);
+    }
+    for (const [name, child] of dirs) {
+      console.log(`${defaultTheme.dim(indent)}${defaultTheme.dim(name + "/")}`);
+      printNode(child, indent + "  ");
+    }
+    if (files.length > 0) {
+      if (showFiles) {
+        for (const [name, child] of files) {
+          const n = child.leaf?.count ?? 0;
+          const suffix = n > 1 ? defaultTheme.dim(` (x${n})`) : "";
+          console.log(`${defaultTheme.dim(indent)}${defaultTheme.primary(name)}${suffix}`);
+        }
+      } else {
+        const count = files.reduce((sum, [, child]) => sum + (child.leaf?.count ?? 0), 0);
+        console.log(`${defaultTheme.dim(indent)}${defaultTheme.primary(`(${count} note${count !== 1 ? "s" : ""})`)}`);
+      }
+    }
+  }
+  printNode(root, "");
+}
+// src/shared/yargs.ts
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+import pc from "picocolors";
+function usage(def, path2, t) {
+  const parts = [];
+  const last = path2.length - 1;
+  for (let i = 0;i < path2.length; i++) {
+    const fmt = t.command;
+    parts.push(i === last ? fmt(path2[i]) : path2[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) {
+    parts.push(t.arg("$command"));
+  }
+  return parts.join(" ");
+}
+function help(def, name, path2 = [], t = defaultTheme) {
+  let prev = false;
+  if (def.description) {
+    console.log(t.description(def.description));
+    prev = true;
+  }
+  if (prev)
+    console.log("");
+  console.log(t.header("usage:"));
+  console.log(`  ${usage(def, [name, ...path2], t)}`);
+  prev = true;
+  const pos = "positionals" in def ? def.positionals : undefined;
+  if (pos && Object.keys(pos).length > 0) {
+    if (prev)
+      console.log("");
+    console.log(t.header("arguments"));
+    prev = true;
+    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)")}`;
+      rows.push([`  ${k}`, v.type, desc]);
+    }
+    cols(rows, [t.arg, t.type, t.description]);
+  }
+  const opts = {
+    ...def.options ?? {},
+    help: { alias: "h", type: "boolean", description: "Show help" }
+  };
+  if (Object.keys(opts).length > 0) {
+    if (prev)
+      console.log("");
+    console.log(t.header("options"));
+    prev = true;
+    const rows = [];
+    for (const [k, v] of Object.entries(opts)) {
+      const short = v.alias ? `-${v.alias}, ` : "    ";
+      let desc = v.description;
+      if (v.default !== undefined && v.type !== "boolean") {
+        desc += ` ${t.dim(`(default: ${v.default})`)}`;
+      }
+      rows.push([`  ${short}--${k}`, v.type, desc]);
+    }
+    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("");
+    console.log(t.header("commands"));
+    const rows = [];
+    const rowCmdFmt = [];
+    for (const [k, v] of Object.entries(cmds)) {
+      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]);
+  }
+}
+function fail(def, name, path2 = []) {
+  return (msg, err) => {
+    if (process.argv.includes("--help") || process.argv.includes("-h")) {
+      help(def, name, path2);
+      process.exit(0);
+    }
+    if (msg?.includes("You must specify") || msg?.includes("Not enough non-option arguments")) {
+      help(def, name, path2);
+      process.exit(1);
+    }
+    const detail = msg ?? (err instanceof globalThis.Error ? err.message : undefined) ?? (typeof err === "string" ? err : undefined) ?? "Unknown error";
+    console.error(pc.red(detail));
+    process.exit(1);
+  };
+}
+function check(def, name, path2 = []) {
+  return (argv) => {
+    if (argv.help && argv._.length === path2.length) {
+      help(def, name, path2);
+      process.exit(0);
+    }
+    return true;
+  };
+}
+function configure(y, def, root, path2) {
+  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
+      });
+    }
+  }
+  if (def.options) {
+    for (const [k, v] of Object.entries(def.options)) {
+      y.option(k, {
+        alias: v.alias,
+        type: v.type,
+        describe: v.description,
+        demandOption: v.required,
+        default: v.default
+      });
+    }
+  }
+  if ("commands" in def && def.commands) {
+    for (const [k, v] of Object.entries(def.commands)) {
+      command(y, k, v, root, path2);
+    }
+    y.demandCommand(1, "You must specify a command");
+  }
+  y.help(false).option("help", { alias: "h", type: "boolean", describe: "Show help" }).check(check(def, root, path2)).fail(fail(def, root, path2));
+}
+function command(y, name, def, root, path2) {
+  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, (yargs2) => configure(yargs2, def, root, [...path2, name]), def.handler);
+}
+function build(def) {
+  const y = yargs(hideBin(process.argv)).scriptName(def.name);
+  configure(y, def, def.name, []);
+  y.strict();
+  return y;
+}
+// src/shared/help.ts
+var activeCli = null;
+function setActiveCli(def) {
+  activeCli = def;
+}
+function printHelp(t = defaultTheme) {
+  if (!activeCli) {
+    throw new Error("printHelp() called before setActiveCli(). Set it in your CLI entrypoint.");
+  }
+  help(activeCli, activeCli.name, [], t);
+}
+// src/shared/progress.ts
+import pc2 from "picocolors";
+import consola from "consola";
+var BAR_WIDTH = 20;
+function renderProgressBar(percent) {
+  const filled = Math.round(percent / 100 * BAR_WIDTH);
+  const empty = BAR_WIDTH - filled;
+  return defaultTheme.primary("\u2588".repeat(filled) + "\u2591".repeat(empty));
+}
+function createModelProgressHandler() {
+  let model = "";
+  return (event) => {
+    switch (event.tag) {
+      case "model.load":
+        consola.info(`Loading model ${defaultTheme.primary(event.info.name)}`);
+        break;
+      case "model.download":
+        model = event.info.name;
+        consola.info(`Downloading model ${defaultTheme.primary(event.info.name)}`);
+        break;
+      case "model.progress": {
+        const percent = event.downloaded / event.total * 100;
+        const bar = renderProgressBar(percent);
+        const percentStr = percent.toFixed(0).padStart(3);
+        process.stderr.write(`\r${bar} ${pc2.bold(percentStr + "%")} ${defaultTheme.primary(model)} ${CLEAR}`);
+        break;
+      }
+      case "model.downloaded":
+        process.stderr.write(`\r${CLEAR}`);
+        consola.success(`Downloaded ${defaultTheme.primary(event.info.name)}`);
+        break;
+    }
+  };
+}
+function formatStreamError(e, path2) {
+  let code2 = "";
+  let msg = "";
+  if (e && typeof e === "object") {
+    code2 = e.code ?? "";
+    msg = e.message ?? String(e);
+  } else {
+    msg = String(e);
+  }
+  if (code2 === "note.exists") {
+    return `Note already exists at ${defaultTheme.primary(path2)}. Use ${defaultTheme.option("--update")} if you meant to update the note.`;
+  }
+  if (code2 === "note.duplicate") {
+    return `Duplicate content detected for ${defaultTheme.primary(path2)}. Use ${defaultTheme.option("--dupe")} to allow duplicates.`;
+  }
+  if (code2)
+    return `${code2}: ${msg}`;
+  return msg;
+}
+// src/shared/workspace.ts
+import consola2 from "consola";
+import { WorkspaceConfig } from "@spader/spall-core";
+import { Client } from "@spader/spall-sdk/client";
+function fail2(message) {
+  consola2.error(message);
+  process.exit(1);
+}
+async function gitRoot(start) {
+  try {
+    const proc = Bun.spawn(["git", "rev-parse", "--show-toplevel"], {
+      cwd: start,
+      stdout: "pipe",
+      stderr: "ignore",
+      stdin: "ignore"
+    });
+    const exit = await proc.exited;
+    if (exit !== 0)
+      return null;
+    const out = (await new Response(proc.stdout).text()).trim();
+    return out || null;
+  } catch {
+    return null;
+  }
+}
+async function resolveScope(input) {
+  const cwd = input.cwd ?? process.cwd();
+  const config = WorkspaceConfig.load(cwd);
+  const located = WorkspaceConfig.locate(cwd);
+  const names = input.corpus ? [input.corpus] : config.scope.read;
+  const tracked = input.tracked ?? false;
+  let viewer = { id: 1, name: "default" };
+  if (tracked && located) {
+    const ensured = await input.client.workspace.create({ name: config.workspace.name }).then(Client.unwrap);
+    viewer = { id: ensured.id, name: ensured.name };
+    if (config.workspace.id !== viewer.id) {
+      WorkspaceConfig.patch(located.root, {
+        workspace: { name: config.workspace.name, id: viewer.id }
+      });
+    }
+  }
+  const corpora = await input.client.corpus.list().then(Client.unwrap);
+  const byName = new Map(corpora.map((c) => [c.name, c.id]));
+  const ids = names.map((name) => {
+    const id = byName.get(name);
+    if (id === undefined) {
+      fail2(`Corpus not found: ${defaultTheme.command(name)}`);
+    }
+    return id;
+  });
+  return { config, located, viewer, names, ids };
+}
+async function createQuery(input) {
+  const scope = await resolveScope({
+    client: input.client,
+    cwd: input.cwd,
+    corpus: input.corpus,
+    tracked: input.tracked
+  });
+  const tracked = Boolean(input.tracked && scope.located);
+  const query = await input.client.query.create({
+    viewer: scope.viewer.id,
+    tracked,
+    corpora: scope.ids
+  }).then(Client.unwrap);
+  return { ...scope, query };
+}
+// src/shared/tree.ts
+function noteTreeEntries(notes, maxDepth) {
+  const unlimited = maxDepth === undefined;
+  const entries = [];
+  const seenDirs = new Map;
+  for (const note of notes) {
+    const parts = note.path.split("/");
+    const fileDepth = parts.length - 1;
+    let prefix = "";
+    for (let i = 0;i < parts.length - 1; i++) {
+      prefix = prefix ? `${prefix}/${parts[i]}` : parts[i];
+      if (!unlimited && i > maxDepth)
+        break;
+      if (!seenDirs.has(prefix)) {
+        const entry = {
+          type: "dir",
+          depth: i,
+          name: parts[i] + "/"
+        };
+        seenDirs.set(prefix, entry);
+        entries.push(entry);
+      }
+    }
+    if (unlimited || fileDepth <= maxDepth) {
+      entries.push({
+        type: "file",
+        depth: fileDepth,
+        name: parts[parts.length - 1],
+        id: note.id
+      });
+    } else {
+      const cutoffKey = parts.slice(0, maxDepth + 1).join("/");
+      const dir = seenDirs.get(cutoffKey);
+      if (dir && dir.type === "dir") {
+        dir.noteCount = (dir.noteCount ?? 0) + 1;
+      }
+    }
+  }
+  return entries;
+}
+function noteDirEntries(notes, maxDepth) {
+  const unlimited = maxDepth === undefined;
+  const dirs = new Map;
+  const ensure = (key, depth, name) => {
+    const existing = dirs.get(key);
+    if (existing)
+      return existing;
+    const created = { hasSubdir: false, noteCount: 0, depth, name };
+    dirs.set(key, created);
+    return created;
+  };
+  for (const note of notes) {
+    const parts = note.path.split("/");
+    if (parts.length <= 1)
+      continue;
+    let prefix = "";
+    for (let i = 0;i < parts.length - 1; i++) {
+      if (!unlimited && i > maxDepth)
+        break;
+      const part = parts[i];
+      const key = prefix ? `${prefix}/${part}` : part;
+      ensure(key, i, part + "/");
+      if (prefix) {
+        const parent = dirs.get(prefix);
+        if (parent && (unlimited || i <= maxDepth)) {
+          parent.hasSubdir = true;
+        }
+      }
+      prefix = key;
+    }
+    if (!unlimited && parts.length - 2 > maxDepth) {
+      const cutoffKey = parts.slice(0, maxDepth + 1).join("/");
+      const cutoff = dirs.get(cutoffKey);
+      if (cutoff)
+        cutoff.noteCount++;
+    } else {
+      const parentKey = parts.slice(0, -1).join("/");
+      const parent = dirs.get(parentKey);
+      if (parent)
+        parent.noteCount++;
+    }
+  }
+  const keys = Array.from(dirs.keys());
+  keys.sort((a, b) => a.localeCompare(b));
+  return keys.filter((key) => {
+    const info = dirs.get(key);
+    return unlimited || info.depth <= maxDepth;
+  }).map((key) => {
+    const info = dirs.get(key);
+    const leaf = !info.hasSubdir;
+    return {
+      type: "dir",
+      depth: info.depth,
+      name: info.name,
+      noteCount: leaf ? info.noteCount : undefined
+    };
+  });
+}
+// src/shared/vsearch.ts
+import { Client as Client2 } from "@spader/spall-sdk/client";
+var Vsearch;
+((Vsearch) => {
+  Vsearch.summary = `Semantic vector ${defaultTheme.search()}`;
+  function description(cliName) {
+    return `Semantic vector ${defaultTheme.search()} using embeddings. Returns truncated previews with note IDs.
+
+Use \`fetch\` with the returned Query ID and note IDs to get full content.
+
+Example:
+  ${cliName} ${defaultTheme.search({ prefix: "v" })} "how to configure r2 bindings"
+`;
+  }
+  Vsearch.description = description;
+  Vsearch.positionals = {
+    query: {
+      type: "string",
+      description: `Natural language ${defaultTheme.search()} query`,
+      required: true
+    }
+  };
+  Vsearch.options = {
+    corpus: {
+      alias: "c",
+      type: "string",
+      description: "Corpus name (default: from spall.json)"
+    },
+    path: {
+      type: "string",
+      description: "Path glob filter"
+    },
+    limit: {
+      alias: "n",
+      type: "number",
+      description: "Max results",
+      default: 10
+    }
+  };
+  function collapseWhitespace(s) {
+    return s.replace(/\s+/g, " ").trim();
+  }
+  Vsearch.collapseWhitespace = collapseWhitespace;
+  async function run(argv) {
+    const client = await Client2.connect();
+    const { query } = await createQuery({
+      client,
+      corpus: argv.corpus,
+      tracked: argv.tracked
+    });
+    const res = await client.query.vsearch({
+      id: String(query.id),
+      q: argv.query,
+      path: argv.path,
+      limit: argv.limit
+    }).then(Client2.unwrap);
+    return { client, query, results: res.results };
+  }
+  Vsearch.run = run;
+})(Vsearch ||= {});
+// src/shared/search.ts
+import { Client as Client3 } from "@spader/spall-sdk/client";
+var Search;
+((Search) => {
+  Search.summary = `Keyword ${defaultTheme.search()} (FTS)`;
+  function description(cliName) {
+    return `Full-text keyword ${defaultTheme.search()}. Returns truncated previews with note IDs.
+
+Use \`fetch\` with the returned Query ID and note IDs to get full content.
+
+Example:
+  ${cliName} ${defaultTheme.search()} "R2Bucket"
+`;
+  }
+  Search.description = description;
+  Search.positionals = {
+    query: {
+      type: "string",
+      description: "Search keywords",
+      required: true
+    }
+  };
+  Search.options = {
+    corpus: {
+      alias: "c",
+      type: "string",
+      description: "Corpus name (default: from spall.json)"
+    },
+    path: {
+      type: "string",
+      description: "Path glob filter"
+    },
+    limit: {
+      alias: "n",
+      type: "number",
+      description: "Max results (default: 20)"
+    }
+  };
+  async function run(argv) {
+    const client = await Client3.connect();
+    const { query } = await createQuery({
+      client,
+      corpus: argv.corpus,
+      tracked: argv.tracked
+    });
+    const res = await client.query.search({
+      id: String(query.id),
+      q: argv.query,
+      path: argv.path,
+      limit: argv.limit,
+      ...argv.mode ? { mode: argv.mode } : {}
+    }).then(Client3.unwrap);
+    return { client, query, results: res.results };
+  }
+  Search.run = run;
+})(Search ||= {});
+// src/shared/list.ts
+import { Client as Client4 } from "@spader/spall-sdk/client";
+var List;
+((List) => {
+  List.positionals = {
+    path: {
+      type: "string",
+      description: "Path or glob to filter notes",
+      default: "*"
+    }
+  };
+  List.options = {
+    corpus: {
+      alias: "c",
+      type: "string",
+      description: "Corpus name"
+    },
+    all: {
+      type: "boolean",
+      description: "List all files (default: directories only)",
+      default: false
+    },
+    depth: {
+      alias: "d",
+      type: "string",
+      description: 'Tree depth (0 = top-level only, 1 = one level deep, "max" = unlimited)'
+    }
+  };
+  function normalizePath(rawInput, completion) {
+    let path2 = String(rawInput ?? "*");
+    if (!/[*?\]]$/.test(path2)) {
+      if (completion && !path2.endsWith("/")) {
+        path2 = path2 + "*";
+      } else {
+        path2 = path2.replace(/\/?$/, "/*");
+      }
+    }
+    return path2;
+  }
+  List.normalizePath = normalizePath;
+  function parseDepth(raw) {
+    if (raw === undefined || raw === null)
+      return 0;
+    const s = String(raw).trim().toLowerCase();
+    if (s === "max" || s === "all")
+      return;
+    const n = parseInt(s, 10);
+    if (isNaN(n) || n < 0)
+      return 0;
+    return n;
+  }
+  List.parseDepth = parseDepth;
+  async function run(argv) {
+    const client = await Client4.connect();
+    const {
+      query,
+      located,
+      names: includeNames
+    } = await createQuery({
+      client,
+      corpus: argv.corpus,
+      tracked: argv.tracked
+    });
+    const path2 = normalizePath(argv.path, Boolean(argv.completion));
+    const notes = [];
+    let cursor = undefined;
+    while (true) {
+      const page = await client.query.notes({ id: String(query.id), path: path2, limit: 100, after: cursor }).then(Client4.unwrap);
+      for (const n of page.notes)
+        notes.push({ id: n.id, path: n.path });
+      if (!page.nextCursor)
+        break;
+      cursor = page.nextCursor;
+    }
+    notes.sort((a, b) => a.path.localeCompare(b.path));
+    return { client, query, notes, path: path2, located, includeNames };
+  }
+  List.run = run;
+})(List ||= {});
+// src/shared/status.ts
+import { Client as Client5 } from "@spader/spall-sdk/client";
+import { WorkspaceConfig as WorkspaceConfig2 } from "@spader/spall-core";
+var Status;
+((Status) => {
+  Status.summary = "List available corpora and workspace status";
+  Status.description = `List available corpora, and which will be included by default in searches (i.e. included in workspace)`;
+  Status.formatTime = (ts) => new Date(ts).toISOString().slice(0, 19).replace("T", " ");
+  async function run() {
+    const client = await Client5.connect();
+    const url = Client5.url(client);
+    const result = await client.corpus.list();
+    if (result.error || !result.data) {
+      return { error: result.error };
+    }
+    const corpora = result.data;
+    const config = WorkspaceConfig2.load(process.cwd());
+    const included = new Set(config.scope.read);
+    return { url, corpora, included };
+  }
+  Status.run = run;
+  function print(result, opts) {
+    const { url, corpora, included } = result;
+    console.log(`${defaultTheme.dim("server")} ${url}`);
+    if (corpora.length === 0) {
+      console.log("No corpora found.");
+      return;
+    }
+    table(["name", "id", "notes", "workspace", "created", "updated"], [
+      corpora.map((p) => p.name),
+      corpora.map((p) => String(p.id)),
+      corpora.map((p) => String(p.noteCount)),
+      corpora.map((p) => included.has(p.name) ? "yes" : "no"),
+      corpora.map((p) => Status.formatTime(p.createdAt)),
+      corpora.map((p) => Status.formatTime(p.updatedAt))
+    ], opts?.highlightWorkspace ? {
+      format: [
+        (s) => s,
+        (s) => s,
+        (s) => s,
+        (s) => {
+          const trimmed = s.trimEnd();
+          const pad = s.slice(trimmed.length);
+          return trimmed === "yes" ? defaultTheme.primary("yes") + pad : "no" + pad;
+        },
+        (s) => s,
+        (s) => s
+      ]
+    } : undefined);
+  }
+  Status.print = print;
+})(Status ||= {});
+export {
+  table,
+  setColorEnabled,
+  setActiveCli,
+  resolveScope,
+  renderProgressBar,
+  printQueryId,
+  printHelp,
+  noteTreeEntries,
+  noteDirEntries,
+  highlightSnippet,
+  help,
+  gitRoot,
+  formatStreamError,
+  displayResults,
+  displayPathTree,
+  displayLlmSearch,
+  displayLlmFetch,
+  defaultTheme,
+  createQuery,
+  createModelProgressHandler,
+  cols,
+  cleanEscapes,
+  build,
+  Vsearch,
+  Status,
+  Search,
+  List,
+  CLEAR
+};
+
+//# debugId=D1FB096FF010260C64756E2164756E21