@payconductor/houndsman 0.1.0 → 0.1.3

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

@@ -0,0 +1,120 @@
+import { describe, expect, test } from "bun:test";
+import {
+	buildAnchor,
+	fingerprintOf,
+	locateAnchor,
+	normalizeLine,
+	reanchor,
+} from "../core/finding-anchor";
+
+const DUPLICATED = [
+	"function a() {",
+	'\tconsole.log("x");',
+	"}",
+	"function b() {",
+	'\tconsole.log("x");',
+	"}",
+].join("\n");
+
+// Após um "auto-fix" que remove o PRIMEIRO console.log.
+const AFTER_FIX = [
+	"function a() {",
+	"}",
+	"function b() {",
+	'\tconsole.log("x");',
+	"}",
+].join("\n");
+
+describe("finding-anchor", () => {
+	test("normalizeLine colapsa espaços e apara as pontas", () => {
+		expect(normalizeLine('  \t console.log( "x" );  ')).toBe('console.log( "x" );');
+		expect(normalizeLine("   ")).toBe("");
+	});
+
+	test("buildAnchor usa a linha quando válida", () => {
+		const anchor = buildAnchor(DUPLICATED, 2);
+		expect(anchor).not.toBeNull();
+		expect(anchor?.snippet).toBe('console.log("x");');
+		expect(anchor?.contextBefore).toBe("function a() {");
+		expect(anchor?.contextAfter).toBe("}");
+		expect(anchor?.line).toBe(2);
+	});
+
+	test("buildAnchor cai na evidence quando a linha é inválida", () => {
+		const anchor = buildAnchor(DUPLICATED, 999, 'console.log("x");');
+		expect(anchor?.line).toBe(2);
+	});
+
+	test("buildAnchor devolve null sem linha válida nem evidence localizável", () => {
+		expect(buildAnchor(DUPLICATED, 999, "inexistente")).toBeNull();
+	});
+
+	test("locateAnchor encontra a linha e conta as ocorrências", () => {
+		const anchor = buildAnchor(DUPLICATED, 2);
+		const located = locateAnchor(DUPLICATED, anchor);
+		expect(located.line).toBe(2);
+		expect(located.occurrences).toBe(1);
+	});
+
+	test("fingerprint é estável e distingue contexto", () => {
+		const a1 = buildAnchor(DUPLICATED, 2);
+		const a2 = buildAnchor(DUPLICATED, 5);
+
+		// Mesmo arquivo + regra + âncora → mesmo fingerprint.
+		expect(fingerprintOf("f.ts", "rule", a1)).toBe(
+			fingerprintOf("f.ts", "rule", buildAnchor(DUPLICATED, 2)),
+		);
+		// Snippet idêntico mas contexto diferente → fingerprints diferentes.
+		expect(fingerprintOf("f.ts", "rule", a1)).not.toBe(
+			fingerprintOf("f.ts", "rule", a2),
+		);
+		// Regra diferente muda o fingerprint.
+		expect(fingerprintOf("f.ts", "outra", a1)).not.toBe(
+			fingerprintOf("f.ts", "rule", a1),
+		);
+	});
+
+	test("fingerprint sem âncora usa o fallback", () => {
+		expect(fingerprintOf("f.ts", "rule", null, "mensagem")).toBe(
+			fingerprintOf("f.ts", "rule", null, "mensagem"),
+		);
+		expect(fingerprintOf("f.ts", "rule", null, "a")).not.toBe(
+			fingerprintOf("f.ts", "rule", null, "b"),
+		);
+	});
+
+	test("reanchor: ok, moved e stale", () => {
+		const anchor = buildAnchor(DUPLICATED, 5);
+		expect(reanchor(DUPLICATED, anchor, 5).status).toBe("ok");
+
+		const moved = reanchor(AFTER_FIX, anchor, 5);
+		expect(moved.status).toBe("moved");
+		expect(moved.line).toBe(4);
+
+		const removed = buildAnchor(DUPLICATED, 2);
+		expect(reanchor(AFTER_FIX, removed, 2).status).toBe("stale");
+	});
+
+	test("duas ocorrências iguais não se perdem quando o fix remove a primeira", () => {
+		const first = buildAnchor(DUPLICATED, 2);
+		const second = buildAnchor(DUPLICATED, 5);
+
+		// A âncora removida vira stale; a sobrevivente apenas desloca de linha.
+		expect(reanchor(AFTER_FIX, first, 2).status).toBe("stale");
+		const survivor = reanchor(AFTER_FIX, second, 5);
+		expect(survivor.status).toBe("moved");
+		expect(survivor.line).toBe(4);
+	});
+
+	test("ocorrências byte-idênticas compartilham o fingerprint (grupo)", () => {
+		// Mesmo snippet E mesmo contexto (sem vizinhos) → mesmo fingerprint.
+		const content = "x\ny\nx\ny";
+		const a1 = buildAnchor(content, 1);
+		const a2 = buildAnchor(content, 3);
+		// contextBefore ausente em ambos (linha 1 vs 3 tem 'y' antes → difere), então
+		// forçamos âncoras sem contexto para simular colisão real.
+		const bare = a1 && { ...a1, contextBefore: undefined, contextAfter: undefined };
+		const bare2 = a2 && { ...a2, contextBefore: undefined, contextAfter: undefined };
+		expect(fingerprintOf("f.ts", "r", bare)).toBe(fingerprintOf("f.ts", "r", bare2));
+	});
+});

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

@@ -0,0 +1,476 @@
+import { describe, expect, test } from "bun:test";
+import {
+	existsSync,
+	mkdirSync,
+	mkdtempSync,
+	readFileSync,
+	rmSync,
+	writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { runFindingsCommand, runVerifyCommand } from "../core/commands/findings";
+import { fakeHoundsmanConfig } from "./fixtures/fake-project";
+
+/** Run fake em disco: classification.json + findings/alpha.json. */
+function makeRun(findings: unknown[]): { dir: string; cleanup: () => void } {
+	const dir = mkdtempSync(join(tmpdir(), "houndsman-findings-"));
+	const outDir = join(dir, "main");
+	mkdirSync(join(outDir, "findings"), { recursive: true });
+	writeFileSync(
+		join(outDir, "classification.json"),
+		JSON.stringify({ watchdogs: { alpha: ["src/alpha/f.ts"] } }),
+	);
+	writeFileSync(
+		join(outDir, "findings", "alpha.json"),
+		JSON.stringify({
+			watchdogId: "alpha",
+			reviewedFiles: ["src/alpha/f.ts"],
+			skipped: [],
+			findings,
+		}),
+	);
+	return { dir, cleanup: () => rmSync(dir, { recursive: true, force: true }) };
+}
+
+const ONE_FINDING = [
+	{
+		rule: "Nunca usar any",
+		severity: "blocking",
+		file: "src/alpha/f.ts",
+		line: 2,
+		message: "any detectado",
+		action: "tipar",
+	},
+];
+
+function run(args: string[]) {
+	return runFindingsCommand(fakeHoundsmanConfig, args);
+}
+
+describe("findings command", () => {
+	test("list reconstrói o estado a partir dos artefatos", () => {
+		const run0 = makeRun(ONE_FINDING);
+		try {
+			const result = run(["list", "--dir", run0.dir, "--branch", "main", "--json"]);
+			expect(result.exitCode).toBe(0);
+			const parsed = JSON.parse(result.output);
+			expect(parsed).toHaveLength(1);
+			expect(parsed[0].decision).toBe("pending");
+			expect(parsed[0].id).toBeTruthy();
+			expect(parsed[0].severity).toBe("blocking");
+		} finally {
+			run0.cleanup();
+		}
+	});
+
+	test("set atualiza decisão + comentário e persiste", () => {
+		const run0 = makeRun(ONE_FINDING);
+		try {
+			const list = JSON.parse(
+				run(["list", "--dir", run0.dir, "--branch", "main", "--json"]).output,
+			);
+			const id = list[0].id;
+
+			const set = run([
+				"set",
+				id,
+				"--decision",
+				"execute",
+				"--comment",
+				"trocar por unknown",
+				"--dir",
+				run0.dir,
+				"--branch",
+				"main",
+			]);
+			expect(set.exitCode).toBe(0);
+
+			const after = JSON.parse(
+				run(["list", "--dir", run0.dir, "--branch", "main", "--json"]).output,
+			);
+			expect(after[0].decision).toBe("execute");
+			expect(after[0].comment).toBe("trocar por unknown");
+			expect(after[0].history.length).toBeGreaterThan(0);
+		} finally {
+			run0.cleanup();
+		}
+	});
+
+	test("done marca execState como done", () => {
+		const run0 = makeRun(ONE_FINDING);
+		try {
+			const id = JSON.parse(
+				run(["list", "--dir", run0.dir, "--branch", "main", "--json"]).output,
+			)[0].id;
+			expect(
+				run(["done", id, "--dir", run0.dir, "--branch", "main"]).exitCode,
+			).toBe(0);
+			const after = JSON.parse(
+				run(["list", "--dir", run0.dir, "--branch", "main", "--json"]).output,
+			);
+			expect(after[0].execState).toBe("done");
+		} finally {
+			run0.cleanup();
+		}
+	});
+
+	test("filtra por decisão e resume contagens", () => {
+		const run0 = makeRun(ONE_FINDING);
+		try {
+			const id = JSON.parse(
+				run(["list", "--dir", run0.dir, "--branch", "main", "--json"]).output,
+			)[0].id;
+			run([
+				"set",
+				id,
+				"--decision",
+				"ignore",
+				"--dir",
+				run0.dir,
+				"--branch",
+				"main",
+			]);
+
+			const pending = JSON.parse(
+				run([
+					"list",
+					"--decision",
+					"pending",
+					"--dir",
+					run0.dir,
+					"--branch",
+					"main",
+					"--json",
+				]).output,
+			);
+			expect(pending).toHaveLength(0);
+
+			const summary = JSON.parse(
+				run(["summary", "--dir", run0.dir, "--branch", "main", "--json"]).output,
+			);
+			expect(summary.total).toBe(1);
+			expect(summary.byDecision.ignore).toBe(1);
+		} finally {
+			run0.cleanup();
+		}
+	});
+
+	test("sync marca como stale quando o arquivo não está disponível", () => {
+		const run0 = makeRun(ONE_FINDING);
+		try {
+			const result = JSON.parse(
+				run(["sync", "--dir", run0.dir, "--branch", "main", "--json"]).output,
+			);
+			expect(result.stale).toHaveLength(1);
+		} finally {
+			run0.cleanup();
+		}
+	});
+
+	test("erros claros: decisão inválida, id inexistente, run ausente", () => {
+		const run0 = makeRun(ONE_FINDING);
+		try {
+			const bad = run([
+				"set",
+				"inexistente",
+				"--decision",
+				"xpto",
+				"--dir",
+				run0.dir,
+				"--branch",
+				"main",
+			]);
+			expect(bad.exitCode).toBe(1);
+			expect(bad.output).toContain("--decision inválido");
+
+			const missing = run([
+				"show",
+				"nao-existe",
+				"--dir",
+				run0.dir,
+				"--branch",
+				"main",
+			]);
+			expect(missing.exitCode).toBe(1);
+			expect(missing.output).toContain("não encontrado");
+
+			const empty = mkdtempSync(join(tmpdir(), "houndsman-empty-"));
+			try {
+				const absent = run(["list", "--dir", empty, "--branch", "main"]);
+				expect(absent.exitCode).toBe(1);
+				expect(absent.output).toContain("--finalize");
+			} finally {
+				rmSync(empty, { recursive: true, force: true });
+			}
+		} finally {
+			run0.cleanup();
+		}
+	});
+
+	test("path devolve o caminho do state.json", () => {
+		const run0 = makeRun(ONE_FINDING);
+		try {
+			run(["list", "--dir", run0.dir, "--branch", "main"]);
+			const result = run(["path", "--dir", run0.dir, "--branch", "main"]);
+			expect(result.exitCode).toBe(0);
+			expect(result.output.replace(/\\/g, "/")).toContain("main/state.json");
+		} finally {
+			run0.cleanup();
+		}
+	});
+
+	test("sub desconhecido devolve erro", () => {
+		const run0 = makeRun(ONE_FINDING);
+		try {
+			const result = run(["xpto", "--dir", run0.dir, "--branch", "main"]);
+			expect(result.exitCode).toBe(1);
+			expect(result.output).toContain("desconhecido");
+		} finally {
+			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();
+		}
+	});
+});