@payconductor/houndsman 0.1.0 → 0.1.3

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

@@ -0,0 +1,325 @@
+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(2);
+		expect(state.slug).toBe("feature-x");
+		expect(state.findings).toEqual({});
+	});
+});
+
+describe("rastreio de revisão (incremental)", () => {
+	test("carimba reviewed e foundAtSha nos findings do ciclo", () => {
+		const project = makeProject({ "src/f.ts": DUPLICATED });
+		try {
+			const state = buildStateFromFindings(
+				[merged({ file: "src/f.ts", rule: "r", line: 2 })],
+				{
+					branch: "main",
+					readFile: fileReader(project.cwd),
+					headSha: "abc1234",
+					reviewed: { headSha: "abc1234", at: "2026-01-01T00:00:00.000Z" },
+				},
+			);
+			expect(state.reviewed?.headSha).toBe("abc1234");
+			const only = Object.values(state.findings)[0];
+			expect(only.foundAtSha).toBe("abc1234");
+		} finally {
+			project.cleanup();
+		}
+	});
+
+	test("carry-over preserva o foundAtSha original", () => {
+		const project = makeProject({ "src/f.ts": DUPLICATED });
+		try {
+			const state = buildStateFromFindings(
+				[
+					// Novo/re-reportado: recebe o head atual.
+					merged({ file: "src/f.ts", rule: "r", line: 2 }),
+					// Carry-over: carrega o `foundAtSha` de quando foi observado.
+					{
+						...merged({ file: "src/f.ts", rule: "r2", line: 5 }),
+						foundAtSha: "old0001",
+					},
+				],
+				{
+					branch: "main",
+					readFile: fileReader(project.cwd),
+					headSha: "new0002",
+					reviewed: { headSha: "new0002", at: "2026-01-02T00:00:00.000Z" },
+				},
+			);
+			const byRule = (rule: string): string | undefined =>
+				Object.values(state.findings).find((f) => f.rule === rule)?.foundAtSha;
+			expect(byRule("r")).toBe("new0002");
+			expect(byRule("r2")).toBe("old0001");
+		} finally {
+			project.cleanup();
+		}
+	});
+});

package/src/tests/fix-batch.test.ts

@@ -0,0 +1,257 @@
+import { describe, expect, test } from "bun:test";
+import type { FindingState, FindingsStateFile } from "../core/findings-state";
+import {
+	buildFixBatch,
+	chooseGrouping,
+	fixQueue,
+	groupFindings,
+} from "../core/fix-batch";
+import type { Severity } from "../core/types";
+
+let seq = 0;
+
+/** Finding de teste com defaults sensatos. */
+function f(
+	partial: Partial<FindingState> & { file: string; rule: string; severity: Severity },
+): FindingState {
+	seq++;
+	return {
+		id: partial.id ?? `id${seq}`,
+		fingerprint: partial.fingerprint ?? `fp${seq}`,
+		watchdogIds: partial.watchdogIds ?? ["alpha"],
+		rule: partial.rule,
+		severity: partial.severity,
+		file: partial.file,
+		line: partial.line ?? 1,
+		message: partial.message ?? "m",
+		action: partial.action ?? "a",
+		evidence: partial.evidence,
+		anchor: null,
+		count: partial.count ?? 1,
+		present: partial.present ?? true,
+		decision: partial.decision ?? "execute",
+		comment: partial.comment,
+		execState: partial.execState ?? "pending",
+		createdAt: "",
+		updatedAt: "",
+		history: [],
+	};
+}
+
+function stateOf(findings: FindingState[]): FindingsStateFile {
+	return {
+		version: 2,
+		branch: "feature/x",
+		slug: "feature-x",
+		updatedAt: "",
+		order: findings.map((item) => item.id),
+		findings: Object.fromEntries(findings.map((item) => [item.id, item])),
+	};
+}
+
+// ---------------------------------------------------------------------------
+// chooseGrouping (heurística determinística)
+// ---------------------------------------------------------------------------
+
+describe("chooseGrouping", () => {
+	test("prefere arquivo quando há poucos arquivos com coesão", () => {
+		const findings = ["f1", "f2", "f3"].flatMap((file, i) => [
+			f({
+				file,
+				rule: `r${i * 2 + 1}`,
+				severity: "attention",
+				watchdogIds: [`w${i}`],
+			}),
+			f({ file, rule: `r${i * 2 + 2}`, severity: "nit", watchdogIds: [`w${i}`] }),
+		]);
+		expect(chooseGrouping(findings)).toBe("file");
+	});
+
+	test("prefere regra quando uma regra domina vários arquivos", () => {
+		const findings = ["f1", "f2", "f3", "f4", "f5", "f6"].map((file, i) =>
+			f({
+				file,
+				rule: i < 3 ? "r1" : "r2",
+				severity: "attention",
+				watchdogIds: [`w${i}`],
+			}),
+		);
+		expect(chooseGrouping(findings)).toBe("rule");
+	});
+
+	test("cai em watchdog quando nem arquivo nem regra têm coesão", () => {
+		const findings = ["f1", "f2", "f3", "f4", "f5", "f6"].map((file, i) =>
+			f({
+				file,
+				rule: `r${Math.min(i, 4)}`,
+				severity: "attention",
+				watchdogIds: [i < 3 ? "w1" : "w2"],
+			}),
+		);
+		expect(chooseGrouping(findings)).toBe("watchdog");
+	});
+
+	test("sem elegíveis (tudo singleton), cai em file", () => {
+		const findings = ["f1", "f2"].map((file, i) =>
+			f({ file, rule: `r${i}`, severity: "nit", watchdogIds: [`w${i}`] }),
+		);
+		expect(chooseGrouping(findings)).toBe("file");
+	});
+
+	test("fila vazia devolve file", () => {
+		expect(chooseGrouping([])).toBe("file");
+	});
+});
+
+describe("groupFindings", () => {
+	test("agrupa por arquivo com chaves prefixadas", () => {
+		const findings = [
+			f({ file: "src/a.ts", rule: "r1", severity: "attention" }),
+			f({ file: "src/a.ts", rule: "r2", severity: "nit" }),
+			f({ file: "src/b.ts", rule: "r3", severity: "nit" }),
+		];
+		const groups = groupFindings(findings, "file");
+		expect(groups.size).toBe(2);
+		expect(groups.get("file:src/a.ts")).toHaveLength(2);
+		expect(groups.get("file:src/b.ts")).toHaveLength(1);
+	});
+});
+
+// ---------------------------------------------------------------------------
+// fixQueue
+// ---------------------------------------------------------------------------
+
+describe("fixQueue", () => {
+	test("só execute, presentes e não done; includeDone inclui", () => {
+		const done = f({
+			file: "a.ts",
+			rule: "r1",
+			severity: "attention",
+			execState: "done",
+		});
+		const pending = f({ file: "a.ts", rule: "r2", severity: "attention" });
+		const ignored = f({
+			file: "a.ts",
+			rule: "r3",
+			severity: "attention",
+			decision: "ignore",
+		});
+		const absent = f({
+			file: "a.ts",
+			rule: "r4",
+			severity: "attention",
+			present: false,
+		});
+		const state = stateOf([done, pending, ignored, absent]);
+
+		expect(fixQueue(state).map((item) => item.id)).toEqual([pending.id]);
+		expect(fixQueue(state, { includeDone: true }).map((item) => item.id)).toEqual([
+			done.id,
+			pending.id,
+		]);
+	});
+
+	test("filtra por severidade", () => {
+		const blocking = f({ file: "a.ts", rule: "r1", severity: "blocking" });
+		const nit = f({ file: "a.ts", rule: "r2", severity: "nit" });
+		const state = stateOf([blocking, nit]);
+		expect(fixQueue(state, { severity: "blocking" }).map((item) => item.id)).toEqual([
+			blocking.id,
+		]);
+	});
+});
+
+// ---------------------------------------------------------------------------
+// buildFixBatch
+// ---------------------------------------------------------------------------
+
+/** Fila coesa em 2 arquivos / 2 watchdogs (arquivo e watchdog empatam → file). */
+function coesaState(): FindingsStateFile {
+	return stateOf([
+		f({ file: "src/a.ts", rule: "r1", severity: "blocking", watchdogIds: ["alpha"] }),
+		f({
+			file: "src/a.ts",
+			rule: "r2",
+			severity: "attention",
+			watchdogIds: ["alpha"],
+		}),
+		f({
+			file: "src/a.ts",
+			rule: "r3",
+			severity: "attention",
+			watchdogIds: ["alpha"],
+		}),
+		f({ file: "src/a.ts", rule: "r4", severity: "nit", watchdogIds: ["alpha"] }),
+		f({ file: "src/b.ts", rule: "r5", severity: "attention", watchdogIds: ["beta"] }),
+		f({
+			file: "src/b.ts",
+			rule: "r6",
+			severity: "suggestion",
+			watchdogIds: ["beta"],
+		}),
+	]);
+}
+
+describe("buildFixBatch", () => {
+	test("escolhe o agrupamento e devolve grupo atual + outros grupos", () => {
+		const result = buildFixBatch(coesaState());
+		expect(result.dimension).toBe("file");
+		expect(result.totals).toEqual({ queue: 6, groups: 2, returned: 4 });
+		expect(result.current.key).toBe("file:src/a.ts");
+		expect(result.current.total).toBe(4);
+		expect(result.current.findings).toHaveLength(4);
+		expect(result.current.remaining).toBe(0);
+		expect(result.others).toHaveLength(1);
+		expect(result.others[0].key).toBe("file:src/b.ts");
+		expect(result.others[0].count).toBe(2);
+	});
+
+	test("pagina o grupo atual com pageSize", () => {
+		const result = buildFixBatch(coesaState(), { pageSize: 2 });
+		expect(result.current.returned).toBe(2);
+		expect(result.current.remaining).toBe(2);
+		expect(result.totals.returned).toBe(2);
+	});
+
+	test("--group foca um grupo específico", () => {
+		const result = buildFixBatch(coesaState(), { group: "file:src/b.ts" });
+		expect(result.current.key).toBe("file:src/b.ts");
+		expect(result.current.total).toBe(2);
+		expect(result.others).toHaveLength(1);
+		expect(result.others[0].key).toBe("file:src/a.ts");
+	});
+
+	test("--group inexistente lança com as chaves disponíveis", () => {
+		expect(() => buildFixBatch(coesaState(), { group: "file:nao-existe" })).toThrow(
+			/não encontrado/,
+		);
+	});
+
+	test("--severity filtra a fila", () => {
+		const result = buildFixBatch(coesaState(), { severity: "blocking" });
+		expect(result.totals.queue).toBe(1);
+		expect(result.current.key).toBe("file:src/a.ts");
+		expect(result.current.total).toBe(1);
+		expect(result.others).toHaveLength(0);
+	});
+
+	test("fila vazia devolve lote vazio", () => {
+		const state = stateOf([
+			f({ file: "a.ts", rule: "r1", severity: "attention", decision: "pending" }),
+		]);
+		const result = buildFixBatch(state);
+		expect(result.totals).toEqual({ queue: 0, groups: 0, returned: 0 });
+		expect(result.current.findings).toHaveLength(0);
+		expect(result.others).toHaveLength(0);
+	});
+
+	test("outros grupos trazem o mix de severidade", () => {
+		const result = buildFixBatch(coesaState());
+		expect(result.others[0].bySeverity).toEqual({
+			blocking: 0,
+			attention: 1,
+			suggestion: 1,
+			nit: 0,
+		});
+	});
+});