@stigmer/react 3.1.1 → 3.1.3

package/src/workspace/__tests__/FileViewer.test.tsx

@@ -0,0 +1,439 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { render, screen, fireEvent, waitFor, cleanup } from "@testing-library/react";
+import { create } from "@bufbuild/protobuf";
+import {
+  FileChangeSchema,
+  FileContentSchema,
+  type FileChange,
+} from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/message_pb";
+import {
+  FileChangeCaptureLevel,
+  FileChangeType,
+} from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
+import type { UseFileChangeContentReturn } from "../../execution/useFileChangeContent";
+
+// Drive FileChangeDiff's content deterministically (it is rendered by the diff
+// pane) — same seam FileChangesView's own tests mock.
+let mockFileChangeContent: UseFileChangeContentReturn;
+vi.mock("../../execution/useFileChangeContent", () => ({
+  useFileChangeContent: () => mockFileChangeContent,
+}));
+
+const { FileViewer } = await import("../FileViewer");
+
+afterEach(cleanup);
+beforeEach(() => {
+  mockFileChangeContent = {
+    beforeText: "alpha\n",
+    afterText: "beta\n",
+    isBinary: false,
+    isLoading: false,
+    error: null,
+    isTruncated: false,
+    downloadUrl: null,
+  };
+});
+import type { WorkspaceEntry } from "../useWorkspaceEntries";
+import type {
+  WorkspaceFileContent,
+  WorkspaceFileReader,
+} from "../WorkspaceFileReader";
+
+function wholeFileChange(path: string): FileChange {
+  return create(FileChangeSchema, {
+    path,
+    changeType: FileChangeType.MODIFY,
+    captureLevel: FileChangeCaptureLevel.WHOLE_FILE,
+    before: create(FileContentSchema, { body: { case: "inline", value: "alpha\n" } }),
+    after: create(FileContentSchema, { body: { case: "inline", value: "beta\n" } }),
+  });
+}
+
+function deleteChange(path: string): FileChange {
+  return create(FileChangeSchema, {
+    path,
+    changeType: FileChangeType.DELETE,
+    captureLevel: FileChangeCaptureLevel.WHOLE_FILE,
+    before: create(FileContentSchema, { body: { case: "inline", value: "alpha\n" } }),
+  });
+}
+
+function gitEntry(id = "e1"): WorkspaceEntry {
+  return {
+    id,
+    name: "acme/repo",
+    type: "git",
+    gitUrl: "https://github.com/acme/repo",
+    gitBranch: "main",
+  };
+}
+
+const ENTRIES = [gitEntry()];
+
+function readerFor(result: WorkspaceFileContent | null): WorkspaceFileReader {
+  return vi.fn(async () => result);
+}
+
+function text(t: string): WorkspaceFileContent {
+  return { text: t, isBinary: false, size: t.length, encoding: "utf-8" };
+}
+
+describe("FileViewer", () => {
+  it("shows the unsupported state when no reader is injected", () => {
+    render(
+      <FileViewer
+        selectedFile={{ entryId: "e1", path: "src/a.ts" }}
+        entries={ENTRIES}
+        reader={undefined}
+      />,
+    );
+    expect(screen.getByText(/Preview isn.t available/i)).toBeTruthy();
+  });
+
+  it("shows a loading skeleton while the read is in flight", () => {
+    const reader: WorkspaceFileReader = () => new Promise(() => {});
+    render(
+      <FileViewer
+        selectedFile={{ entryId: "e1", path: "src/a.ts" }}
+        entries={ENTRIES}
+        reader={reader}
+      />,
+    );
+    expect(screen.getByLabelText("Loading file")).toBeTruthy();
+  });
+
+  it("renders displayable text via the shared renderer", async () => {
+    render(
+      <FileViewer
+        selectedFile={{ entryId: "e1", path: "src/a.ts" }}
+        entries={ENTRIES}
+        reader={readerFor(text("const answer = 42;"))}
+      />,
+    );
+    await waitFor(() =>
+      expect(screen.getByText("const answer = 42;")).toBeTruthy(),
+    );
+  });
+
+  it("shows the binary state for binary content", async () => {
+    render(
+      <FileViewer
+        selectedFile={{ entryId: "e1", path: "logo.png" }}
+        entries={ENTRIES}
+        reader={readerFor({ text: null, isBinary: true, size: 2048, encoding: "unknown" })}
+      />,
+    );
+    await waitFor(() => expect(screen.getByText(/Binary file/i)).toBeTruthy());
+  });
+
+  it("shows the too-large state for a size-capped read with no text", async () => {
+    render(
+      <FileViewer
+        selectedFile={{ entryId: "e1", path: "big.log" }}
+        entries={ENTRIES}
+        reader={readerFor({
+          text: null,
+          isBinary: false,
+          size: 20 * 1024 * 1024,
+          encoding: "none",
+          truncated: true,
+        })}
+      />,
+    );
+    await waitFor(() =>
+      expect(screen.getByText(/too large to preview/i)).toBeTruthy(),
+    );
+  });
+
+  it("shows the undecodable state when text is null without truncation or binary", async () => {
+    render(
+      <FileViewer
+        selectedFile={{ entryId: "e1", path: "weird.dat" }}
+        entries={ENTRIES}
+        reader={readerFor({ text: null, isBinary: false, size: 5, encoding: "unknown" })}
+      />,
+    );
+    await waitFor(() =>
+      expect(screen.getByText(/can.t be displayed as text/i)).toBeTruthy(),
+    );
+  });
+
+  it("shows the error state with a working Retry", async () => {
+    let attempt = 0;
+    const reader: WorkspaceFileReader = vi.fn(async () => {
+      attempt += 1;
+      if (attempt === 1) throw new Error("network down");
+      return text("recovered");
+    });
+    render(
+      <FileViewer
+        selectedFile={{ entryId: "e1", path: "src/a.ts" }}
+        entries={ENTRIES}
+        reader={reader}
+      />,
+    );
+
+    await waitFor(() => expect(screen.getByText("network down")).toBeTruthy());
+
+    fireEvent.click(screen.getByText("Retry"));
+
+    await waitFor(() => expect(screen.getByText("recovered")).toBeTruthy());
+    expect(reader).toHaveBeenCalledTimes(2);
+  });
+
+  it("shows the empty state when the owning entry has been removed", () => {
+    render(
+      <FileViewer
+        selectedFile={{ entryId: "gone", path: "src/a.ts" }}
+        entries={ENTRIES}
+        reader={readerFor(text("x"))}
+      />,
+    );
+    expect(screen.getByText(/no longer in the workspace/i)).toBeTruthy();
+  });
+
+  it("renders the basename and directory in the header", async () => {
+    render(
+      <FileViewer
+        selectedFile={{ entryId: "e1", path: "src/deep/module.ts" }}
+        entries={ENTRIES}
+        reader={readerFor(text("ok"))}
+      />,
+    );
+    expect(screen.getByText("module.ts")).toBeTruthy();
+    expect(screen.getByText("src/deep")).toBeTruthy();
+  });
+
+  it("invokes onClose from the close button", async () => {
+    const onClose = vi.fn();
+    render(
+      <FileViewer
+        selectedFile={{ entryId: "e1", path: "src/a.ts" }}
+        entries={ENTRIES}
+        reader={readerFor(text("ok"))}
+        onClose={onClose}
+      />,
+    );
+    fireEvent.click(screen.getByLabelText("Close file viewer"));
+    expect(onClose).toHaveBeenCalledTimes(1);
+  });
+
+  // --- no `change` prop: unchanged browse-only behavior (regression) --------
+
+  it("shows no view toggle when no change is provided", async () => {
+    render(
+      <FileViewer
+        selectedFile={{ entryId: "e1", path: "src/a.ts" }}
+        entries={ENTRIES}
+        reader={readerFor(text("plain content"))}
+      />,
+    );
+    await waitFor(() => expect(screen.getByText("plain content")).toBeTruthy());
+    expect(screen.queryByRole("radiogroup", { name: "File view" })).toBeNull();
+    expect(screen.queryByText(/Live — may differ/i)).toBeNull();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Diff mode (Slice 4) — a changed file defaults to its authoritative diff
+// ---------------------------------------------------------------------------
+
+describe("FileViewer — diff mode", () => {
+  it("defaults a changed file to the Diff view", async () => {
+    render(
+      <FileViewer
+        selectedFile={{ entryId: "e1", path: "src/a.ts" }}
+        entries={ENTRIES}
+        reader={readerFor(text("live content"))}
+        change={wholeFileChange("src/a.ts")}
+      />,
+    );
+
+    const group = screen.getByRole("radiogroup", { name: "File view" });
+    const diffRadio = screen.getByRole("radio", { name: "Diff" });
+    expect(diffRadio.getAttribute("aria-checked")).toBe("true");
+    expect(group).toBeTruthy();
+    // The diff (added side) renders; the live file body does not.
+    await waitFor(() => expect(screen.getByText("beta")).toBeTruthy());
+    expect(screen.queryByText("live content")).toBeNull();
+    // Refresh is meaningless for an immutable captured diff.
+    expect(screen.queryByLabelText("Reload a.ts")).toBeNull();
+  });
+
+  it("toggles to the live File view, showing the live caption and content", async () => {
+    render(
+      <FileViewer
+        selectedFile={{ entryId: "e1", path: "src/a.ts" }}
+        entries={ENTRIES}
+        reader={readerFor(text("live content"))}
+        change={wholeFileChange("src/a.ts")}
+      />,
+    );
+
+    fireEvent.click(screen.getByRole("radio", { name: "File" }));
+
+    await waitFor(() => expect(screen.getByText("live content")).toBeTruthy());
+    expect(screen.getByText(/Live — may differ from the reviewed change/i)).toBeTruthy();
+    expect(screen.getByRole("radio", { name: "File" }).getAttribute("aria-checked")).toBe("true");
+    // Refresh returns in the live view.
+    expect(screen.getByLabelText("Reload a.ts")).toBeTruthy();
+  });
+
+  it("omits the File option when no reader supports the substrate (diff only)", async () => {
+    render(
+      <FileViewer
+        selectedFile={{ entryId: "e1", path: "src/a.ts" }}
+        entries={ENTRIES}
+        reader={undefined}
+        change={wholeFileChange("src/a.ts")}
+      />,
+    );
+    await waitFor(() => expect(screen.getByText("beta")).toBeTruthy());
+    expect(screen.queryByRole("radiogroup", { name: "File view" })).toBeNull();
+  });
+
+  it("omits the File option for a DELETE change (no current bytes)", async () => {
+    render(
+      <FileViewer
+        selectedFile={{ entryId: "e1", path: "src/gone.ts" }}
+        entries={ENTRIES}
+        reader={readerFor(text("should not be reachable"))}
+        change={deleteChange("src/gone.ts")}
+      />,
+    );
+    await waitFor(() => expect(screen.getByText("alpha")).toBeTruthy());
+    expect(screen.queryByRole("radiogroup", { name: "File view" })).toBeNull();
+  });
+
+  it("supports arrow-key roving between Diff and File (radiogroup a11y)", async () => {
+    render(
+      <FileViewer
+        selectedFile={{ entryId: "e1", path: "src/a.ts" }}
+        entries={ENTRIES}
+        reader={readerFor(text("live content"))}
+        change={wholeFileChange("src/a.ts")}
+      />,
+    );
+
+    const diffRadio = screen.getByRole("radio", { name: "Diff" });
+    fireEvent.keyDown(diffRadio, { key: "ArrowRight" });
+    await waitFor(() =>
+      expect(screen.getByRole("radio", { name: "File" }).getAttribute("aria-checked")).toBe("true"),
+    );
+
+    fireEvent.keyDown(screen.getByRole("radio", { name: "File" }), { key: "ArrowLeft" });
+    await waitFor(() =>
+      expect(screen.getByRole("radio", { name: "Diff" }).getAttribute("aria-checked")).toBe("true"),
+    );
+  });
+
+  it("moves focus with selection when roving Diff|File", async () => {
+    render(
+      <FileViewer
+        selectedFile={{ entryId: "e1", path: "src/a.ts" }}
+        entries={ENTRIES}
+        reader={readerFor(text("live content"))}
+        change={wholeFileChange("src/a.ts")}
+      />,
+    );
+
+    const diffRadio = screen.getByRole("radio", { name: "Diff" });
+    diffRadio.focus();
+    fireEvent.keyDown(diffRadio, { key: "ArrowRight" });
+    await waitFor(() =>
+      expect(document.activeElement).toBe(screen.getByRole("radio", { name: "File" })),
+    );
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Reveal (jump-to-line) — a line target opens File view and scrolls to it
+// ---------------------------------------------------------------------------
+
+describe("FileViewer — reveal (jump-to-line)", () => {
+  let scrollIntoView: ReturnType<typeof vi.fn>;
+  beforeEach(() => {
+    scrollIntoView = vi.fn();
+    Element.prototype.scrollIntoView =
+      scrollIntoView as unknown as typeof Element.prototype.scrollIntoView;
+  });
+
+  it("opens a changed file in the live File view when a reveal is present (DR-1)", async () => {
+    render(
+      <FileViewer
+        selectedFile={{ entryId: "e1", path: "src/a.ts" }}
+        entries={ENTRIES}
+        reader={readerFor(text("live content"))}
+        change={wholeFileChange("src/a.ts")}
+        reveal={{ line: 1, nonce: 1 }}
+      />,
+    );
+
+    // File view wins over the diff-default, but the Diff toggle stays available.
+    expect(screen.getByRole("radio", { name: "File" }).getAttribute("aria-checked")).toBe("true");
+    expect(screen.getByRole("radio", { name: "Diff" })).toBeTruthy();
+    await waitFor(() => expect(screen.getByText("live content")).toBeTruthy());
+  });
+
+  it("highlights the revealed line and scrolls to it", async () => {
+    const { container } = render(
+      <FileViewer
+        selectedFile={{ entryId: "e1", path: "src/a.ts" }}
+        entries={ENTRIES}
+        reader={readerFor(text("one\ntwo\nthree"))}
+        reveal={{ line: 2, nonce: 1 }}
+      />,
+    );
+    await waitFor(() => expect(container.querySelector('[data-line="2"]')).not.toBeNull());
+    expect(container.querySelector('[data-line="2"]')?.className).toContain(
+      "bg-primary-subtle",
+    );
+    expect(scrollIntoView).toHaveBeenCalled();
+  });
+
+  it("re-forces the File view when a new reveal nonce arrives after a manual toggle", async () => {
+    const { rerender } = render(
+      <FileViewer
+        selectedFile={{ entryId: "e1", path: "src/a.ts" }}
+        entries={ENTRIES}
+        reader={readerFor(text("live content"))}
+        change={wholeFileChange("src/a.ts")}
+        reveal={{ line: 1, nonce: 1 }}
+      />,
+    );
+    // User flips to Diff.
+    fireEvent.click(screen.getByRole("radio", { name: "Diff" }));
+    await waitFor(() =>
+      expect(screen.getByRole("radio", { name: "Diff" }).getAttribute("aria-checked")).toBe("true"),
+    );
+
+    // A second search hit in the same (already-mounted) file bumps the nonce.
+    rerender(
+      <FileViewer
+        selectedFile={{ entryId: "e1", path: "src/a.ts" }}
+        entries={ENTRIES}
+        reader={readerFor(text("live content"))}
+        change={wholeFileChange("src/a.ts")}
+        reveal={{ line: 1, nonce: 2 }}
+      />,
+    );
+    await waitFor(() =>
+      expect(screen.getByRole("radio", { name: "File" }).getAttribute("aria-checked")).toBe("true"),
+    );
+  });
+
+  it("is a no-op for a DELETE change (no live bytes to anchor)", async () => {
+    render(
+      <FileViewer
+        selectedFile={{ entryId: "e1", path: "src/gone.ts" }}
+        entries={ENTRIES}
+        reader={readerFor(text("unused"))}
+        change={deleteChange("src/gone.ts")}
+        reveal={{ line: 1, nonce: 1 }}
+      />,
+    );
+    // Falls back to the diff (deleted side); no view toggle, no crash.
+    await waitFor(() => expect(screen.getByText("alpha")).toBeTruthy());
+    expect(screen.queryByRole("radiogroup", { name: "File view" })).toBeNull();
+  });
+});

package/src/workspace/__tests__/WorkspaceContentSearch.test.tsx

@@ -0,0 +1,229 @@
+import { describe, it, expect, vi, afterEach } from "vitest";
+import { render, screen, fireEvent, cleanup } from "@testing-library/react";
+import { WorkspaceContentSearch } from "../WorkspaceContentSearch";
+import type { WorkspaceEntry } from "../useWorkspaceEntries";
+import type {
+  WorkspaceContentMatch,
+  WorkspaceContentSearchResult,
+  WorkspaceContentSearcher,
+} from "../WorkspaceContentSearcher";
+
+let entryIdCounter = 0;
+
+function makeEntry(overrides?: Partial<WorkspaceEntry>): WorkspaceEntry {
+  return {
+    id: `ws-${++entryIdCounter}`,
+    name: "acme/api",
+    type: "local",
+    localPath: "/repo",
+    ...overrides,
+  };
+}
+
+function match(path: string, line: number, preview: string): WorkspaceContentMatch {
+  return { path, line, preview };
+}
+
+function ok(
+  matches: WorkspaceContentMatch[],
+  truncated = false,
+): WorkspaceContentSearchResult {
+  return { matches, truncated };
+}
+
+function searcherReturning(result: WorkspaceContentSearchResult): WorkspaceContentSearcher {
+  return vi.fn(async () => result);
+}
+
+function typeQuery(value: string) {
+  const input = screen.getByRole("combobox");
+  fireEvent.change(input, { target: { value } });
+  return input;
+}
+
+afterEach(cleanup);
+
+describe("WorkspaceContentSearch", () => {
+  it("shows an unavailable state and disables input when no searcher is injected", () => {
+    render(
+      <WorkspaceContentSearch entries={[makeEntry()]} searcher={undefined} onOpenFile={vi.fn()} />,
+    );
+    expect(screen.getByText(/text search isn.t available here/i)).toBeTruthy();
+    expect(screen.getByRole("combobox")).toHaveProperty("disabled", true);
+  });
+
+  it("shows a hint when the query is empty", () => {
+    render(
+      <WorkspaceContentSearch
+        entries={[makeEntry()]}
+        searcher={searcherReturning(ok([]))}
+        onOpenFile={vi.fn()}
+      />,
+    );
+    expect(screen.getByText(/search file contents across the whole workspace/i)).toBeTruthy();
+  });
+
+  it("shows a min-length hint below the threshold and does not search", () => {
+    const searcher = searcherReturning(ok([match("a.ts", 1, "x")]));
+    render(
+      <WorkspaceContentSearch entries={[makeEntry()]} searcher={searcher} onOpenFile={vi.fn()} />,
+    );
+    typeQuery("a");
+    // Assert the visible message, not the parallel sr-only live-region copy.
+    expect(
+      screen.getByText(/type at least 2 characters/i, { ignore: ".sr-only" }),
+    ).toBeTruthy();
+    expect(searcher).not.toHaveBeenCalled();
+  });
+
+  it("renders a file header with line rows and opens the file on click (single entry)", async () => {
+    const entry = makeEntry();
+    const onOpenFile = vi.fn();
+    render(
+      <WorkspaceContentSearch
+        entries={[entry]}
+        searcher={searcherReturning(
+          ok([match("src/app.ts", 3, "const foo = 1"), match("src/app.ts", 7, "return foo")]),
+        )}
+        onOpenFile={onOpenFile}
+      />,
+    );
+
+    typeQuery("foo");
+    const options = await screen.findAllByRole("option");
+    expect(options).toHaveLength(2);
+    // File header (basename) present; single entry → no entry header.
+    expect(screen.getByText("app.ts")).toBeTruthy();
+    expect(screen.queryByText("acme/api")).toBeNull();
+
+    // Clicking a line hit opens via the shared onOpenFile seam (the same path a
+    // tree/filename click uses — this is what makes a changed file honor the
+    // FileViewer diff-default; see FileViewer diff-mode suite).
+    fireEvent.click(options[0]);
+    // The hit's line rides along so the viewer jumps to it (DR-1/DR-2).
+    expect(onOpenFile).toHaveBeenCalledWith(entry.id, "src/app.ts", { line: 3 });
+  });
+
+  it("shows an entry header when more than one entry has hits", async () => {
+    const a = makeEntry({ name: "acme/api" });
+    const b = makeEntry({ name: "acme/web" });
+    const searcher: WorkspaceContentSearcher = vi.fn(async (e) =>
+      e.id === a.id ? ok([match("a.ts", 1, "foo")]) : ok([match("b.ts", 2, "foo")]),
+    );
+    render(<WorkspaceContentSearch entries={[a, b]} searcher={searcher} onOpenFile={vi.fn()} />);
+
+    typeQuery("foo");
+    await screen.findAllByRole("option");
+    expect(screen.getByText("acme/api")).toBeTruthy();
+    expect(screen.getByText("acme/web")).toBeTruthy();
+  });
+
+  it("highlights every occurrence of the query in the preview", async () => {
+    const { container } = render(
+      <WorkspaceContentSearch
+        entries={[makeEntry()]}
+        searcher={searcherReturning(ok([match("a.ts", 1, "foo and foo")]))}
+        onOpenFile={vi.fn()}
+      />,
+    );
+    typeQuery("foo");
+    await screen.findByRole("option");
+    const highlights = container.querySelectorAll(".font-semibold");
+    expect(Array.from(highlights).map((el) => el.textContent)).toEqual(["foo", "foo"]);
+  });
+
+  it("shows a no-match state", async () => {
+    render(
+      <WorkspaceContentSearch
+        entries={[makeEntry()]}
+        searcher={searcherReturning(ok([]))}
+        onOpenFile={vi.fn()}
+      />,
+    );
+    typeQuery("zzz");
+    expect(
+      await screen.findByText(/no files containing/i, { ignore: ".sr-only" }),
+    ).toBeTruthy();
+  });
+
+  it("moves virtual focus with ArrowDown and opens on Enter", async () => {
+    const entry = makeEntry();
+    const onOpenFile = vi.fn();
+    render(
+      <WorkspaceContentSearch
+        entries={[entry]}
+        searcher={searcherReturning(
+          ok([match("a.ts", 1, "foo"), match("a.ts", 2, "foo")]),
+        )}
+        onOpenFile={onOpenFile}
+      />,
+    );
+
+    const input = typeQuery("foo");
+    await screen.findAllByRole("option");
+
+    fireEvent.keyDown(input, { key: "ArrowDown" });
+    const active = input.getAttribute("aria-activedescendant");
+    expect(active).toBeTruthy();
+    expect(document.getElementById(active!)?.getAttribute("aria-selected")).toBe("true");
+
+    fireEvent.keyDown(input, { key: "Enter" });
+    expect(onOpenFile).toHaveBeenCalledWith(entry.id, "a.ts", { line: 1 });
+  });
+
+  it("caps rendered rows and reports the total", async () => {
+    const many = Array.from({ length: 250 }, (_, i) => match("a.ts", i + 1, "foo"));
+    render(
+      <WorkspaceContentSearch
+        entries={[makeEntry()]}
+        searcher={searcherReturning(ok(many))}
+        onOpenFile={vi.fn()}
+      />,
+    );
+    typeQuery("foo");
+    await screen.findAllByRole("option");
+    expect(screen.getAllByRole("option")).toHaveLength(200);
+    expect(
+      screen.getByText(/showing the first 200 of 250 matches/i, {
+        ignore: ".sr-only",
+      }),
+    ).toBeTruthy();
+  });
+
+  it("announces result status in a polite live region", async () => {
+    // Content matching is backend-delegated, so the searcher must vary by query.
+    const searcher: WorkspaceContentSearcher = vi.fn(async (_e, query) =>
+      query === "foo" ? ok([match("a.ts", 1, "foo")]) : ok([]),
+    );
+    render(
+      <WorkspaceContentSearch
+        entries={[makeEntry()]}
+        searcher={searcher}
+        onOpenFile={vi.fn()}
+      />,
+    );
+    const status = screen.getByRole("status");
+    expect(status.getAttribute("aria-live")).toBe("polite");
+
+    typeQuery("foo");
+    await screen.findByRole("option");
+    expect(status.textContent).toMatch(/match/i);
+
+    typeQuery("zzz");
+    await screen.findByText(/no files containing/i, { ignore: ".sr-only" });
+    expect(status.textContent).toMatch(/no files containing/i);
+  });
+
+  it("renders a truncation notice when a search was capped", async () => {
+    render(
+      <WorkspaceContentSearch
+        entries={[makeEntry()]}
+        searcher={searcherReturning(ok([match("a.ts", 1, "foo")], true))}
+        onOpenFile={vi.fn()}
+      />,
+    );
+    typeQuery("foo");
+    await screen.findByRole("option");
+    expect(screen.getByText(/more matches exist than shown/i)).toBeTruthy();
+  });
+});

package/src/workspace/__tests__/WorkspaceEditor-initialPanel.test.tsx

@@ -146,6 +146,25 @@ describe("WorkspaceEditor initialPanel", () => {
     expect(screen.getByText("new-repo")).toBeTruthy();
   });
 
+  it("labels the manual git inputs for assistive tech (no OAuth connection)", () => {
+    // With no gitHubConnection, the panel falls back to manual URL/branch entry.
+    render(
+      <WorkspaceEditor
+        workspace={createMockWorkspace()}
+        enableGitHub
+        enableLocal={false}
+        initialPanel="github"
+      />,
+    );
+    // Accessible names come from aria-label, not the disappearing placeholder.
+    expect(
+      screen.getByRole("textbox", { name: "Git repository URL" }),
+    ).toBeTruthy();
+    expect(
+      screen.getByRole("textbox", { name: "Branch (optional)" }),
+    ).toBeTruthy();
+  });
+
   it("shows loading state when GitHub is checking connection with initialPanel='github'", () => {
     const connection = createMockGitHubConnection({ isLoading: true });