@payconductor/houndsman 0.12.0 → 0.14.0

package/src/tests/review-scripts.test.ts

@@ -14,6 +14,9 @@ import {
 } from "../core/config";
 import { parseDiffIndex, parseNumstat } from "../core/diff-source";
 import { discoverDocs } from "../core/doc-discoverer";
+import { riskOf } from "../core/domain/budget";
+import { coverageOf, unaccountedFiles } from "../core/engine/finalize-pipeline";
+import { overlapMessage } from "../core/engine/prepare-pipeline";
 import {
 	type ClassificationResult,
 	churnOf,
@@ -37,8 +40,6 @@ import {
 	dedupeFindings,
 	parseContextSummary,
 	parseWatchdogReport,
-	renderDomainReport,
-	renderReport,
 	sanitizeBranch,
 	type WatchdogReport,
 } from "../core/report-builder";
@@ -451,6 +452,83 @@ describe("triage", () => {
 		expect(overflow).toEqual(["a.ts"]);
 	});
 
+	test("prioridade soma ao churn (linhas equivalentes) sem virar tier rígido", () => {
+		const priorities = [{ pattern: /^server\/db\//, bonus: 300 }];
+		const files = ["client/big.ts", "server/db/small.ts"];
+		expect(
+			sortByRisk(
+				files,
+				{
+					"client/big.ts": { additions: 200, deletions: 0 },
+					"server/db/small.ts": { additions: 10, deletions: 0 },
+				},
+				priorities,
+			),
+		).toEqual(["server/db/small.ts", "client/big.ts"]);
+		// Churn puro continua vencendo quando é muito maior (400 > 10 + 300).
+		expect(
+			sortByRisk(
+				files,
+				{
+					"client/big.ts": { additions: 400, deletions: 0 },
+					"server/db/small.ts": { additions: 10, deletions: 0 },
+				},
+				priorities,
+			),
+		).toEqual(["client/big.ts", "server/db/small.ts"]);
+		// Sem prioridade configurada, comportamento antigo.
+		expect(
+			sortByRisk(files, {
+				"client/big.ts": { additions: 200, deletions: 0 },
+				"server/db/small.ts": { additions: 10, deletions: 0 },
+			}),
+		).toEqual(["client/big.ts", "server/db/small.ts"]);
+		// O orçamento respeita a prioridade.
+		expect(
+			selectByBudget(
+				files,
+				{
+					"client/big.ts": { additions: 200, deletions: 0 },
+					"server/db/small.ts": { additions: 10, deletions: 0 },
+				},
+				1,
+				priorities,
+			).selected,
+		).toEqual(["server/db/small.ts"]);
+	});
+
+	test("maxRiskFromChurn satura o superchurn de caminho com baixa criticidade", () => {
+		const priorities = [
+			{ pattern: /^server\/db\//, bonus: 300 },
+			{ pattern: /^client\//, maxRiskFromChurn: 120 },
+		];
+		const files = ["client/table.tsx", "server/db/migration.ts"];
+		const churn = {
+			"client/table.tsx": { additions: 1900, deletions: 100 },
+			"server/db/migration.ts": { additions: 20, deletions: 0 },
+		};
+		// 2.000 linhas de UI "boba" viram 120; 20 linhas de db valem 320.
+		expect(riskOf("client/table.tsx", churn, priorities)).toBe(120);
+		expect(sortByRisk(files, churn, priorities)).toEqual([
+			"server/db/migration.ts",
+			"client/table.tsx",
+		]);
+		// Abaixo do teto, o caminho mantém o peso natural do churn.
+		expect(
+			riskOf(
+				"client/table.tsx",
+				{
+					"client/table.tsx": { additions: 15, deletions: 0 },
+				},
+				priorities,
+			),
+		).toBe(15);
+		// Sem teto configurado, o churn puro continua vencendo.
+		expect(
+			riskOf("client/table.tsx", churn, [{ pattern: /^server\/db\//, bonus: 300 }]),
+		).toBe(2000);
+	});
+
 	test("maxFiles não-positivo desativa o orçamento", () => {
 		const { selected, overflow } = selectByBudget(["a.ts", "b.ts"], churn, 0);
 		expect(selected).toHaveLength(2);
@@ -572,196 +650,35 @@ describe("report-builder", () => {
 		expect(merged[0].message).toBe("maior");
 	});
 
-	test("renderReport marca status conforme severidade", () => {
-		const reports: WatchdogReport[] = [
-			{ watchdogId: "alpha", reviewedFiles: ["s.ts"], skipped: [], findings: [] },
-		];
-
-		expect(renderReport("main", reports, [], {})).toContain("✅ Aprovado");
-
-		const blockers = renderReport(
-			"main",
-			reports,
-			[
-				{
-					rule: "Regra bloqueante",
-					severity: "blocking",
-					file: "s.ts",
-					message: "m",
-					action: "a",
-					watchdogs: ["alpha"],
-				},
-			],
-			{},
-		);
-		expect(blockers).toContain("❌ Mudanças Necessárias");
-		expect(blockers).toContain("## ❌ blocking");
-	});
-
-	test("renderReport mostra cobertura pendente", () => {
-		const reports: WatchdogReport[] = [
-			{ watchdogId: "alpha", reviewedFiles: ["s.ts"], skipped: [], findings: [] },
-		];
-		const md = renderReport("main", reports, [], {
-			classified: { alpha: ["s.ts", "t.ts"] },
-		});
-		expect(md).toContain("faltam 1");
-	});
-
-	test("renderReport usa o resolver de nome injetado", () => {
-		const reports: WatchdogReport[] = [
-			{ watchdogId: "alpha", reviewedFiles: [], skipped: [], findings: [] },
-		];
-		const md = renderReport("main", reports, [], {}, undefined, undefined, (id) =>
-			id === "alpha" ? "Watchdog Alpha" : id,
-		);
-		expect(md).toContain("Watchdog Alpha");
-	});
-
-	test("renderReport agrupa achados por arquivo", () => {
-		const merged = [
-			{
-				rule: "R1",
-				severity: "blocking" as const,
-				file: "a.ts",
-				line: 1,
-				message: "m",
-				action: "a",
-				watchdogs: ["alpha"],
-			},
-			{
-				rule: "R2",
-				severity: "blocking" as const,
-				file: "b.ts",
-				line: 2,
-				message: "m",
-				action: "a",
-				watchdogs: ["alpha"],
-			},
-		];
-		const md = renderReport(
-			"main",
-			[{ watchdogId: "alpha", reviewedFiles: [], skipped: [], findings: [] }],
-			merged,
-			{},
-		);
-		expect(md).toContain("### `a.ts`");
-		expect(md).toContain("### `b.ts`");
-	});
-
-	test("renderReport indexa os relatórios por domínio", () => {
-		const md = renderReport(
-			"main",
-			[{ watchdogId: "alpha", reviewedFiles: [], skipped: [], findings: [] }],
-			[],
-			{},
-			undefined,
-			undefined,
-			undefined,
-			[
-				{
-					id: "alpha",
-					name: "Alpha",
-					file: "review.alpha.md",
-					findings: 2,
-					reviewedFiles: 3,
-					expectedFiles: 5,
-				},
-			],
+	test("cobertura ignora arquivos declarados fora do escopo", () => {
+		const coverage = coverageOf(
+			["src/a.ts", "src/b.ts", "src/outro.ts", "src/a.ts"],
+			["src/a.ts", "src/b.ts", "src/c.ts"],
 		);
-		expect(md).toContain("## Relatórios por domínio");
-		expect(md).toContain("review.alpha.md");
+		expect(coverage).toEqual({ reviewed: 2, expected: 3 });
 	});
 
-	test("renderReport coloca o sumário antes dos achados", () => {
-		const md = renderReport(
-			"main",
-			[{ watchdogId: "alpha", reviewedFiles: ["a.ts"], skipped: [], findings: [] }],
-			[
-				{
-					rule: "R1",
-					severity: "blocking" as const,
-					file: "a.ts",
-					line: 1,
-					message: "m",
-					action: "a",
-					watchdogs: ["alpha"],
-				},
-			],
-			{ classified: { alpha: ["a.ts"] } },
-			null,
-			undefined,
-			undefined,
-			[
-				{
-					id: "alpha",
-					name: "Alpha",
-					file: "review.alpha.md",
-					findings: 1,
-					reviewedFiles: 1,
-					expectedFiles: 1,
-				},
-			],
-		);
-		const sections = [
-			"## Relatórios por domínio",
-			"## Cobertura",
-			"## Conclusão",
-			"## ❌ blocking",
-		].map((section) => md.indexOf(section));
-		expect(sections.every((index) => index >= 0)).toBe(true);
-		expect([...sections].sort((a, b) => a - b)).toEqual(sections);
-	});
-
-	test("renderReport anexa candidatos Jev depois dos achados", () => {
-		const md = renderReport(
-			"main",
-			[{ watchdogId: "alpha", reviewedFiles: [], skipped: [], findings: [] }],
-			[
-				{
-					rule: "R1",
-					severity: "blocking" as const,
-					file: "a.ts",
-					line: 1,
-					message: "m",
-					action: "a",
-					watchdogs: ["alpha"],
-				},
-			],
-			{},
-			null,
-			[
-				{
-					watchdogId: "alpha",
-					rule: "R2",
-					severity: "attention",
-					file: "b.ts",
-					confidence: 0.6,
-					questionKey: "q",
-				},
-			],
-		);
-		expect(md.indexOf("## ❌ blocking")).toBeLessThan(
-			md.indexOf("## 🔎 Candidatos não verificados"),
-		);
+	test("lista arquivos sem revisão e sem declaração em skipped", () => {
+		expect(
+			unaccountedFiles(
+				["src/a.ts", "src/fora.ts"],
+				["src/c.ts"],
+				["src/a.ts", "src/c.ts", "src/b.ts"],
+			),
+		).toEqual(["src/b.ts"]);
 	});
 
-	test("renderDomainReport mostra cobertura e não revisados", () => {
-		const md = renderDomainReport(
-			"main",
-			{
-				watchdogId: "alpha",
-				reviewedFiles: ["a.ts"],
-				skipped: ["b.ts"],
-				findings: [],
-			},
-			[],
-			2,
-			null,
-		);
-		expect(md).toContain("1/2");
-		expect(md).toContain("Não revisados");
-		expect(md).toContain("Nenhum achado");
+	test("avisa quando um arquivo entra em vários domínios", () => {
+		expect(
+			overlapMessage({
+				watchdogs: { alpha: ["a.ts", "b.ts"], beta: ["b.ts"], gamma: [] },
+			}),
+		).toEqual([
+			"Escopo: 1 arquivo(s) em mais de um domínio (máx. 2) — cada domínio revisa o arquivo com o seu recorte.",
+		]);
+		expect(
+			overlapMessage({ watchdogs: { alpha: ["a.ts"], beta: ["b.ts"] } }),
+		).toEqual([]);
 	});
 });
 
@@ -803,35 +720,6 @@ describe("context-summary", () => {
 		expect(summary?.objective?.endsWith("…")).toBe(true);
 		expect(summary?.changeSummary).toHaveLength(6);
 	});
-
-	test("renderReport coloca a seção de contexto quando presente", () => {
-		const reports: WatchdogReport[] = [
-			{ watchdogId: "alpha", reviewedFiles: [], skipped: [], findings: [] },
-		];
-		const md = renderReport(
-			"main",
-			reports,
-			[],
-			{},
-			{
-				available: true,
-				objective: "Entregar X",
-				motivation: "Reduzir Y",
-				changeSummary: ["Faz A"],
-			},
-		);
-		expect(md).toContain("## Contexto da PR");
-		expect(md).toContain("**Objetivo:** Entregar X");
-	});
-
-	test("renderReport omite a seção sem contexto", () => {
-		const reports: WatchdogReport[] = [
-			{ watchdogId: "alpha", reviewedFiles: [], skipped: [], findings: [] },
-		];
-		expect(renderReport("main", reports, [], {}, null)).not.toContain(
-			"## Contexto da PR",
-		);
-	});
 });
 
 // ---------------------------------------------------------------------------
@@ -894,7 +782,7 @@ describe("houndsman brief", () => {
 		expect(brief).toContain("**Objetivo:** Entregar X");
 	});
 
-	test("mostra churn e lista arquivos fora do orçamento", () => {
+	test("mostra churn e lista arquivos fora do recorte", () => {
 		const brief = renderBrief(alphaWatchdog, {
 			watchdogId: "alpha",
 			files: ["src/alpha/keep.ts"],
@@ -908,7 +796,7 @@ describe("houndsman brief", () => {
 			deleted: [],
 		});
 		expect(brief).toContain("+12/−3");
-		expect(brief).toContain("Fora do orçamento");
+		expect(brief).toContain("Fora do recorte");
 		expect(brief).toContain("src/alpha/skip.ts");
 	});
 

package/src/tests/server.test.ts

@@ -64,8 +64,8 @@ function makeEnv(): {
 		content: JSON.stringify({ watchdogs: { alpha: ["src/alpha/f.ts"] } }),
 	});
 	storage.writeArtifact(review.id, {
-		name: "review.md",
-		kind: "review",
+		name: "review-resume.md",
+		kind: "resume",
 		content: "# Review\n",
 	});
 	storage.writeArtifact(review.id, {
@@ -386,7 +386,7 @@ describe("server API", () => {
 				expect.arrayContaining([
 					"manifest.json",
 					"classification.json",
-					"review.md",
+					"review-resume.md",
 					"briefs/alpha.md",
 				]),
 			);
@@ -406,7 +406,10 @@ describe("server API", () => {
 			expect(ok.status).toBe(200);
 			expect(await ok.json()).toEqual({ branch: "main" });
 
-			const review = await get(handler, "/api/runs/main/artifacts/review.md");
+			const review = await get(
+				handler,
+				"/api/runs/main/artifacts/review-resume.md",
+			);
 			expect(review.status).toBe(200);
 			expect(await review.text()).toContain("# Review");
 

package/src/tests/storage.test.ts

@@ -142,6 +142,59 @@ function contract(
 			}
 		});
 
+		test("variantes A/B: mesma branch, runs separadas e findings isolados", () => {
+			const { storage, cleanup } = make();
+			try {
+				const repo = buildRepoIdentity(null, "/tmp/app");
+				const main = storage.getOrCreateReview({
+					repo,
+					branch: "feature/x",
+					slug: "feature-x",
+				});
+				const a = storage.getOrCreateReview({
+					repo,
+					branch: "feature/x",
+					variant: "baseline",
+					slug: "feature-x--baseline-abc123",
+				});
+				const b = storage.getOrCreateReview({
+					repo,
+					branch: "feature/x",
+					variant: "otimizado",
+					slug: "feature-x--otimizado-def456",
+				});
+				expect(new Set([main.id, a.id, b.id]).size).toBe(3);
+				expect(storage.findReview(repo.key, "feature/x")?.id).toBe(main.id);
+				expect(storage.findReview(repo.key, "feature/x", "baseline")?.id).toBe(
+					a.id,
+				);
+				expect(storage.findReview(repo.key, "feature/x", "otimizado")?.id).toBe(
+					b.id,
+				);
+				expect(storage.findReview(repo.key, "feature/x", "ausente")).toBeNull();
+
+				// Idempotente por (branch, variante).
+				expect(
+					storage.getOrCreateReview({
+						repo,
+						branch: "feature/x",
+						variant: "baseline",
+						slug: "outro",
+					}).id,
+				).toBe(a.id);
+				expect(storage.listReviews(repo.key)).toHaveLength(3);
+
+				// Findings/staging são por review.
+				storage.writeFindings(a.id, sampleState());
+				expect(storage.readFindings(a.id)?.findings.ab12cd34ef?.rule).toBe(
+					"regra",
+				);
+				expect(storage.readFindings(b.id)).toBeNull();
+			} finally {
+				cleanup();
+			}
+		});
+
 		test("findings: round-trip completo e preservação do short id", () => {
 			const { storage, cleanup } = make();
 			try {
@@ -195,18 +248,18 @@ function contract(
 					slug: "main",
 				});
 				const first = storage.writeArtifact(review.id, {
-					name: "review.md",
-					kind: "review",
+					name: "review-resume.md",
+					kind: "resume",
 					content: "# Review\n",
 				});
 				expect(first.id).toMatch(UUID);
 				const second = storage.writeArtifact(review.id, {
-					name: "review.md",
-					kind: "review",
+					name: "review-resume.md",
+					kind: "resume",
 					content: "# Review 2\n",
 				});
 				expect(second.id).toBe(first.id);
-				expect(storage.readArtifact(review.id, "review.md")?.content).toBe(
+				expect(storage.readArtifact(review.id, "review-resume.md")?.content).toBe(
 					"# Review 2\n",
 				);
 				storage.writeArtifact(review.id, {
@@ -215,7 +268,7 @@ function contract(
 					content: "{}",
 				});
 				expect(storage.listArtifacts(review.id).map((item) => item.name)).toEqual(
-					["manifest.json", "review.md"],
+					["manifest.json", "review-resume.md"],
 				);
 				storage.deleteArtifact(review.id, "manifest.json");
 				expect(storage.listArtifacts(review.id)).toHaveLength(1);
@@ -235,14 +288,14 @@ function contract(
 				});
 				storage.writeFindings(review.id, sampleState("main"));
 				storage.writeArtifact(review.id, {
-					name: "review.md",
-					kind: "review",
+					name: "review-resume.md",
+					kind: "resume",
 					content: "# Review\n",
 				});
 				storage.deleteReview(review.id);
 				expect(storage.getReview(review.id)).toBeNull();
 				expect(storage.readFindings(review.id)).toBeNull();
-				expect(storage.readArtifact(review.id, "review.md")).toBeNull();
+				expect(storage.readArtifact(review.id, "review-resume.md")).toBeNull();
 			} finally {
 				cleanup();
 			}
@@ -446,4 +499,136 @@ describe("migração do schema SQLite", () => {
 			rmSync(dir, { recursive: true, force: true });
 		}
 	});
+
+	test("banco v4 ganha `variant` sem perder findings (rebuild da reviews)", () => {
+		const dir = mkdtempSync(join(tmpdir(), "houndsman-migrate-v4-"));
+		const path = join(dir, "houndsman.db");
+		const reviewId = "22222222-2222-4222-8222-222222222222";
+		const legacy = new Database(path);
+		try {
+			legacy.exec(`
+				CREATE TABLE reviews (
+					id TEXT PRIMARY KEY,
+					repo_key TEXT NOT NULL,
+					repo_root TEXT NOT NULL,
+					repo_remote TEXT,
+					branch TEXT NOT NULL,
+					slug TEXT NOT NULL,
+					base TEXT,
+					head TEXT,
+					head_sha TEXT,
+					reviewed_sha TEXT,
+					reviewed_at TEXT,
+					status TEXT,
+					started_at TEXT,
+					heartbeat_at TEXT,
+					worktree_path TEXT,
+					pr_number INTEGER,
+					created_at TEXT NOT NULL,
+					updated_at TEXT NOT NULL,
+					UNIQUE(repo_key, branch)
+				);
+				CREATE TABLE findings (
+					id TEXT PRIMARY KEY,
+					review_id TEXT NOT NULL REFERENCES reviews(id) ON DELETE CASCADE,
+					short_id TEXT NOT NULL,
+					fingerprint TEXT NOT NULL,
+					watchdog_ids TEXT NOT NULL,
+					rule TEXT NOT NULL,
+					severity TEXT NOT NULL,
+					file TEXT NOT NULL,
+					line INTEGER,
+					message TEXT NOT NULL,
+					action TEXT NOT NULL,
+					evidence TEXT,
+					scenario TEXT,
+					impact TEXT,
+					confidence REAL,
+					basis TEXT,
+					anchor TEXT,
+					found_at_sha TEXT,
+					count INTEGER NOT NULL DEFAULT 1,
+					present INTEGER NOT NULL DEFAULT 1,
+					decision TEXT NOT NULL,
+					comment TEXT,
+					exec_state TEXT NOT NULL,
+					github TEXT,
+					created_at TEXT NOT NULL,
+					updated_at TEXT NOT NULL,
+					UNIQUE(review_id, short_id),
+					UNIQUE(review_id, fingerprint)
+				);
+				PRAGMA user_version = 4;
+			`);
+			legacy.run(
+				`INSERT INTO reviews
+					(id, repo_key, repo_root, branch, slug, created_at, updated_at)
+				 VALUES (?, ?, ?, ?, ?, ?, ?)`,
+				[
+					reviewId,
+					"path:/repo",
+					dir,
+					"feature/x",
+					"feature-x",
+					"2026-01-01T00:00:00.000Z",
+					"2026-01-01T00:00:00.000Z",
+				],
+			);
+			legacy.run(
+				`INSERT INTO findings
+					(id, review_id, short_id, fingerprint, watchdog_ids, rule, severity,
+					 file, line, message, action, decision, exec_state, created_at, updated_at)
+				 VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+				[
+					"33333333-3333-4333-8333-333333333333",
+					reviewId,
+					"ab12cd34ef",
+					"fp-legado",
+					'["alpha"]',
+					"regra",
+					"attention",
+					"src/a.ts",
+					3,
+					"msg",
+					"ação",
+					"pending",
+					"pending",
+					"2026-01-01T00:00:00.000Z",
+					"2026-01-01T00:00:00.000Z",
+				],
+			);
+		} finally {
+			legacy.close();
+		}
+
+		const storage = new SQLiteStorageProvider(path);
+		try {
+			const review = storage.getReview(reviewId);
+			expect(review?.variant).toBeUndefined();
+			// O rebuild preserva os filhos (FKs desligadas durante a troca).
+			expect(storage.readFindings(reviewId)?.findings.ab12cd34ef?.rule).toBe(
+				"regra",
+			);
+			// E a identidade agora aceita variantes na mesma branch.
+			const repo = buildRepoIdentity(null, dir);
+			const a = storage.getOrCreateReview({
+				repo,
+				branch: "feature/x",
+				variant: "baseline",
+				slug: "feature-x--baseline-abc123",
+			});
+			const b = storage.getOrCreateReview({
+				repo,
+				branch: "feature/x",
+				variant: "otimizado",
+				slug: "feature-x--otimizado-def456",
+			});
+			expect(a.id).not.toBe(b.id);
+			expect(a.id).not.toBe(reviewId);
+			expect(storage.findReview(a.repoKey, "feature/x", "baseline")?.id).toBe(a.id);
+		} finally {
+			storage.close();
+			rmSync(dir, { recursive: true, force: true });
+		}
+	});
 });