@payconductor/houndsman 0.12.0 → 0.14.0

package/src/tests/progress.test.ts

@@ -0,0 +1,145 @@
+/**
+ * Progresso do CLI — formatação, fases sequenciais e board concorrente.
+ *
+ * O board em TTY pinta um bloco com loader; fora de TTY mantém as linhas de
+ * início/fim e um heartbeat periódico.
+ */
+
+import { describe, expect, test } from "bun:test";
+import {
+	formatDuration,
+	Logger,
+	ParallelPhaseReporter,
+	PhaseReporter,
+	ProgressBoard,
+} from "../core/logging";
+
+function memoryStream(): { stream: NodeJS.WritableStream; text: () => string } {
+	let content = "";
+	const stream = {
+		write(chunk: string) {
+			content += chunk;
+			return true;
+		},
+		isTTY: false,
+	} as unknown as NodeJS.WritableStream;
+	return { stream, text: () => content };
+}
+
+function loggerFor(tty: boolean): {
+	logger: Logger;
+	out: ReturnType<typeof memoryStream>;
+	err: ReturnType<typeof memoryStream>;
+} {
+	const out = memoryStream();
+	const err = memoryStream();
+	const logger = new Logger({
+		stdout: out.stream,
+		stderr: err.stream,
+		color: false,
+		isTTY: tty,
+	});
+	return { logger, out, err };
+}
+
+const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
+
+describe("formatDuration", () => {
+	test("ms, segundos e minutos", () => {
+		expect(formatDuration(820)).toBe("820ms");
+		expect(formatDuration(3_400)).toBe("3.4s");
+		expect(formatDuration(42_000)).toBe("42s");
+		expect(formatDuration(125_000)).toBe("2m05s");
+	});
+});
+
+describe("PhaseReporter", () => {
+	test("em pipe imprime início e fim com a duração", () => {
+		const { logger, out } = loggerFor(false);
+		const reporter = new PhaseReporter(logger);
+		reporter.begin("diff", "Lendo o diff");
+		expect(out.text()).toContain("→ Lendo o diff");
+		reporter.end("diff", "Diff lido", 1_200);
+		expect(out.text()).toContain("✔ Diff lido (1.2s)");
+	});
+
+	test("fase sem início ainda reporta o fim", () => {
+		const { logger, out } = loggerFor(false);
+		new PhaseReporter(logger).end("ast", "AST analisada", 40);
+		expect(out.text()).toContain("AST analisada (40ms)");
+	});
+});
+
+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);
+		const board = new ProgressBoard({ logger, heartbeatMs: 10_000 });
+		board.start(2);
+		board.add("alpha", "revisando");
+		board.add("beta", "revisando");
+		board.succeed("alpha", "alpha — 2 finding(s) (12s)");
+		board.fail("beta", "beta falhou");
+		board.stop();
+		const text = out.text();
+		expect(text).toContain("alpha: revisando…");
+		expect(text).toContain("alpha — 2 finding(s) (12s)");
+		expect(err.text()).toContain("beta falhou");
+		expect(`${text}${err.text()}`).not.toContain("\u001b[");
+	});
+
+	test("em pipe emite heartbeat enquanto há tarefa em execução", async () => {
+		const { logger, out } = loggerFor(false);
+		const board = new ProgressBoard({ logger, heartbeatMs: 5 });
+		board.start(1);
+		board.add("alpha", "revisando");
+		await sleep(40);
+		board.stop();
+		expect(out.text()).toContain("1 tarefa(s) em execução: alpha");
+	});
+
+	test("em TTY pinta o bloco com loader e apaga ao concluir", () => {
+		const { logger, out } = loggerFor(true);
+		const board = new ProgressBoard({ logger, frameMs: 1_000 });
+		board.start(1);
+		board.add("alpha", "revisando");
+		const painted = out.text();
+		expect(painted).toContain("\u001b[2K");
+		expect(painted).toContain("alpha");
+		expect(painted).toContain("0/1 concluído(s)");
+		board.succeed("alpha", "alpha — 1 finding(s) (5s)");
+		board.stop();
+		expect(out.text()).toContain("✔ alpha — 1 finding(s) (5s)");
+	});
+
+	test("retry atualiza o detalhe sem derrubar o board", () => {
+		const { logger, out } = loggerFor(false);
+		const board = new ProgressBoard({ logger });
+		board.start(1);
+		board.add("alpha", "revisando");
+		board.retry("alpha", "tentativa 2/2", "alpha: repetindo (2/2)");
+		board.stop();
+		expect(out.text()).toContain("alpha: repetindo (2/2)");
+	});
+});

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

@@ -12,6 +12,7 @@ import { join } from "node:path";
 import { AstService } from "../core/ast/service";
 import { ReviewScopeResolver, type ScopeOptions } from "../core/engine/review-scope";
 import type { FindingState, FindingsStateFile } from "../core/findings-state";
+import type { PrepareProgressEvent } from "../core/orchestrator";
 import { defaultOptions, finalize, prepare, reviewContext } from "../core/orchestrator";
 import { resolveRepoIdentity } from "../core/storage/repo-identity";
 import { SQLiteStorageProvider } from "../core/storage/sqlite/sqlite-storage";
@@ -255,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(
@@ -280,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");
@@ -311,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(
@@ -363,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();
@@ -383,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 {
@@ -400,3 +410,64 @@ describe("prepare sem alterações", () => {
 		}
 	}, 30_000);
 });
+
+// ---------------------------------------------------------------------------
+// Progresso do prepare
+// ---------------------------------------------------------------------------
+
+describe("prepare — progresso", () => {
+	test("emite início/fim das etapas que realmente rodam", async () => {
+		const repo = makeRepo();
+		const originalCwd = process.cwd();
+		const originalHome = process.env.HOUNDSMAN_HOME;
+		let storage: SQLiteStorageProvider | null = null;
+
+		try {
+			process.env.HOUNDSMAN_HOME = join(repo.cwd, ".home");
+			process.chdir(repo.cwd);
+
+			storage = new SQLiteStorageProvider(join(repo.cwd, "houndsman.db"));
+			const record = storage.getOrCreateReview({
+				repo: resolveRepoIdentity(),
+				branch: "main",
+				slug: "main",
+			});
+			const opts = {
+				...defaultOptions(),
+				base: repo.base,
+				head: "HEAD",
+				noJev: true,
+				noAst: true,
+			};
+
+			const events: PrepareProgressEvent[] = [];
+			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",
+				"business",
+				"briefs",
+				"manifest",
+			]);
+			const done = events.filter((event) => event.type === "done");
+			expect(done.map((event) => event.stage)).toEqual(starts);
+			for (const event of done) {
+				if (event.type === "done") {
+					expect(event.durationMs).toBeGreaterThanOrEqual(0);
+				}
+			}
+		} finally {
+			storage?.close();
+			process.chdir(originalCwd);
+			if (originalHome === undefined) delete process.env.HOUNDSMAN_HOME;
+			else process.env.HOUNDSMAN_HOME = originalHome;
+			repo.cleanup();
+		}
+	}, 30_000);
+});