@payconductor/houndsman 0.13.0 → 0.14.0

package/src/tests/propagation.test.ts

@@ -0,0 +1,119 @@
+/**
+ * Propagação mecânica — cluster de micro-alterações e lacunas de importadores.
+ *
+ * Congela a heurística usada no brief para não ler N diffs de uma linha e para
+ * apontar contratos cujos importadores ficaram fora do diff.
+ */
+
+import { describe, expect, test } from "bun:test";
+import type { AstAnalysis, AstImpact } from "../core/ast/types";
+import { detectPropagation, detectPropagationGaps } from "../core/propagation";
+import type { ChurnMap } from "../core/types";
+
+const files = Array.from({ length: 7 }, (_, index) => `src/f${index}.ts`);
+
+function patchFor(line: string): Map<string, string> {
+	return new Map(
+		files.map((file) => [file, `@@ -1 +1 @@\n-  await pay(charge);\n+${line}`]),
+	);
+}
+
+function churnFor(extra: ChurnMap = {}): ChurnMap {
+	const base: ChurnMap = Object.fromEntries(
+		files.map((file) => [file, { additions: 1, deletions: 1 }]),
+	);
+	return { ...base, ...extra };
+}
+
+describe("detectPropagation", () => {
+	test("agrupa o padrão dominante e isola os outliers", () => {
+		const patch = patchFor("  await pay(charge, true);");
+		patch.set(
+			"src/f6.ts",
+			"@@ -1 +1 @@\n-  await pay(charge);\n+  await pay(charge, false);",
+		);
+		const cluster = detectPropagation(files, patch, churnFor());
+		expect(cluster?.files).toEqual(files.slice(0, 6));
+		expect(cluster?.lines).toEqual(["await pay(charge, true);"]);
+		expect(cluster?.outliers).toEqual([
+			{ file: "src/f6.ts", lines: ["await pay(charge, false);"] },
+		]);
+	});
+
+	test("ignora arquivos com churn acima do limite de micro-alteração", () => {
+		const patch = patchFor("  await pay(charge, true);");
+		patch.set("src/big.ts", "+  await pay(charge, true);");
+		const cluster = detectPropagation([...files, "src/big.ts"], patch, {
+			...churnFor(),
+			"src/big.ts": { additions: 40, deletions: 0 },
+		});
+		expect(cluster?.files).not.toContain("src/big.ts");
+	});
+
+	test("sem grupo dominante devolve null", () => {
+		const patch = new Map(
+			files.slice(0, 3).map((file) => [file, "+  await pay(charge, true);"]),
+		);
+		expect(detectPropagation(files.slice(0, 3), patch, churnFor())).toBeNull();
+	});
+});
+
+describe("detectPropagationGaps", () => {
+	const analysis = {
+		facts: {},
+		delta: {
+			addedSymbols: [],
+			removedSymbols: [],
+			modifiedSymbols: [],
+			changedSignatures: [
+				{
+					name: "pay",
+					before: "pay(charge)",
+					after: "pay(charge, x)",
+					exported: true,
+				},
+			],
+			changedExports: [],
+			addedImports: [],
+			removedImports: [],
+		},
+	} as unknown as AstAnalysis;
+	const impact = {
+		affectedFiles: [],
+		importers: {
+			"src/types.ts": ["src/a.ts", "src/b.ts"],
+			"src/other.ts": ["src/c.ts"],
+		},
+		exportedChanges: [],
+	} as unknown as AstImpact;
+
+	test("lista só importadores que não estão no diff", () => {
+		const gaps = detectPropagationGaps(
+			["src/types.ts", "src/other.ts"],
+			new Map([["src/types.ts", analysis]]),
+			impact,
+			new Set(["src/a.ts"]),
+		);
+		expect(gaps).toEqual([{ file: "src/types.ts", importers: ["src/b.ts"] }]);
+	});
+
+	test("ignora mudança que não toca contrato exportado", () => {
+		const internal = {
+			...analysis,
+			delta: {
+				...analysis.delta,
+				changedSignatures: [
+					{ name: "pay", before: "pay(a)", after: "pay(b)", exported: false },
+				],
+			},
+		} as unknown as AstAnalysis;
+		expect(
+			detectPropagationGaps(
+				["src/types.ts"],
+				new Map([["src/types.ts", internal]]),
+				impact,
+				new Set(),
+			),
+		).toEqual([]);
+	});
+});

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

@@ -95,6 +95,63 @@ describe("renderReviewResume", () => {
 		expect(md).toContain("Sem mudanças estruturais detectadas nesta revisão.");
 	});
 
+	test("inclui cobertura por domínio, candidatos e conclusão", () => {
+		const md = renderReviewResume({
+			branch: "feat/x",
+			date: "2026-10-17",
+			classification,
+			findings: [
+				finding({ severity: "blocking" }),
+				finding({ severity: "attention", file: "src/b.ts" }),
+			],
+			domains: [
+				{
+					id: "alpha",
+					name: "Alpha",
+					findings: 1,
+					reviewedFiles: 1,
+					expectedFiles: 2,
+				},
+				{
+					id: "beta",
+					name: "Beta",
+					findings: 1,
+					reviewedFiles: 1,
+					expectedFiles: 1,
+				},
+			],
+			candidates: [
+				{
+					watchdogId: "alpha",
+					rule: "Suspeita X",
+					severity: "attention",
+					file: "src/c.ts",
+					confidence: 0.7,
+					questionKey: "q1",
+				},
+				{
+					watchdogId: "alpha",
+					rule: "regra",
+					severity: "attention",
+					file: "src/a.ts",
+					confidence: 0.7,
+					questionKey: "q2",
+				},
+			],
+		});
+
+		expect(md).toContain("## Cobertura por domínio");
+		expect(md).toContain("| Alpha | 1 | 1/2 | — | 1 |");
+		expect(md).toContain("| Beta | 1 | 1/1 | — | — |");
+		expect(md).toContain("## Candidatos não verificados (1)");
+		expect(md).toContain("Suspeita X");
+		expect(md).not.toContain("`src/a.ts` ·");
+		expect(md).toContain("## Conclusão");
+		expect(md).toContain(
+			"**Resumo:** 1 bloqueantes · 1 atenção · 0 sugestões · 0 nits.",
+		);
+	});
+
 	test("respeita o teto de caracteres", () => {
 		const findings = Array.from({ length: 40 }, (_, index) =>
 			finding({
@@ -124,6 +181,8 @@ describe("renderReviewResume", () => {
 		});
 
 		expect(md.length).toBeLessThanOrEqual(RESUME_MAX_CHARS);
-		expect(md.endsWith("…")).toBe(true);
+		// O corte acontece no texto narrativo; tabelas e conclusão seguem inteiras.
+		expect(md).toContain("\n…");
+		expect(md).toContain("## Conclusão");
 	});
 });

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

@@ -256,7 +256,7 @@ describe("prepare/finalize — mesmo commit", () => {
 			};
 
 			let ctx = reviewContext(storage, record);
-			await prepare(opts, "main", fakeHoundsmanConfig, ctx);
+			await prepare(ctx, fakeHoundsmanConfig, opts);
 			expect(storage.getReview(record.id)?.status).toBe("reviewing");
 
 			writeFileSync(
@@ -281,30 +281,46 @@ describe("prepare/finalize — mesmo commit", () => {
 					2,
 				)}\n`,
 			);
-			finalize(opts, "main", fakeHoundsmanConfig, ctx);
+			writeFileSync(
+				ctx.work.findingFile("general"),
+				`${JSON.stringify(
+					{
+						watchdogId: "general",
+						reviewedFiles: ["src/alpha/a.ts"],
+						skipped: [],
+						findings: [],
+					},
+					null,
+					2,
+				)}\n`,
+			);
+			finalize(ctx, fakeHoundsmanConfig, opts);
 
 			const classificationBefore = storage.readArtifact(
 				record.id,
 				"classification.json",
 			)?.content;
-			const reportBefore = storage.readArtifact(record.id, "review.md")?.content;
+			const reportBefore = storage.readArtifact(
+				record.id,
+				"review-resume.md",
+			)?.content;
 			const findingsBefore = JSON.stringify(
 				storage.readFindings(record.id)?.findings,
 			);
 			const reviewedBefore = storage.getReview(record.id)?.reviewedSha;
 			expect(classificationBefore).toBeTruthy();
-			expect(reportBefore).toContain("src/alpha/a.ts");
+			expect(reportBefore).toContain("## Cobertura por domínio");
 
 			// Mesmo commit: prepare vira no-op e nada é reescrito.
 			ctx = reviewContext(storage, storage.getReview(record.id) ?? record);
-			const again = await prepare(opts, "main", fakeHoundsmanConfig, ctx);
+			const again = await prepare(ctx, fakeHoundsmanConfig, opts);
 			expect(again.messages.join("\n")).toContain(
 				"Nenhuma alteração desde a última revisão",
 			);
 			expect(storage.readArtifact(record.id, "classification.json")?.content).toBe(
 				classificationBefore,
 			);
-			expect(storage.readArtifact(record.id, "review.md")?.content).toBe(
+			expect(storage.readArtifact(record.id, "review-resume.md")?.content).toBe(
 				reportBefore,
 			);
 			expect(storage.getReview(record.id)?.status).toBe("review_done");
@@ -312,13 +328,12 @@ describe("prepare/finalize — mesmo commit", () => {
 
 			// Finalize sem ciclo preparado: no-op (não degrada o relatório).
 			const finalizedAgain = finalize(
-				opts,
-				"main",
-				fakeHoundsmanConfig,
 				reviewContext(storage, storage.getReview(record.id) ?? record),
+				fakeHoundsmanConfig,
+				opts,
 			);
 			expect(finalizedAgain.messages.join("\n")).toContain("Nada a finalizar");
-			expect(storage.readArtifact(record.id, "review.md")?.content).toBe(
+			expect(storage.readArtifact(record.id, "review-resume.md")?.content).toBe(
 				reportBefore,
 			);
 			expect(JSON.stringify(storage.readFindings(record.id)?.findings)).toBe(
@@ -364,10 +379,9 @@ describe("prepare sem alterações", () => {
 			};
 
 			const result = await prepare(
-				opts,
-				"main",
-				fakeHoundsmanConfig,
 				reviewContext(storage, record),
+				fakeHoundsmanConfig,
+				opts,
 			);
 			expect(result.messages.join("\n")).toContain("nenhuma run criada");
 			expect(storage.getReview(record.id)).toBeNull();
@@ -384,12 +398,7 @@ describe("prepare sem alterações", () => {
 				kind: "context",
 				content: "{}\n",
 			});
-			await prepare(
-				opts,
-				"main",
-				fakeHoundsmanConfig,
-				reviewContext(storage, kept),
-			);
+			await prepare(reviewContext(storage, kept), fakeHoundsmanConfig, opts);
 			expect(storage.getReview(kept.id)?.status).toBe("review_done");
 			expect(storage.readArtifact(kept.id, "context.json")).not.toBeNull();
 		} finally {
@@ -432,20 +441,20 @@ describe("prepare — progresso", () => {
 			};
 
 			const events: PrepareProgressEvent[] = [];
-			await prepare(
-				opts,
-				"main",
-				fakeHoundsmanConfig,
-				reviewContext(storage, record),
-				undefined,
-				undefined,
-				(event) => events.push(event),
-			);
+			await prepare(reviewContext(storage, record), fakeHoundsmanConfig, opts, {
+				onProgress: (event) => events.push(event),
+			});
 
 			const starts = events
 				.filter((event) => event.type === "start")
 				.map((event) => event.stage);
-			expect(starts).toEqual(["diff", "classify", "briefs", "manifest"]);
+			expect(starts).toEqual([
+				"diff",
+				"classify",
+				"business",
+				"briefs",
+				"manifest",
+			]);
 			const done = events.filter((event) => event.type === "done");
 			expect(done.map((event) => event.stage)).toEqual(starts);
 			for (const event of done) {

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");
 	});