@spader/spall-cli 1.0.0

package/dist/src/spall/index.js

@@ -0,0 +1,1648 @@
+#!/usr/bin/env bun
+// @bun
+var __require = import.meta.require;
+
+// src/spall/index.ts
+import { build, setActiveCli } from "@spader/spall-cli/shared";
+
+// src/spall/commands/corpus/create.ts
+import pc from "picocolors";
+import consola from "consola";
+import { Client } from "@spader/spall-sdk/client";
+var create = {
+  description: "Create a new corpus",
+  positionals: {
+    name: {
+      type: "string",
+      description: "Corpus name",
+      required: true
+    }
+  },
+  handler: async (argv) => {
+    const client = await Client.connect();
+    const result = await client.corpus.create({
+      name: argv.name
+    }).then(Client.unwrap);
+    consola.success(`Corpus ${pc.cyanBright(result.name)} (id: ${result.id})`);
+  }
+};
+
+// src/spall/commands/corpus/delete.ts
+import pc2 from "picocolors";
+import consola2 from "consola";
+import { Client as Client2 } from "@spader/spall-sdk";
+var remove = {
+  description: "Delete a corpus by ID",
+  positionals: {
+    id: {
+      type: "number",
+      description: "Corpus ID"
+    }
+  },
+  handler: async (argv) => {
+    if (argv.id === undefined || isNaN(Number(argv.id))) {
+      consola2.error("Missing required argument: id");
+      process.exit(1);
+    }
+    const client = await Client2.connect();
+    const result = await client.corpus.delete({ id: String(argv.id) });
+    if (result.error) {
+      consola2.error(result.error.message);
+      process.exit(1);
+    }
+    consola2.success(`Deleted corpus ${pc2.cyanBright(argv.id)}`);
+  }
+};
+
+// src/spall/commands/corpus/index.ts
+var corpus = {
+  description: "Manage corpora",
+  commands: { create, delete: remove }
+};
+// src/spall/commands/workspace/init.ts
+import { existsSync } from "fs";
+import { basename } from "path";
+import * as prompts from "@clack/prompts";
+import consola3 from "consola";
+import { WorkspaceConfig } from "@spader/spall-core";
+import { Client as Client3 } from "@spader/spall-sdk/client";
+var init = {
+  description: "Initialize a workspace in this directory",
+  options: {
+    path: {
+      alias: "p",
+      type: "string",
+      description: "Directory to initialize (defaults to git root or cwd)"
+    },
+    force: {
+      alias: "f",
+      type: "boolean",
+      description: "Overwrite existing .spall/spall.json",
+      default: false
+    }
+  },
+  handler: async (argv) => {
+    const cwd = process.cwd();
+    const root = argv.path ?? cwd;
+    const configPath = WorkspaceConfig.path(root);
+    prompts.intro("Workspace init");
+    if (existsSync(configPath) && !argv.force) {
+      const overwrite = await prompts.confirm({
+        message: "Workspace config already exists. Overwrite?",
+        initialValue: false
+      });
+      if (prompts.isCancel(overwrite) || !overwrite) {
+        prompts.outro("Done");
+        return;
+      }
+    }
+    const defaultName = basename(root) || "default";
+    const workspaceName = await prompts.text({
+      message: "Workspace name",
+      initialValue: defaultName,
+      validate: (s) => s && s.trim().length > 0 ? undefined : "Required"
+    });
+    if (prompts.isCancel(workspaceName)) {
+      prompts.outro("Done");
+      return;
+    }
+    const createCorpus = await prompts.confirm({
+      message: "Create a corpus for this repo?",
+      initialValue: true
+    });
+    if (prompts.isCancel(createCorpus)) {
+      prompts.outro("Done");
+      return;
+    }
+    let corpusName = null;
+    if (createCorpus) {
+      const name = await prompts.text({
+        message: "Corpus name",
+        initialValue: defaultName,
+        validate: (s) => s && s.trim().length > 0 ? undefined : "Required"
+      });
+      if (prompts.isCancel(name)) {
+        prompts.outro("Done");
+        return;
+      }
+      corpusName = String(name).trim();
+    }
+    const spinner2 = prompts.spinner();
+    spinner2.start("Creating workspace");
+    try {
+      const client = await Client3.connect();
+      const ws = await client.workspace.create({ name: String(workspaceName).trim() }).then(Client3.unwrap);
+      if (corpusName) {
+        spinner2.message("Creating corpus");
+        await client.corpus.create({ name: corpusName }).then(Client3.unwrap);
+      }
+      spinner2.message("Loading corpora");
+      const corpora = await client.corpus.list().then(Client3.unwrap);
+      const options = corpora.map((c) => {
+        const name = c.name;
+        const noteCount = typeof c.noteCount === "number" ? c.noteCount : null;
+        return {
+          label: name,
+          value: name,
+          hint: noteCount == null ? undefined : `${noteCount} notes`
+        };
+      }).sort((a, b) => a.label.localeCompare(b.label));
+      const defaults = new Set(["default"]);
+      if (corpusName)
+        defaults.add(corpusName);
+      spinner2.stop("Workspace created");
+      const picked = await prompts.autocompleteMultiselect({
+        message: "Select corpora to include in read scope (type to filter)",
+        options,
+        placeholder: "Type to filter...",
+        maxItems: 12,
+        initialValues: Array.from(defaults),
+        required: true
+      });
+      if (prompts.isCancel(picked)) {
+        prompts.outro("Done");
+        return;
+      }
+      if (!(Array.isArray(picked) && picked.every((x) => typeof x === "string"))) {
+        throw new Error("Unexpected autocompleteMultiselect result");
+      }
+      const read = picked;
+      const write = await prompts.select({
+        message: "Select default corpus for writes",
+        options: read.map((name) => ({ label: name, value: name })),
+        initialValue: (corpusName && read.includes(corpusName) ? corpusName : undefined) ?? (read.includes("default") ? "default" : read[0])
+      });
+      if (prompts.isCancel(write)) {
+        prompts.outro("Done");
+        return;
+      }
+      const next = {
+        workspace: { name: ws.name, id: ws.id },
+        scope: { read, write: String(write) }
+      };
+      WorkspaceConfig.write(root, next);
+      prompts.outro(`Wrote ${configPath}`);
+    } catch (e) {
+      spinner2.stop("Failed");
+      consola3.error(e?.message ?? String(e));
+      prompts.outro("Done");
+      process.exit(1);
+    }
+  }
+};
+
+// src/spall/commands/workspace/add.ts
+import consola4 from "consola";
+import { WorkspaceConfig as WorkspaceConfig2 } from "@spader/spall-core";
+import { Client as Client4 } from "@spader/spall-sdk/client";
+var add = {
+  description: "Add a corpus to the workspace read scope",
+  positionals: {
+    corpus: {
+      type: "string",
+      description: "Corpus name",
+      required: true
+    }
+  },
+  handler: async (argv) => {
+    const located = WorkspaceConfig2.locate(process.cwd());
+    if (!located) {
+      consola4.error("No workspace config found. Run `spall workspace init`.");
+      process.exit(1);
+    }
+    const name = String(argv.corpus ?? "").trim();
+    if (!name) {
+      consola4.error("Missing required argument: corpus");
+      process.exit(1);
+    }
+    const client = await Client4.connect();
+    await client.corpus.create({ name }).then(Client4.unwrap);
+    const cfg = WorkspaceConfig2.load(located.root);
+    const read = cfg.scope.read.includes(name) ? cfg.scope.read : [...cfg.scope.read, name];
+    WorkspaceConfig2.patch(located.root, { scope: { read } });
+    consola4.success(`Included corpus: ${name}`);
+  }
+};
+
+// src/spall/commands/workspace/remove.ts
+import consola5 from "consola";
+import { WorkspaceConfig as WorkspaceConfig3 } from "@spader/spall-core";
+var remove2 = {
+  description: "Remove a corpus from the workspace read scope",
+  positionals: {
+    corpus: {
+      type: "string",
+      description: "Corpus name",
+      required: true
+    }
+  },
+  handler: async (argv) => {
+    const located = WorkspaceConfig3.locate(process.cwd());
+    if (!located) {
+      consola5.error("No workspace config found. Run `spall workspace init`.");
+      process.exit(1);
+    }
+    const name = String(argv.corpus ?? "").trim();
+    if (!name) {
+      consola5.error("Missing required argument: corpus");
+      process.exit(1);
+    }
+    const cfg = WorkspaceConfig3.load(located.root);
+    const read = cfg.scope.read.filter((c) => c !== name);
+    const write = cfg.scope.write === name ? read[0] ?? "default" : cfg.scope.write;
+    WorkspaceConfig3.patch(located.root, { scope: { read, write } });
+    consola5.success(`Removed corpus: ${name}`);
+  }
+};
+
+// src/spall/commands/workspace/edit.ts
+import * as prompts2 from "@clack/prompts";
+import consola6 from "consola";
+import { WorkspaceConfig as WorkspaceConfig4 } from "@spader/spall-core";
+import { Client as Client5 } from "@spader/spall-sdk/client";
+var edit = {
+  description: "Interactively edit the workspace",
+  handler: async () => {
+    const located = WorkspaceConfig4.locate(process.cwd());
+    if (!located) {
+      consola6.error("No workspace config found. Run `spall workspace init`.");
+      process.exit(1);
+    }
+    const cfg = WorkspaceConfig4.load(located.root);
+    const client = await Client5.connect();
+    const corpora = await client.corpus.list().then(Client5.unwrap);
+    const options = corpora.map((c) => {
+      const name = c.name;
+      const noteCount = typeof c.noteCount === "number" ? c.noteCount : null;
+      return {
+        label: name,
+        value: name,
+        hint: noteCount == null ? undefined : `${noteCount} notes`
+      };
+    }).sort((a, b) => a.label.localeCompare(b.label));
+    prompts2.intro("Workspace scope");
+    const picked = await prompts2.autocompleteMultiselect({
+      message: "Select corpora to include in read scope (type to filter)",
+      options,
+      placeholder: "Type to filter...",
+      maxItems: 12,
+      initialValues: cfg.scope.read.filter((c) => options.some((o) => o.value === c)),
+      required: true
+    });
+    if (prompts2.isCancel(picked)) {
+      prompts2.outro("Done");
+      return;
+    }
+    if (!(Array.isArray(picked) && picked.every((x) => typeof x === "string"))) {
+      throw new Error("Unexpected autocompleteMultiselect result");
+    }
+    const read = picked;
+    const write = await prompts2.select({
+      message: "Select default corpus for writes",
+      options: read.map((name) => ({ label: name, value: name })),
+      initialValue: read.includes(cfg.scope.write) ? cfg.scope.write : read[0]
+    });
+    if (prompts2.isCancel(write)) {
+      prompts2.outro("Done");
+      return;
+    }
+    WorkspaceConfig4.patch(located.root, {
+      scope: { read, write: String(write) }
+    });
+    prompts2.outro("Updated workspace scope");
+  }
+};
+
+// src/spall/commands/workspace/index.ts
+import { defaultTheme as theme } from "@spader/spall-cli/shared";
+var workspace = {
+  summary: "Manage the current workspace",
+  description: `A workspace allows you to define which corpora are included in ${theme.guide("searches")}, per directory. Separately, it provides a context for spall to automatically learn note weights based on access patterns.
+
+It's very useful to ingest documentation with spall, but you don't want TypeScript documentation polluting ${theme.guide("search")} results for a C project. Workspaces solve this by allowing you to restrict which corpora are included in ${theme.guide("searches")} within a directory.`,
+  commands: { init, add, remove: remove2, edit }
+};
+// src/spall/commands/add.ts
+import * as prompts3 from "@clack/prompts";
+import consola7 from "consola";
+import { Client as Client6 } from "@spader/spall-sdk/client";
+import { WorkspaceConfig as WorkspaceConfig5 } from "@spader/spall-core";
+import {
+  defaultTheme as theme2,
+  createModelProgressHandler,
+  formatStreamError
+} from "@spader/spall-cli/shared";
+function splitPath(input) {
+  const normalized = input.replace(/\\/g, "/").replace(/^\/+|\/+$/g, "");
+  if (normalized.length === 0)
+    return { dir: "", name: "" };
+  const i = normalized.lastIndexOf("/");
+  if (i < 0)
+    return { dir: "", name: normalized };
+  return {
+    dir: normalized.slice(0, i),
+    name: normalized.slice(i + 1)
+  };
+}
+function joinPath(dir, name) {
+  const d = dir.replace(/\\/g, "/").replace(/^\/+|\/+$/g, "");
+  const n = name.replace(/\\/g, "/").replace(/^\/+|\/+$/g, "");
+  return d.length > 0 ? `${d}/${n}` : n;
+}
+function collectDirectories(paths) {
+  const dirs = new Set;
+  dirs.add("");
+  for (const path of paths) {
+    const parts = path.split("/");
+    if (parts.length <= 1)
+      continue;
+    let prefix = "";
+    for (let i = 0;i < parts.length - 1; i++) {
+      const part = parts[i];
+      prefix = prefix ? `${prefix}/${part}` : part;
+      dirs.add(prefix);
+    }
+  }
+  return Array.from(dirs).sort((a, b) => a.localeCompare(b));
+}
+var NEW_DIRECTORY = "__new_directory__";
+function keepServerAlive(client, signal) {
+  (async () => {
+    try {
+      const { stream } = await client.events({ signal });
+      for await (const _event of stream) {}
+    } catch {}
+  })();
+}
+async function submitNote(input) {
+  const corpus2 = await input.client.corpus.get({ name: input.corpusName }).catch(() => {
+    consola7.error(`Failed to find corpus: ${theme2.primary(String(input.corpusName))}`);
+    process.exit(1);
+  }).then(Client6.unwrap);
+  const handleProgress = createModelProgressHandler();
+  const handleStreamError = (event) => {
+    if (event?.tag !== "error")
+      return false;
+    const formatted = formatStreamError(event.error, input.path);
+    const raw = (() => {
+      try {
+        return JSON.stringify(event.error);
+      } catch {
+        return String(event.error);
+      }
+    })();
+    consola7.error(formatted);
+    consola7.error(`Raw SSE error payload: ${raw}`);
+    process.exit(1);
+  };
+  if (input.update) {
+    const existing = await input.client.note.get({ id: corpus2.id.toString(), path: input.path }).then(Client6.unwrap).catch(() => null);
+    if (!existing) {
+      consola7.error(`Note not found: ${theme2.primary(input.path)}`);
+      process.exit(1);
+    }
+    const { stream: stream2 } = await input.client.sse.note.update({
+      id: existing.id.toString(),
+      content: input.content,
+      dupe: true
+    });
+    for await (const event of stream2) {
+      handleProgress(event);
+      handleStreamError(event);
+      if (event.tag === "note.updated") {
+        return { action: "updated", info: event.info };
+      }
+    }
+    throw new Error("Note stream ended without result");
+  }
+  const { stream } = await input.client.sse.note.add({
+    path: input.path,
+    content: input.content,
+    corpus: corpus2.id,
+    dupe: true
+  });
+  for await (const event of stream) {
+    handleProgress(event);
+    handleStreamError(event);
+    if (event.tag === "note.created") {
+      return { action: "added", info: event.info };
+    }
+  }
+  throw new Error("Note stream ended without result");
+}
+var add2 = {
+  description: "Add a note to a corpus",
+  positionals: {
+    path: {
+      type: "string",
+      description: "Path/name for the note",
+      required: false
+    }
+  },
+  options: {
+    text: {
+      alias: "t",
+      type: "string",
+      description: "Note content"
+    },
+    corpus: {
+      alias: "c",
+      type: "string",
+      description: "Corpus name"
+    },
+    update: {
+      alias: "u",
+      type: "boolean",
+      description: "Update if note exists (upsert)"
+    }
+  },
+  handler: async (argv) => {
+    const hasPathArg = typeof argv.path === "string" && argv.path.length > 0;
+    const hasTextArg = typeof argv.text === "string";
+    const interactive = !hasPathArg || !hasTextArg;
+    const defaultCorpusName = WorkspaceConfig5.load(process.cwd()).scope.write;
+    let corpusName = typeof argv.corpus === "string" ? String(argv.corpus) : defaultCorpusName;
+    let path = hasPathArg ? String(argv.path) : "";
+    let content = hasTextArg ? String(argv.text) : "";
+    const client = await Client6.connect();
+    const keepAlive = interactive ? new AbortController : null;
+    if (keepAlive) {
+      keepServerAlive(client, keepAlive.signal);
+    }
+    try {
+      if (interactive) {
+        prompts3.intro("spall add");
+        if (typeof argv.corpus !== "string") {
+          const corpora = await client.corpus.list().then(Client6.unwrap);
+          const corpusOptions = corpora.map((c) => {
+            const name = String(c.name);
+            const noteCount = typeof c.noteCount === "number" ? c.noteCount : undefined;
+            return {
+              label: name,
+              value: name,
+              hint: noteCount === undefined ? undefined : `${noteCount} ${noteCount === 1 ? "note" : "notes"}`
+            };
+          }).sort((a, b) => a.label.localeCompare(b.label));
+          const pickedCorpus = await prompts3.autocomplete({
+            message: "Select corpus",
+            options: corpusOptions,
+            placeholder: "Type to filter...",
+            maxItems: 12,
+            initialValue: corpusName
+          });
+          if (prompts3.isCancel(pickedCorpus)) {
+            prompts3.outro("Cancelled");
+            return;
+          }
+          corpusName = String(pickedCorpus);
+        }
+        const corpusForPath = await client.corpus.get({ name: corpusName }).catch(() => {
+          consola7.error(`Failed to find corpus: ${theme2.primary(corpusName)}`);
+          process.exit(1);
+        }).then(Client6.unwrap);
+        const existing = await client.note.list({ id: String(corpusForPath.id) }).then(Client6.unwrap).catch(() => []);
+        const existingPaths = existing.map((item) => String(item.path)).sort((a, b) => a.localeCompare(b));
+        const initial = hasPathArg ? splitPath(path) : { dir: "", name: "" };
+        const directories = collectDirectories(existingPaths);
+        const dirOptions = [
+          {
+            label: "(new directory)",
+            value: NEW_DIRECTORY,
+            hint: "type custom path"
+          },
+          ...directories.map((dir2) => ({
+            label: dir2.length === 0 ? "(root)" : dir2,
+            value: dir2
+          }))
+        ];
+        const pickedDir = await prompts3.autocomplete({
+          message: "Select directory",
+          options: dirOptions,
+          placeholder: "Type to filter...",
+          maxItems: 16,
+          initialValue: directories.includes(initial.dir) ? initial.dir : NEW_DIRECTORY
+        });
+        if (prompts3.isCancel(pickedDir)) {
+          prompts3.outro("Cancelled");
+          return;
+        }
+        let dir = String(pickedDir);
+        if (dir === NEW_DIRECTORY) {
+          const enteredDir = await prompts3.text({
+            message: "Directory",
+            placeholder: "(root)",
+            initialValue: initial.dir,
+            validate: (s) => {
+              const value = String(s ?? "");
+              if (value.startsWith("/") || value.endsWith("/")) {
+                return "Do not start or end with '/'";
+              }
+              if (value.includes("\\"))
+                return "Use '/' as path separator";
+              return;
+            }
+          });
+          if (prompts3.isCancel(enteredDir)) {
+            prompts3.outro("Cancelled");
+            return;
+          }
+          dir = String(enteredDir);
+        }
+        const docName = await prompts3.text({
+          message: "Document name",
+          placeholder: "e.g. overview.md",
+          initialValue: initial.name,
+          validate: (s) => {
+            const name = String(s ?? "");
+            if (name.length === 0)
+              return "Document name is required";
+            if (name.includes("/") || name.includes("\\")) {
+              return "Use directory picker for folders";
+            }
+            return;
+          }
+        });
+        if (prompts3.isCancel(docName)) {
+          prompts3.outro("Cancelled");
+          return;
+        }
+        path = joinPath(dir, String(docName));
+        if (!hasTextArg) {
+          const entered = await prompts3.text({
+            message: "Note content",
+            placeholder: "Write note content",
+            validate: (s) => (s ?? "").length > 0 ? undefined : "Content is required"
+          });
+          if (prompts3.isCancel(entered)) {
+            prompts3.outro("Cancelled");
+            return;
+          }
+          content = String(entered);
+        }
+        const action = argv.update ? "Update" : "Add";
+        const confirmed = await prompts3.confirm({
+          message: `${action} ${theme2.primary(path)} in corpus ${theme2.primary(corpusName)}?`,
+          initialValue: true
+        });
+        if (prompts3.isCancel(confirmed) || !confirmed) {
+          prompts3.outro("Cancelled");
+          return;
+        }
+      }
+      if (path.length === 0) {
+        consola7.error("Path is required");
+        process.exit(1);
+      }
+      if (content.length === 0) {
+        consola7.error(`Note content cannot be empty: ${theme2.primary(path)}`);
+        process.exit(1);
+      }
+      let result;
+      try {
+        result = await submitNote({
+          client,
+          corpusName,
+          path,
+          content,
+          update: argv.update
+        });
+      } catch (error) {
+        const msg = error?.message ?? String(error);
+        const stack = error?.stack ? `
+${String(error.stack)}` : "";
+        consola7.error(`add submit failed: ${msg}${stack}`);
+        throw error;
+      }
+      if (result.action === "updated") {
+        consola7.success(`Updated note ${theme2.primary(result.info.path)} (id: ${result.info.id}, corpus: ${result.info.corpus})`);
+      } else {
+        consola7.success(`Added note ${theme2.primary(result.info.path)} (id: ${result.info.id}, corpus: ${result.info.corpus})`);
+      }
+      if (interactive) {
+        prompts3.outro("Done");
+      }
+    } finally {
+      keepAlive?.abort();
+    }
+  }
+};
+// src/spall/commands/commit.ts
+import consola8 from "consola";
+import { Client as Client7 } from "@spader/spall-sdk/client";
+import { defaultTheme as theme3 } from "@spader/spall-cli/shared";
+var commit = {
+  description: "Update note weights based on queries since last commit",
+  handler: async () => {
+    const client = await Client7.connect();
+    const res = await client.commit.run({ body: {} }).then(Client7.unwrap);
+    const moved = Number(res?.moved ?? 0);
+    if (moved === 0) {
+      consola8.info("No staged events to commit");
+      return;
+    }
+    consola8.success(`Committed ${theme3.primary(String(moved))} event(s)`);
+  }
+};
+// src/spall/commands/hook.ts
+import { hooks, supportedShells } from "@spader/spall-integration";
+var hook = {
+  description: "Print shell hook for completion support",
+  hidden: true,
+  positionals: {
+    shell: {
+      type: "string",
+      description: `Shell to generate hook for (${supportedShells.join(", ")})`,
+      required: true
+    }
+  },
+  handler: async (argv) => {
+    const shell = argv.shell;
+    if (!supportedShells.includes(shell)) {
+      console.error(`Unknown shell: ${shell}. Supported: ${supportedShells.join(", ")}`);
+      process.exit(1);
+    }
+    process.stdout.write(hooks[shell]);
+  }
+};
+// src/spall/commands/integrate/index.ts
+import * as prompts6 from "@clack/prompts";
+
+// src/spall/commands/integrate/shell.ts
+import { existsSync as existsSync2, readFileSync, appendFileSync } from "fs";
+import { homedir, platform } from "os";
+import { join } from "path";
+import * as prompts4 from "@clack/prompts";
+import { snippets } from "@spader/spall-integration";
+import { defaultTheme as theme4 } from "@spader/spall-cli/shared";
+var bash = {
+  label: "bash",
+  hint: "path completions, cli completions",
+  handler: () => shellIntegration("bash")
+};
+var zsh = {
+  label: "zsh",
+  hint: "path completions, cli completions",
+  handler: () => shellIntegration("zsh")
+};
+var SPALL_CANARY = "@spall_canary";
+var configs = {
+  bash: {
+    defaultRc: join(homedir(), platform() === "darwin" ? ".bash_profile" : ".bashrc")
+  },
+  zsh: {
+    defaultRc: join(homedir(), ".zshrc")
+  }
+};
+async function shellIntegration(shell) {
+  const cfg = configs[shell];
+  const snippet = snippets[shell];
+  const rcFile = await prompts4.text({
+    message: "Where should the hook be installed?",
+    initialValue: cfg.defaultRc,
+    validate: (s) => s && s.trim() ? undefined : "Required"
+  });
+  if (prompts4.isCancel(rcFile)) {
+    prompts4.cancel("Cancelled");
+    return;
+  }
+  const rc = String(rcFile).trim();
+  if (existsSync2(rc)) {
+    const contents = readFileSync(rc, "utf-8");
+    if (contents.includes(SPALL_CANARY)) {
+      prompts4.outro(`Hook is already installed in ${theme4.primary(rc)}`);
+      return;
+    }
+  }
+  appendFileSync(rc, `
+` + snippet);
+  prompts4.log.info(`Added hook to ${theme4.primary(rc)}`);
+  prompts4.note(`Run ${theme4.code(`source ${rc}`)} or restart your shell to activate
+
+Get completions for available commands:
+> ${theme4.code("spall")} <tab>
+
+Get completions for paths:
+> ${theme4.code("spall list ai-gateway/tutorials/")} <tab>
+ai-gateway/tutorials/create-first-aig-workers.mdx
+ai-gateway/tutorials/index.mdx
+ai-gateway/tutorials/deploy-aig-worker.mdx`);
+}
+
+// src/spall/commands/integrate/opencode.ts
+import * as prompts5 from "@clack/prompts";
+import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { homedir as homedir2 } from "os";
+import { dirname, join as join2, resolve } from "path";
+import { defaultTheme as theme5 } from "@spader/spall-cli/shared";
+var HELLO_PLUGIN_PKG = "@spader/spall-plugin-opencode";
+function configCandidates(dir) {
+  return [join2(dir, "opencode.jsonc"), join2(dir, "opencode.json")];
+}
+function pickExistingConfigPath(dir) {
+  for (const p of configCandidates(dir)) {
+    if (existsSync3(p))
+      return p;
+  }
+  return null;
+}
+function findOpencodeDir(startDir) {
+  let dir = resolve(startDir);
+  while (true) {
+    const candidate = join2(dir, ".opencode");
+    if (existsSync3(candidate))
+      return candidate;
+    const parent = dirname(dir);
+    if (parent === dir)
+      return null;
+    dir = parent;
+  }
+}
+var opencode = {
+  label: "opencode",
+  hint: "install an OpenCode plugin",
+  handler: async () => {
+    const scope = await prompts5.select({
+      message: "Install for",
+      options: [
+        {
+          value: "project",
+          label: "This project",
+          hint: "uses .opencode/plugins"
+        },
+        {
+          value: "global",
+          label: "Global",
+          hint: "uses ~/.config/opencode/plugins"
+        }
+      ]
+    });
+    if (prompts5.isCancel(scope)) {
+      prompts5.cancel("Cancelled");
+      return;
+    }
+    let configDir;
+    if (scope === "global") {
+      configDir = join2(homedir2(), ".config", "opencode");
+    } else {
+      const opencodeDir = findOpencodeDir(process.cwd());
+      if (!opencodeDir) {
+        prompts5.log.error(`No ${theme5.primary(".opencode")} directory found walking up from ${theme5.primary(process.cwd())}`);
+        prompts5.note(`Create one (or run OpenCode in this repo once), then re-run ${theme5.code("spall integrate opencode")}.`);
+        return;
+      }
+      configDir = opencodeDir;
+    }
+    const existingConfig = pickExistingConfigPath(configDir);
+    const configPath = existingConfig ?? join2(configDir, "opencode.jsonc");
+    if (!existsSync3(configPath)) {
+      const ok = await prompts5.confirm({
+        message: `Create ${theme5.primary(configPath)}?`,
+        initialValue: true
+      });
+      if (prompts5.isCancel(ok) || !ok) {
+        prompts5.cancel("Cancelled");
+        return;
+      }
+      mkdirSync(dirname(configPath), { recursive: true });
+      const initial = configPath.endsWith(".jsonc") ? `{
+  "$schema": "https://opencode.ai/config.json",
+  "plugin": ["${HELLO_PLUGIN_PKG}"]
+}
+` : JSON.stringify({
+        $schema: "https://opencode.ai/config.json",
+        plugin: [HELLO_PLUGIN_PKG]
+      }, null, 2) + `
+`;
+      writeFileSync(configPath, initial, "utf-8");
+      prompts5.outro(`Wrote ${theme5.primary(configPath)}`);
+      prompts5.note("Restart OpenCode to load the plugin.");
+      return;
+    }
+    const raw = readFileSync2(configPath, "utf-8");
+    if (raw.includes(HELLO_PLUGIN_PKG)) {
+      prompts5.outro(`Already configured in ${theme5.primary(configPath)}`);
+      return;
+    }
+    if (configPath.endsWith(".jsonc")) {
+      prompts5.log.warn(`Detected JSONC config at ${theme5.primary(configPath)}. Automatic editing is disabled to preserve formatting/comments.`);
+      prompts5.note(`Please add ${theme5.code(`"${HELLO_PLUGIN_PKG}"`)} to the ${theme5.code("plugin")} array in ${theme5.primary(configPath)}.`);
+      prompts5.note("Restart OpenCode to load the plugin.");
+      return;
+    }
+    let config;
+    try {
+      config = JSON.parse(raw);
+    } catch {
+      prompts5.log.error(`Failed to parse ${theme5.primary(configPath)} as JSON`);
+      return;
+    }
+    if (config == null || typeof config !== "object" || Array.isArray(config)) {
+      prompts5.log.error(`Unexpected config shape in ${theme5.primary(configPath)}`);
+      return;
+    }
+    const existing = config.plugin;
+    if (existing === undefined) {
+      config.plugin = [];
+    } else if (!Array.isArray(existing) || existing.some((x) => typeof x !== "string")) {
+      prompts5.log.error(`Expected ${theme5.primary("plugin")} to be an array of strings in ${theme5.primary(configPath)}`);
+      return;
+    }
+    if (!config.plugin.includes(HELLO_PLUGIN_PKG)) {
+      config.plugin.push(HELLO_PLUGIN_PKG);
+    }
+    if (!config.$schema) {
+      config.$schema = "https://opencode.ai/config.json";
+    }
+    writeFileSync(configPath, JSON.stringify(config, null, 2) + `
+`, "utf-8");
+    prompts5.outro(`Updated ${theme5.primary(configPath)}`);
+    prompts5.note("Restart OpenCode to load the plugin.");
+  }
+};
+
+// src/spall/commands/integrate/index.ts
+var integrations = {
+  bash,
+  zsh,
+  opencode
+};
+var integrate = {
+  description: "Set up integrations with third party tools",
+  handler: async () => {
+    prompts6.intro("Integrations");
+    const choice = await prompts6.select({
+      message: "Select a tool",
+      options: Object.entries(integrations).map(([key, cfg]) => ({
+        value: key,
+        hint: cfg.hint,
+        label: cfg.label
+      }))
+    });
+    if (prompts6.isCancel(choice)) {
+      prompts6.cancel("Cancelled");
+      return;
+    }
+    await integrations[choice].handler();
+  }
+};
+// src/spall/commands/serve.ts
+import { Config } from "@spader/spall-core/config";
+var serve = {
+  description: "Start the spall server",
+  options: {
+    kill: {
+      type: "boolean",
+      description: "Stop the running server (best-effort) and remove the lock file"
+    },
+    daemon: {
+      alias: "d",
+      type: "boolean",
+      description: "Do not stop after last client disconnects"
+    },
+    timeout: {
+      alias: "t",
+      type: "number",
+      description: "Seconds to wait after last client disconnects",
+      default: Config.get().server.idleTimeout
+    },
+    force: {
+      alias: "f",
+      type: "boolean",
+      description: "Kill existing server if running"
+    }
+  },
+  handler: async (argv) => {
+    if (argv.kill) {
+      const { Lock, checkHealth, isProcessAlive } = await import("@spader/spall-sdk/server");
+      const lock = Lock.read();
+      try {
+        let shutdownOk = false;
+        if (lock?.port != null) {
+          const controller = new AbortController;
+          const timeout = setTimeout(() => controller.abort(), 500);
+          try {
+            const res = await fetch(`http://127.0.0.1:${lock.port}/shutdown`, {
+              method: "POST",
+              signal: controller.signal
+            });
+            shutdownOk = res.ok;
+          } catch {} finally {
+            clearTimeout(timeout);
+          }
+        }
+        if (shutdownOk) {
+          const start = Date.now();
+          while (Date.now() - start < 1000) {
+            if (lock?.pid != null && !isProcessAlive(lock.pid)) {
+              return;
+            }
+            if (lock?.port != null && !await checkHealth(lock.port)) {
+              return;
+            }
+            await Bun.sleep(50);
+          }
+        }
+        if (lock?.pid != null) {
+          try {
+            process.kill(lock.pid, "SIGTERM");
+          } catch {}
+        }
+      } finally {
+        Lock.remove();
+      }
+      return;
+    }
+    const { Server } = await import("@spader/spall-sdk/server");
+    const { port, stopped } = await Server.start({
+      persist: argv.daemon,
+      idleTimeoutMs: argv.timeout * 1000,
+      force: argv.force
+    });
+    await stopped;
+  }
+};
+// src/spall/commands/get.ts
+import { Client as Client8 } from "@spader/spall-sdk/client";
+import {
+  createQuery,
+  displayResults
+} from "@spader/spall-cli/shared";
+var get = {
+  description: "Get note(s) by path or glob",
+  positionals: {
+    path: {
+      type: "string",
+      description: "Path or glob to notes",
+      required: true
+    }
+  },
+  options: {
+    corpus: {
+      alias: "c",
+      type: "string",
+      description: "Corpus name"
+    },
+    max: {
+      alias: "n",
+      type: "number",
+      description: "Maximum number of notes to return"
+    },
+    output: {
+      alias: "o",
+      type: "string",
+      description: "Output format: list, tree, table, json"
+    },
+    all: {
+      alias: "a",
+      type: "boolean",
+      description: "Print all results without limiting output"
+    }
+  },
+  handler: async (argv) => {
+    const client = await Client8.connect();
+    const { query } = await createQuery({
+      client,
+      corpus: argv.corpus,
+      tracked: false
+    });
+    const output = argv.output ?? (argv.path === "*" ? "tree" : "list");
+    const showAll = argv.all === true;
+    const notes = [];
+    let cursor = undefined;
+    const termRows = process.stdout.rows ?? 24;
+    const displayRows = showAll || output === "json" ? Infinity : Math.max(1, termRows - (output === "table" ? 4 : 3));
+    const fetchLimit = Math.min(argv.max ?? Infinity, displayRows + 1);
+    while (notes.length < fetchLimit) {
+      const page = await client.query.notes({
+        id: String(query.id),
+        path: argv.path,
+        limit: Math.min(100, fetchLimit - notes.length),
+        after: cursor
+      }).then(Client8.unwrap);
+      notes.push(...page.notes);
+      if (!page.nextCursor)
+        break;
+      cursor = page.nextCursor;
+    }
+    displayResults(notes, {
+      output,
+      showAll,
+      empty: "(no notes matching pattern)",
+      path: (n) => n.path,
+      id: (n) => String(n.id),
+      preview: (n) => n.content
+    });
+  }
+};
+// src/spall/commands/list.ts
+import {
+  defaultTheme,
+  List,
+  noteDirEntries,
+  noteTreeEntries
+} from "@spader/spall-cli/shared";
+var list = {
+  description: "List note paths as a tree",
+  positionals: List.positionals,
+  options: {
+    ...List.options,
+    completion: {
+      type: "boolean",
+      description: "Output bare paths for shell completion"
+    }
+  },
+  handler: async (argv) => {
+    const theme6 = defaultTheme;
+    const rawInput = String(argv.path ?? "*");
+    const isCompletion = Boolean(argv.completion);
+    const { notes, located, includeNames } = await List.run({
+      path: rawInput,
+      corpus: argv.corpus,
+      tracked: false,
+      completion: isCompletion
+    });
+    if (isCompletion) {
+      printCompletions(notes.map((n) => n.path), rawInput);
+      return;
+    }
+    if (notes.length === 0) {
+      console.log("(no notes found)");
+      if (!located && includeNames.length === 1 && includeNames[0] === "default") {
+        console.log(`hint: no workspace found, only searched default corpus. run ${theme6.code("spall status")} to check workspace scope, or ${theme6.code("spall workspace init")} to create a workspace)`);
+      }
+      return;
+    }
+    const showAll = Boolean(argv.all);
+    const maxDepth = showAll ? List.parseDepth(argv.depth ?? "max") : List.parseDepth(argv.depth);
+    const entries = showAll ? noteTreeEntries(notes, maxDepth) : noteDirEntries(notes, maxDepth);
+    for (const e of entries) {
+      const indent = "  ".repeat(e.depth);
+      if (e.type === "dir") {
+        const suffix = typeof e.noteCount === "number" ? theme6.dim(` (${e.noteCount} note${e.noteCount === 1 ? "" : "s"})`) : "";
+        console.log(`${indent}${e.name}${suffix}`);
+      } else {
+        console.log(`${theme6.dim(indent)}${e.name}${theme6.dim(` (id: ${e.id})`)}`);
+      }
+    }
+  }
+};
+function printCompletions(paths, rawInput) {
+  const lastSlash = rawInput.lastIndexOf("/");
+  const prefix = lastSlash >= 0 ? rawInput.slice(0, lastSlash + 1) : "";
+  const seen = new Set;
+  for (const p of paths) {
+    if (prefix && !p.startsWith(prefix))
+      continue;
+    const rest = p.slice(prefix.length);
+    const slash = rest.indexOf("/");
+    if (slash >= 0) {
+      const dir = prefix + rest.slice(0, slash + 1);
+      if (!seen.has(dir)) {
+        seen.add(dir);
+        console.log(dir);
+      }
+    } else {
+      if (!seen.has(p)) {
+        seen.add(p);
+        console.log(p);
+      }
+    }
+  }
+}
+// src/spall/commands/search.ts
+import consola9 from "consola";
+import {
+  defaultTheme as theme6,
+  displayResults as displayResults2,
+  highlightSnippet,
+  Search
+} from "@spader/spall-cli/shared";
+var search = {
+  description: `Full text keyword ${theme6.search()} against note content`,
+  positionals: Search.positionals,
+  options: {
+    output: {
+      alias: "o",
+      type: "string",
+      description: "Output format (table, json, tree, list)",
+      default: "table"
+    },
+    ...Search.options,
+    mode: {
+      alias: "m",
+      type: "string",
+      description: "Query mode (plain, fts)",
+      default: "plain"
+    }
+  },
+  handler: async (argv) => {
+    const mode = String(argv.mode ?? "plain");
+    if (mode !== "plain" && mode !== "fts") {
+      consola9.error(`Invalid mode: ${theme6.primary(String(argv.mode))}`);
+      consola9.info(`Use ${theme6.option("--mode")} plain | fts`);
+      process.exit(1);
+    }
+    const out = String(argv.output ?? "table");
+    const { results } = await Search.run({
+      query: argv.query,
+      corpus: argv.corpus,
+      path: argv.path,
+      limit: argv.limit,
+      tracked: false,
+      mode
+    });
+    displayResults2(results, {
+      output: out,
+      empty: "(no matches)",
+      path: (r) => r.path,
+      id: (r) => String(r.id),
+      preview: (r) => r.snippet,
+      previewFormat: highlightSnippet,
+      extraColumns: [
+        {
+          header: "score",
+          value: (r) => r.score.toFixed(3),
+          flex: 0,
+          noTruncate: true,
+          format: (s) => theme6.code(s)
+        }
+      ]
+    });
+  }
+};
+// src/spall/commands/sync.ts
+import pc3 from "picocolors";
+import consola10 from "consola";
+import { existsSync as existsSync4, statSync } from "fs";
+import { basename as basename2, resolve as resolve2 } from "path";
+import * as prompts7 from "@clack/prompts";
+var {Glob } = globalThis.Bun;
+import { Client as Client9 } from "@spader/spall-sdk/client";
+import {
+  defaultTheme as theme7,
+  createModelProgressHandler as createModelProgressHandler2
+} from "@spader/spall-cli/shared";
+function keepServerAlive2(client, signal) {
+  (async () => {
+    try {
+      const { stream } = await client.events({ signal });
+      for await (const _ev of stream) {}
+    } catch {}
+  })();
+}
+function canonicalize(path) {
+  let p = path.replace(/\\/g, "/");
+  p = p.replace(/\/+$/, "");
+  p = p.replace(/^\.\//, "");
+  p = p.replace(/^\//, "");
+  p = p.replace(/\/+/g, "/");
+  if (p === ".")
+    return "";
+  return p;
+}
+async function countFiles(dir, globPattern) {
+  const glob = new Glob(globPattern);
+  let count = 0;
+  let first = null;
+  for await (const file of glob.scan({ cwd: dir, absolute: false })) {
+    count++;
+    if (!first)
+      first = file;
+  }
+  return { count, first };
+}
+async function extensionCounts(dir) {
+  const glob = new Glob("**/*");
+  const counts = new Map;
+  for await (const file of glob.scan({ cwd: dir, absolute: false })) {
+    const base = file.split("/").pop() ?? file;
+    const dot = base.lastIndexOf(".");
+    if (dot <= 0 || dot === base.length - 1)
+      continue;
+    const ext = base.slice(dot + 1);
+    counts.set(ext, (counts.get(ext) ?? 0) + 1);
+  }
+  return counts;
+}
+function pickDefaultMask(counts) {
+  let bestExt = null;
+  let bestCount = 0;
+  for (const [ext, count] of counts) {
+    if (count > bestCount) {
+      bestExt = ext;
+      bestCount = count;
+    }
+  }
+  return bestExt ? `*.${bestExt}` : "*";
+}
+var sync = {
+  description: "Sync a directory under a path in a corpus",
+  positionals: {
+    dir: {
+      type: "string",
+      description: "Directory to scan, recursively",
+      required: true
+    }
+  },
+  options: {
+    glob: {
+      alias: "g",
+      type: "string",
+      description: "Glob pattern to match (default: **/*.md)"
+    },
+    mask: {
+      alias: "m",
+      type: "string",
+      description: "File mask to match (default: *.md)"
+    },
+    corpus: {
+      alias: "c",
+      type: "string",
+      description: "Corpus name",
+      default: "default"
+    },
+    path: {
+      alias: "p",
+      type: "string",
+      description: "Destination path prefix in corpus"
+    },
+    interactive: {
+      type: "boolean",
+      description: "Enable interactive prompts (use --no-interactive to disable)",
+      default: true
+    }
+  },
+  handler: async (argv) => {
+    let onSigint = null;
+    const controller = new AbortController;
+    try {
+      const inputDir = argv.dir;
+      const dir = resolve2(inputDir);
+      if (!existsSync4(dir) || !statSync(dir).isDirectory()) {
+        consola10.error(`Not a directory: ${theme7.primary(inputDir)}`);
+        process.exit(1);
+      }
+      let interrupted = false;
+      onSigint = () => {
+        if (interrupted)
+          process.exit(130);
+        interrupted = true;
+        controller.abort();
+        process.exit(130);
+      };
+      process.on("SIGINT", onSigint);
+      const client = await Client9.connect(controller.signal);
+      keepServerAlive2(client, controller.signal);
+      const interactive = argv.interactive !== false && process.stdin.isTTY && process.stdout.isTTY;
+      const corpora = await client.corpus.list().then(Client9.unwrap);
+      const corpusOptions = corpora.map((c) => {
+        const name = c.name;
+        const noteCount = typeof c.noteCount === "number" ? c.noteCount : null;
+        return {
+          label: name,
+          value: name,
+          hint: noteCount == null ? undefined : `${noteCount} notes`
+        };
+      }).sort((a, b) => a.label.localeCompare(b.label));
+      const CREATE = "__create_corpus__";
+      const corpusPickerOptions = [
+        ...corpusOptions,
+        { label: "Create new corpus...", value: CREATE, hint: "new" }
+      ];
+      const defaultCorpusName = String(argv.corpus ?? "default");
+      const initialCorpus = corpusOptions.some((o) => o.value === defaultCorpusName) ? defaultCorpusName : corpusOptions[0]?.value;
+      const cliPath = typeof argv.path === "string" ? argv.path : "";
+      const cliGlob = typeof argv.glob === "string" ? argv.glob : undefined;
+      const cliMask = typeof argv.mask === "string" ? argv.mask : undefined;
+      let corpusName = initialCorpus ?? "default";
+      const defaultDestPrefix = cliPath || basename2(inputDir) || inputDir;
+      let destPrefix = defaultDestPrefix;
+      let mask = cliMask ?? (cliGlob ? cliGlob.replace(/^\*\*\//, "") : "");
+      if (!mask) {
+        const counts = await extensionCounts(dir);
+        mask = pickDefaultMask(counts);
+      }
+      if (interactive) {
+        prompts7.intro(`${theme7.dim("spall")} ${theme7.primary("sync")}`);
+        const pickedCorpus = await prompts7.autocomplete({
+          message: "Select a corpus",
+          options: corpusPickerOptions,
+          placeholder: "Type to filter...",
+          maxItems: 12,
+          initialValue: corpusName
+        });
+        if (prompts7.isCancel(pickedCorpus)) {
+          controller.abort();
+          prompts7.outro("Cancelled");
+          return;
+        }
+        if (String(pickedCorpus) === CREATE) {
+          const name = await prompts7.text({
+            message: "New corpus name",
+            initialValue: basename2(inputDir) || "docs",
+            validate: (s) => s && s.trim().length > 0 ? undefined : "Required"
+          });
+          if (prompts7.isCancel(name)) {
+            controller.abort();
+            prompts7.outro("Cancelled");
+            return;
+          }
+          corpusName = String(name).trim();
+          await client.corpus.create({ name: corpusName }).then(Client9.unwrap);
+        } else {
+          corpusName = String(pickedCorpus);
+        }
+        const pickedPath = await prompts7.text({
+          message: "Destination path prefix",
+          placeholder: "(e.g. ai-gateway)",
+          initialValue: destPrefix
+        });
+        if (prompts7.isCancel(pickedPath)) {
+          controller.abort();
+          prompts7.outro("Cancelled");
+          return;
+        }
+        destPrefix = String(pickedPath ?? "");
+        const pickedMask = await prompts7.text({
+          message: "File mask",
+          placeholder: "(e.g. *.mdx)",
+          initialValue: mask
+        });
+        if (prompts7.isCancel(pickedMask)) {
+          controller.abort();
+          prompts7.outro("Cancelled");
+          return;
+        }
+        mask = String(pickedMask ?? "");
+      }
+      const corpus2 = await client.corpus.get({ name: corpusName }).catch(() => {
+        consola10.error(`Corpus not found: ${theme7.command(String(corpusName))}`);
+        process.exit(1);
+      }).then(Client9.unwrap);
+      const globPattern = cliGlob ?? `**/${mask || "*.md"}`;
+      const { count: fileCount, first: firstFile } = await countFiles(dir, globPattern);
+      if (interactive) {
+        const prefixLabel = canonicalize(destPrefix) || "(root)";
+        const msg = `Syncing ${theme7.code(String(fileCount))} files under ${theme7.dim(prefixLabel)}${theme7.dim("/")} in corpus ${theme7.primary(corpusName)}`;
+        const ok = await prompts7.confirm({ message: msg, initialValue: true });
+        if (prompts7.isCancel(ok) || ok === false) {
+          controller.abort();
+          prompts7.outro("Cancelled");
+          return;
+        }
+      }
+      const handleModelEvent = (() => {
+        const base = createModelProgressHandler2();
+        return (event) => {
+          switch (event?.tag) {
+            case "model.load":
+              prompts7.log.info(`Loading model ${theme7.primary(event.info.name)}`);
+              return;
+            case "model.download":
+              prompts7.log.info(`Downloading model ${theme7.primary(event.info.name)}`);
+              return;
+            case "model.downloaded":
+              prompts7.log.success(`Downloaded ${theme7.primary(event.info.name)}`);
+              return;
+            case "model.progress":
+              return;
+            default:
+              return base(event);
+          }
+        };
+      })();
+      let scanTotal = 0;
+      let scanProcessed = 0;
+      let scanProgress = null;
+      let embedTotalBytes = 0;
+      let embedTotalFiles = 0;
+      let embedStartTime = 0;
+      let embedBytesProcessed = 0;
+      let embedProgress = null;
+      let ftsSpinner = null;
+      let ftsActive = false;
+      const { stream } = await client.sse.note.sync({
+        directory: dir,
+        glob: globPattern,
+        corpus: corpus2.id,
+        path: destPrefix
+      }, { signal: controller.signal });
+      for await (const event of stream) {
+        if (event?.tag === "error") {
+          const e = event.error;
+          const msg = e?.message ?? String(e ?? "unknown error");
+          const code = e?.code ? `${e.code}: ` : "";
+          consola10.error(code + msg);
+          process.exit(1);
+        }
+        handleModelEvent(event);
+        switch (event?.tag) {
+          case "scan.start":
+            scanTotal = event.numFiles;
+            scanProgress = prompts7.progress({
+              max: Math.max(1, scanTotal),
+              indicator: "timer"
+            });
+            scanProgress.start(`Scanning ${theme7.primary(dir)} (${theme7.primary(String(scanTotal))} files)`);
+            break;
+          case "scan.progress": {
+            scanProcessed++;
+            scanProgress?.advance(1, `Scanning ${scanProcessed}/${scanTotal}`);
+            break;
+          }
+          case "scan.done":
+            scanProgress?.stop(`Scan done (added: ${event.added}, modified: ${event.modified}, removed: ${event.removed}, ok: ${event.ok})`);
+            scanProgress = null;
+            break;
+          case "embed.start":
+            embedTotalFiles = event.numFiles;
+            embedTotalBytes = event.numBytes;
+            embedStartTime = performance.now();
+            embedBytesProcessed = 0;
+            const sizeStr = embedTotalBytes >= 1024 * 1024 ? `${(embedTotalBytes / (1024 * 1024)).toFixed(1)} MB` : embedTotalBytes >= 1024 ? `${(embedTotalBytes / 1024).toFixed(1)} KB` : `${embedTotalBytes} B`;
+            embedProgress = prompts7.progress({
+              max: Math.max(1, embedTotalBytes),
+              indicator: "timer"
+            });
+            embedProgress.start(`Embedding ${event.numChunks} chunks from ${event.numFiles} files ${pc3.dim(`(${sizeStr})`)}`);
+            break;
+          case "embed.progress": {
+            const delta = Math.max(0, event.numBytesProcessed - embedBytesProcessed);
+            embedBytesProcessed = event.numBytesProcessed;
+            const percent = embedTotalBytes ? event.numBytesProcessed / embedTotalBytes * 100 : 0;
+            const percentStr = percent.toFixed(0).padStart(3);
+            const elapsed = (performance.now() - embedStartTime) / 1000;
+            const bps = elapsed > 0 ? event.numBytesProcessed / elapsed : 0;
+            const bpsStr = bps >= 1024 * 1024 ? `${(bps / (1024 * 1024)).toFixed(1)} MB/s` : bps >= 1024 ? `${(bps / 1024).toFixed(1)} KB/s` : `${bps.toFixed(0)} B/s`;
+            embedProgress?.advance(delta, `${pc3.bold(percentStr + "%")} ${event.numFilesProcessed}/${embedTotalFiles} ${pc3.dim(`(${bpsStr})`)}`);
+            break;
+          }
+          case "embed.cancel": {
+            embedProgress?.stop(`CANCELLED ${event.numFilesProcessed}/${embedTotalFiles}`);
+            embedProgress = null;
+            prompts7.log.warn("Index cancelled");
+            break;
+          }
+          case "embed.done":
+            embedProgress?.stop("Index complete");
+            embedProgress = null;
+            break;
+          case "fts.start":
+            ftsActive = true;
+            ftsSpinner = prompts7.spinner({ indicator: "timer" });
+            ftsSpinner.start("Indexing text (FTS)");
+            break;
+          case "fts.done":
+            if (ftsActive) {
+              ftsActive = false;
+              ftsSpinner?.stop("FTS index updated");
+              ftsSpinner = null;
+            }
+            break;
+        }
+      }
+      if (onSigint)
+        process.off("SIGINT", onSigint);
+    } catch (e) {
+      if (onSigint)
+        process.off("SIGINT", onSigint);
+      const msg = e?.message ?? String(e ?? "Unknown error");
+      if (process.stdin.isTTY && process.stdout.isTTY) {
+        prompts7.log.error(msg);
+        prompts7.outro("Done");
+      } else {
+        consola10.error(msg);
+      }
+      process.exit(1);
+    } finally {
+      controller.abort();
+    }
+  }
+};
+// src/spall/commands/tui.ts
+import { db } from "@spader/spall-tui/store";
+var tui = {
+  description: "Launch the interactive TUI",
+  handler: async () => {
+    db.init();
+    await import("@opentui/solid/preload");
+    const { tui: tui2 } = await import("@spader/spall-tui/app");
+    await tui2({ repoPath: process.cwd() });
+  }
+};
+// src/spall/commands/vsearch.ts
+import { displayResults as displayResults3, Vsearch } from "@spader/spall-cli/shared";
+function rgb(r, g, b) {
+  return (s) => `\x1B[38;2;${r};${g};${b}m${s}\x1B[39m`;
+}
+function hsvToRgb(h, s, v) {
+  const c = v * s;
+  const x = c * (1 - Math.abs(h / 60 % 2 - 1));
+  const m = v - c;
+  let r = 0, g = 0, b = 0;
+  if (h < 60)
+    [r, g, b] = [c, x, 0];
+  else if (h < 120)
+    [r, g, b] = [x, c, 0];
+  else if (h < 180)
+    [r, g, b] = [0, c, x];
+  else if (h < 240)
+    [r, g, b] = [0, x, c];
+  else if (h < 300)
+    [r, g, b] = [x, 0, c];
+  else
+    [r, g, b] = [c, 0, x];
+  return [
+    Math.round((r + m) * 255),
+    Math.round((g + m) * 255),
+    Math.round((b + m) * 255)
+  ];
+}
+function heatColor(score) {
+  const shifted = (score - 0.5) / 0.35;
+  const t = Math.max(0, Math.min(1, shifted));
+  const sat = t * t;
+  const [r, g, b] = hsvToRgb(140, sat, 0.85);
+  return rgb(r, g, b);
+}
+var vsearch = {
+  summary: Vsearch.summary,
+  description: Vsearch.description("spall"),
+  positionals: Vsearch.positionals,
+  options: {
+    ...Vsearch.options,
+    output: {
+      alias: "o",
+      type: "string",
+      description: "Output format: table | json | tree | list",
+      default: "table"
+    }
+  },
+  handler: async (argv) => {
+    const out = String(argv.output ?? "table");
+    const { results } = await Vsearch.run({
+      query: argv.query,
+      corpus: argv.corpus,
+      path: argv.path,
+      limit: argv.limit,
+      tracked: false
+    });
+    const scoreMap = new Map(results.map((r, i) => [i, r.score]));
+    displayResults3(results, {
+      output: out,
+      empty: "(no matches)",
+      path: (r) => r.path,
+      id: (r) => String(r.id),
+      preview: (r) => Vsearch.collapseWhitespace(r.chunk),
+      extraColumns: [
+        {
+          header: "score",
+          value: (r) => r.score.toFixed(3),
+          flex: 0,
+          noTruncate: true,
+          format: (s, row) => heatColor(scoreMap.get(row) ?? 0)(s)
+        }
+      ]
+    });
+  }
+};
+// src/spall/commands/status.ts
+import consola11 from "consola";
+import { Status } from "@spader/spall-cli/shared";
+var status = {
+  summary: Status.summary,
+  description: Status.description,
+  handler: async () => {
+    const result = await Status.run();
+    if ("error" in result) {
+      consola11.error("Failed to list corpora:", result.error);
+      process.exit(1);
+    }
+    Status.print(result, { highlightWorkspace: true });
+  }
+};
+// src/spall/index.ts
+var cliDef = {
+  name: "spall",
+  description: "Fast, local, searchable memory for LLMs and humans",
+  commands: {
+    workspace,
+    add: add2,
+    get,
+    list,
+    status,
+    search,
+    vsearch,
+    sync,
+    commit,
+    integrate,
+    corpus,
+    serve,
+    tui,
+    hook
+  }
+};
+setActiveCli(cliDef);
+build(cliDef).parse();
+
+//# debugId=851406C8532EA36164756E2164756E21