@payconductor/houndsman 0.1.1 → 0.1.3

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/run-status.test.ts

@@ -0,0 +1,147 @@
+import { describe, expect, test } from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { FindingState, FindingsStateFile } from "../core/findings-state";
+import {
+	pingFindingsStatus,
+	readRunStatus,
+	statusAfterFindingsChange,
+	writeRunStatus,
+} from "../core/run-status";
+
+function findingState(partial: Partial<FindingState>): FindingState {
+	return {
+		id: partial.id ?? "id",
+		fingerprint: partial.fingerprint ?? "fp",
+		watchdogIds: partial.watchdogIds ?? ["alpha"],
+		rule: partial.rule ?? "r",
+		severity: partial.severity ?? "attention",
+		file: partial.file ?? "a.ts",
+		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])),
+	};
+}
+
+/** Diretório temporário isolado. */
+function withTempDir(fn: (dir: string) => void): void {
+	const dir = mkdtempSync(join(tmpdir(), "houndsman-run-status-"));
+	try {
+		fn(dir);
+	} finally {
+		rmSync(dir, { recursive: true, force: true });
+	}
+}
+
+describe("run-status — arquivo", () => {
+	test("grava, lê e preserva/restaura o startedAt", () => {
+		withTempDir((dir) => {
+			writeRunStatus(dir, {
+				branch: "feature/x",
+				status: "reviewing",
+				resetStartedAt: true,
+				now: "2026-01-01T00:00:00.000Z",
+			});
+			const first = readRunStatus(dir);
+			expect(first?.status).toBe("reviewing");
+			expect(first?.slug).toBe("feature-x");
+			expect(first?.startedAt).toBe("2026-01-01T00:00:00.000Z");
+
+			writeRunStatus(dir, {
+				branch: "feature/x",
+				status: "review_done",
+				now: "2026-01-01T00:10:00.000Z",
+			});
+			const second = readRunStatus(dir);
+			expect(second?.status).toBe("review_done");
+			expect(second?.startedAt).toBe("2026-01-01T00:00:00.000Z");
+			expect(second?.updatedAt).toBe("2026-01-01T00:10:00.000Z");
+
+			writeRunStatus(dir, {
+				branch: "feature/x",
+				status: "reviewing",
+				resetStartedAt: true,
+				now: "2026-01-01T00:20:00.000Z",
+			});
+			expect(readRunStatus(dir)?.startedAt).toBe("2026-01-01T00:20:00.000Z");
+		});
+	});
+
+	test("readRunStatus devolve null sem arquivo", () => {
+		withTempDir((dir) => {
+			expect(readRunStatus(dir)).toBeNull();
+		});
+	});
+});
+
+describe("statusAfterFindingsChange", () => {
+	test("in_progress → fixing", () => {
+		const state = stateOf([findingState({ execState: "in_progress" })]);
+		expect(statusAfterFindingsChange("review_done", state)).toBe("fixing");
+	});
+
+	test("review_done + fila (triado, não iniciado) → mantém review_done", () => {
+		const state = stateOf([
+			findingState({ decision: "execute", execState: "pending" }),
+		]);
+		expect(statusAfterFindingsChange("review_done", state)).toBe("review_done");
+	});
+
+	test("fixing + fila → fixing", () => {
+		const state = stateOf([
+			findingState({ id: "a", execState: "done" }),
+			findingState({ id: "b", execState: "pending" }),
+		]);
+		expect(statusAfterFindingsChange("fixing", state)).toBe("fixing");
+	});
+
+	test("fixing + fila vazia → fix_done", () => {
+		const state = stateOf([findingState({ execState: "done" })]);
+		expect(statusAfterFindingsChange("fixing", state)).toBe("fix_done");
+	});
+
+	test("done sem nunca ter iniciado → fix_done", () => {
+		const state = stateOf([findingState({ execState: "done" })]);
+		expect(statusAfterFindingsChange("review_done", state)).toBe("fix_done");
+	});
+
+	test("sem run.json e sem fix → fallback review_done", () => {
+		const state = stateOf([
+			findingState({ decision: "pending", execState: "pending" }),
+		]);
+		expect(statusAfterFindingsChange(null, state)).toBe("review_done");
+	});
+});
+
+describe("pingFindingsStatus", () => {
+	test("deriva do estado e grava o run.json", () => {
+		withTempDir((dir) => {
+			const state = stateOf([findingState({ execState: "in_progress" })]);
+			const file = pingFindingsStatus(dir, state);
+			expect(file.status).toBe("fixing");
+			expect(readRunStatus(dir)?.status).toBe("fixing");
+		});
+	});
+});

package/src/tests/scaffold.test.ts

@@ -0,0 +1,59 @@
+import { describe, expect, test } from "bun:test";
+import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { createScaffoldContext, syncGeneratedFiles } from "../core/commands/scaffold";
+
+/** Cria um diretório temporário, roda `fn` e limpa ao final. */
+function withTempDir(fn: (cwd: string) => void): void {
+	const cwd = mkdtempSync(join(tmpdir(), "houndsman-scaffold-"));
+	try {
+		fn(cwd);
+	} finally {
+		rmSync(cwd, { recursive: true, force: true });
+	}
+}
+
+describe("scaffold — ponteiros de skill", () => {
+	test("gera 1 skill 'houndsman' por harness e os docs de capability", () => {
+		withTempDir((cwd) => {
+			syncGeneratedFiles(createScaffoldContext(cwd, [], false));
+
+			for (const harness of ["agents", "claude"]) {
+				expect(
+					existsSync(join(cwd, `.${harness}/skills/houndsman/SKILL.md`)),
+				).toBe(true);
+			}
+
+			for (const name of ["hunt.md", "train.md", "fix.md"]) {
+				expect(existsSync(join(cwd, ".houndsman/core/skill", name))).toBe(true);
+			}
+			// O entry point é o SKILL.md do harness — não um doc da camada.
+			expect(existsSync(join(cwd, ".houndsman/core/skill/SKILL.md"))).toBe(false);
+		});
+	});
+
+	test("o SKILL.md descreve as capabilities e resolve o projectName", () => {
+		withTempDir((cwd) => {
+			syncGeneratedFiles(createScaffoldContext(cwd, ["--name", "acme"], false));
+
+			const skill = readFileSync(
+				join(cwd, ".agents/skills/houndsman/SKILL.md"),
+				"utf8",
+			);
+			for (const capability of ["hunt", "train", "fix"]) {
+				expect(skill).toContain(capability);
+			}
+			expect(skill).toContain("acme");
+			expect(skill).not.toContain("{{projectName}}");
+		});
+	});
+
+	test("--harness none não gera ponteiros de harness", () => {
+		withTempDir((cwd) => {
+			syncGeneratedFiles(createScaffoldContext(cwd, ["--harness", "none"], false));
+			expect(existsSync(join(cwd, ".agents"))).toBe(false);
+			expect(existsSync(join(cwd, ".claude"))).toBe(false);
+		});
+	});
+});

package/src/tests/server.test.ts

@@ -110,6 +110,36 @@ describe("server API", () => {
 		}
 	});
 
+	test("PATCH expõe o run status em /api/runs", async () => {
+		const env = makeEnv();
+		try {
+			const handler = createRequestHandler(env.config);
+			const before = (await (await get(handler, "/api/runs")).json()) as {
+				runs: { status: string | null }[];
+			};
+			expect(before.runs[0].status).toBeNull();
+
+			const list = (await (
+				await get(handler, "/api/runs/main/findings?all=1")
+			).json()) as { findings: { id: string }[] };
+			const id = list.findings[0].id;
+			await handler(
+				new Request(`http://localhost/api/runs/main/findings/${id}`, {
+					method: "PATCH",
+					headers: { "content-type": "application/json" },
+					body: JSON.stringify({ execState: "in_progress" }),
+				}),
+			);
+
+			const after = (await (await get(handler, "/api/runs")).json()) as {
+				runs: { status: string | null }[];
+			};
+			expect(after.runs[0].status).toBe("fixing");
+		} finally {
+			env.cleanup();
+		}
+	});
+
 	test("POST sync devolve o resultado da reancoragem", async () => {
 		const env = makeEnv();
 		try {

package/src/tests/verify.test.ts

@@ -0,0 +1,170 @@
+import { describe, expect, test } from "bun:test";
+import { buildAnchor } from "../core/finding-anchor";
+import {
+	emptyState,
+	type FindingState,
+	type FindingsStateFile,
+} from "../core/findings-state";
+import { type JevClient, JevVerifier } from "../core/jev";
+import {
+	applyJev,
+	applyResolutions,
+	selectVerifiable,
+	summarizeVerify,
+	verifyLocal,
+} from "../core/verify";
+
+const CONTENT = ["function a() {", '\tconsole.log("x");', "}"].join("\n");
+const FIXED = ["function a() {", "}"].join("\n");
+const ANCHOR = buildAnchor(CONTENT, 2);
+
+/** Finding mínimo, com overrides. */
+function makeFinding(overrides: Partial<FindingState> = {}): FindingState {
+	return {
+		id: "f1",
+		fingerprint: "fp",
+		watchdogIds: ["alpha"],
+		rule: "Evitar console.log",
+		severity: "attention",
+		file: "f.ts",
+		line: 2,
+		message: "console.log",
+		action: "remover",
+		anchor: ANCHOR,
+		count: 1,
+		present: true,
+		decision: "execute",
+		execState: "in_progress",
+		createdAt: "2026-01-01T00:00:00.000Z",
+		updatedAt: "2026-01-01T00:00:00.000Z",
+		history: [],
+		...overrides,
+	};
+}
+
+function withFindings(findings: FindingState[]): FindingsStateFile {
+	const state = emptyState("main");
+	for (const finding of findings) state.findings[finding.id] = finding;
+	return state;
+}
+
+describe("verifyLocal", () => {
+	test("âncora presente ⇒ persisting (definitivo)", () => {
+		const [entry] = verifyLocal([makeFinding()], () => CONTENT);
+		expect(entry.status).toBe("persisting");
+		expect(entry.basis).toBe("anchor");
+		expect(entry.ambiguous).toBe(false);
+	});
+
+	test("âncora sumida ⇒ resolved provisório e ambíguo", () => {
+		const [entry] = verifyLocal([makeFinding()], () => FIXED);
+		expect(entry.status).toBe("resolved");
+		expect(entry.ambiguous).toBe(true);
+	});
+
+	test("arquivo ausente ⇒ file-missing", () => {
+		const [entry] = verifyLocal([makeFinding()], () => null);
+		expect(entry.status).toBe("file-missing");
+		expect(entry.ambiguous).toBe(false);
+	});
+
+	test("sem âncora ⇒ uncertain e ambíguo", () => {
+		const [entry] = verifyLocal([makeFinding({ anchor: null })], () => CONTENT);
+		expect(entry.status).toBe("uncertain");
+		expect(entry.ambiguous).toBe(true);
+	});
+});
+
+describe("applyJev", () => {
+	test("alta confiança confirma persistência; baixa confirma resolução", () => {
+		const entries = verifyLocal(
+			[
+				makeFinding({ id: "removed", anchor: buildAnchor(CONTENT, 2) }),
+				makeFinding({ id: "noanchor", anchor: null }),
+			],
+			() => FIXED,
+		);
+		const applied = applyJev(
+			entries,
+			new Map([
+				["removed", 0.9],
+				["noanchor", 0.1],
+			]),
+			0.6,
+		);
+		expect(applied).toBe(2);
+		const byId = (id: string) => entries.find((entry) => entry.id === id);
+		expect(byId("removed")?.status).toBe("persisting");
+		expect(byId("removed")?.basis).toBe("jev");
+		expect(byId("removed")?.confidence).toBe(0.9);
+		expect(byId("noanchor")?.status).toBe("resolved");
+	});
+
+	test("id sem resposta mantém o provisório local (fail-open)", () => {
+		const entries = verifyLocal([makeFinding()], () => FIXED);
+		applyJev(entries, new Map(), 0.6);
+		expect(entries[0].status).toBe("resolved");
+		expect(entries[0].basis).toBe("anchor");
+	});
+});
+
+describe("summarizeVerify / applyResolutions", () => {
+	test("conta por status e marca os resolved como done", () => {
+		const findings = [
+			makeFinding({ id: "keeps", file: "keeps.ts" }),
+			makeFinding({ id: "fixed", file: "fixed.ts" }),
+			makeFinding({ id: "gone", file: "gone.ts" }),
+		];
+		const reader = (path: string): string | null =>
+			path === "gone.ts" ? null : path === "fixed.ts" ? FIXED : CONTENT;
+		const entries = verifyLocal(findings, reader);
+
+		const summary = summarizeVerify(entries);
+		expect(summary.persisting).toBe(1);
+		expect(summary.resolved).toBe(1);
+		expect(summary["file-missing"]).toBe(1);
+
+		const state = withFindings(findings);
+		const changed = applyResolutions(state, entries);
+		expect(changed).toEqual(["fixed"]);
+		expect(state.findings.fixed.execState).toBe("done");
+		expect(state.findings.fixed.history.at(-1)?.by).toBe("verify");
+		expect(state.findings.keeps.execState).toBe("in_progress");
+		expect(state.findings.gone.execState).toBe("in_progress");
+	});
+});
+
+describe("selectVerifiable", () => {
+	test("inclui presentes e exclui ignore/ausentes", () => {
+		const state = withFindings([
+			makeFinding({ id: "p", decision: "pending" }),
+			makeFinding({ id: "e", decision: "execute" }),
+			makeFinding({ id: "i", decision: "ignore" }),
+			makeFinding({ id: "absent", present: false }),
+		]);
+		expect(
+			selectVerifiable(state)
+				.map((finding) => finding.id)
+				.sort(),
+		).toEqual(["e", "p"]);
+	});
+});
+
+describe("JevVerifier", () => {
+	test("sem chave ⇒ nada confirmado (fail-open)", async () => {
+		const client = { isConfigured: () => false } as unknown as JevClient;
+		const outcome = await new JevVerifier(client).verify([
+			{ id: "a", file: "f.ts", rule: "r", foundAtSha: "old" },
+		]);
+		expect(outcome.checked).toBe(0);
+		expect(outcome.skipped).toBe(1);
+		expect(outcome.reason).toContain("TYPESAFE_API_KEY");
+	});
+
+	test("sem casos ⇒ vazio", async () => {
+		const client = { isConfigured: () => true } as unknown as JevClient;
+		const outcome = await new JevVerifier(client).verify([]);
+		expect(outcome.checked).toBe(0);
+		expect(outcome.skipped).toBe(0);
+	});
+});