@payconductor/houndsman 0.1.1 → 0.1.4

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

@@ -1,8 +1,15 @@
 import { describe, expect, test } from "bun:test";
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import {
+	existsSync,
+	mkdirSync,
+	mkdtempSync,
+	readFileSync,
+	rmSync,
+	writeFileSync,
+} from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { runFindingsCommand } from "../core/commands/findings";
+import { runFindingsCommand, runVerifyCommand } from "../core/commands/findings";
 import { fakeHoundsmanConfig } from "./fixtures/fake-project";
 
 /** Run fake em disco: classification.json + findings/alpha.json. */
@@ -223,4 +230,247 @@ describe("findings command", () => {
 			run0.cleanup();
 		}
 	});
+
+	test("batch agrupa a fila e devolve o grupo atual + outros grupos", () => {
+		const dir = mkdtempSync(join(tmpdir(), "houndsman-batch-"));
+		const outDir = join(dir, "main");
+		mkdirSync(join(outDir, "findings"), { recursive: true });
+		writeFileSync(
+			join(outDir, "classification.json"),
+			JSON.stringify({ watchdogs: { alpha: ["src/a.ts"], beta: ["src/b.ts"] } }),
+		);
+		writeFileSync(
+			join(outDir, "findings", "alpha.json"),
+			JSON.stringify({
+				watchdogId: "alpha",
+				reviewedFiles: ["src/a.ts"],
+				skipped: [],
+				findings: [
+					{
+						rule: "R1",
+						severity: "blocking",
+						file: "src/a.ts",
+						line: 1,
+						message: "m1",
+						action: "a",
+					},
+					{
+						rule: "R2",
+						severity: "attention",
+						file: "src/a.ts",
+						line: 2,
+						message: "m2",
+						action: "a",
+					},
+					{
+						rule: "R3",
+						severity: "attention",
+						file: "src/a.ts",
+						line: 3,
+						message: "m3",
+						action: "a",
+					},
+					{
+						rule: "R4",
+						severity: "nit",
+						file: "src/a.ts",
+						line: 4,
+						message: "m4",
+						action: "a",
+					},
+				],
+			}),
+		);
+		writeFileSync(
+			join(outDir, "findings", "beta.json"),
+			JSON.stringify({
+				watchdogId: "beta",
+				reviewedFiles: ["src/b.ts"],
+				skipped: [],
+				findings: [
+					{
+						rule: "R5",
+						severity: "attention",
+						file: "src/b.ts",
+						line: 1,
+						message: "m5",
+						action: "a",
+					},
+					{
+						rule: "R6",
+						severity: "suggestion",
+						file: "src/b.ts",
+						line: 2,
+						message: "m6",
+						action: "a",
+					},
+				],
+			}),
+		);
+		try {
+			const list = JSON.parse(
+				run(["list", "--dir", dir, "--branch", "main", "--json"]).output,
+			);
+			for (const item of list) {
+				run([
+					"set",
+					item.id,
+					"--decision",
+					"execute",
+					"--dir",
+					dir,
+					"--branch",
+					"main",
+				]);
+			}
+
+			const result = run(["batch", "--dir", dir, "--branch", "main", "--json"]);
+			expect(result.exitCode).toBe(0);
+			const parsed = JSON.parse(result.output);
+			expect(parsed.dimension).toBe("file");
+			expect(parsed.totals.queue).toBe(6);
+			expect(parsed.totals.groups).toBe(2);
+			expect(parsed.current.key).toBe("file:src/a.ts");
+			expect(parsed.current.findings).toHaveLength(4);
+			expect(parsed.others).toEqual([
+				expect.objectContaining({ key: "file:src/b.ts", count: 2 }),
+			]);
+
+			const markdown = run(["batch", "--dir", dir, "--branch", "main"]);
+			expect(markdown.output).toContain("Grupo atual");
+			expect(markdown.output).toContain("Outros grupos");
+
+			const scoped = run([
+				"batch",
+				"--group",
+				"file:src/b.ts",
+				"--dir",
+				dir,
+				"--branch",
+				"main",
+				"--json",
+			]);
+			expect(JSON.parse(scoped.output).current.key).toBe("file:src/b.ts");
+		} finally {
+			rmSync(dir, { recursive: true, force: true });
+		}
+	});
+
+	test("mutações fazem ping no run.json (status)", () => {
+		const run0 = makeRun(ONE_FINDING);
+		try {
+			const id = JSON.parse(
+				run(["list", "--dir", run0.dir, "--branch", "main", "--json"]).output,
+			)[0].id;
+			const runJson = join(run0.dir, "main", "run.json");
+
+			run([
+				"set",
+				id,
+				"--decision",
+				"execute",
+				"--dir",
+				run0.dir,
+				"--branch",
+				"main",
+			]);
+			expect(JSON.parse(readFileSync(runJson, "utf8")).status).toBe("review_done");
+
+			run([
+				"set",
+				id,
+				"--exec",
+				"in_progress",
+				"--dir",
+				run0.dir,
+				"--branch",
+				"main",
+			]);
+			expect(JSON.parse(readFileSync(runJson, "utf8")).status).toBe("fixing");
+
+			run(["done", id, "--dir", run0.dir, "--branch", "main"]);
+			expect(JSON.parse(readFileSync(runJson, "utf8")).status).toBe("fix_done");
+		} finally {
+			run0.cleanup();
+		}
+	});
+});
+
+describe("findings verify", () => {
+	const FILE = "src/tests/fixtures/fake-project.ts";
+
+	/** Run fake apontando para um arquivo real (relativo ao cwd → âncora resolvível). */
+	function makeVerifyRun(): { dir: string; outDir: string; cleanup: () => void } {
+		const dir = mkdtempSync(join(tmpdir(), "houndsman-verify-"));
+		const outDir = join(dir, "main");
+		mkdirSync(join(outDir, "findings"), { recursive: true });
+		writeFileSync(
+			join(outDir, "classification.json"),
+			JSON.stringify({ watchdogs: { alpha: [FILE] } }),
+		);
+		writeFileSync(
+			join(outDir, "findings", "alpha.json"),
+			JSON.stringify({
+				watchdogId: "alpha",
+				reviewedFiles: [FILE],
+				skipped: [],
+				findings: [
+					{
+						rule: "regra",
+						severity: "attention",
+						file: FILE,
+						line: 1,
+						message: "msg",
+						action: "ação",
+					},
+				],
+			}),
+		);
+		return {
+			dir,
+			outDir,
+			cleanup: () => rmSync(dir, { recursive: true, force: true }),
+		};
+	}
+
+	test("reporta persisting e grava o verify.md (tier local)", async () => {
+		const run0 = makeVerifyRun();
+		try {
+			const result = await runVerifyCommand(fakeHoundsmanConfig, [
+				"verify",
+				"--dir",
+				run0.dir,
+				"--branch",
+				"main",
+				"--json",
+			]);
+			expect(result.exitCode).toBe(0);
+			const parsed = JSON.parse(result.output);
+			expect(parsed.summary.persisting).toBe(1);
+			expect(parsed.entries[0].basis).toBe("anchor");
+			expect(existsSync(join(run0.outDir, "verify.md"))).toBe(true);
+		} finally {
+			run0.cleanup();
+		}
+	});
+
+	test("sem --apply não altera o estado", async () => {
+		const run0 = makeVerifyRun();
+		try {
+			await runVerifyCommand(fakeHoundsmanConfig, [
+				"verify",
+				"--dir",
+				run0.dir,
+				"--branch",
+				"main",
+			]);
+			const state = JSON.parse(
+				readFileSync(join(run0.outDir, "state.json"), "utf8"),
+			) as { findings: Record<string, { execState: string }> };
+			const only = Object.values(state.findings)[0];
+			expect(only.execState).toBe("pending");
+		} finally {
+			run0.cleanup();
+		}
+	});
 });

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

@@ -267,8 +267,59 @@ describe("FindingsStateStore", () => {
 
 	test("emptyState cria um estado vazio válido", () => {
 		const state = emptyState("feature/x");
-		expect(state.version).toBe(1);
+		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,
+		});
+	});
+});

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

@@ -139,6 +139,42 @@ describe("registry-check", () => {
 		const { warnings } = checkRegistry(config as typeof fakeHoundsmanConfig);
 		expect(warnings).toEqual([]);
 	});
+
+	test("regra duplicada no mesmo watchdog gera aviso", () => {
+		const config = {
+			...fakeHoundsmanConfig,
+			watchdogs: {
+				...fakeHoundsmanConfig.watchdogs,
+				alpha: {
+					...alphaWatchdog,
+					rules: [
+						{ severity: "attention" as const, text: "Evitar console.log." },
+						{ severity: "blocking" as const, text: "Evitar   console.log." },
+					],
+				},
+			},
+		};
+		const { warnings } = checkRegistry(config as typeof fakeHoundsmanConfig);
+		expect(warnings.some((w) => w.includes("duplicada"))).toBe(true);
+	});
+
+	test("texto de regra em reviewFocus/contextFiles gera aviso", () => {
+		const config = {
+			...fakeHoundsmanConfig,
+			watchdogs: {
+				...fakeHoundsmanConfig.watchdogs,
+				alpha: {
+					...alphaWatchdog,
+					reviewFocus: ["Evitar: console.log."],
+					contextFiles: ["Promover: validar a entrada."],
+				},
+			},
+		};
+		const { warnings } = checkRegistry(config as typeof fakeHoundsmanConfig);
+		expect(
+			warnings.filter((w) => w.includes("a regra vive só em 'rules'")),
+		).toHaveLength(2);
+	});
 });
 
 // ---------------------------------------------------------------------------