@payconductor/houndsman 0.1.0 → 0.1.3

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: [],

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);
+		});
+	});
+});