vscode-cowriting-plugin/test/e2e/suite/undoMarks.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";
import { undoWorks, UNDO_SKIP_REASON } from "./undoCapable";

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?.attributionController && api?.trackChangesPreviewController, "exports attribution + preview");
  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);
  await vscode.window.showTextDocument(doc);
  await settle();
  return { doc, key: uri.toString() };
}

// #38 (P1): undo in the editor renders WRONG marks in the F10 review preview.
// Root cause: attribution attributes every non-seam change to the human and
// ignores e.reason, so an undo that re-inserts text falsely colors it human.
// We drive a MID-EDIT undo (buffer stays dirty, so the disk-sync guard doesn't
// mask it) and assert the restored baseline text is NOT re-attributed.
suite("F10 #38 — undo does not mis-attribute restored text (host E2E, no LLM)", () => {
  const DOC_REL = "docs/undo38.md";
  const BASE = "Alpha bravo charlie.\n";

  // #54: skip (loudly) where executeCommand("undo") is non-functional; run where it works.
  suiteSetup(async function () {
    if (!(await undoWorks())) {
      console.warn(UNDO_SKIP_REASON);
      this.skip();
    }
  });

  test("undo of a deletion of baseline text leaves it unattributed (not human)", async () => {
    const { doc, key } = await freshDoc(DOC_REL, BASE);
    const api = await getApi();

    // Forward edit 1 (human): append a tail so a LATER undo of edit 2 keeps the
    // buffer dirty (≠ disk) → the attribution branch runs, not the disk-sync one.
    const e1 = new vscode.WorkspaceEdit();
    e1.insert(doc.uri, doc.positionAt(doc.getText().length), "\nHuman tail.\n");
    assert.ok(await vscode.workspace.applyEdit(e1), "edit 1 applied");
    await settle();

    // Forward edit 2 (human): delete the baseline word "bravo " (offsets 6..12).
    const e2 = new vscode.WorkspaceEdit();
    e2.delete(doc.uri, new vscode.Range(doc.positionAt(6), doc.positionAt(12)));
    assert.ok(await vscode.workspace.applyEdit(e2), "edit 2 applied");
    await settle();
    assert.ok(!doc.getText().includes("bravo"), "bravo deleted");

    // Undo edit 2 → "bravo " is re-inserted. It is RESTORED baseline text, not
    // freshly authored — it must NOT become a human-attributed span.
    await vscode.commands.executeCommand("undo");
    await settle();
    assert.ok(doc.getText().includes("Alpha bravo charlie."), "undo restored 'bravo '");
    assert.ok(doc.isDirty, "buffer still dirty (mid-edit undo → attribution branch, not disk-sync)");

    const bravoStart = doc.getText().indexOf("bravo");
    const spans = api.attributionController.spansFor(doc);
    const overBravo = spans.filter((s) => s.start < bravoStart + 5 && s.end > bravoStart);
    assert.deepStrictEqual(
      overBravo,
      [],
      `restored baseline text 'bravo' must be unattributed, got spans: ${JSON.stringify(overBravo)}`,
    );

    // And the on-state render must not color 'bravo' as human-authored.
    const html = api.trackChangesPreviewController.renderHtmlFor(key);
    const bravoColoredHuman = /<span class="cw-by-human">[^<]*bravo/.test(html);
    assert.ok(!bravoColoredHuman, "restored 'bravo' is not colored cw-by-human in the preview");
  });
});