@payconductor/houndsman 0.1.0 → 0.1.1

package/src/tests/findings-state.test.ts

@@ -0,0 +1,274 @@
+import { describe, expect, test } from "bun:test";
+import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import {
+	applyFindingUpdate,
+	buildStateFromFindings,
+	emptyState,
+	FindingsStateStore,
+	fileReader,
+	filterFindings,
+	summarize,
+	syncState,
+} from "../core/findings-state";
+import type { MergedFinding } from "../core/report-builder";
+import type { Severity } from "../core/types";
+
+/** Projeto em disco temporário (limpo no fim). */
+function makeProject(files: Record<string, string>): {
+	cwd: string;
+	cleanup: () => void;
+} {
+	const cwd = mkdtempSync(join(tmpdir(), "houndsman-state-"));
+	for (const [rel, content] of Object.entries(files)) {
+		const full = join(cwd, rel);
+		mkdirSync(dirname(full), { recursive: true });
+		writeFileSync(full, content);
+	}
+	return { cwd, cleanup: () => rmSync(cwd, { recursive: true, force: true }) };
+}
+
+function merged(
+	partial: Partial<MergedFinding> & { file: string; rule: string },
+): MergedFinding {
+	return {
+		rule: partial.rule,
+		severity: (partial.severity ?? "attention") as Severity,
+		file: partial.file,
+		line: partial.line,
+		message: partial.message ?? "msg",
+		action: partial.action ?? "ação",
+		evidence: partial.evidence,
+		watchdogs: partial.watchdogs ?? ["alpha"],
+	};
+}
+
+const DUPLICATED = [
+	"function a() {",
+	'\tconsole.log("x");',
+	"}",
+	"function b() {",
+	'\tconsole.log("x");',
+	"}",
+].join("\n");
+
+const AFTER_FIX = [
+	"function a() {",
+	"}",
+	"function b() {",
+	'\tconsole.log("x");',
+	"}",
+].join("\n");
+
+describe("buildStateFromFindings", () => {
+	test("cria entradas pendentes com id e ancora a linha", () => {
+		const project = makeProject({ "src/f.ts": DUPLICATED });
+		try {
+			const findings = [
+				merged({ file: "src/f.ts", rule: "r", line: 2 }),
+				merged({ file: "src/f.ts", rule: "r", line: 5 }),
+			];
+			const state = buildStateFromFindings(findings, {
+				branch: "feature/x",
+				readFile: fileReader(project.cwd),
+			});
+
+			expect(state.slug).toBe("feature-x");
+			expect(Object.keys(state.findings)).toHaveLength(2);
+			// Os ids voltam para os findings (usados no relatório).
+			expect(findings[0].id).toBeTruthy();
+			expect(findings[0].id).not.toBe(findings[1].id);
+			for (const finding of Object.values(state.findings)) {
+				expect(finding.decision).toBe("pending");
+				expect(finding.execState).toBe("pending");
+				expect(finding.present).toBe(true);
+				expect(finding.line).toBeGreaterThan(0);
+			}
+		} finally {
+			project.cleanup();
+		}
+	});
+
+	test("preserva id e decisão entre execuções (casa por fingerprint)", () => {
+		const project = makeProject({ "src/f.ts": DUPLICATED });
+		try {
+			const reader = fileReader(project.cwd);
+			const first = buildStateFromFindings(
+				[merged({ file: "src/f.ts", rule: "r", line: 2 })],
+				{ branch: "main", readFile: reader },
+			);
+			const id = Object.keys(first.findings)[0];
+			applyFindingUpdate(first.findings[id], { decision: "ignore" });
+
+			const second = buildStateFromFindings(
+				[merged({ file: "src/f.ts", rule: "r", line: 2 })],
+				{ branch: "main", readFile: reader, previous: first },
+			);
+			expect(Object.keys(second.findings)).toEqual([id]);
+			expect(second.findings[id].decision).toBe("ignore");
+		} finally {
+			project.cleanup();
+		}
+	});
+
+	test("finding que sumiu fica ausente e vira done se era 'execute'", () => {
+		const project = makeProject({ "src/f.ts": DUPLICATED });
+		try {
+			const reader = fileReader(project.cwd);
+			const first = buildStateFromFindings(
+				[merged({ file: "src/f.ts", rule: "r", line: 2 })],
+				{ branch: "main", readFile: reader },
+			);
+			const id = Object.keys(first.findings)[0];
+			applyFindingUpdate(first.findings[id], { decision: "execute" });
+
+			const second = buildStateFromFindings([], {
+				branch: "main",
+				readFile: reader,
+				previous: first,
+			});
+			expect(second.findings[id].present).toBe(false);
+			expect(second.findings[id].execState).toBe("done");
+		} finally {
+			project.cleanup();
+		}
+	});
+
+	test("ocorrências idênticas (mesmo contexto) viram um grupo com count", () => {
+		const content = [
+			"const a = 1;",
+			'console.log("x");',
+			"const a = 1;",
+			'console.log("x");',
+			"const a = 1;",
+		].join("\n");
+		const project = makeProject({ "src/g.ts": content });
+		try {
+			const findings = [
+				merged({ file: "src/g.ts", rule: "r", line: 2 }),
+				merged({ file: "src/g.ts", rule: "r", line: 4 }),
+			];
+			const state = buildStateFromFindings(findings, {
+				branch: "main",
+				readFile: fileReader(project.cwd),
+			});
+			expect(Object.keys(state.findings)).toHaveLength(1);
+			const only = Object.values(state.findings)[0];
+			expect(only.count).toBe(2);
+			expect(findings[0].id).toBe(findings[1].id);
+		} finally {
+			project.cleanup();
+		}
+	});
+});
+
+describe("syncState", () => {
+	test("move a sobrevivente de linha e marca a removida como stale/done", () => {
+		const before = makeProject({ "src/f.ts": DUPLICATED });
+		const after = makeProject({ "src/f.ts": AFTER_FIX });
+		try {
+			const state = buildStateFromFindings(
+				[
+					merged({ file: "src/f.ts", rule: "r", line: 2 }),
+					merged({ file: "src/f.ts", rule: "r", line: 5 }),
+				],
+				{ branch: "main", readFile: fileReader(before.cwd) },
+			);
+			const ids = Object.keys(state.findings);
+			// A primeira ocorrência foi marcada para executar.
+			const firstId = ids[0];
+			applyFindingUpdate(state.findings[firstId], { decision: "execute" });
+
+			const result = syncState(state, fileReader(after.cwd));
+			expect(result.moved).toHaveLength(1);
+			expect(result.stale).toHaveLength(1);
+			expect(result.stale).toContain(firstId);
+			expect(state.findings[firstId].execState).toBe("done");
+
+			const survivor = state.findings[result.moved[0]];
+			expect(survivor.line).toBe(4);
+		} finally {
+			before.cleanup();
+			after.cleanup();
+		}
+	});
+});
+
+describe("filterFindings / summarize", () => {
+	test("filtra por decisão e severity, e resume as contagens", () => {
+		const project = makeProject({ "src/f.ts": DUPLICATED });
+		try {
+			const state = buildStateFromFindings(
+				[
+					merged({
+						file: "src/f.ts",
+						rule: "r",
+						line: 2,
+						severity: "blocking",
+					}),
+					merged({ file: "src/f.ts", rule: "r2", line: 5, severity: "nit" }),
+				],
+				{ branch: "main", readFile: fileReader(project.cwd) },
+			);
+			const ids = Object.keys(state.findings);
+			applyFindingUpdate(state.findings[ids[0]], { decision: "execute" });
+
+			expect(
+				filterFindings(state, { decision: "execute" }).map((f) => f.id),
+			).toEqual([ids[0]]);
+			expect(filterFindings(state, { severity: "nit" }).map((f) => f.id)).toEqual([
+				ids[1],
+			]);
+
+			const summary = summarize(state);
+			expect(summary.total).toBe(2);
+			expect(summary.byDecision.execute).toBe(1);
+			expect(summary.byDecision.pending).toBe(1);
+			expect(summary.bySeverity.blocking).toBe(1);
+		} finally {
+			project.cleanup();
+		}
+	});
+});
+
+describe("FindingsStateStore", () => {
+	test("grava e lê o state.json de forma atômica", () => {
+		const project = makeProject({ "src/f.ts": DUPLICATED });
+		const outDir = join(project.cwd, "artifacts");
+		try {
+			const store = FindingsStateStore.at(outDir, "feature/x");
+			const state = buildStateFromFindings(
+				[merged({ file: "src/f.ts", rule: "r", line: 2 })],
+				{ branch: "feature/x", readFile: fileReader(project.cwd) },
+			);
+			store.write(state);
+
+			expect(store.filePath).toBe(join(outDir, "feature-x", "state.json"));
+			expect(existsSync(store.filePath)).toBe(true);
+			const read = store.read();
+			expect(read?.slug).toBe("feature-x");
+			expect(Object.keys(read?.findings ?? {})).toHaveLength(1);
+		} finally {
+			project.cleanup();
+		}
+	});
+
+	test("read devolve null quando o arquivo não existe", () => {
+		const project = makeProject({});
+		try {
+			const store = FindingsStateStore.at(join(project.cwd, "artifacts"), "main");
+			expect(store.read()).toBeNull();
+			expect(store.update(() => {})).toBeTruthy();
+		} finally {
+			project.cleanup();
+		}
+	});
+
+	test("emptyState cria um estado vazio válido", () => {
+		const state = emptyState("feature/x");
+		expect(state.version).toBe(1);
+		expect(state.slug).toBe("feature-x");
+		expect(state.findings).toEqual({});
+	});
+});

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

@@ -6,13 +6,23 @@ import type { AxiosInstance } from "axios";
 import { renderBrief } from "../core/brief";
 import { parseReviewArgs } from "../core/commands/review";
 import { renderWatchdogContext } from "../core/commands/watchdog";
+import {
+	DEFAULT_JEV_CONCURRENCY,
+	DEFAULT_MAX_FILES_PER_BRIEF,
+	resolveJevConcurrency,
+	resolveMaxFilesPerBrief,
+} from "../core/config";
+import { parseDiffIndex, parseNumstat } from "../core/diff-source";
 import { discoverDocs } from "../core/doc-discoverer";
 import {
 	type ClassificationResult,
+	churnOf,
 	classifyEntries,
 	isExcludedPath,
 	matchWatchdogs,
 	parseEntries,
+	selectByBudget,
+	sortByRisk,
 } from "../core/file-classifier";
 import {
 	type JevCandidatesFile,
@@ -27,6 +37,7 @@ import {
 	dedupeFindings,
 	parseContextSummary,
 	parseWatchdogReport,
+	renderDomainReport,
 	renderReport,
 	sanitizeBranch,
 	type WatchdogReport,
@@ -306,6 +317,136 @@ describe("isExcludedPath", () => {
 	});
 });
 
+// ---------------------------------------------------------------------------
+// diff-source (diff único: patch + churn)
+// ---------------------------------------------------------------------------
+
+describe("diff-source", () => {
+	test("parseNumstat lê adições/remoções por arquivo", () => {
+		const map = parseNumstat("3\t1\tsrc/a.ts\0");
+		expect(map.get("src/a.ts")).toEqual({ additions: 3, deletions: 1 });
+	});
+
+	test("parseNumstat trata rename (path vazio) e binário ('-')", () => {
+		const nul = String.fromCharCode(0);
+		const raw = [
+			"2	0	",
+			"src/old.ts",
+			"src/new.ts",
+			"10	-	dist/x.png",
+			"",
+		].join(nul);
+		const map = parseNumstat(raw);
+		expect(map.get("src/new.ts")).toEqual({ additions: 2, deletions: 0 });
+		expect(map.get("dist/x.png")).toEqual({ additions: 10, deletions: 0 });
+	});
+
+	test("parseDiffIndex fatia o patch e extrai o path novo (renames)", () => {
+		const patch = [
+			"diff --git a/src/a.ts b/src/a.ts",
+			"index 111..222 100644",
+			"--- a/src/a.ts",
+			"+++ b/src/a.ts",
+			"@@ -1 +1 @@",
+			"-old",
+			"+new",
+			"diff --git a/src/old.ts b/src/new.ts",
+			"similarity index 90%",
+			"rename from src/old.ts",
+			"rename to src/new.ts",
+			"--- a/src/old.ts",
+			"+++ b/src/new.ts",
+			"@@ -1 +1 @@",
+			"-a",
+			"+b",
+		].join("\n");
+
+		const map = parseDiffIndex(patch);
+		expect([...map.keys()]).toEqual(["src/a.ts", "src/new.ts"]);
+		expect(map.get("src/a.ts")).toContain("+new");
+		expect(map.get("src/new.ts")).toContain("+b");
+	});
+
+	test("parseDiffIndex não confunde linha de conteúdo com o header", () => {
+		const patch = [
+			"diff --git a/x.ts b/x.ts",
+			"--- a/x.ts",
+			"+++ b/x.ts",
+			"@@ -1 +1,2 @@",
+			" keep",
+			"+++ b/fake.ts",
+		].join("\n");
+		expect([...parseDiffIndex(patch).keys()]).toEqual(["x.ts"]);
+	});
+
+	test("parseDiffIndex respeita o teto por arquivo", () => {
+		const patch = "diff --git a/x.ts b/x.ts\n--- a/x.ts\n+++ b/x.ts\n@@ -1 +1 @@\n+a";
+		expect(parseDiffIndex(patch, 10).get("x.ts")).toHaveLength(10);
+	});
+});
+
+// ---------------------------------------------------------------------------
+// triage (churn + orçamento por brief)
+// ---------------------------------------------------------------------------
+
+describe("triage", () => {
+	const churn = {
+		"a.ts": { additions: 1, deletions: 0 },
+		"b.ts": { additions: 50, deletions: 50 },
+		"c.ts": { additions: 10, deletions: 0 },
+	};
+
+	test("churnOf soma adições/remoções e trata ausente", () => {
+		expect(churnOf("b.ts", churn)).toBe(100);
+		expect(churnOf("ausente.ts", churn)).toBe(0);
+	});
+
+	test("sortByRisk ordena por churn desc", () => {
+		expect(sortByRisk(["a.ts", "b.ts", "c.ts"], churn)).toEqual([
+			"b.ts",
+			"c.ts",
+			"a.ts",
+		]);
+	});
+
+	test("selectByBudget mantém os de maior risco e devolve o excedente", () => {
+		const { selected, overflow } = selectByBudget(["a.ts", "b.ts", "c.ts"], churn, 2);
+		expect(selected).toEqual(["b.ts", "c.ts"]);
+		expect(overflow).toEqual(["a.ts"]);
+	});
+
+	test("maxFiles não-positivo desativa o orçamento", () => {
+		const { selected, overflow } = selectByBudget(["a.ts", "b.ts"], churn, 0);
+		expect(selected).toHaveLength(2);
+		expect(overflow).toEqual([]);
+	});
+
+	test("resolveMaxFilesPerBrief usa default e sobrepõe", () => {
+		expect(resolveMaxFilesPerBrief(fakeHoundsmanConfig)).toBe(
+			DEFAULT_MAX_FILES_PER_BRIEF,
+		);
+		expect(
+			resolveMaxFilesPerBrief({
+				...fakeHoundsmanConfig,
+				budgets: { maxFilesPerBrief: 5 },
+			}),
+		).toBe(5);
+		expect(
+			resolveMaxFilesPerBrief({
+				...fakeHoundsmanConfig,
+				budgets: { maxFilesPerBrief: 0 },
+			}),
+		).toBe(DEFAULT_MAX_FILES_PER_BRIEF);
+	});
+
+	test("resolveJevConcurrency usa default e sobrepõe", () => {
+		expect(resolveJevConcurrency(fakeHoundsmanConfig)).toBe(DEFAULT_JEV_CONCURRENCY);
+		expect(
+			resolveJevConcurrency({ ...fakeHoundsmanConfig, concurrency: { jev: 9 } }),
+		).toBe(9);
+	});
+});
+
 // ---------------------------------------------------------------------------
 // doc-discoverer
 // ---------------------------------------------------------------------------
@@ -440,6 +581,79 @@ describe("report-builder", () => {
 		);
 		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,
+				},
+			],
+		);
+		expect(md).toContain("## Relatórios por domínio");
+		expect(md).toContain("review.alpha.md");
+	});
+
+	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");
+	});
 });
 
 // ---------------------------------------------------------------------------
@@ -571,6 +785,24 @@ describe("houndsman brief", () => {
 		expect(brief).toContain("**Objetivo:** Entregar X");
 	});
 
+	test("mostra churn e lista arquivos fora do orçamento", () => {
+		const brief = renderBrief(alphaWatchdog, {
+			watchdogId: "alpha",
+			files: ["src/alpha/keep.ts"],
+			overflow: ["src/alpha/skip.ts"],
+			churn: { "src/alpha/keep.ts": { additions: 12, deletions: 3 } },
+			branch: "feature/x",
+			outputPath: "o.json",
+			outputFormatPath: OUTPUT_FORMAT,
+			docs: [],
+			statuses: { "src/alpha/keep.ts": { status: "modified" } },
+			deleted: [],
+		});
+		expect(brief).toContain("+12/−3");
+		expect(brief).toContain("Fora do orçamento");
+		expect(brief).toContain("src/alpha/skip.ts");
+	});
+
 	test("hook custom de renderBrief é usado no lugar do default", () => {
 		const custom = { ...alphaWatchdog, renderBrief: () => ["# Custom"] };
 		const brief = renderBrief(custom, {
@@ -691,6 +923,72 @@ describe("jev-client", () => {
 	});
 });
 
+describe("jev-client — validateCredential", () => {
+	/** Erro no formato do axios (isAxiosError + response.status). */
+	function axiosError(status: number): Error {
+		return Object.assign(new Error(`HTTP ${status}`), {
+			isAxiosError: true,
+			response: { status, data: "unauthorized" },
+		});
+	}
+
+	test("sem chave → unreachable e não faz chamada", async () => {
+		let called = false;
+		const http = {
+			post: async () => {
+				called = true;
+				return { data: { model: "x", answers: {} } };
+			},
+		} as unknown as AxiosInstance;
+		const check = await new JevClient({ apiKey: "", http }).validateCredential();
+		expect(check.ok).toBe(false);
+		if (!check.ok) expect(check.kind).toBe("unreachable");
+		expect(called).toBe(false);
+	});
+
+	test("2xx → credencial válida com o modelo", async () => {
+		const http = {
+			post: async () => ({ data: { model: "jev-test", answers: {} } }),
+		} as unknown as AxiosInstance;
+		const check = await new JevClient({ apiKey: "k", http }).validateCredential();
+		expect(check).toEqual({ ok: true, model: "jev-test" });
+	});
+
+	test("401 → credencial inválida", async () => {
+		const http = {
+			post: async () => {
+				throw axiosError(401);
+			},
+		} as unknown as AxiosInstance;
+		const check = await new JevClient({ apiKey: "k", http }).validateCredential();
+		expect(check.ok).toBe(false);
+		if (!check.ok) expect(check.kind).toBe("invalid");
+	});
+
+	test("falha de rede → indeterminada (unreachable)", async () => {
+		const http = {
+			post: async () => {
+				throw new Error("network down");
+			},
+		} as unknown as AxiosInstance;
+		const check = await new JevClient({ apiKey: "k", http }).validateCredential();
+		expect(check.ok).toBe(false);
+		if (!check.ok) expect(check.kind).toBe("unreachable");
+	});
+
+	test("evaluate preserva o status HTTP no JevError", async () => {
+		const http = {
+			post: async () => {
+				throw axiosError(403);
+			},
+		} as unknown as AxiosInstance;
+		const client = new JevClient({ apiKey: "k", http });
+		await expect(
+			client.evaluate({ state: "s", questions: {} }),
+		).rejects.toMatchObject({ status: 403 });
+	});
+});
+
 // ---------------------------------------------------------------------------
 // Jev — detector (fail-open)
 // ---------------------------------------------------------------------------
@@ -699,6 +997,7 @@ describe("jev-detector", () => {
 	const classification: ClassificationResult = {
 		watchdogs: { alpha: ["src/alpha/x.ts"] },
 		files: { "src/alpha/x.ts": { status: "modified" } },
+		churn: {},
 		unclassified: [],
 		excluded: [],
 		deleted: [],