@ilya-lesikov/pi-pi 0.8.0 → 0.10.0

package/extensions/orchestrator/pp-menu.test.ts

@@ -1,11 +1,45 @@
 import { afterEach, describe, expect, it, vi } from "vitest";
 import { join } from "path";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "fs";
+import { tmpdir } from "os";
 import { getDefaultConfig, GLOBAL_CONFIG_PATH, parseDuration } from "./config.js";
 import * as configModule from "./config.js";
 import * as flantInfra from "./flant-infra.js";
-import { formatDuration, formatSourceTags, getConfigSourceInfo, pickMaxReviewPasses, showUsage } from "./pp-menu.js";
+import { formatDuration, formatSourceTags, getConfigSourceInfo, pickMaxReviewPasses, publishGuard, publishFileCommentsBanner, publishPrCommentsBanner, showActiveTaskMenu, showUsage } from "./pp-menu.js";
 import { createUsageTracker } from "./usage-tracker.js";
 
+// Drives showActiveTaskMenu's submenu navigation by scripting selectOption answers.
+const askQueue: string[] = [];
+const askQuestions: string[] = [];
+vi.mock("../../3p/pi-ask-user/index.js", () => ({
+  isCancel: (r: any) => r?.__cancel === true,
+  askUser: vi.fn(async (_ctx: any, opts: any) => {
+    askQuestions.push(opts.question);
+    const next = askQueue.shift();
+    if (next === undefined || next === "__ESC__") return { __cancel: true, reason: "user" };
+    return { kind: "selection", selections: [next] };
+  }),
+}));
+
+// Scripts per-repo Plannotator outcomes for the #3a interleaved cursor tests.
+const plannotatorResults: Array<{ approved: boolean; feedback?: string; error?: string }> = [];
+const plannotatorOpenCwds: string[] = [];
+const annotateReviewResults: Array<{ feedback: string; approved?: boolean; exit?: boolean } | null> = [];
+const annotateReviewPayloads: any[] = [];
+vi.mock("./plannotator.js", () => ({
+  cancelPendingPlannotatorWait: () => {},
+  openPlannotator: vi.fn(async (_pi: any, _action: string, payload: any) => {
+    plannotatorOpenCwds.push(payload?.cwd);
+    return { opened: true, reviewId: "rev" };
+  }),
+  openAnnotateReview: vi.fn(async (_pi: any, payload: any) => {
+    annotateReviewPayloads.push(payload);
+    const result = annotateReviewResults.shift() ?? { feedback: "", approved: true };
+    return { opened: true, result };
+  }),
+  waitForPlannotatorResult: vi.fn(async () => plannotatorResults.shift() ?? { approved: true }),
+}));
+
 const USAGE_TRACKER_SYMBOL = Symbol.for("pi-pi:usage-tracker");
 
 afterEach(() => {
@@ -205,3 +239,282 @@ describe("pickMaxReviewPasses", () => {
     expect(await pickMaxReviewPasses(makeInputCtx([""]), 3)).toBeNull();
   });
 });
+
+describe("publishGuard", () => {
+  let taskDir: string;
+
+  afterEach(() => {
+    if (taskDir) rmSync(taskDir, { recursive: true, force: true });
+  });
+
+  function makeTask(): string {
+    taskDir = mkdtempSync(join(tmpdir(), "pp-guard-"));
+    return taskDir;
+  }
+
+  it("blocks publishing when no review has run (no code-reviews dir)", () => {
+    const dir = makeTask();
+    const msg = publishGuard(dir);
+    expect(msg).toBeTruthy();
+    expect(msg).toContain("review pass");
+  });
+
+  it("blocks publishing when a final_pass file exists but carries no ANCHORS block", () => {
+    const dir = makeTask();
+    mkdirSync(join(dir, "code-reviews"));
+    writeFileSync(join(dir, "code-reviews", "20260101-000000_final_pass-1.md"), "# Findings\n\nSome prose without anchors.\n");
+    expect(publishGuard(dir)).toBeTruthy();
+  });
+
+  it("allows publishing when the latest final_pass file has an ANCHORS block", () => {
+    const dir = makeTask();
+    mkdirSync(join(dir, "code-reviews"));
+    writeFileSync(join(dir, "code-reviews", "20260101-000000_final_pass-1.md"), "ANCHORS:\nsrc/a.ts:10 — bug\n");
+    expect(publishGuard(dir)).toBeUndefined();
+  });
+
+  it("resolves the newest final_pass file by name and honors its ANCHORS block", () => {
+    const dir = makeTask();
+    mkdirSync(join(dir, "code-reviews"));
+    writeFileSync(join(dir, "code-reviews", "20260101-000000_final_pass-1.md"), "ANCHORS:\nsrc/a.ts:10 — bug\n");
+    writeFileSync(join(dir, "code-reviews", "20260102-000000_final_pass-2.md"), "# Findings\n\nno anchors here\n");
+    expect(publishGuard(dir)).toBeTruthy();
+  });
+});
+
+describe("publish banners", () => {
+  it("PR banner posts one bundled COMMENT review per repo, pre-validated against the diff", () => {
+    const banner = publishPrCommentsBanner("/tmp/task");
+    expect(banner).toContain("pulls/<number>/reviews");
+    expect(banner).toContain("event=COMMENT");
+    expect(banner).not.toContain("event=APPROVE");
+    expect(banner).toContain("never APPROVE or REQUEST_CHANGES");
+    expect(banner).toContain("PRE-VALIDATE");
+    expect(banner).toContain("all-or-nothing");
+    expect(banner).toContain("Findings not anchorable to the diff:");
+    expect(banner).toContain("(generated by pi-pi)");
+  });
+
+  it("PR banner idempotency matches on path+line+footer+body", () => {
+    const banner = publishPrCommentsBanner("/tmp/task");
+    expect(banner).toContain("footer, AND body text all match");
+    expect(banner).toContain("Two distinct findings on the same line are NOT duplicates");
+  });
+
+  it("both banners carry the privacy instruction", () => {
+    for (const banner of [publishPrCommentsBanner("/tmp/task"), publishFileCommentsBanner("/tmp/task")]) {
+      expect(banner).toContain("PRIVACY:");
+      expect(banner).toContain("the ticket");
+      expect(banner).toContain("self-contained");
+    }
+  });
+});
+
+describe("showActiveTaskMenu Publish/Next Back navigation (#6)", () => {
+  let taskDir: string;
+
+  afterEach(() => {
+    askQueue.length = 0;
+    askQuestions.length = 0;
+    if (taskDir) rmSync(taskDir, { recursive: true, force: true });
+  });
+
+  function makeReviewOrchestrator(): any {
+    taskDir = mkdtempSync(join(tmpdir(), "pp-nav-"));
+    return {
+      active: {
+        type: "review",
+        dir: taskDir,
+        state: { phase: "review", step: "llm_work", mode: "guided" },
+      },
+      transitionController: {
+        isRunning: () => false,
+        abortMainAgent: () => {},
+      },
+      cancelPendingRetry: () => {},
+      abortAllSubagents: () => {},
+    };
+  }
+
+  const ctx = { ui: { notify: () => {} }, waitForIdle: async () => {}, abort: () => {} };
+
+  it("Publish 'Back' re-renders the Next submenu instead of the top-level menu", async () => {
+    const orchestrator = makeReviewOrchestrator();
+    // /pp -> Next -> Publish -> Back (should return to Next) -> Back (to top-level) -> Back (exit).
+    askQueue.push("Next", "Publish", "Back", "Back", "Back to prompt");
+    const result = await showActiveTaskMenu(orchestrator, ctx, "/pp", "tool");
+    expect(result).toBe("");
+    // After Publish's Back we must see the "Next" submenu rendered again before the
+    // top-level menu reappears: questions = [top, Next, Publish, Next(again), top].
+    const nextRenders = askQuestions.filter((q) => q === "Next").length;
+    expect(nextRenders).toBe(2);
+    expect(askQuestions[askQuestions.length - 1]).toContain("/pp");
+  });
+
+  it("Next 'Back' returns straight to the top-level menu", async () => {
+    const orchestrator = makeReviewOrchestrator();
+    askQueue.push("Next", "Back", "Back to prompt");
+    const result = await showActiveTaskMenu(orchestrator, ctx, "/pp", "tool");
+    expect(result).toBe("");
+    expect(askQuestions.filter((q) => q === "Next").length).toBe(1);
+    // Top-level rendered twice (initial + after Next's Back), Next once.
+    expect(askQuestions.filter((q) => q.startsWith("/pp")).length).toBe(2);
+  });
+
+  it("Review submenu 'Editor review' Back returns to Review, not the top-level menu (#3d)", async () => {
+    const orchestrator = makeReviewOrchestrator();
+    // /pp -> Review -> Review on my own -> Editor review Back (should return to
+    // Review) -> Review Back (to top-level) -> top-level Back (exit).
+    askQueue.push("Review", "Review on my own", "Back", "Back", "Back to prompt");
+    const result = await showActiveTaskMenu(orchestrator, ctx, "/pp", "tool");
+    expect(result).toBe("");
+    // Review submenu rendered twice (initial + after the Editor-review Back).
+    expect(askQuestions.filter((q) => q === "Review").length).toBe(2);
+    // Top-level rendered twice (initial + after Review's explicit Back).
+    expect(askQuestions.filter((q) => q.startsWith("/pp")).length).toBe(2);
+  });
+
+  it("resumes the per-repo Plannotator cursor and interleaves fixes (#3a)", async () => {
+    const orchestrator = makeReviewOrchestrator();
+    orchestrator.active.type = "implement";
+    orchestrator.active.state.phase = "implement";
+    orchestrator.active.state.repos = [
+      { path: "/repo/a", isRoot: true },
+      { path: "/repo/b", isRoot: false },
+    ];
+    orchestrator.active.state.plannotatorCursor = { repoPaths: ["/repo/a", "/repo/b"], index: 0 };
+    orchestrator.pi = { exec: vi.fn(async () => ({ code: 0, stdout: "", stderr: "" })) };
+    orchestrator.config = getDefaultConfig();
+
+    // First repo: choose a diff scope, Plannotator returns NEEDS_CHANGES → the
+    // menu exits with a work instruction and the cursor advances to repo b.
+    plannotatorResults.push({ approved: false, feedback: "fix the thing" });
+    askQueue.push("Uncommitted changes");
+    const first = await showActiveTaskMenu(orchestrator, ctx, "/pp", "tool");
+    expect(first).toContain("Plannotator requested changes");
+    expect(first).toContain("fix the thing");
+    expect(orchestrator.active.state.plannotatorCursor).toEqual({ repoPaths: ["/repo/a", "/repo/b"], index: 1 });
+
+    // Next /pp resumes at repo b; APPROVED → cursor is cleared and the loop ends,
+    // falling through to the normal menu (top-level Back exits).
+    plannotatorResults.push({ approved: true });
+    askQueue.push("Uncommitted changes", "Back to prompt");
+    const second = await showActiveTaskMenu(orchestrator, ctx, "/pp", "tool");
+    expect(second).toBe("");
+    expect(orchestrator.active.state.plannotatorCursor).toBeUndefined();
+  });
+
+  function makeCursorOrchestrator(): any {
+    const orchestrator = makeReviewOrchestrator();
+    orchestrator.active.type = "implement";
+    orchestrator.active.state.phase = "implement";
+    orchestrator.active.state.repos = [{ path: "/repo/a", isRoot: true }, { path: "/repo/b", isRoot: false }];
+    orchestrator.active.state.plannotatorCursor = { repoPaths: ["/repo/a", "/repo/b"], index: 0 };
+    orchestrator.pi = { exec: vi.fn(async () => ({ code: 0, stdout: "", stderr: "" })) };
+    orchestrator.config = getDefaultConfig();
+    return orchestrator;
+  }
+
+  it("Plannotator error + Retry leaves the cursor on the same repo (#3, error retention)", async () => {
+    const orchestrator = makeCursorOrchestrator();
+    plannotatorOpenCwds.length = 0;
+    // Repo a errors; user chooses Retry → cursor stays at index 0. Then a second
+    // attempt on repo a approves, advancing to b, which approves and clears.
+    plannotatorResults.push({ approved: false, error: "boom" });
+    plannotatorResults.push({ approved: true });
+    plannotatorResults.push({ approved: true });
+    askQueue.push("Uncommitted changes", "Retry", "Uncommitted changes", "Uncommitted changes", "Back to prompt");
+    const result = await showActiveTaskMenu(orchestrator, ctx, "/pp", "tool");
+    expect(result).toBe("");
+    // Retry re-opened repo a (opened twice) before advancing to b; none dropped.
+    expect(plannotatorOpenCwds).toEqual(["/repo/a", "/repo/a", "/repo/b"]);
+    // Both repos ultimately reviewed and the cursor cleared (none silently dropped).
+    expect(orchestrator.active.state.plannotatorCursor).toBeUndefined();
+  });
+
+  it("Plannotator error + Skip advances the cursor past the failed repo (#3)", async () => {
+    const orchestrator = makeCursorOrchestrator();
+    plannotatorOpenCwds.length = 0;
+    // Repo a errors; Skip advances to repo b, which approves and clears the cursor.
+    plannotatorResults.push({ approved: false, error: "boom" });
+    plannotatorResults.push({ approved: true });
+    askQueue.push("Uncommitted changes", "Skip this repo", "Uncommitted changes", "Back to prompt");
+    await showActiveTaskMenu(orchestrator, ctx, "/pp", "tool");
+    // Skip moved on to repo b (each repo opened exactly once — a not retried, b reached).
+    expect(plannotatorOpenCwds).toEqual(["/repo/a", "/repo/b"]);
+    expect(orchestrator.active.state.plannotatorCursor).toBeUndefined();
+  });
+
+  it("Plannotator error + Done stops and clears the cursor (#3)", async () => {
+    const orchestrator = makeCursorOrchestrator();
+    plannotatorResults.push({ approved: false, error: "boom" });
+    askQueue.push("Uncommitted changes", "Done (stop reviewing)");
+    await showActiveTaskMenu(orchestrator, ctx, "/pp", "tool");
+    expect(orchestrator.active.state.plannotatorCursor).toBeUndefined();
+  });
+
+  it("blocks a second review while one is already running (#3b)", async () => {
+    const orchestrator = makeReviewOrchestrator();
+    orchestrator.active.state.reviewCycle = { kind: "auto", step: "await_reviewers", pass: 1 };
+    // isRunning() true so the top-level "Review" option is offered.
+    orchestrator.transitionController.isRunning = () => true;
+    let notified = "";
+    const notifyCtx = { ui: { notify: (t: string) => { notified = t; } }, waitForIdle: async () => {}, abort: () => {} };
+    // Pick Review (blocked → notify + back to top-level menu), then Back to exit.
+    askQueue.push("Review", "Back to prompt");
+    const result = await showActiveTaskMenu(orchestrator, notifyCtx, "/pp", "tool");
+    expect(result).toBe("");
+    expect(notified).toBe("A review is already running");
+    // The live cycle is untouched (not finalized/nulled) and the top-level menu
+    // re-rendered rather than /pp exiting.
+    expect(orchestrator.active.state.reviewCycle).toEqual({ kind: "auto", step: "await_reviewers", pass: 1 });
+    expect(askQuestions.filter((q) => q.startsWith("/pp")).length).toBe(2);
+  });
+});
+
+describe("brainstorm/debug Review in Plannotator (annotate-folder) (#4)", () => {
+  let taskDir: string;
+
+  afterEach(() => {
+    askQueue.length = 0;
+    askQuestions.length = 0;
+    annotateReviewResults.length = 0;
+    annotateReviewPayloads.length = 0;
+    if (taskDir) rmSync(taskDir, { recursive: true, force: true });
+  });
+
+  function makeBrainstormOrchestrator(): any {
+    taskDir = mkdtempSync(join(tmpdir(), "pp-annotate-"));
+    return {
+      active: { type: "brainstorm", dir: taskDir, state: { phase: "brainstorm", step: "llm_work", mode: "guided" } },
+      transitionController: { isRunning: () => false, abortMainAgent: () => {} },
+      pi: {},
+      cancelPendingRetry: () => {},
+      abortAllSubagents: () => {},
+    };
+  }
+
+  const ctx = { ui: { notify: () => {} }, waitForIdle: async () => {}, abort: () => {} };
+
+  it("opens an annotate-folder review over the task dir and injects feedback", async () => {
+    const orchestrator = makeBrainstormOrchestrator();
+    annotateReviewResults.push({ feedback: "tighten the scope section" });
+    askQueue.push("Review", "Review in Plannotator");
+    const result = await showActiveTaskMenu(orchestrator, ctx, "/pp", "tool");
+    expect(result).toContain("tighten the scope section");
+    expect(annotateReviewPayloads[0]).toMatchObject({
+      filePath: taskDir,
+      folderPath: taskDir,
+      mode: "annotate-folder",
+      gate: true,
+    });
+  });
+
+  it("stays in the menu when the review is approved", async () => {
+    const orchestrator = makeBrainstormOrchestrator();
+    annotateReviewResults.push({ feedback: "", approved: true });
+    askQueue.push("Review", "Review in Plannotator", "Back", "Back to prompt");
+    const result = await showActiveTaskMenu(orchestrator, ctx, "/pp", "tool");
+    expect(result).toBe("");
+  });
+});