@cueloop/client 0.1.0-alpha.67 → 0.1.0-alpha.69

package/src/session-controller.live-diff.test.ts

@@ -0,0 +1,198 @@
+/**
+ * A non-diff thread (here a plan) still renders a real diff in the Changes view:
+ * the controller eagerly captures the live working-tree diff, so repoChanges()
+ * carries file contents and rows() derives from the patch - the same shape a
+ * cueloop diff pins, just computed live.
+ */
+
+import { describe, expect, mock, test } from "bun:test";
+import { SCHEMA_VERSION, type Annotation, type ReviewSession } from "@cueloop/schema";
+import type { SessionClient } from "@cueloop/daemon/client";
+import { createReviewController, type ShareTransport } from "./session-controller";
+import { mergeFromShare } from "./share";
+
+const AT = "2026-01-01T00:00:00.000Z";
+
+const PATCH = `diff --git a/src/x.ts b/src/x.ts
+--- a/src/x.ts
++++ b/src/x.ts
+@@ -1,1 +1,1 @@
+-const a = 1;
++const a = 2;
+`;
+
+const FILES = [
+  {
+    path: "src/x.ts",
+    oldContents: "const a = 1;\n",
+    newContents: "const a = 2;\n",
+    status: "modified" as const,
+  },
+];
+
+const shareTransport: ShareTransport = {
+  publish: mock(async (session: ReviewSession) => ({
+    line: `ssh p_${session.id}@cueloop.dev`,
+    copied: true,
+  })),
+  pull: mock(async () => planSession()),
+  push: mock(async () => {}),
+  watch: () => () => {},
+  parseShareId: (line) => line.match(/^ssh (\S+)@/)?.[1],
+  collaboratorAnnotations: (session) => session.annotations.filter((entry) => entry.author),
+  mergeFromShare,
+};
+
+function planSession(id = "ses_plan", repoRoot = "/repo"): ReviewSession {
+  return {
+    schemaVersion: SCHEMA_VERSION,
+    id,
+    workspace: { repoRoot, branch: "main" },
+    artifact: { type: "plan", content: "# Plan\n", meta: {} },
+    revisions: [{ revision: 1, content: "# Plan\n", submittedAt: AT }],
+    annotations: [],
+    verdict: null,
+    status: "pending",
+    createdAt: AT,
+  };
+}
+
+const unimplemented = (member: string) => () =>
+  Promise.reject(new Error(`fakeClient does not implement ${member}`));
+
+function fakeClient(session: ReviewSession): SessionClient {
+  return {
+    onEvent: () => () => {},
+    subscribe: async () => {},
+    sessionGet: async () => session,
+    sessionList: async () => [session],
+    sessionAnnotate: unimplemented("sessionAnnotate"),
+    sessionRemoveAnnotation: unimplemented("sessionRemoveAnnotation"),
+    sessionSetWorkingCopy: unimplemented("sessionSetWorkingCopy"),
+    sessionCutBlock: unimplemented("sessionCutBlock"),
+    sessionRestoreBlock: unimplemented("sessionRestoreBlock"),
+    sessionCurate: unimplemented("sessionCurate"),
+    sessionNavigate: unimplemented("sessionNavigate"),
+    sessionBranch: unimplemented("sessionBranch"),
+    sessionSwitch: unimplemented("sessionSwitch"),
+    sessionLabel: unimplemented("sessionLabel"),
+    sessionFork: unimplemented("sessionFork"),
+    sessionSetViewed: unimplemented("sessionSetViewed"),
+    sessionSetTitle: unimplemented("sessionSetTitle"),
+    sessionSetShareId: unimplemented("sessionSetShareId"),
+    sessionMergeShared: unimplemented("sessionMergeShared"),
+    sessionDelete: unimplemented("sessionDelete"),
+    sessionSetSelfName: unimplemented("sessionSetSelfName"),
+    sessionResolve: unimplemented("sessionResolve"),
+    repoDiff: async () => ({ patch: PATCH, files: FILES }),
+    close: () => {},
+  } satisfies SessionClient;
+}
+
+const tick = () => new Promise((resolve) => setTimeout(resolve, 0));
+
+describe("live working-tree diff for a non-diff thread", () => {
+  test("repoChanges carries file contents and rows derive from the patch", async () => {
+    const session = planSession();
+    const controller = createReviewController({
+      sessionId: session.id,
+      openClient: async () => fakeClient(session),
+      shareTransport,
+    });
+    controller.connect();
+    await tick();
+
+    // Act - the Changes navigator loads
+    const changes = await controller.repoChanges();
+
+    // Assert - real per-file contents, not empty stubs
+    expect(changes.map((file) => file.path)).toEqual(["src/x.ts"]);
+    expect(changes[0]!.newContents).toBe("const a = 2;\n");
+
+    // and the diff rows derive from the live patch, so an opened file tab shows a diff
+    expect(controller.rows().some((row) => row.file === "src/x.ts")).toBe(true);
+
+    // the live per-file contents let a non-diff thread expand a folded file too
+    expect(controller.canExpandFile("src/x.ts")).toBe(true);
+
+    controller.close();
+  });
+
+  test("annotating the Changes diff stamps a file target anchored to the diff rows", async () => {
+    const session = planSession();
+    let sent: Annotation | undefined;
+    const client = {
+      ...fakeClient(session),
+      sessionAnnotate: async (_id: string, annotation: Annotation) => {
+        sent = annotation;
+
+        return { ...session, annotations: [{ ...annotation, createdAt: AT }] };
+      },
+    } satisfies SessionClient;
+    const controller = createReviewController({
+      sessionId: session.id,
+      openClient: async () => client,
+      shareTransport,
+    });
+    controller.connect();
+    await tick();
+    await controller.repoChanges();
+
+    // Act - comment the added line of the working-tree diff, as the Changes surface does
+    const rows = controller.rows();
+    const addIndex = rows.findIndex((row) => row.kind === "add");
+    const addText = rows[addIndex]!.text.replace(/\n$/, "");
+
+    controller.annotate("comment", addIndex, 0, addText.length, "eviction?", addIndex, {
+      kind: "file",
+      path: "",
+      rev: "worktree",
+    });
+
+    // Assert - the note carries the file target (path and rev filled from the row) and quotes the diff
+    expect(sent?.target).toEqual({ kind: "file", path: "src/x.ts", rev: "worktree" });
+    expect(sent?.anchor.quote).toContain("const a = 2");
+
+    controller.close();
+  });
+
+  test("a late diff response from a previous thread never overwrites the active one", async () => {
+    const sessionA = planSession("ses_A", "/repoA");
+    const sessionB = planSession("ses_B", "/repoB");
+    let resolveA: (diff: { patch: string; files: typeof FILES }) => void = () => {};
+    const pendingA = new Promise<{ patch: string; files: typeof FILES }>((resolve) => {
+      resolveA = resolve;
+    });
+    const diffB = {
+      patch: PATCH.replace(/x\.ts/g, "y.ts"),
+      files: [{ ...FILES[0]!, path: "src/y.ts" }],
+    };
+    const client = {
+      ...fakeClient(sessionA),
+      sessionList: async () => [sessionA, sessionB],
+      repoDiff: async (cwd: string) => (cwd === "/repoA" ? pendingA : diffB),
+    } satisfies SessionClient;
+
+    const controller = createReviewController({
+      sessionId: sessionA.id,
+      openClient: async () => client,
+      shareTransport,
+    });
+    controller.connect();
+    await tick();
+
+    // thread A's diff is still in flight when the user switches to thread B
+    const inFlightA = controller.repoChanges();
+    controller.open("ses_B");
+    await controller.repoChanges();
+    // B's diff is showing; now A's stale response lands
+    resolveA({ patch: PATCH, files: FILES });
+    await inFlightA;
+
+    // the active thread keeps B's changes; A's late response is dropped
+    expect(controller.rows().some((row) => row.file === "src/y.ts")).toBe(true);
+    expect(controller.rows().some((row) => row.file === "src/x.ts")).toBe(false);
+
+    controller.close();
+  });
+});

package/src/session-controller.ts

@@ -26,7 +26,9 @@ import {
   returnPaneFor,
   switchBranch,
   viewOfPath,
+  type Anchor,
   type Annotation,
+  type AnnotationTarget,
   type DiffFileContents,
   type ReviewSession,
   type SessionHistory,
@@ -44,7 +46,7 @@ import {
 } from "./share";
 import { buildDisplay, nextWorkBlock, type DisplayBlock } from "./view-plan";
 import { entryTarget, treeRows, type TreeRow } from "./tree-view";
-import { diffRowBlocks, diffRows, fileChangeCounts, type DiffRow } from "./view-diff";
+import { diffRowBlocks, diffRows, fileChangeCounts, fileRowRange, type DiffRow } from "./view-diff";
 import { applyFold } from "./diff-fold";
 import { copyToClipboard } from "./clipboard";
 import {
@@ -60,7 +62,8 @@ import type { FileDiffMetadata } from "@pierre/diffs";
 import { firstUnviewedIndex, walkFiles, type WalkFile } from "./walk";
 import { editInEditor } from "./editor";
 import { focusHerdrPane } from "./herdr";
-import { persistAutoClose, type AutoClose, type CueloopConfig } from "./config";
+import { persistAutoClose, type AutoClose, type CueloopConfig, type QuickAction } from "./config";
+import { slashItemsFrom } from "./slash-palette";
 
 /**
  * Post-submit lifecycle (a review pane should hand you back to the agent,
@@ -254,7 +257,17 @@ export interface ReviewController {
     end: number,
     body: string,
     endDisplayIndex?: number,
+    /** The surface being annotated; a `file` target anchors into the Changes diff rows. */
+    target?: AnnotationTarget,
   ): string | undefined;
+  /** Persist a comment whose anchor a surface already built (e.g. a file-contents view). */
+  addComment(anchor: Anchor, target: AnnotationTarget, body: string): string | undefined;
+  /**
+   * Comment from the bare launch shell, where no thread is open: find-or-create the per-repo
+   * workbench thread, open it (the shell becomes a thread view), then add the comment. This is the
+   * first write a browse-only launch makes - nothing is on disk until it runs.
+   */
+  commentOnWorkbench(anchor: Anchor, target: AnnotationTarget, body: string): Promise<void>;
   /**
    * Reply to `rootAnnotationId`: the reply shares the root's anchor and names
    * it in replyTo, so the discussion stays one conversation. Returns the minted id.
@@ -315,6 +328,12 @@ interface DerivedSessionProjection {
   tree: TreeRow[];
 }
 
+/** A live working-tree diff: the same patch + per-file contents a diff capture pins. */
+interface LiveWorkingDiff {
+  patch: string;
+  files: readonly DiffFileContents[];
+}
+
 class Controller implements ReviewController {
   readonly readOnly: boolean;
   private client: SessionClient | null = null;
@@ -331,6 +350,7 @@ class Controller implements ReviewController {
   };
   private listeners = new Set<() => void>();
   private autoClose: AutoClose = "off";
+  private quickActions: QuickAction[] = [];
   private editor: string | undefined;
   private exporters: BundledExporter[] = [];
   private readonly clock: Clock;
@@ -339,8 +359,11 @@ class Controller implements ReviewController {
   private shareReconnect: TimerHandle | undefined;
   private shareStop: (() => void) | null = null;
   private shareRun: object | null = null;
-  /** Projections keyed by session identity so renders reuse one computation. */
+  /** Projections keyed by session identity (and the live diff for non-diff threads) so renders reuse one computation. */
   private derivedFor: ReviewSession | null = null;
+  /** The launch/workspace repo's live working-tree diff, feeding the Changes view for non-diff threads. */
+  private liveDiff: LiveWorkingDiff | null = null;
+  private derivedForLiveDiff: LiveWorkingDiff | null = null;
   private derived: DerivedSessionProjection = {
     display: [],
     rows: [],
@@ -424,6 +447,7 @@ class Controller implements ReviewController {
 
   applyConfig(config: CueloopConfig): void {
     this.autoClose = config.ui.autoClose;
+    this.quickActions = config.actions;
     this.editor = config.ui.editor;
     void loadBundledExporters(config.integrations).then((exporters) => {
       this.exporters = exporters;
@@ -446,17 +470,25 @@ class Controller implements ReviewController {
   // ── derived projections ─────────────────────
   private ensureDerived(): void {
     const session = this.snapshot.session;
-
-    if (this.derivedFor === session) return;
+    const isDiff = session?.artifact.type === "diff";
+    // a diff thread reads its pinned capture; every other thread reflects the live working tree
+    const liveDiff = isDiff ? null : this.liveDiff;
+
+    if (this.derivedFor === session && this.derivedForLiveDiff === liveDiff) return;
+    // fold state belongs to the session, so a live-tree refresh keeps it; only a new session resets it
+    if (this.derivedFor !== session) {
+      this.collapsedFiles.clear();
+      this.expandedFiles.clear();
+    }
     this.derivedFor = session;
-    // a new session starts fully expanded, never inheriting the prior diff's fold state
-    this.collapsedFiles.clear();
-    this.expandedFiles.clear();
-    const rows =
-      session && session.artifact.type === "diff" ? diffRows(session.artifact.content) : [];
+    this.derivedForLiveDiff = liveDiff;
+
+    const content = isDiff ? session!.artifact.content : (liveDiff?.patch ?? "");
+    const files = isDiff ? (session?.artifact.files ?? []) : (liveDiff?.files ?? []);
+    const rows = content ? diffRows(content) : [];
     const models = new Map<string, FileDiffMetadata>();
 
-    for (const file of session?.artifact.files ?? []) models.set(file.path, parseFileDiff(file));
+    for (const file of files) models.set(file.path, parseFileDiff(file));
     this.derived = {
       display: session ? buildDisplay(session.artifact.content, session.workingCopy) : [],
       rows,
@@ -466,6 +498,13 @@ class Controller implements ReviewController {
     };
   }
 
+  /** The per-file contents that back the current rows: a diff thread's capture, else the live working tree. */
+  private foldFiles(): readonly DiffFileContents[] | undefined {
+    const session = this.snapshot.session;
+
+    return session?.artifact.type === "diff" ? session.artifact.files : this.liveDiff?.files;
+  }
+
   treeRows(): TreeRow[] {
     this.ensureDerived();
 
@@ -482,12 +521,7 @@ class Controller implements ReviewController {
     this.ensureDerived();
     if (this.collapsedFiles.size === 0 && this.expandedFiles.size === 0) return this.derived.rows;
 
-    return applyFold(
-      this.derived.rows,
-      this.collapsedFiles,
-      this.expandedFiles,
-      this.snapshot.session?.artifact.files,
-    );
+    return applyFold(this.derived.rows, this.collapsedFiles, this.expandedFiles, this.foldFiles());
   }
 
   setFileCollapsed(file: string, collapsed: boolean): void {
@@ -519,7 +553,9 @@ class Controller implements ReviewController {
   }
 
   canExpandFile(file: string): boolean {
-    return (this.snapshot.session?.artifact.files ?? []).some((entry) => entry.path === file);
+    // a live working-tree diff carries the same per-file contents as a captured one,
+    // so a non-diff thread can expand its files too
+    return (this.foldFiles() ?? []).some((entry) => entry.path === file);
   }
 
   copyFilePath(file: string): void {
@@ -581,6 +617,19 @@ class Controller implements ReviewController {
     // a diff review pins its captured snapshot; every other thread reflects the live working tree
     const session = this.snapshot.session;
     if (session?.artifact.type === "diff") return session.artifact.files ?? [];
+    // eager: capture the live working-tree diff so the Changes navigator and its file tabs render a real diff
+    if (this.client?.repoDiff !== undefined) {
+      const diff = await this.client.repoDiff(this.sidebarRepoRoot());
+      // a thread switch during the request would let this response overwrite the new
+      // thread's diff, showing changes from the wrong repo; drop it when the session moved on
+      if (this.snapshot.session !== session) return diff.files;
+      this.liveDiff = diff;
+      // rows() derive from the fresh patch; re-render so an open diff tab repaints
+      this.update({});
+
+      return diff.files;
+    }
+    // a peer without the live-diff capability still lists changes, just without a diff body
     if (this.client?.repoChanges === undefined) return [];
     const changes = await this.client.repoChanges(this.sidebarRepoRoot());
 
@@ -947,13 +996,37 @@ class Controller implements ReviewController {
     end: number,
     body: string,
     endDisplayIndex: number = displayIndex,
+    target: AnnotationTarget = { kind: "artifact" },
   ): string | undefined {
     const session = this.snapshot.session;
 
     if (!session) return undefined;
     let anchor;
+    let resolvedTarget = target;
+    // a file target (a Changes-panel diff note) and a diff artifact both anchor into the diff rows
+    const onDiff = target.kind === "file" || session.artifact.type === "diff";
+
+    if (target.kind === "file") {
+      // a Changes-panel note anchors within its own file's rows, so a quote never attaches across
+      // files; a selection that spills into the next file is clamped back to the file it started in
+      const rows = this.rows();
+      const startRow = rows[displayIndex];
+      const path = startRow?.file ?? "";
+      const range = fileRowRange(rows, path);
+      const base = range?.start ?? 0;
+      const fileRows = range ? rows.slice(range.start, range.end) : rows;
+      const lastInFile = fileRows.length - 1;
+      const clamp = (index: number): number => Math.max(0, Math.min(index - base, lastInFile));
 
-    if (session.artifact.type === "diff") {
+      anchor = makeAnchor(
+        diffRowBlocks(fileRows),
+        clamp(displayIndex),
+        start,
+        end,
+        clamp(endDisplayIndex),
+      );
+      resolvedTarget = { kind: "file", path, rev: startRow?.kind === "del" ? "head" : "worktree" };
+    } else if (onDiff) {
       // rows are the diff's blocks: a span over one or more code rows anchors with the
       // same quote, context, and position selectors a plan span does
       anchor = makeAnchor(diffRowBlocks(this.rows()), displayIndex, start, end, endDisplayIndex);
@@ -971,34 +1044,74 @@ class Controller implements ReviewController {
         workIndexOf(endDisplayIndex),
       );
     }
-    const wire = { id: newAnnotationId(), kind, anchor, body };
+    // absent target means the reviewed artifact, so keep artifact notes free of the field
+    const wire =
+      resolvedTarget.kind === "artifact"
+        ? { id: newAnnotationId(), kind, anchor, body }
+        : { id: newAnnotationId(), kind, anchor, body, target: resolvedTarget };
     const persisted = this.client!.sessionAnnotate(session.id, wire);
 
     this.apply(persisted);
     this.mirrorAnnotation(persisted, wire);
-    this.setStatus("comment added");
 
     return wire.id;
   }
 
+  addComment(anchor: Anchor, target: AnnotationTarget, body: string): string | undefined {
+    const session = this.snapshot.session;
+
+    if (!session) return undefined;
+    const wire =
+      target.kind === "artifact"
+        ? { id: newAnnotationId(), kind: "comment", anchor, body }
+        : { id: newAnnotationId(), kind: "comment", anchor, body, target };
+    const persisted = this.client!.sessionAnnotate(session.id, wire);
+
+    this.apply(persisted);
+    this.mirrorAnnotation(persisted, wire);
+
+    return wire.id;
+  }
+
+  async commentOnWorkbench(anchor: Anchor, target: AnnotationTarget, body: string): Promise<void> {
+    if (!this.snapshot.session) {
+      if (this.client?.sessionWorkbench === undefined) return;
+      let workbench;
+
+      try {
+        workbench = await this.client.sessionWorkbench(this.options.cwd ?? process.cwd());
+      } catch (cause) {
+        // the composer already closed, so a lost first comment must at least surface, not vanish
+        this.setStatus(String(cause instanceof Error ? cause.message : cause));
+
+        return;
+      }
+      // adopt the thread as active (the shell flips to the thread view) and let the inbox catch up
+      this.update({ session: workbench });
+      void this.refreshInbox();
+    }
+    this.addComment(anchor, target, body);
+  }
+
   reply(rootAnnotationId: string, body: string): string | undefined {
     const session = this.snapshot.session;
     const root = session?.annotations.find((annotation) => annotation.id === rootAnnotationId);
 
     if (!session || !root) return undefined;
-    // a reply to a reply still hangs off the discussion's root comment
-    const wire = {
+    // a reply to a reply still hangs off the discussion's root comment, and shares its target
+    // so it renders and resolves on the same surface
+    const base = {
       id: newAnnotationId(),
       kind: "comment",
       anchor: root.anchor,
       body,
       replyTo: root.replyTo ?? root.id,
     };
+    const wire = root.target ? { ...base, target: root.target } : base;
     const persisted = this.client!.sessionAnnotate(session.id, wire);
 
     this.apply(persisted);
     this.mirrorAnnotation(persisted, wire);
-    this.setStatus("reply added");
 
     return wire.id;
   }
@@ -1013,7 +1126,6 @@ class Controller implements ReviewController {
 
     this.apply(persisted);
     this.mirrorAnnotation(persisted, wire);
-    this.setStatus("comment added");
 
     return wire.id;
   }
@@ -1125,7 +1237,10 @@ class Controller implements ReviewController {
 
     if (!session) return;
     this.walkLeave();
-    this.client!.sessionResolve(session.id, verdict, summary)
+    const actionBodies = Object.fromEntries(
+      slashItemsFrom(this.quickActions).map((item) => [item.name, item.body]),
+    );
+    this.client!.sessionResolve(session.id, verdict, summary, actionBodies)
       .then((resolved) => {
         // The completion overlay heading already states the verdict, so the
         // status line stays empty here - only export/error messages fill it.

package/src/slash-palette.test.ts

@@ -0,0 +1,54 @@
+import { describe, expect, test } from "bun:test";
+import { inlineSlashToken, scoreMatch, slashFilter, type SlashItem } from "./slash-palette";
+
+function item(name: string): SlashItem {
+  return { name, description: name, body: name };
+}
+
+const ITEMS: SlashItem[] = [
+  item("zoom-out-research-in-depth"),
+  item("restate-simplified"),
+  item("out-of-scope"),
+  item("lgtm"),
+];
+
+describe("scoreMatch", () => {
+  test("an exact name scores highest, then a prefix, then a subsequence", () => {
+    const exact = scoreMatch("lgtm", "lgtm")!;
+    const prefix = scoreMatch("lgtm-please", "lgtm")!;
+    const subsequence = scoreMatch("looking-good-to-me", "lgtm")!;
+
+    expect(exact).toBeGreaterThan(prefix);
+    expect(prefix).toBeGreaterThan(subsequence);
+  });
+
+  test("a query whose characters are not all present, in order, does not match", () => {
+    expect(scoreMatch("restate", "zzz")).toBeNull();
+    expect(scoreMatch("abc", "acb")).toBeNull();
+  });
+
+  test("an empty query matches everything", () => {
+    expect(scoreMatch("anything", "")).toBe(0);
+  });
+});
+
+describe("slashFilter", () => {
+  test("ranks a prefix match above a mere subsequence match", () => {
+    const ranked = slashFilter(ITEMS, "out");
+
+    expect(ranked[0]!.name).toBe("out-of-scope");
+    expect(ranked.map((entry) => entry.name)).toContain("zoom-out-research-in-depth");
+  });
+
+  test("drops items that do not match and returns all on an empty query", () => {
+    expect(slashFilter(ITEMS, "zzzz")).toEqual([]);
+    expect(slashFilter(ITEMS, "")).toHaveLength(ITEMS.length);
+  });
+});
+
+describe("inlineSlashToken", () => {
+  test("finds a trailing /word only when text precedes it", () => {
+    expect(inlineSlashToken("use /vitest-patt")).toBe("/vitest-patt");
+    expect(inlineSlashToken("/vitest-patt")).toBeNull();
+  });
+});

package/src/slash-palette.ts

@@ -23,28 +23,42 @@ export function slashItemsFrom(quickActions: QuickAction[]): SlashItem[] {
   }));
 }
 
-/** Prefix beats substring beats subsequence. */
-export function slashFilter(items: SlashItem[], query: string): SlashItem[] {
-  const needle = query.toLowerCase();
+const WORD_BOUNDARY = /[\s\-_./:]/;
+
+/** Order-preserving subsequence score, or null when a query character is missing; higher is better. */
+export function scoreMatch(name: string, query: string): number | null {
+  if (query.length === 0) return 0;
+  const lowerName = name.toLowerCase();
+  const lowerQuery = query.toLowerCase();
+
+  if (lowerName === lowerQuery) return 1000;
+  if (lowerName.startsWith(lowerQuery)) return 500 - name.length;
+  let score = 0;
+  let cursor = 0;
+  let run = 0;
+
+  for (const character of lowerQuery) {
+    const found = lowerName.indexOf(character, cursor);
+
+    if (found === -1) return null;
+    run = found === cursor ? run + 1 : 0;
+    score += found === cursor ? 5 + run : 1;
+    if (found === 0 || WORD_BOUNDARY.test(lowerName[found - 1]!)) score += 10;
+    score -= found - cursor;
+    cursor = found + 1;
+  }
+
+  return score;
+}
 
-  if (needle.length === 0) return items;
+export function slashFilter(items: SlashItem[], query: string): SlashItem[] {
+  if (query.length === 0) return items;
   const scored: Array<{ item: SlashItem; score: number }> = [];
 
   for (const item of items) {
-    const name = item.name.toLowerCase();
-    let score = 0;
-
-    if (name.startsWith(needle)) score = 3;
-    else if (name.includes(needle)) score = 2;
-    else {
-      let matched = 0;
-
-      for (const character of name) {
-        if (character === needle[matched]) matched++;
-      }
-      if (matched === needle.length) score = 1;
-    }
-    if (score > 0) scored.push({ item, score });
+    const score = scoreMatch(item.name, query);
+
+    if (score !== null) scored.push({ item, score });
   }
 
   return scored.toSorted((left, right) => right.score - left.score).map((entry) => entry.item);

package/src/test-support.test.ts

@@ -14,6 +14,7 @@ import {
   frameRow,
   isolateUserConfig,
   locateText,
+  locateTextInFrame,
   pressKey,
   waitForText,
   type FrameLocation,
@@ -250,3 +251,14 @@ describe("dragText", () => {
     expect(log.mouseEvents).toContainEqual({ type: "up", x: 9, y: 3 });
   });
 });
+
+describe("locateTextInFrame", () => {
+  test("finds the 0-based row and column of the first match, null when absent", () => {
+    // Arrange
+    const frame = "header\n  ● draft here\nfooter";
+
+    // Act + Assert
+    expect(locateTextInFrame(frame, "draft")).toEqual({ row: 1, column: 4 });
+    expect(locateTextInFrame(frame, "missing")).toBeNull();
+  });
+});