vscode-cowriting-plugin/test/e2e/suite/f12Reach.test.ts

import * as assert from "assert";
import * as fs from "fs";
import * as path from "path";
import * as vscode from "vscode";
import type { CowritingApi } from "../../../src/extension";

const WS = process.env.E2E_WORKSPACE!;
const settle = () => new Promise((r) => setTimeout(r, 400));

async function getApi(): Promise<CowritingApi> {
  const ext = vscode.extensions.getExtension("benstull.vscode-cowriting-plugin")!;
  const api = (await ext.activate()) as CowritingApi;
  assert.ok(api?.threadController, "exports thread controller");
  return api;
}

async function freshDoc(rel: string, body: string): Promise<{ doc: vscode.TextDocument; key: string }> {
  const abs = path.join(WS, rel);
  fs.mkdirSync(path.dirname(abs), { recursive: true });
  fs.writeFileSync(abs, body, "utf8");
  const uri = vscode.Uri.file(abs);
  const doc = await vscode.workspace.openTextDocument(uri);
  // INV-10: cowriting.editDocument now warns instead of editing a non-entered
  // doc (Task 4) — enter it here (briefly making it active) so the tests below
  // exercise the routing/targeting behavior, not the gate. The caller
  // re-establishes whichever doc it wants active afterward.
  await vscode.window.showTextDocument(doc);
  await vscode.commands.executeCommand("cowriting.coeditDocument");
  return { doc, key: uri.toString() };
}

function pkg(): any {
  return JSON.parse(fs.readFileSync(path.join(__dirname, "../../../../package.json"), "utf8"));
}
function menu(id: string): Array<{ command: string; when?: string; group?: string }> {
  return pkg().contributes.menus[id] ?? [];
}

// SLICE-1 / #42 (reach): "Ask Claude to Edit" reachable from the editor BODY and
// the editor TAB. The two split commands (editSelection / editDocument) were
// unified behind ONE user-facing command `cowriting.edit` that auto-routes by
// selection at runtime (routeEdit: selection → editSelection, none → editDocument)
// — so the menus carry a SINGLE selection-agnostic entry, both markdown/authorable
// -gated. The routing itself is unit-tested (routeEdit) and exercised through the
// command below; here we assert the declarative menu `when` clauses.
suite("F12 SLICE-1 — Ask-Claude reach (#42, INV-38)", () => {
  // PUC-1/2: editor BODY (editor/context) offers the single unified entry,
  // markdown + authorable gated, NOT selection-gated (it routes both cases).
  test("editor/context offers a single 'Ask Claude to Edit' (cowriting.edit), markdown+authorable", () => {
    const m = menu("editor/context");
    const edit = m.find((e) => e.command === "cowriting.edit");
    assert.ok(edit, "cowriting.edit is in editor/context");
    assert.match(edit!.when ?? "", /editorLangId == markdown/, "gated on markdown");
    assert.match(edit!.when ?? "", /resourceScheme == file|resourceScheme == untitled/, "gated authorable");
    assert.ok(!/editorHasSelection/.test(edit!.when ?? ""), "not selection-gated — one entry routes both cases");
    // The old split pair is gone from the menu (the commands stay registered/hidden).
    assert.ok(!m.some((e) => e.command === "cowriting.editSelection"), "old editSelection menu entry removed");
    assert.ok(!m.some((e) => e.command === "cowriting.editDocument"), "old editDocument menu entry removed");
  });

  // PUC-3: editor TAB (editor/title/context) carries the same single entry.
  test("editor/title/context offers a single 'Ask Claude to Edit' (cowriting.edit), markdown-gated", () => {
    const m = menu("editor/title/context");
    const edit = m.find((e) => e.command === "cowriting.edit");
    assert.ok(edit, "cowriting.edit is in editor/title/context");
    assert.match(edit!.when ?? "", /resourceLangId == markdown/, "tab entry gated on markdown");
    assert.ok(
      !m.some((e) => e.command === "cowriting.editSelection" || e.command === "cowriting.editDocument"),
      "old split pair removed from the tab menu",
    );
  });

  // PUC-3 behavior: editDocument invoked with a tab URI targets THAT document,
  // not whatever editor happens to be active (mirrors #41's clicked-doc resolution).
  // Finding 1 fix (native-surfaces code review): editDocument no longer prompts via
  // the removed askEditInstruction webview stub (that path threw a silent, `void`'d,
  // unhandled rejection — no toast, no thread, no proposal). It now resolves/focuses
  // its target document and hands off to ThreadController.askClaude() (D19), same as
  // editSelection. The turn→proposal cut itself (EditFlow.runEditAndPropose against a
  // {kind:"document"} target) is exercised directly, without the command, in
  // f11Toolbar.test.ts / f12Accept.test.ts / f12Review.test.ts — this test's job is
  // the URI-targeting/focus behavior, plus confirming the routing actually reaches
  // askClaude (proving Finding 1's dead end is gone).
  test("editDocument(uri) targets the clicked tab's document, not the active editor", async () => {
    const api = await getApi();

    // Doc A is the active editor; Doc B is the "clicked tab" we pass by URI.
    const a = await freshDoc("docs/f12-active.md", "# Active\n\nThe active editor paragraph.\n");
    const b = await freshDoc("docs/f12-tab.md", "# Tab\n\nThe tab target paragraph to rewrite.\n");
    await vscode.window.showTextDocument(a.doc);
    await settle();

    let askClaudeCalls = 0;
    // Capture the active-editor doc INSIDE the spy, before delegating to the real
    // askClaude — askClaude's own `workbench.action.addComment` side effect moves
    // focus to the ephemeral comment-input widget (a `comment://` URI), which would
    // make a post-hoc `activeTextEditor` check meaningless. What we're proving here
    // is editDocument's OWN resolve-and-focus step ran against the right document
    // before handing off.
    let focusedDocAtHandoff: string | undefined;
    const origAskClaude = api.threadController.askClaude.bind(api.threadController);
    api.threadController.askClaude = async () => {
      askClaudeCalls++;
      focusedDocAtHandoff = vscode.window.activeTextEditor?.document.uri.toString();
      return origAskClaude();
    };
    try {
      await vscode.commands.executeCommand("cowriting.editDocument", b.doc.uri);
      await settle();
    } finally {
      api.threadController.askClaude = origAskClaude;
    }

    assert.strictEqual(
      askClaudeCalls,
      1,
      "editDocument(uri) reached ThreadController.askClaude — not the removed prompt stub",
    );
    assert.strictEqual(
      focusedDocAtHandoff,
      b.doc.uri.toString(),
      "editDocument(uri) focused the TAB doc B, not the previously-active doc A, before handing off to askClaude",
    );
  });

  // No URI arg (palette / keybinding) → fall back to the active editor.
  test("editDocument() with no arg targets the active editor", async () => {
    const api = await getApi();
    const a = await freshDoc("docs/f12-noarg.md", "# No arg\n\nThe active doc paragraph here.\n");
    await vscode.window.showTextDocument(a.doc);
    await settle();

    let askClaudeCalls = 0;
    // See the sibling test above for why this is captured inside the spy rather
    // than after askClaude() returns.
    let focusedDocAtHandoff: string | undefined;
    const origAskClaude = api.threadController.askClaude.bind(api.threadController);
    api.threadController.askClaude = async () => {
      askClaudeCalls++;
      focusedDocAtHandoff = vscode.window.activeTextEditor?.document.uri.toString();
      return origAskClaude();
    };
    try {
      await vscode.commands.executeCommand("cowriting.editDocument");
      await settle();
    } finally {
      api.threadController.askClaude = origAskClaude;
    }

    assert.strictEqual(askClaudeCalls, 1, "editDocument() with no arg reached ThreadController.askClaude");
    assert.strictEqual(
      focusedDocAtHandoff,
      a.doc.uri.toString(),
      "editDocument() with no arg kept the active editor's doc active before handing off to askClaude",
    );
  });
});