@visual-z/xeno 0.8.4 → 0.9.0

package/src/store/worktree.ts

@@ -1,278 +0,0 @@
-/**
- * Git worktree isolation for branches that write.
- *
- * A worktree is a second checkout sharing one object database, which is why
- * it is the isolation primitive parallel agents converged on: each branch
- * edits its own files, and conflicts surface at merge time through ordinary
- * git tooling instead of as silent overwrites during the work.
- *
- * What this does NOT isolate, stated because assuming otherwise is how these
- * setups break:
- *
- *   ENVIRONMENT. Ports, databases, and anything else outside the working
- *   directory are still shared. Two branches running a dev server or a
- *   migration will collide, and a test can fail because a sibling took the
- *   port rather than because the branch is wrong. That needs containers.
- *
- *   ESCAPE. A branch can point git back at the shared checkout with `git -C`
- *   or GIT_DIR, which has been an actual reported escape. Preventing it is a
- *   sandbox's job, and this project has no sandbox layer; the isolation here
- *   is for cooperative branches, not adversarial ones.
- */
-
-import { mkdir, mkdtemp, rm, realpath } from "node:fs/promises";
-import { existsSync } from "node:fs";
-import { createHash } from "node:crypto";
-import { basename, join } from "node:path";
-import { tmpdir } from "node:os";
-
-/** Branch prefix, so a stale worktree is identifiable months later. */
-export const WORKTREE_BRANCH_PREFIX = "xeno/";
-
-export interface WorktreeInfo {
-  path: string;
-  branch: string | null;
-  locked: boolean;
-}
-
-export type CreateResult =
-  | { ok: true; path: string; branch: string; snapshot: { head: string; tree: string } }
-  | { ok: false; error: string };
-
-export interface CreateOptions {
-  /**
-   * Where the checkout goes. Default: a fresh temp directory, which suits a
-   * writing branch that lives for one subtask. A model-entered worktree is
-   * kept across sessions, so it names a stable parent and its own leaf.
-   */
-  location?: { parent: string; leaf: string };
-  /** Carry the parent's uncommitted files (default, as a branch needs). */
-  includeChanges?: boolean;
-}
-
-/**
- * The stable home of model-entered worktrees for one repository.
- *
- * Under xeno's config directory rather than the project: inside `.xeno` it
- * would collide with the rule that session state is never edited, and a
- * sibling directory leaves xeno's checkouts in the user's project tree (Codex
- * keeps its worktrees under its own home for the same reason). The digest of
- * the repository path keeps two clones with the same name apart.
- */
-export function persistentWorktreeParent(configDir: string, repo: string): string {
-  const digest = createHash("sha256").update(repo).digest("hex").slice(0, 8);
-  return join(configDir, "worktrees", `${basename(repo)}-${digest}`);
-}
-
-/** The repository's main checkout: `git worktree list` always lists it first. */
-export async function mainWorktree(dir: string): Promise<string | null> {
-  const listed = await listWorktrees(dir).catch(() => []);
-  return listed[0]?.path ?? null;
-}
-
-export type RemoveResult =
-  | { ok: true }
-  | { ok: false; error: string; dirty: boolean };
-
-interface GitRun {
-  code: number;
-  stdout: string;
-  stderr: string;
-}
-
-function git(cwd: string, args: string[], env?: Record<string, string | undefined>): GitRun {
-  const p = Bun.spawnSync(["git", ...args], { cwd, ...(env ? { env } : {}) });
-  const dec = new TextDecoder();
-  return {
-    code: p.exitCode,
-    stdout: dec.decode(p.stdout),
-    stderr: dec.decode(p.stderr),
-  };
-}
-
-export async function isGitRepo(dir: string): Promise<boolean> {
-  return git(dir, ["rev-parse", "--git-dir"]).code === 0;
-}
-
-export async function createWorktree(repo: string, name: string, options: CreateOptions = {}): Promise<CreateResult> {
-  // Refused rather than degraded. Falling back to the shared directory is the
-  // exact failure isolation exists to prevent: parallel writing branches
-  // would overwrite each other with nothing to indicate isolation was never
-  // in place.
-  if (!(await isGitRepo(repo))) {
-    return {
-      ok: false,
-      error:
-        `${repo} is not a git repository, so a writing branch cannot be isolated. ` +
-        "Initialise one, or run the branch read-only.",
-    };
-  }
-
-  // O.4: snapshot the working copy through a private index. Never stash, reset,
-  // or stage the user's index merely to construct a child input.
-  const root = git(repo, ["rev-parse", "--show-toplevel"]);
-  if (root.code !== 0 || await realpath(repo) !== await realpath(root.stdout.trim())) {
-    return { ok: false, error: "writing branch input must be the repository root" };
-  }
-  const head = git(repo, ["rev-parse", "--verify", "HEAD"]);
-  if (head.code !== 0) return { ok: false, error: "writing branch input requires an existing HEAD commit" };
-  const unmerged = git(repo, ["ls-files", "--unmerged"]);
-  if (unmerged.code !== 0 || unmerged.stdout.length > 0) return { ok: false, error: "resolve index conflicts before creating a writing branch" };
-  const staged = git(repo, ["ls-files", "--stage", "-z"]);
-  if (staged.code !== 0 || staged.stdout.split("\0").some(entry => entry.startsWith("160000 "))) {
-    return { ok: false, error: "writing branch snapshots do not yet support submodules" };
-  }
-  const scratch = await mkdtemp(join(tmpdir(), "xeno-input-index-"));
-  let tree: string;
-  try {
-    const env = { ...process.env, GIT_INDEX_FILE: join(scratch, "index") };
-    for (const args of [["read-tree", head.stdout.trim()], ["add", "--all", "--", "."]]) {
-      const result = git(repo, args, env);
-      if (result.code !== 0) return { ok: false, error: `cannot capture branch input: ${result.stderr.trim()}` };
-    }
-    const captured = git(repo, ["ls-files", "--stage", "-z"], env);
-    if (captured.code !== 0 || captured.stdout.split("\0").some(entry => entry.startsWith("160000 "))) {
-      return { ok: false, error: "writing branch snapshots do not yet support nested repositories or submodules" };
-    }
-    const written = git(repo, ["write-tree"], env);
-    if (written.code !== 0) return { ok: false, error: `cannot capture branch input tree: ${written.stderr.trim()}` };
-    tree = written.stdout.trim();
-  } finally { await rm(scratch, { recursive: true, force: true }); }
-
-  const branch = `${WORKTREE_BRANCH_PREFIX}${name}`;
-  if (git(repo, ["rev-parse", "--verify", "--quiet", `refs/heads/${branch}`]).code === 0) {
-    return { ok: false, error: `branch ${branch} already exists; choose another name or work in its existing checkout` };
-  }
-  let path: string;
-  if (options.location) {
-    await mkdir(options.location.parent, { recursive: true });
-    // Resolved for the same reason as the temp path below.
-    path = join(await realpath(options.location.parent), options.location.leaf);
-    if (existsSync(path)) return { ok: false, error: `${path} already exists; choose another name` };
-  } else {
-    const created = await mkdtemp(join(tmpdir(), `xeno-wt-${name}-`));
-    // Resolved through symlinks, because git reports the real path and a
-    // caller comparing the two would never match. On macOS /var is a symlink
-    // to /private/var, so every temp path differs by default.
-    path = await realpath(created);
-    // mkdtemp created it; git worktree add needs the path not to exist.
-    await rm(path, { recursive: true, force: true });
-  }
-
-  // --lock in the same call: locking afterwards leaves a window in which a
-  // concurrent prune can remove the worktree that was just created.
-  const add = git(repo, ["worktree", "add", "--lock", "-b", branch, path, head.stdout.trim()]);
-  if (add.code !== 0) {
-    return { ok: false, error: `git worktree add failed: ${add.stderr.trim()}` };
-  }
-  if (options.includeChanges === false) return { ok: true, path, branch, snapshot: { head: head.stdout.trim(), tree: git(path, ["rev-parse", "HEAD^{tree}"]).stdout.trim() } };
-  // Only this freshly created disposable checkout is reset. The child index
-  // carries the parent's uncommitted input, so normal diff/inspection still sees it.
-  const hydrate = git(path, ["read-tree", "--reset", "-u", tree]);
-  if (hydrate.code !== 0) {
-    const removed = await removeWorktree(repo, path, branch, { force: true });
-    return { ok: false, error: `cannot materialize branch input: ${hydrate.stderr.trim()}` +
-      (removed.ok ? "" : `; cleanup required at ${path}: ${removed.error}`) };
-  }
-  return { ok: true, path, branch, snapshot: { head: head.stdout.trim(), tree } };
-}
-
-/**
- * Parses `--porcelain -z`, the only output format documented as stable
- * across git versions and user configuration. `-z` additionally survives a
- * path containing a newline, which a line-based parse would split into two
- * bogus entries.
- */
-export async function listWorktrees(repo: string): Promise<WorktreeInfo[]> {
-  const out = git(repo, ["worktree", "list", "--porcelain", "-z"]);
-  if (out.code !== 0) return [];
-
-  const worktrees: WorktreeInfo[] = [];
-  let current: Partial<WorktreeInfo> = {};
-  for (const record of out.stdout.split("\0")) {
-    if (record === "") {
-      // A blank record terminates one worktree's attributes.
-      if (current.path) {
-        worktrees.push({
-          path: current.path,
-          branch: current.branch ?? null,
-          locked: current.locked ?? false,
-        });
-      }
-      current = {};
-      continue;
-    }
-    const [key, ...rest] = record.split(" ");
-    const value = rest.join(" ");
-    if (key === "worktree") current.path = value;
-    else if (key === "branch") current.branch = value.replace(/^refs\/heads\//, "");
-    else if (key === "locked") current.locked = true;
-  }
-  if (current.path) {
-    worktrees.push({
-      path: current.path,
-      branch: current.branch ?? null,
-      locked: current.locked ?? false,
-    });
-  }
-  return worktrees;
-}
-
-/**
- * Removes a worktree, its registration and its branch.
- *
- * A dirty worktree is reported rather than forced. The refusal is evidence
- * to look at: uncommitted changes there may be exactly the work the branch
- * was for, and discarding them silently is the destructive-restore mistake
- * in a different costume. `force` exists for a caller that has decided.
- */
-export async function removeWorktree(
-  repo: string,
-  path: string,
-  branch: string | null,
-  opts: { force?: boolean } = {},
-): Promise<RemoveResult> {
-  // Created with --lock, so unlock first; a locked worktree otherwise needs
-  // --force twice, which would conflate "locked" with "dirty".
-  git(repo, ["worktree", "unlock", path]);
-
-  const args = ["worktree", "remove", path];
-  if (opts.force) args.push("--force");
-  const removed = git(repo, args);
-
-  if (removed.code !== 0) {
-    const dirty = /contains modified or untracked files|is dirty/i.test(removed.stderr);
-    return {
-      ok: false,
-      error: dirty
-        ? `${path} has uncommitted changes. Inspect them before removing, ` +
-          "or pass force to discard them."
-        : `git worktree remove failed: ${removed.stderr.trim()}`,
-      dirty,
-    };
-  }
-
-  // Removing a worktree never deletes its branch, so a run of branches would
-  // otherwise leave a branch behind for every one of them.
-  if (branch) git(repo, ["branch", "-D", branch]);
-  return { ok: true };
-}
-
-/**
- * Clears registrations left behind by hand-deleted directories.
- *
- * Only for that case. A worktree that was MOVED must be repaired instead --
- * pruning it discards a working directory that still exists.
- */
-export async function pruneWorktrees(repo: string): Promise<void> {
-  // A lock exists to stop pruning, and createWorktree takes one -- so a
-  // hand-deleted worktree of ours would stay registered forever without
-  // unlocking first. Only ours: the prefix check keeps this from unlocking
-  // a worktree someone locked deliberately.
-  for (const wt of await listWorktrees(repo)) {
-    if (wt.locked && wt.branch?.startsWith(WORKTREE_BRANCH_PREFIX)) {
-      git(repo, ["worktree", "unlock", wt.path]);
-    }
-  }
-  git(repo, ["worktree", "prune"]);
-}

package/src/tui/ansi-spans.ts

@@ -1,126 +0,0 @@
-/**
- * ANSI → styled spans. Pure; no renderer import.
- *
- * Message content (Markdown with highlighting, Mermaid, diffs, tool views)
- * and every extension renderer produce `string[]` lines with SGR escapes —
- * that is the Pi-compatible component contract extensions already rely on.
- * The OpenTUI view draws cells from styled chunks, not escapes, and ships no
- * ANSI parser, so this module is the one bridge: it turns those lines into
- * spans the view converts to TextChunks. Keeping the bridge here (instead of
- * re-implementing every renderer natively) keeps the extension API and the
- * tested renderers intact across the UI rewrite (D20).
- *
- * Supported: SGR 0/1/2/3/4/7/9/22/23/24/27/29, 30–37/90–97/39, 40–47/100–107/49,
- * 38;5;n / 48;5;n, 38;2;r;g;b / 48;2;r;g;b, OSC 8 hyperlinks. Every other
- * CSI/OSC/APC (cursor moves, Pi's cursor marker, kitty graphics) is dropped:
- * a renderable lays out its own cells, so movement escapes have no meaning.
- */
-
-export type SpanColor = { kind: "index"; index: number } | { kind: "rgb"; r: number; g: number; b: number };
-
-export interface SpanStyle {
-  readonly fg?: SpanColor;
-  readonly bg?: SpanColor;
-  readonly bold?: boolean;
-  readonly dim?: boolean;
-  readonly italic?: boolean;
-  readonly underline?: boolean;
-  readonly reverse?: boolean;
-  readonly strikethrough?: boolean;
-  readonly link?: string;
-}
-
-export interface Span { readonly text: string; readonly style: SpanStyle }
-
-type Mutable = { -readonly [K in keyof SpanStyle]: SpanStyle[K] };
-
-function applySgr(style: Mutable, params: number[]): void {
-  if (params.length === 0) params = [0];
-  for (let i = 0; i < params.length; i++) {
-    const p = params[i]!;
-    if (p === 0) { for (const key of Object.keys(style) as (keyof Mutable)[]) if (key !== "link") delete style[key]; }
-    else if (p === 1) style.bold = true;
-    else if (p === 2) style.dim = true;
-    else if (p === 3) style.italic = true;
-    else if (p === 4) style.underline = true;
-    else if (p === 7) style.reverse = true;
-    else if (p === 9) style.strikethrough = true;
-    else if (p === 22) { delete style.bold; delete style.dim; }
-    else if (p === 23) delete style.italic;
-    else if (p === 24) delete style.underline;
-    else if (p === 27) delete style.reverse;
-    else if (p === 29) delete style.strikethrough;
-    else if (p >= 30 && p <= 37) style.fg = { kind: "index", index: p - 30 };
-    else if (p >= 90 && p <= 97) style.fg = { kind: "index", index: p - 90 + 8 };
-    else if (p === 39) delete style.fg;
-    else if (p >= 40 && p <= 47) style.bg = { kind: "index", index: p - 40 };
-    else if (p >= 100 && p <= 107) style.bg = { kind: "index", index: p - 100 + 8 };
-    else if (p === 49) delete style.bg;
-    else if (p === 38 || p === 48) {
-      const mode = params[i + 1];
-      let color: SpanColor | undefined;
-      if (mode === 5 && params[i + 2] !== undefined) { color = { kind: "index", index: clamp(params[i + 2]!) }; i += 2; }
-      else if (mode === 2 && params[i + 4] !== undefined) { color = { kind: "rgb", r: clamp(params[i + 2]!), g: clamp(params[i + 3]!), b: clamp(params[i + 4]!) }; i += 4; }
-      else break; // malformed extended colour: ignore the rest of this sequence
-      if (p === 38) style.fg = color; else style.bg = color;
-    }
-  }
-}
-
-function clamp(n: number): number { return Math.max(0, Math.min(255, Number.isFinite(n) ? n : 0)); }
-
-function freeze(style: Mutable): SpanStyle { return { ...style }; }
-
-function sameStyle(a: SpanStyle, b: SpanStyle): boolean { return JSON.stringify(a) === JSON.stringify(b); }
-
-/** Parse one line. Adjacent text with equal style merges into one span. */
-export function ansiSpans(line: string): Span[] {
-  const spans: Span[] = [];
-  const style: Mutable = {};
-  let text = "";
-  const flush = () => {
-    if (!text) return;
-    const frozen = freeze(style);
-    const last = spans[spans.length - 1];
-    if (last && sameStyle(last.style, frozen)) spans[spans.length - 1] = { text: last.text + text, style: frozen };
-    else spans.push({ text, style: frozen });
-    text = "";
-  };
-  let i = 0;
-  while (i < line.length) {
-    const ch = line[i]!;
-    if (ch !== "\x1b") { text += ch; i++; continue; }
-    const kind = line[i + 1];
-    if (kind === "[") {
-      let j = i + 2;
-      while (j < line.length && !/[@-~]/.test(line[j]!)) j++;
-      const body = line.slice(i + 2, j);
-      if (line[j] === "m" && /^[0-9;]*$/.test(body)) {
-        flush();
-        applySgr(style, body === "" ? [] : body.split(";").map(part => (part === "" ? 0 : Number(part))));
-      }
-      i = j + 1;
-      continue;
-    }
-    if (kind === "]" || kind === "_" || kind === "P") {
-      let j = i + 2;
-      while (j < line.length && line[j] !== "\x07" && !(line[j] === "\x1b" && line[j + 1] === "\\")) j++;
-      const body = line.slice(i + 2, j);
-      if (kind === "]" && body.startsWith("8;")) {
-        flush();
-        const url = body.slice(body.indexOf(";", 2) + 1);
-        if (url) style.link = url; else delete style.link;
-      }
-      i = line[j] === "\x07" ? j + 1 : j + 2;
-      continue;
-    }
-    i += 2;
-  }
-  flush();
-  return spans;
-}
-
-/** Visible text of a line: what a terminal would print, escapes removed. */
-export function plainText(line: string): string {
-  return ansiSpans(line).map(span => span.text).join("");
-}

package/src/tui/diff.ts

@@ -1,160 +0,0 @@
-/**
- * Line diff for an edit's old/new snippets.
- *
- * Ported from pi (earendil-works/pi, MIT) — packages/coding-agent/src/core/tools/edit-diff.ts
- * `generateDiffString`: context around changed lines, skip the rest. We cannot
- * take the `diff` package (tui may not import npm), so the hunks are an LCS
- * of lines rather than Myers. Edits carry snippets, not whole files, so O(n·m)
- * stays small.
- *
- * Why not the whole file: the information in an edit is what changed. Dumping
- * the destination file fills the live region and makes the user hunt.
- */
-
-import { PLAIN_ATTRS, paint, type Attrs, type Style } from "./style.ts";
-import { displayWidth } from "./width.ts";
-
-/**
- * Unchanged lines kept on each side of a hunk. From pi's generateDiffString
- * default (4). Assumed, not measured: more context drowns the `+`/`-` lines
- * this view exists to show.
- */
-const CONTEXT_LINES = 4;
-
-export type DiffOp = { kind: "eq" | "del" | "add"; line: string };
-
-export function diffLines(oldText: string, newText: string): DiffOp[] {
-  const a = oldText.split("\n");
-  const b = newText.split("\n");
-  const n = a.length;
-  const m = b.length;
-  const dp: number[][] = Array.from({ length: n + 1 }, () => Array<number>(m + 1).fill(0));
-  for (let i = n - 1; i >= 0; i--) {
-    for (let j = m - 1; j >= 0; j--) {
-      dp[i]![j] = a[i] === b[j] ? dp[i + 1]![j + 1]! + 1 : Math.max(dp[i + 1]![j]!, dp[i]![j + 1]!);
-    }
-  }
-  const out: DiffOp[] = [];
-  let i = 0;
-  let j = 0;
-  while (i < n && j < m) {
-    if (a[i] === b[j]) {
-      out.push({ kind: "eq", line: a[i]! });
-      i++;
-      j++;
-    } else if (dp[i + 1]![j]! >= dp[i]![j + 1]!) {
-      out.push({ kind: "del", line: a[i]! });
-      i++;
-    } else {
-      out.push({ kind: "add", line: b[j]! });
-      j++;
-    }
-  }
-  while (i < n) {
-    out.push({ kind: "del", line: a[i]! });
-    i++;
-  }
-  while (j < m) {
-    out.push({ kind: "add", line: b[j]! });
-    j++;
-  }
-  return out;
-}
-
-/**
- * Keep only ops within CONTEXT_LINES of a change. Skipped equal runs become
- * a dim `... (N lines)` so the omission is counted, not silent.
- */
-export function withContext(ops: readonly DiffOp[]): DiffOp[] {
-  const keep = new Array<boolean>(ops.length).fill(false);
-  for (let i = 0; i < ops.length; i++) {
-    if (ops[i]!.kind === "eq") continue;
-    const from = Math.max(0, i - CONTEXT_LINES);
-    const to = Math.min(ops.length - 1, i + CONTEXT_LINES);
-    for (let k = from; k <= to; k++) keep[k] = true;
-  }
-  const out: DiffOp[] = [];
-  let i = 0;
-  while (i < ops.length) {
-    if (keep[i]) {
-      out.push(ops[i]!);
-      i++;
-      continue;
-    }
-    let j = i;
-    while (j < ops.length && !keep[j]) j++;
-    const skipped = j - i;
-    if (skipped > 0) out.push({ kind: "eq", line: `... (${skipped} lines)` });
-    i = j;
-  }
-  return out;
-}
-
-const DEL: Attrs = { ...PLAIN_ATTRS, red: true };
-const ADD: Attrs = { ...PLAIN_ATTRS, green: true };
-const EQ: Attrs = { ...PLAIN_ATTRS, dim: true };
-
-export function renderDiff(oldText: string, newText: string, width: number, style: Style): string[] {
-  const ops = withContext(diffLines(oldText, newText));
-  const out: string[] = [];
-  for (const op of ops) {
-    const mark = op.kind === "del" ? "-" : op.kind === "add" ? "+" : " ";
-    const attrs = op.kind === "del" ? DEL : op.kind === "add" ? ADD : EQ;
-    out.push(...emitPrefixed(mark, op.line, width, style, attrs));
-  }
-  return out;
-}
-
-/**
- * Columns left for the body after the prefix. A prefix that does not
- * leave at least one column is dropped: wrapPlain floors a zero budget
- * at 1, so keeping the prefix would paint prefixW+1 columns and the
- * terminal would wrap. The line-diff renderer then counts one row where
- * the screen used two — the same trap as a 0-column pty (`usableColumns`
- * in terminal.ts).
- */
-export function innerWidth(prefix: string, width: number): number {
-  const w = Math.max(0, Math.floor(width));
-  if (w <= 0) return 0;
-  const prefixW = displayWidth(prefix);
-  return prefixW > 0 && prefixW < w ? w - prefixW : w;
-}
-
-export function emitPrefixed(
-  prefix: string,
-  body: string,
-  width: number,
-  style: Style,
-  attrs: Attrs,
-): string[] {
-  const w = Math.max(0, Math.floor(width));
-  if (w <= 0) return [""];
-  const prefixW = displayWidth(prefix);
-  const inner = innerWidth(prefix, w);
-  const rows = wrapPlain(body, inner);
-  if (inner === w) {
-    return rows.map((row) => paint(row, attrs, style));
-  }
-  const pad = " ".repeat(prefixW);
-  return rows.map((row, i) => paint((i === 0 ? prefix : pad) + row, attrs, style));
-}
-
-export function wrapPlain(text: string, width: number): string[] {
-  if (width <= 0) return [""];
-  const lines: string[] = [];
-  let current = "";
-  let currentW = 0;
-  for (const ch of text) {
-    const cw = displayWidth(ch);
-    if (cw > 0 && currentW + cw > width && current.length > 0) {
-      lines.push(current);
-      current = ch;
-      currentW = cw;
-    } else {
-      current += ch;
-      currentW += cw;
-    }
-  }
-  lines.push(current);
-  return lines;
-}

package/src/tui/exhaustive.ts

@@ -1,14 +0,0 @@
-/**
- * Exhaustiveness for discriminated unions.
- *
- * Copied rather than imported from core: tui may not import src/ outside
- * itself, and the boundary checker exists to keep that true. The two copies
- * must stay one function; if they drift, the newer union is the one that
- * will fail to compile first.
- */
-export function assertNever(value: never, context: string): never {
-  throw new Error(
-    `${context}: unhandled variant ${JSON.stringify(value)} -- ` +
-      "a union gained a member without every switch over it being updated",
-  );
-}

package/src/tui/fuzzy.ts

@@ -1,75 +0,0 @@
-/**
- * Subsequence fuzzy matching with a stable rank.
- *
- * Consecutive hits and word-start hits score better (pi-tui's scheme,
- * lower is better). Ties keep the original index: an unstable sort would
- * reshuffle the select list between two renders, and Enter would confirm
- * a different item than the one under the cursor.
- */
-
-export interface FuzzyMatch {
-  readonly text: string;
-  readonly score: number;
-  readonly index: number;
-}
-
-/**
- * Lower is better. `null` if `query` is not a subsequence of `text`.
- * Case-insensitive. Empty query matches with score 0.
- */
-export function fuzzyMatch(text: string, query: string): number | null {
-  if (query.length === 0) return 0;
-  return score(text, query);
-}
-
-export function fuzzyFilter(candidates: readonly string[], query: string): string[] {
-  if (query.length === 0) return [...candidates];
-  const ranked: FuzzyMatch[] = [];
-  for (let index = 0; index < candidates.length; index++) {
-    const text = candidates[index]!;
-    const s = score(text, query);
-    if (s === null) continue;
-    ranked.push({ text, score: s, index });
-  }
-  ranked.sort((a, b) => a.score - b.score || a.index - b.index);
-  return ranked.map((r) => r.text);
-}
-
-/**
- * Leftmost greedy subsequence, scored like pi-tui:
- * consecutive run bonus, word-boundary bonus, later-match penalty.
- * Walks code points so a CJK query cannot land on a UTF-16 half-unit.
- */
-function score(text: string, query: string): number | null {
-  const t = [...text.toLowerCase()];
-  const q = [...query.toLowerCase()];
-  if (q.length > t.length) return null;
-
-  let qi = 0;
-  let total = 0;
-  let last = -1;
-  let consecutive = 0;
-
-  for (let i = 0; i < t.length && qi < q.length; i++) {
-    if (t[i] !== q[qi]) continue;
-    const prev = i === 0 ? "" : t[i - 1]!;
-    const boundary = i === 0 || /[\s\-_./:]/.test(prev);
-
-    if (last === i - 1) {
-      consecutive++;
-      total -= consecutive * 5;
-    } else {
-      consecutive = 0;
-      if (last >= 0) total += (i - last - 1) * 2;
-    }
-    if (boundary) total -= 10;
-    total += i * 0.1;
-
-    last = i;
-    qi++;
-  }
-
-  if (qi < q.length) return null;
-  if (q.join("") === t.join("")) total -= 100;
-  return total;
-}