@payconductor/houndsman 0.13.0 → 0.16.0

package/src/tests/markdown.test.ts

@@ -116,11 +116,11 @@ describe("parseInline", () => {
 	});
 
 	test("destaca caminhos de arquivo no texto corrido", () => {
-		expect(parseInline("veja src/foo/bar.ts e review.md")).toEqual([
+		expect(parseInline("veja src/foo/bar.ts e manifest.json")).toEqual([
 			{ type: "text", text: "veja " },
 			{ type: "path", text: "src/foo/bar.ts" },
 			{ type: "text", text: " e " },
-			{ type: "path", text: "review.md" },
+			{ type: "path", text: "manifest.json" },
 		]);
 	});
 });
@@ -128,7 +128,7 @@ describe("parseInline", () => {
 describe("isFilePath", () => {
 	test("reconhece arquivos e caminhos, sem confundir texto comum", () => {
 		expect(isFilePath("src/foo/bar.ts")).toBe(true);
-		expect(isFilePath("review.md")).toBe(true);
+		expect(isFilePath("manifest.json")).toBe(true);
 		expect(isFilePath("./scripts/ci.sh")).toBe(true);
 		expect(isFilePath("M/D")).toBe(false);
 		expect(isFilePath("duas palavras.ts")).toBe(false);

package/src/tests/progress.test.ts

@@ -6,7 +6,13 @@
  */
 
 import { describe, expect, test } from "bun:test";
-import { formatDuration, Logger, PhaseReporter, ProgressBoard } from "../core/logging";
+import {
+	formatDuration,
+	Logger,
+	ParallelPhaseReporter,
+	PhaseReporter,
+	ProgressBoard,
+} from "../core/logging";
 
 function memoryStream(): { stream: NodeJS.WritableStream; text: () => string } {
 	let content = "";
@@ -64,6 +70,28 @@ describe("PhaseReporter", () => {
 	});
 });
 
+describe("ParallelPhaseReporter", () => {
+	test("em pipe aceita fases concorrentes e loga cada uma", () => {
+		const { logger, out } = loggerFor(false);
+		const reporter = new ParallelPhaseReporter(logger);
+		reporter.begin("context", "Resumindo o contexto");
+		reporter.begin("business", "Reconstruindo a intenção");
+		reporter.end("context", "Contexto resumido", 50);
+		reporter.end("business", "Intenção reconstruída", 80);
+		reporter.stop();
+		const text = out.text();
+		expect(text).toContain("→ Resumindo o contexto");
+		expect(text).toContain("→ Reconstruindo a intenção");
+		expect(text).toContain("✔ Contexto resumido (50ms)");
+		expect(text).toContain("✔ Intenção reconstruída (80ms)");
+	});
+
+	test("stop sem fases ativas não lança", () => {
+		const { logger } = loggerFor(false);
+		expect(() => new ParallelPhaseReporter(logger).stop()).not.toThrow();
+	});
+});
+
 describe("ProgressBoard", () => {
 	test("em pipe loga início/fim e não usa ANSI", () => {
 		const { logger, out, err } = loggerFor(false);

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) {