@payconductor/houndsman 0.13.0 → 0.16.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";
@@ -48,6 +49,7 @@ import { findWatchdog, getWatchdogContext } from "../core/watchdog-registry";
 
 import {
 	alphaWatchdog,
+	betaWatchdog,
 	FAKE_WATCHDOG_DEFINITIONS,
 	fakeHoundsmanConfig,
 } from "./fixtures/fake-project";
@@ -158,6 +160,24 @@ describe("registry-check", () => {
 		expect(warnings.some((w) => w.includes("duplicada"))).toBe(true);
 	});
 
+	test("mesma regra com severidades diferentes entre watchdogs gera aviso", () => {
+		const config = {
+			...fakeHoundsmanConfig,
+			watchdogs: {
+				...fakeHoundsmanConfig.watchdogs,
+				beta: {
+					...betaWatchdog,
+					rules: [
+						...betaWatchdog.rules,
+						{ severity: "suggestion" as const, text: "Nunca usar `any`." },
+					],
+				},
+			},
+		};
+		const { warnings } = checkRegistry(config as typeof fakeHoundsmanConfig);
+		expect(warnings.some((w) => w.includes("severidades divergentes"))).toBe(true);
+	});
+
 	test("texto de regra em reviewFocus/contextFiles gera aviso", () => {
 		const config = {
 			...fakeHoundsmanConfig,
@@ -451,6 +471,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 +669,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 +739,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 +801,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 +815,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/severity.test.ts

@@ -0,0 +1,235 @@
+/** Severidade determinística: ancoragem por regra e por classe de impacto. */
+
+import { describe, expect, test } from "bun:test";
+import type { Finding, WatchdogReport } from "../core/report-builder";
+import {
+	anchorReports,
+	IMPACT_CLASSES,
+	normalizeRuleText,
+	resolveDeclaredSeverity,
+	SEVERITY_BY_IMPACT,
+	severityAnchoringMessages,
+} from "../core/severity";
+import type { Rule } from "../core/types";
+import { FAKE_WATCHDOG_DEFINITIONS } from "./fixtures/fake-project";
+
+/** União das regras do projeto fake (o mesmo que o finalize monta). */
+function declaredRules(): Rule[] {
+	return Object.values(FAKE_WATCHDOG_DEFINITIONS).flatMap((def) => [...def.rules]);
+}
+
+function finding(partial: Partial<Finding> & { rule: string }): Finding {
+	return {
+		rule: partial.rule,
+		severity: partial.severity ?? "attention",
+		file: partial.file ?? "src/alpha/a.ts",
+		line: partial.line,
+		message: partial.message ?? "msg",
+		action: partial.action ?? "ação",
+		basis: partial.basis,
+		impactClass: partial.impactClass,
+		evidence: partial.evidence,
+		scenario: partial.scenario,
+	};
+}
+
+function report(findings: Finding[], watchdogId = "alpha"): WatchdogReport {
+	return {
+		watchdogId,
+		reviewedFiles: ["src/alpha/a.ts"],
+		skipped: [],
+		findings,
+	};
+}
+
+describe("normalizeRuleText", () => {
+	test("remove markdown, emoji, bullet e prefixo de severidade do brief", () => {
+		expect(
+			normalizeRuleText(
+				"- ❌ **blocking** — Promover: todo fluxo tem caminho completo.",
+			),
+		).toBe("promover: todo fluxo tem caminho completo");
+	});
+
+	test("colapsa espaços e ignora caixa", () => {
+		expect(normalizeRuleText("Evitar   CONSOLE.log")).toBe("evitar console.log");
+	});
+});
+
+describe("resolveDeclaredSeverity", () => {
+	test("casa pelo texto exato normalizado", () => {
+		expect(
+			resolveDeclaredSeverity("Nunca usar `any`.", declaredRules())?.severity,
+		).toBe("blocking");
+	});
+
+	test("casa quando o watchdog cita um trecho da regra", () => {
+		const declared = resolveDeclaredSeverity(
+			"Vale para todo handler: validar entrada do usuário",
+			declaredRules(),
+		);
+		expect(declared?.severity).toBe("attention");
+	});
+
+	test("texto sem casamento devolve null", () => {
+		expect(
+			resolveDeclaredSeverity(
+				"Regra inventada que não está no brief.",
+				declaredRules(),
+			),
+		).toBeNull();
+	});
+
+	test("mesmo texto em dois watchdogs fica com a severidade mais grave", () => {
+		const rules: Rule[] = [
+			{ severity: "attention", text: "Promover: todo fluxo tem caminho completo." },
+			{ severity: "blocking", text: "Promover: todo fluxo tem caminho completo." },
+		];
+		expect(
+			resolveDeclaredSeverity("Promover: todo fluxo tem caminho completo.", rules)
+				?.severity,
+		).toBe("blocking");
+	});
+});
+
+describe("impactClass", () => {
+	test("toda classe tem severidade mapeada", () => {
+		expect(IMPACT_CLASSES).toHaveLength(4);
+		expect(SEVERITY_BY_IMPACT["flow-break"]).toBe("blocking");
+		expect(SEVERITY_BY_IMPACT["contract-drift"]).toBe("attention");
+		expect(SEVERITY_BY_IMPACT.degradation).toBe("suggestion");
+		expect(SEVERITY_BY_IMPACT.cosmetic).toBe("nit");
+	});
+});
+
+describe("anchorReports", () => {
+	test("finding de regra assume a severidade declarada e registra a divergência", () => {
+		const anchoring = anchorReports(
+			[report([finding({ rule: "Nunca usar `any`.", severity: "attention" })])],
+			declaredRules(),
+		);
+		expect(anchoring.reports[0]?.findings[0]?.severity).toBe("blocking");
+		expect(anchoring.anchored).toBe(1);
+		expect(anchoring.diverged).toHaveLength(1);
+		expect(anchoring.diverged[0]).toMatchObject({
+			emitted: "attention",
+			resolved: "blocking",
+			source: "rule",
+			watchdogId: "alpha",
+		});
+	});
+
+	test("finding de regra sem casamento mantém o valor e entra em unmatched", () => {
+		const anchoring = anchorReports(
+			[
+				report([
+					finding({
+						rule: "Regra parafraseada fora do brief",
+						severity: "nit",
+					}),
+				]),
+			],
+			declaredRules(),
+		);
+		expect(anchoring.reports[0]?.findings[0]?.severity).toBe("nit");
+		expect(anchoring.unmatched).toBe(1);
+		expect(anchoring.diverged).toHaveLength(0);
+	});
+
+	test("emergente com flow-break e prova vira blocking", () => {
+		const anchoring = anchorReports(
+			[
+				report([
+					finding({
+						rule: "Lógica: renovação não fecha o fluxo",
+						severity: "suggestion",
+						basis: "logic",
+						impactClass: "flow-break",
+						scenario: "renovação de assinatura",
+						evidence: "await renew(data)",
+					}),
+				]),
+			],
+			declaredRules(),
+		);
+		expect(anchoring.reports[0]?.findings[0]?.severity).toBe("blocking");
+		expect(anchoring.classified).toBe(1);
+		expect(anchoring.diverged[0]).toMatchObject({
+			source: "impact",
+			resolved: "blocking",
+		});
+	});
+
+	test("flow-break sem cenário+evidência cai para attention", () => {
+		const anchoring = anchorReports(
+			[
+				report([
+					finding({
+						rule: "Domínio: estado sem tratamento",
+						severity: "suggestion",
+						basis: "domain",
+						impactClass: "flow-break",
+					}),
+				]),
+			],
+			declaredRules(),
+		);
+		expect(anchoring.reports[0]?.findings[0]?.severity).toBe("attention");
+		expect(anchoring.diverged[0]?.resolved).toBe("attention");
+	});
+
+	test("emergente sem impactClass mantém o valor emitido", () => {
+		const anchoring = anchorReports(
+			[
+				report([
+					finding({
+						rule: "Domínio: algo",
+						severity: "nit",
+						basis: "domain",
+						impactClass: "desconhecida",
+					}),
+				]),
+			],
+			declaredRules(),
+		);
+		expect(anchoring.reports[0]?.findings[0]?.severity).toBe("nit");
+		expect(anchoring.classified).toBe(0);
+		expect(anchoring.unmatched).toBe(0);
+		expect(anchoring.diverged).toHaveLength(0);
+	});
+});
+
+describe("severityAnchoringMessages", () => {
+	test("resume contagens, exemplos e a falta de casamento", () => {
+		const anchoring = anchorReports(
+			[
+				report([
+					finding({ rule: "Nunca usar `any`.", severity: "attention" }),
+					finding({
+						rule: "Lógica: fluxo não fecha",
+						severity: "nit",
+						basis: "logic",
+						impactClass: "flow-break",
+						scenario: "gatilho",
+						evidence: "trecho",
+					}),
+					finding({ rule: "Regra inventada", severity: "nit" }),
+				]),
+			],
+			declaredRules(),
+		);
+		const messages = severityAnchoringMessages(anchoring);
+		expect(messages[0]).toContain("1 pela regra");
+		expect(messages[0]).toContain("1 pelo impacto");
+		expect(messages[0]).toContain("2 divergência(s)");
+		expect(messages.some((message) => message.includes("sem casamento"))).toBe(true);
+	});
+
+	test("silencia quando nada é resolvido", () => {
+		const anchoring = anchorReports(
+			[report([finding({ rule: "Lógica: x", basis: "logic" })])],
+			declaredRules(),
+		);
+		expect(severityAnchoringMessages(anchoring)).toEqual([]);
+	});
+});