import { existsSync, mkdtempSync, readFileSync, rmSync, symlinkSync, } from "node:fs"; import { tmpdir } from "node:os"; import { join } from "node:path"; import { fileURLToPath } from "node:url"; import { type ExtensionContext, initTheme, } from "@earendil-works/pi-coding-agent"; import { afterEach, describe, expect, it, vi } from "vitest"; import { createPiSession, type PiSession, } from "../../../test/fixture/create-pi-session.ts"; import type { GoodJobRecord, Remediation } from "../core.js"; import { atomicWriteJson, ensureLayout, goodJobDataDirectory, layout, loadRecords, loadRemediation, loadRemediations, migrateStore, parseRemediation, saveRemediation, } from "../storage.js"; const problem: GoodJobRecord = { version: 2, id: "wtf-0000000001", kind: "problem", createdAt: "2026-01-01T00:00:00.000Z", completedAt: "2026-01-01T00:01:00.000Z", feedback: "Unverified completion", source: { type: "import", importer: "test", fingerprint: "fixture", importedAt: "2026-01-01T00:00:00.000Z", }, analysisModel: null, usage: null, learning: { slug: "verify-consumer-outcome", summary: "Consumer outcome remained unverified", evidence: ["Consumer failed"], behaviors: ["Verify the consumer"], candidateRule: null, }, }; const verified: Remediation = { version: 1, recordId: problem.id, status: "verified", changeRef: "commit abc123: consumer check", appliedAt: "2026-01-02", verifiedAt: "2026-01-03", evidence: "Fresh consumer passed; Linux only.", updatedAt: "2026-01-04T00:00:00.000Z", }; const roots: string[] = []; let session: PiSession | undefined; function temporaryRoot(): string { const root = mkdtempSync(join(tmpdir(), "good-job-remediation-test-")); roots.push(root); return root; } async function seed(root: string) { const paths = layout(root); await ensureLayout(paths); await atomicWriteJson(join(paths.records, `${problem.id}.json`), problem); return paths; } async function commandContext(userSettings?: Record) { session = await createPiSession({ extensionPaths: [fileURLToPath(new URL("../index.ts", import.meta.url))], ...(userSettings ? { userSettings } : {}), }); const paths = await seed( goodJobDataDirectory(session.env, process.platform, session.env["HOME"]), ); const base = session.session.extensionRunner.createContext(); const ctx = Object.create(base) as ExtensionContext; Object.defineProperties(ctx, { hasUI: { value: true, configurable: true }, mode: { value: "rpc", configurable: true }, }); const ui = Object.create(base.ui) as ExtensionContext["ui"]; Object.defineProperty(ctx, "ui", { value: ui }); const run = (args: string) => session!.extensions[0]!.commands.get("gj")!.handler(args, ctx as never); return { ctx, ui, paths, run }; } afterEach(async () => { await session?.dispose(); session = undefined; vi.restoreAllMocks(); for (const root of roots.splice(0)) rmSync(root, { recursive: true, force: true }); }); describe("good-job remediation", () => { it("stores proposed, applied, and verified metadata without modifying learning bytes", async () => { const paths = await seed(temporaryRoot()); const file = join(paths.records, `${problem.id}.json`); const original = readFileSync(file, "utf8"); expect(await loadRemediation(problem.id, paths)).toBeUndefined(); for (const value of [ { ...verified, status: "proposed" as const, appliedAt: null, verifiedAt: null, evidence: "", }, { ...verified, status: "applied" as const, verifiedAt: null, evidence: "", }, verified, ]) { await saveRemediation(value, paths); expect(await loadRemediation(problem.id, paths)).toEqual(value); expect(readFileSync(file, "utf8")).toBe(original); } expect((await loadRecords(paths)).records).toEqual([problem]); }); it.each([ { status: "closed" }, { changeRef: " " }, { evidence: " " }, { appliedAt: "2026-02-30" }, { verifiedAt: "2026-01-01" }, { recordId: "../../outside" }, { recordId: "gj-0000000001" }, { changeRef: "x".repeat(1001) }, { evidence: "x".repeat(4001) }, ])("rejects invalid remediation metadata %j", (patch) => { expect(parseRemediation({ ...verified, ...patch })).toBeUndefined(); }); it("requires an existing problem, rejects praise, and surfaces malformed sidecars", async () => { const paths = await seed(temporaryRoot()); await expect( saveRemediation({ ...verified, recordId: "wtf-0000000002" }, paths), ).rejects.toThrow(); await expect( saveRemediation({ ...verified, recordId: "gj-0000000001" }, paths), ).rejects.toThrow(); await atomicWriteJson(join(paths.remediations, `${problem.id}.json`), { ...verified, recordId: "wtf-0000000002", }); await expect(loadRemediation(problem.id, paths)).rejects.toThrow( "invalid remediation", ); const loaded = await loadRemediations(paths, [problem]); expect(loaded.remediations.size).toBe(0); expect(loaded.errors).toHaveLength(1); await expect(migrateStore(paths.root, paths.root)).resolves.toMatchObject({ remediations: 0, }); await saveRemediation(verified, paths); const original = readFileSync( join(paths.remediations, `${problem.id}.json`), "utf8", ); await expect( saveRemediation({ ...verified, evidence: "" }, paths), ).rejects.toThrow("invalid remediation"); expect( readFileSync(join(paths.remediations, `${problem.id}.json`), "utf8"), ).toBe(original); }); it("moves linked remediation with its record and preserves it for aliased/no-op migration", async () => { const paths = await seed(temporaryRoot()); await saveRemediation(verified, paths); const target = layout(temporaryRoot()); expect(await migrateStore(paths.root, target.root)).toMatchObject({ records: 1, remediations: 1, }); expect(await loadRemediation(problem.id, target)).toEqual(verified); expect(existsSync(join(paths.remediations, `${problem.id}.json`))).toBe( false, ); const alias = join(temporaryRoot(), "alias"); symlinkSync(target.root, alias, "dir"); await migrateStore(target.root, alias); expect(await loadRemediation(problem.id, target)).toEqual(verified); }); it("migrates remediation on startup when a configured directory replaces the default", async () => { const target = layout(temporaryRoot()); const { ctx, paths, run } = await commandContext({ "good-job": { directory: target.root }, }); await saveRemediation(verified, paths); const start = session!.extensions[0]!.handlers.get("session_start")![0]!; start({ type: "session_start", reason: "startup" }, ctx); await run("status"); expect(await loadRemediation(problem.id, target)).toEqual(verified); expect((await loadRecords(target)).records).toEqual([problem]); expect(existsSync(join(paths.remediations, `${problem.id}.json`))).toBe( false, ); }); it("shows persisted status in /gj list and complete remediation in its selected detail", async () => { const { ctx, ui, paths, run } = await commandContext(); await saveRemediation(verified, paths); Object.defineProperty(ctx, "mode", { value: "tui" }); initTheme(undefined, false); const screens: string[] = []; vi.spyOn(ui, "custom").mockImplementation( async (factory) => new Promise((resolve) => { void Promise.resolve( factory( { requestRender: vi.fn() } as never, ui.theme, {} as never, resolve, ), ).then((component) => { screens.push(component.render(180).join("\n")); component.handleInput?.("\r"); }); }), ); await run("list"); expect(screens).toHaveLength(2); expect(screens[0]).toContain(problem.id); expect(screens[0]).toContain("verified"); for (const text of [ verified.changeRef, verified.appliedAt!, verified.verifiedAt!, verified.evidence, ]) expect(screens[1]).toContain(text); }); it.each(["tui", "rpc"])( "remediates the selected problem through /gj in %s without entering an ID", async (mode) => { const { ctx, ui, paths, run } = await commandContext(); Object.defineProperty(ctx, "mode", { value: mode }); initTheme(undefined, false); const select = vi.spyOn(ui, "select"); if (mode === "tui") { let screen = 0; vi.spyOn(ui, "custom").mockImplementation( async (factory) => new Promise((resolve) => { void Promise.resolve( factory( { requestRender: vi.fn() } as never, ui.theme, {} as never, resolve, ), ).then((component) => { component.render(120); component.handleInput?.(screen++ === 0 ? "\r" : "r"); }); }), ); } else { select .mockImplementationOnce(async (_title, choices) => choices.find((choice) => choice.includes(problem.id)), ) .mockResolvedValueOnce("Remediate"); } select.mockResolvedValueOnce("applied"); vi.spyOn(ui, "editor").mockResolvedValue(verified.changeRef); vi.spyOn(ui, "input").mockResolvedValue(verified.appliedAt!); vi.spyOn(ui, "confirm").mockResolvedValue(true); await run("list"); expect(await loadRemediation(problem.id, paths)).toMatchObject({ status: "applied", changeRef: verified.changeRef, }); }, ); it("saves directly verified remediation via public command after confirmation", async () => { const { ui, paths, run } = await commandContext(); const original = readFileSync( join(paths.records, `${problem.id}.json`), "utf8", ); vi.spyOn(ui, "select").mockResolvedValue("verified"); vi.spyOn(ui, "editor") .mockResolvedValueOnce(verified.changeRef) .mockResolvedValueOnce(verified.evidence); vi.spyOn(ui, "input") .mockResolvedValueOnce(verified.appliedAt!) .mockResolvedValueOnce(verified.verifiedAt!); vi.spyOn(ui, "confirm").mockResolvedValue(true); await run(`remediate ${problem.id}`); expect(await loadRemediation(problem.id, paths)).toMatchObject({ ...verified, updatedAt: expect.any(String), }); expect( readFileSync(join(paths.records, `${problem.id}.json`), "utf8"), ).toBe(original); }); it.each(["status", "reference", "confirmation"])( "leaves existing remediation unchanged when cancelling %s", async (stage) => { const { ui, paths, run } = await commandContext(); await saveRemediation(verified, paths); vi.spyOn(ui, "select").mockResolvedValue( stage === "status" ? undefined : "proposed", ); vi.spyOn(ui, "editor").mockResolvedValue( stage === "reference" ? undefined : "different proposal", ); vi.spyOn(ui, "confirm").mockResolvedValue(false); await run(`remediate ${problem.id}`); expect(await loadRemediation(problem.id, paths)).toEqual(verified); }, ); it.each(["applied date", "verification date", "evidence"])( "preserves sidecar bytes after invalid input then cancellation at %s", async (stage) => { const { ui, paths, run } = await commandContext(); await saveRemediation(verified, paths); const file = join(paths.remediations, `${problem.id}.json`); const original = readFileSync(file, "utf8"); vi.spyOn(ui, "notify").mockImplementation(() => {}); vi.spyOn(ui, "select").mockResolvedValue("verified"); const editor = vi .spyOn(ui, "editor") .mockResolvedValueOnce(verified.changeRef); const input = vi.spyOn(ui, "input"); if (stage === "applied date") input .mockResolvedValueOnce("2026-02-30") .mockResolvedValueOnce(undefined); else { input.mockResolvedValueOnce(verified.appliedAt!); if (stage === "verification date") input .mockResolvedValueOnce("2026-01-01") .mockResolvedValueOnce(undefined); else { input.mockResolvedValueOnce(verified.verifiedAt!); editor.mockResolvedValueOnce(" ").mockResolvedValueOnce(undefined); } } await run(`remediate ${problem.id}`); expect(readFileSync(file, "utf8")).toBe(original); }, ); it("selects only problems and retries invalid input before saving applied status", async () => { const { ui, paths, run } = await commandContext(); await atomicWriteJson(join(paths.records, "gj-0000000001.json"), { ...problem, id: "gj-0000000001", kind: "praise", }); vi.spyOn(ui, "notify").mockImplementation(() => {}); vi.spyOn(ui, "select") .mockImplementationOnce(async (_title, choices) => { expect(choices).toHaveLength(1); return choices.find((choice) => choice.includes(problem.id)); }) .mockResolvedValueOnce("applied"); vi.spyOn(ui, "editor") .mockResolvedValueOnce(" ") .mockResolvedValueOnce(verified.changeRef); vi.spyOn(ui, "input") .mockResolvedValueOnce("not a date") .mockResolvedValueOnce(verified.appliedAt!); vi.spyOn(ui, "confirm").mockResolvedValue(true); await run("remediate"); expect(await loadRemediation(problem.id, paths)).toMatchObject({ status: "applied", changeRef: verified.changeRef, appliedAt: verified.appliedAt, verifiedAt: null, evidence: "", }); }); it("rejects praise before prompting and refuses unavailable dialogs without writing", async () => { const { ctx, ui, paths, run } = await commandContext(); const select = vi.spyOn(ui, "select"); const notify = vi.spyOn(ui, "notify").mockImplementation(() => {}); await run("remediate gj-0000000001"); expect(notify).toHaveBeenCalledWith( expect.stringContaining("praise"), "warning", ); expect(select).not.toHaveBeenCalled(); Object.defineProperty(ctx, "hasUI", { value: false }); await expect(run(`remediate ${problem.id}`)).rejects.toThrow( "requires interactive dialogs", ); expect(await loadRemediation(problem.id, paths)).toBeUndefined(); }); });