@payconductor/houndsman 0.3.0 → 0.5.0

package/src/tests/run-status-view.test.ts

@@ -0,0 +1,94 @@
+/**
+ * View do status na sidebar — timeout só vale quando há heartbeat de execução.
+ * `updatedAt` (triagem/sync) não deve simular uma revisão em andamento.
+ */
+
+import { describe, expect, test } from "bun:test";
+import {
+	describeRunStatus,
+	REVIEW_TIMEOUT_MS,
+	STATUS_TIMEOUT_MS,
+} from "../server/client/utils/constants";
+import type { RunSummary, Summary } from "../server/client/utils/types";
+
+const summary: Summary = {
+	total: 0,
+	present: 0,
+	byDecision: { pending: 0, execute: 0, ignore: 0 },
+	byExecState: { pending: 0, in_progress: 0, done: 0, stale: 0 },
+	bySeverity: { blocking: 0, attention: 0, suggestion: 0, nit: 0 },
+};
+
+const NOW = Date.parse("2026-10-17T12:00:00.000Z");
+const iso = (offsetMs: number): string => new Date(NOW + offsetMs).toISOString();
+
+function run(overrides: Partial<RunSummary>): RunSummary {
+	return {
+		slug: "feature-x",
+		branch: "feature/x",
+		summary,
+		...overrides,
+	};
+}
+
+describe("describeRunStatus", () => {
+	test("heartbeat recente mantém o status de execução", () => {
+		expect(
+			describeRunStatus(
+				run({ status: "reviewing", heartbeatAt: iso(-60_000) }),
+				NOW,
+			),
+		).toEqual({ kind: "reviewing", label: "Revisando", timeout: false });
+	});
+
+	test("heartbeat antigo vira timeout", () => {
+		expect(
+			describeRunStatus(
+				run({
+					status: "reviewing",
+					heartbeatAt: iso(-REVIEW_TIMEOUT_MS - 1_000),
+				}),
+				NOW,
+			),
+		).toEqual({ kind: "timeout", label: "Timeout na revisão", timeout: true });
+	});
+
+	test("updatedAt recente não mascara heartbeat antigo", () => {
+		expect(
+			describeRunStatus(
+				run({
+					status: "reviewing",
+					updatedAt: iso(-1_000),
+					heartbeatAt: iso(-REVIEW_TIMEOUT_MS - 1_000),
+				}),
+				NOW,
+			)?.timeout,
+		).toBe(true);
+	});
+
+	test("sem heartbeat não inventa revisão em andamento", () => {
+		expect(
+			describeRunStatus(run({ status: "reviewing", updatedAt: iso(-1_000) }), NOW),
+		).toBeNull();
+	});
+
+	test("status terminal aparece normalmente sem heartbeat", () => {
+		expect(describeRunStatus(run({ status: "review_done" }), NOW)).toEqual({
+			kind: "review_done",
+			label: "Revisão pronta",
+			timeout: false,
+		});
+	});
+
+	test("correção também usa heartbeat para timeout", () => {
+		expect(
+			describeRunStatus(
+				run({
+					status: "fixing",
+					heartbeatAt: iso(-STATUS_TIMEOUT_MS - 1_000),
+				}),
+				NOW,
+			),
+		).toEqual({ kind: "timeout", label: "Timeout na correção", timeout: true });
+	});
+});

package/src/tests/run-status.test.ts

@@ -7,8 +7,11 @@ import {
 	pingFindingsStatus,
 	readRunStatus,
 	statusAfterFindingsChange,
+	touchRunStatus,
 	writeRunStatus,
 } from "../core/run-status";
+import { buildRepoIdentity } from "../core/storage/repo-identity";
+import { SQLiteStorageProvider } from "../core/storage/sqlite/sqlite-storage";
 
 function findingState(partial: Partial<FindingState>): FindingState {
 	return {
@@ -45,53 +48,113 @@ function stateOf(findings: FindingState[]): FindingsStateFile {
 	};
 }
 
-/** Diretório temporário isolado. */
-function withTempDir(fn: (dir: string) => void): void {
+/** Banco temporário isolado + review da branch padrão. */
+function withStorage(
+	fn: (storage: SQLiteStorageProvider, reviewId: string) => void,
+): void {
 	const dir = mkdtempSync(join(tmpdir(), "houndsman-run-status-"));
+	const storage = new SQLiteStorageProvider(join(dir, "houndsman.db"));
 	try {
-		fn(dir);
+		const review = storage.getOrCreateReview({
+			repo: buildRepoIdentity(null, dir),
+			branch: "feature/x",
+			slug: "feature-x",
+		});
+		fn(storage, review.id);
 	} finally {
+		storage.close();
 		rmSync(dir, { recursive: true, force: true });
 	}
 }
 
-describe("run-status — arquivo", () => {
+describe("run-status — storage", () => {
 	test("grava, lê e preserva/restaura o startedAt", () => {
-		withTempDir((dir) => {
-			writeRunStatus(dir, {
-				branch: "feature/x",
+		withStorage((storage, reviewId) => {
+			writeRunStatus(storage, reviewId, {
 				status: "reviewing",
 				resetStartedAt: true,
 				now: "2026-01-01T00:00:00.000Z",
 			});
-			const first = readRunStatus(dir);
+			const first = readRunStatus(storage, reviewId);
 			expect(first?.status).toBe("reviewing");
 			expect(first?.slug).toBe("feature-x");
 			expect(first?.startedAt).toBe("2026-01-01T00:00:00.000Z");
+			expect(first?.heartbeatAt).toBe("2026-01-01T00:00:00.000Z");
 
-			writeRunStatus(dir, {
-				branch: "feature/x",
+			writeRunStatus(storage, reviewId, {
 				status: "review_done",
 				now: "2026-01-01T00:10:00.000Z",
 			});
-			const second = readRunStatus(dir);
+			const second = readRunStatus(storage, reviewId);
 			expect(second?.status).toBe("review_done");
 			expect(second?.startedAt).toBe("2026-01-01T00:00:00.000Z");
+			expect(second?.heartbeatAt).toBeUndefined();
 			expect(second?.updatedAt).toBe("2026-01-01T00:10:00.000Z");
 
-			writeRunStatus(dir, {
-				branch: "feature/x",
+			writeRunStatus(storage, reviewId, {
 				status: "reviewing",
 				resetStartedAt: true,
 				now: "2026-01-01T00:20:00.000Z",
 			});
-			expect(readRunStatus(dir)?.startedAt).toBe("2026-01-01T00:20:00.000Z");
+			expect(readRunStatus(storage, reviewId)?.startedAt).toBe(
+				"2026-01-01T00:20:00.000Z",
+			);
+			expect(readRunStatus(storage, reviewId)?.heartbeatAt).toBe(
+				"2026-01-01T00:20:00.000Z",
+			);
+		});
+	});
+
+	test("touch renova o heartbeat apenas em execução ativa", () => {
+		withStorage((storage, reviewId) => {
+			writeRunStatus(storage, reviewId, {
+				status: "reviewing",
+				resetStartedAt: true,
+				now: "2026-01-01T00:00:00.000Z",
+			});
+			touchRunStatus(storage, reviewId, "2026-01-01T00:05:00.000Z");
+			expect(readRunStatus(storage, reviewId)?.heartbeatAt).toBe(
+				"2026-01-01T00:05:00.000Z",
+			);
+
+			writeRunStatus(storage, reviewId, {
+				status: "review_done",
+				now: "2026-01-01T00:10:00.000Z",
+			});
+			touchRunStatus(storage, reviewId, "2026-01-01T00:15:00.000Z");
+			expect(readRunStatus(storage, reviewId)?.heartbeatAt).toBeUndefined();
+		});
+	});
+
+	test("triagem em reviewing não renova o heartbeat; fix em andamento sim", () => {
+		withStorage((storage, reviewId) => {
+			writeRunStatus(storage, reviewId, {
+				status: "reviewing",
+				resetStartedAt: true,
+				now: "2026-01-01T00:00:00.000Z",
+			});
+
+			// Triagem (decision/comment) mantém reviewing — não é execução.
+			pingFindingsStatus(storage, reviewId, stateOf([]));
+			expect(readRunStatus(storage, reviewId)?.heartbeatAt).toBe(
+				"2026-01-01T00:00:00.000Z",
+			);
+
+			// Correção em andamento renova o heartbeat.
+			pingFindingsStatus(
+				storage,
+				reviewId,
+				stateOf([findingState({ execState: "in_progress" })]),
+			);
+			const fixed = readRunStatus(storage, reviewId);
+			expect(fixed?.status).toBe("fixing");
+			expect(fixed?.heartbeatAt).not.toBe("2026-01-01T00:00:00.000Z");
 		});
 	});
 
-	test("readRunStatus devolve null sem arquivo", () => {
-		withTempDir((dir) => {
-			expect(readRunStatus(dir)).toBeNull();
+	test("readRunStatus devolve null para review inexistente", () => {
+		withStorage((storage) => {
+			expect(readRunStatus(storage, "missing")).toBeNull();
 		});
 	});
 });
@@ -127,7 +190,7 @@ describe("statusAfterFindingsChange", () => {
 		expect(statusAfterFindingsChange("review_done", state)).toBe("fix_done");
 	});
 
-	test("sem run.json e sem fix → fallback review_done", () => {
+	test("sem review e sem fix → fallback review_done", () => {
 		const state = stateOf([
 			findingState({ decision: "pending", execState: "pending" }),
 		]);
@@ -136,12 +199,12 @@ describe("statusAfterFindingsChange", () => {
 });
 
 describe("pingFindingsStatus", () => {
-	test("deriva do estado e grava o run.json", () => {
-		withTempDir((dir) => {
+	test("deriva do estado e grava o status na review", () => {
+		withStorage((storage, reviewId) => {
 			const state = stateOf([findingState({ execState: "in_progress" })]);
-			const file = pingFindingsStatus(dir, state);
-			expect(file.status).toBe("fixing");
-			expect(readRunStatus(dir)?.status).toBe("fixing");
+			const review = pingFindingsStatus(storage, reviewId, state);
+			expect(review.status).toBe("fixing");
+			expect(readRunStatus(storage, reviewId)?.status).toBe("fixing");
 		});
 	});
 });

package/src/tests/server.test.ts

@@ -1,30 +1,31 @@
 import { describe, expect, test } from "bun:test";
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import type { HoundsmanConfig } from "../core/config";
+import { buildStateFromFindings, fileReader } from "../core/findings-state";
+import { dedupeFindings, parseWatchdogReport } from "../core/report-builder";
+import { buildRepoIdentity } from "../core/storage/repo-identity";
+import { SQLiteStorageProvider } from "../core/storage/sqlite/sqlite-storage";
+import type { RepoIdentity } from "../core/storage/types";
 import { createRequestHandler, startServer } from "../server";
-import { readRunFile, runDirForSlug } from "../server/artifacts";
+import { isSlug } from "../server/artifacts";
 import { fakeHoundsmanConfig } from "./fixtures/fake-project";
 
-/** Run fake em disco + config apontando para ela. */
+/** Ambiente fake: banco temporário + review `main` com um finding. */
 function makeEnv(): {
-	artifactDir: string;
+	storage: SQLiteStorageProvider;
+	repo: RepoIdentity;
+	reviewId: string;
 	config: HoundsmanConfig;
 	cleanup: () => void;
 } {
-	const artifactDir = mkdtempSync(join(tmpdir(), "houndsman-server-"));
-	const outDir = join(artifactDir, "main");
-	mkdirSync(join(outDir, "findings"), { recursive: true });
-	writeFileSync(join(outDir, "manifest.json"), JSON.stringify({ branch: "main" }));
-	writeFileSync(
-		join(outDir, "classification.json"),
-		JSON.stringify({ watchdogs: { alpha: ["src/alpha/f.ts"] } }),
-	);
-	writeFileSync(join(outDir, "review.md"), "# Review\n");
-	writeFileSync(
-		join(outDir, "findings", "alpha.json"),
-		JSON.stringify({
+	const dir = mkdtempSync(join(tmpdir(), "houndsman-server-"));
+	const storage = new SQLiteStorageProvider(join(dir, "houndsman.db"));
+	const repo = buildRepoIdentity(null, dir);
+	const review = storage.getOrCreateReview({ repo, branch: "main", slug: "main" });
+	const report = parseWatchdogReport(
+		{
 			watchdogId: "alpha",
 			reviewedFiles: ["src/alpha/f.ts"],
 			skipped: [],
@@ -38,58 +39,64 @@ function makeEnv(): {
 					action: "tipar",
 				},
 			],
-		}),
+		},
+		"alpha.json",
 	);
+	if (report) {
+		const state = buildStateFromFindings(dedupeFindings([report]), {
+			branch: "main",
+			readFile: fileReader(process.cwd()),
+		});
+		// O arquivo fake não existe no cwd → sem âncora. Fixa a linha para o
+		// cenário de comentário inline no teste de submit.
+		for (const finding of Object.values(state.findings)) finding.line = 2;
+		storage.writeFindings(review.id, state);
+	}
+	storage.writeArtifact(review.id, {
+		name: "manifest.json",
+		kind: "manifest",
+		content: JSON.stringify({ branch: "main" }),
+	});
+	storage.writeArtifact(review.id, {
+		name: "classification.json",
+		kind: "classification",
+		content: JSON.stringify({ watchdogs: { alpha: ["src/alpha/f.ts"] } }),
+	});
+	storage.writeArtifact(review.id, {
+		name: "review.md",
+		kind: "review",
+		content: "# Review\n",
+	});
+	storage.writeArtifact(review.id, {
+		name: "briefs/alpha.md",
+		kind: "brief",
+		content: "# Brief alpha\n",
+	});
 	return {
-		artifactDir,
-		config: { ...fakeHoundsmanConfig, artifactDir },
-		cleanup: () => rmSync(artifactDir, { recursive: true, force: true }),
+		storage,
+		repo,
+		reviewId: review.id,
+		config: fakeHoundsmanConfig,
+		cleanup: () => {
+			storage.close();
+			rmSync(dir, { recursive: true, force: true });
+		},
 	};
 }
 
-/** Semeia um `state.json` com um finding inline (tem linha) na run. */
-function seedState(artifactDir: string, branch: string): void {
-	writeFileSync(
-		join(artifactDir, branch, "state.json"),
-		JSON.stringify({
-			version: 2,
-			branch,
-			slug: branch,
-			updatedAt: "2026-01-01T00:00:00.000Z",
-			order: ["f1"],
-			findings: {
-				f1: {
-					id: "f1",
-					fingerprint: "fp1",
-					watchdogIds: ["alpha"],
-					rule: "Nunca usar any",
-					severity: "blocking",
-					file: "src/alpha/f.ts",
-					line: 2,
-					message: "any detectado",
-					action: "tipar",
-					anchor: null,
-					count: 1,
-					present: true,
-					decision: "pending",
-					execState: "pending",
-					createdAt: "2026-01-01T00:00:00.000Z",
-					updatedAt: "2026-01-01T00:00:00.000Z",
-					history: [],
-				},
-			},
-		}),
-	);
-}
-
 const get = (handler: (r: Request) => Promise<Response>, path: string) =>
 	handler(new Request(`http://localhost${path}`));
 
+/** Resposta OK do `gh` com um JSON. */
+function ghJson(payload: unknown) {
+	return { ok: true, code: 0, stderr: "", stdout: JSON.stringify(payload) };
+}
+
 describe("server API", () => {
 	test("GET /api/runs lista as runs com resumo", async () => {
 		const env = makeEnv();
 		try {
-			const handler = createRequestHandler(env.config);
+			const handler = createRequestHandler(env.config, env);
 			const res = await get(handler, "/api/runs");
 			expect(res.status).toBe(200);
 			const body = (await res.json()) as {
@@ -106,7 +113,7 @@ describe("server API", () => {
 	test("GET findings reconstrói do artefato e PATCH atualiza o estado", async () => {
 		const env = makeEnv();
 		try {
-			const handler = createRequestHandler(env.config);
+			const handler = createRequestHandler(env.config, env);
 			const list = await get(handler, "/api/runs/main/findings?all=1");
 			const body = (await list.json()) as {
 				findings: { id: string; decision: string }[];
@@ -148,7 +155,7 @@ describe("server API", () => {
 	test("PATCH expõe o run status em /api/runs", async () => {
 		const env = makeEnv();
 		try {
-			const handler = createRequestHandler(env.config);
+			const handler = createRequestHandler(env.config, env);
 			const before = (await (await get(handler, "/api/runs")).json()) as {
 				runs: { status: string | null }[];
 			};
@@ -178,7 +185,7 @@ describe("server API", () => {
 	test("POST sync devolve o resultado da reancoragem", async () => {
 		const env = makeEnv();
 		try {
-			const handler = createRequestHandler(env.config);
+			const handler = createRequestHandler(env.config, env);
 			await get(handler, "/api/runs/main/findings?all=1");
 			const res = await handler(
 				new Request("http://localhost/api/runs/main/sync", { method: "POST" }),
@@ -195,6 +202,8 @@ describe("server API", () => {
 		const env = makeEnv();
 		try {
 			const handler = createRequestHandler(env.config, {
+				storage: env.storage,
+				repo: env.repo,
 				ghRunner: () => ({
 					ok: true,
 					code: 0,
@@ -224,29 +233,80 @@ describe("server API", () => {
 	test("POST submit posta comentários e grava o vínculo no estado", async () => {
 		const env = makeEnv();
 		try {
-			seedState(env.artifactDir, "main");
 			const handler = createRequestHandler(env.config, {
-				ghRunner: (args) =>
-					args[0] === "pr"
-						? {
-								ok: true,
-								code: 0,
-								stderr: "",
-								stdout: JSON.stringify({
-									number: 12,
-									url: "https://github.com/acme/app/pull/12",
-									headRefOid: "deadbeef",
-								}),
-							}
-						: {
-								ok: true,
-								code: 0,
-								stderr: "",
-								stdout: JSON.stringify({
-									id: 501,
-									html_url: "https://x/501",
-								}),
-							},
+				storage: env.storage,
+				repo: env.repo,
+				ghRunner: (args) => {
+					if (args[0] === "pr") {
+						return ghJson({
+							number: 12,
+							url: "https://github.com/acme/app/pull/12",
+							headRefOid: "deadbeef",
+						});
+					}
+					if (args[1] === "graphql") {
+						const query = args.find((arg) => arg.startsWith("query=")) ?? "";
+						if (query.includes("states: [PENDING]")) {
+							return ghJson({
+								data: {
+									repository: {
+										pullRequest: {
+											id: "PR_1",
+											reviews: { nodes: [] },
+										},
+									},
+								},
+							});
+						}
+						if (query.includes("addPullRequestReview(input")) {
+							return ghJson({
+								data: {
+									addPullRequestReview: {
+										pullRequestReview: {
+											id: "REV_NEW",
+											databaseId: 11,
+											resourcePath:
+												"/acme/app/pull/12#pullrequestreview-11",
+										},
+									},
+								},
+							});
+						}
+						if (query.includes("addPullRequestReviewThread")) {
+							return ghJson({
+								data: {
+									addPullRequestReviewThread: {
+										thread: {
+											comments: {
+												nodes: [
+													{
+														databaseId: 501,
+														resourcePath:
+															"/acme/app/pull/12#discussion_r501",
+													},
+												],
+											},
+										},
+									},
+								},
+							});
+						}
+						if (query.includes("submitPullRequestReview")) {
+							return ghJson({
+								data: {
+									submitPullRequestReview: {
+										pullRequestReview: {
+											id: "REV_NEW",
+											databaseId: 11,
+											state: "CHANGES_REQUESTED",
+										},
+									},
+								},
+							});
+						}
+					}
+					return { ok: false, code: 404, stderr: "", stdout: "" };
+				},
 			});
 			const res = await handler(
 				new Request("http://localhost/api/runs/main/submit", {
@@ -273,10 +333,35 @@ describe("server API", () => {
 		}
 	});
 
+	test("artifacts lista todos os artefatos da run (inclui briefs)", async () => {
+		const env = makeEnv();
+		try {
+			const handler = createRequestHandler(env.config, env);
+			const res = await get(handler, "/api/runs/main/artifacts");
+			expect(res.status).toBe(200);
+			const body = (await res.json()) as {
+				artifacts: { name: string; kind: string }[];
+			};
+			expect(body.artifacts.map((item) => item.name)).toEqual(
+				expect.arrayContaining([
+					"manifest.json",
+					"classification.json",
+					"review.md",
+					"briefs/alpha.md",
+				]),
+			);
+			expect(
+				body.artifacts.find((item) => item.name === "briefs/alpha.md")?.kind,
+			).toBe("brief");
+		} finally {
+			env.cleanup();
+		}
+	});
+
 	test("artifacts serve arquivos da run e barra o resto", async () => {
 		const env = makeEnv();
 		try {
-			const handler = createRequestHandler(env.config);
+			const handler = createRequestHandler(env.config, env);
 			const ok = await get(handler, "/api/runs/main/artifacts/manifest.json");
 			expect(ok.status).toBe(200);
 			expect(await ok.json()).toEqual({ branch: "main" });
@@ -285,6 +370,10 @@ describe("server API", () => {
 			expect(review.status).toBe(200);
 			expect(await review.text()).toContain("# Review");
 
+			const brief = await get(handler, "/api/runs/main/artifacts/briefs/alpha.md");
+			expect(brief.status).toBe(200);
+			expect(await brief.text()).toContain("# Brief alpha");
+
 			const denied = await get(handler, "/api/runs/main/artifacts/evil.txt");
 			expect(denied.status).toBe(404);
 
@@ -295,23 +384,17 @@ describe("server API", () => {
 		}
 	});
 
-	test("readRunFile barra path traversal", () => {
-		const env = makeEnv();
-		try {
-			const dir = runDirForSlug(env.artifactDir, "main");
-			expect(dir).not.toBeNull();
-			expect(readRunFile(dir as string, "../../../etc/passwd")).toBeNull();
-			expect(readRunFile(dir as string, "manifest.json")).toContain("main");
-			expect(runDirForSlug(env.artifactDir, "../main")).toBeNull();
-		} finally {
-			env.cleanup();
-		}
+	test("valida o slug usado nas rotas", () => {
+		expect(isSlug("main")).toBe(true);
+		expect(isSlug("feature-x")).toBe(true);
+		expect(isSlug("../main")).toBe(false);
+		expect(isSlug("a/b")).toBe(false);
 	});
 
 	test("GET / serve o shell e /assets/app.js empacota o cliente", async () => {
 		const env = makeEnv();
 		try {
-			const handler = createRequestHandler(env.config);
+			const handler = createRequestHandler(env.config, env);
 			const shell = await get(handler, "/");
 			expect(await shell.text()).toContain('id="app"');
 
@@ -328,7 +411,7 @@ describe("server API", () => {
 	test("serve sem cache (no-store) e busta o bundle com um build id", async () => {
 		const env = makeEnv();
 		try {
-			const handler = createRequestHandler(env.config);
+			const handler = createRequestHandler(env.config, env);
 			const shell = await get(handler, "/");
 			expect(shell.headers.get("cache-control")).toContain("no-store");
 			expect(await shell.text()).toContain("/assets/app.js?v=");
@@ -346,7 +429,12 @@ describe("startServer", () => {
 		const env = makeEnv();
 		let server: ReturnType<typeof startServer>["server"] | undefined;
 		try {
-			const started = startServer({ config: env.config, port: 0 });
+			const started = startServer({
+				config: env.config,
+				port: 0,
+				storage: env.storage,
+				repo: env.repo,
+			});
 			server = started.server;
 			const res = await fetch(`${started.url}/api/health`);
 			expect(res.status).toBe(200);