@payconductor/houndsman 0.1.4 → 0.3.0

package/src/tests/domain.test.ts

@@ -0,0 +1,328 @@
+/**
+ * Domínio (Fase 2 do refactor OO): watchdog, registry, config do projeto,
+ * diff, classificação e descoberta de docs.
+ */
+
+import { describe, expect, test } from "bun:test";
+import { defineHoundsmanConfig } from "../core/config";
+import { DocDiscoverer, discoverDocs } from "../core/doc-discoverer";
+import { Classification } from "../core/domain/classification";
+import { Diff } from "../core/domain/diff";
+import { matchesClassifyRule, Watchdog } from "../core/domain/watchdog";
+import {
+	emptyState,
+	Finding,
+	type FindingState,
+	FindingsState,
+} from "../core/findings-state";
+import { ProjectConfig } from "../core/project-config";
+import { defineWatchdog } from "../core/types";
+import { WatchdogRegistry } from "../core/watchdog-registry";
+import { fakeHoundsmanConfig } from "./fixtures/fake-project";
+
+// ---------------------------------------------------------------------------
+// Watchdog / WatchdogRegistry
+// ---------------------------------------------------------------------------
+
+describe("Watchdog", () => {
+	const alpha = new Watchdog(fakeHoundsmanConfig.watchdogs.alpha);
+
+	test("casa arquivos do próprio domínio", () => {
+		expect(alpha.matches("src/alpha/a.ts")).toBe(true);
+		expect(alpha.matches("src/beta/a.ts")).toBe(false);
+	});
+
+	test("ordena regras por severidade e expõe contexto sem regras", () => {
+		expect(alpha.rules.map((rule) => rule.severity)).toEqual([
+			"blocking",
+			"attention",
+			"suggestion",
+		]);
+		const context = alpha.context();
+		expect(context.id).toBe("alpha");
+		expect(context.contextFiles).toEqual(["README.md"]);
+		expect("rules" in context).toBe(false);
+	});
+
+	test("casa por conteúdo quando a regra é type=content", () => {
+		const probe = new Watchdog(
+			defineWatchdog({
+				id: "probe",
+				name: "Probe",
+				description: "Por conteúdo.",
+				scope: "qualquer",
+				classify: [{ type: "content", value: "NEEDLE" }],
+				rules: [],
+				contextFiles: [],
+			}),
+		);
+		expect(probe.matches("a.ts", "// NEEDLE")).toBe(true);
+		expect(probe.matches("a.ts", "sem alvo")).toBe(false);
+		expect(probe.matches("a.ts")).toBe(false);
+	});
+
+	test("matchesClassifyRule respeita filename/content", () => {
+		expect(
+			matchesClassifyRule("src/alpha/a.ts", { value: "^src/alpha/" }, undefined),
+		).toBe(true);
+		expect(
+			matchesClassifyRule("a.ts", { type: "content", value: "X" }, "contém X"),
+		).toBe(true);
+		expect(
+			matchesClassifyRule("a.ts", { type: "content", value: "X" }, undefined),
+		).toBe(false);
+	});
+});
+
+describe("WatchdogRegistry", () => {
+	const registry = new WatchdogRegistry(fakeHoundsmanConfig);
+
+	test("resolve ids, nomes e buscas null-safe", () => {
+		expect(registry.ids).toEqual(["alpha", "beta"]);
+		expect(registry.get("alpha").name).toBe("Alpha");
+		expect(registry.find("alpha")?.name).toBe("Alpha");
+		expect(registry.find("nao-existe")).toBeNull();
+		expect(registry.nameOf("nao-existe")).toBe("nao-existe");
+		expect(registry.all()).toHaveLength(2);
+	});
+
+	test("contexto e matching por arquivo", () => {
+		expect(registry.context("beta").contextFiles).toContain("README.md");
+		expect(registry.matching("src/alpha/a.ts")).toEqual(["alpha"]);
+		expect(registry.matching("lib/special.ts")).toEqual(["beta"]);
+		expect(registry.matching("scripts/foo.ts")).toEqual([]);
+	});
+});
+
+// ---------------------------------------------------------------------------
+// ProjectConfig
+// ---------------------------------------------------------------------------
+
+describe("ProjectConfig", () => {
+	test("resolve defaults e valores do projeto", () => {
+		const project = new ProjectConfig(fakeHoundsmanConfig);
+		expect(project.projectName).toBe("Fake Project");
+		expect(project.artifactDir).toBe("tmp/fake-review");
+		expect(project.maxFilesPerBrief).toBe(40);
+		expect(project.jevConcurrency).toBe(5);
+		expect(project.alwaysIncludeDocs).toEqual(["README.md"]);
+		expect(project.watchdogs.ids).toEqual(["alpha", "beta"]);
+	});
+
+	test("sobrepõe orçamento/concorrência e ignora valores inválidos", () => {
+		const custom = defineHoundsmanConfig({
+			...fakeHoundsmanConfig,
+			budgets: { maxFilesPerBrief: 60 },
+			concurrency: { jev: 8 },
+		});
+		const project = new ProjectConfig(custom);
+		expect(project.maxFilesPerBrief).toBe(60);
+		expect(project.jevConcurrency).toBe(8);
+
+		const invalid = defineHoundsmanConfig({
+			...fakeHoundsmanConfig,
+			budgets: { maxFilesPerBrief: 0 },
+			concurrency: { jev: -1 },
+		});
+		const fallback = new ProjectConfig(invalid);
+		expect(fallback.maxFilesPerBrief).toBe(40);
+		expect(fallback.jevConcurrency).toBe(5);
+	});
+});
+
+// ---------------------------------------------------------------------------
+// Diff / Classification
+// ---------------------------------------------------------------------------
+
+describe("Diff", () => {
+	const diff = new Diff({
+		byFile: new Map([["src/a.ts", "patch-a"]]),
+		churn: new Map([
+			["src/a.ts", { additions: 2, deletions: 1 }],
+			["src/b.ts", { additions: 3, deletions: 0 }],
+		]),
+	});
+
+	test("consulta patch, churn e totais", () => {
+		expect(diff.paths.sort()).toEqual(["src/a.ts", "src/b.ts"]);
+		expect(diff.patchFor("src/a.ts")).toBe("patch-a");
+		expect(diff.patchFor("src/b.ts")).toBeUndefined();
+		expect(diff.churnOf("src/a.ts")).toEqual({ additions: 2, deletions: 1 });
+		expect(diff.churnOf("src/missing.ts")).toEqual({
+			additions: 0,
+			deletions: 0,
+		});
+		expect(diff.totals).toEqual({ additions: 5, deletions: 1 });
+	});
+
+	test("empty não tem paths nem churn", () => {
+		expect(Diff.empty().paths).toEqual([]);
+		expect(Diff.empty().totals).toEqual({ additions: 0, deletions: 0 });
+	});
+});
+
+describe("Classification", () => {
+	const data = {
+		watchdogs: { alpha: ["src/a.ts", "src/b.ts"], beta: ["src/c.ts"] },
+		files: {
+			"src/a.ts": { status: "modified" as const },
+			"src/b.ts": { status: "added" as const },
+			"src/c.ts": { status: "modified" as const },
+		},
+		churn: {
+			"src/a.ts": { additions: 10, deletions: 0 },
+			"src/b.ts": { additions: 1, deletions: 0 },
+			"src/c.ts": { additions: 4, deletions: 2 },
+		},
+		unclassified: ["scripts/x.ts"],
+		excluded: ["dist/x.js"],
+		deleted: [],
+		stats: { alpha: 2, beta: 1 },
+		excludedCount: 1,
+		base: "main",
+		head: "HEAD",
+	};
+	const classification = Classification.from(data);
+
+	test("expõe coleções e ids ativos", () => {
+		expect(classification.activeIds).toEqual(["alpha", "beta"]);
+		expect(classification.watchdogsFor("alpha")).toEqual(["src/a.ts", "src/b.ts"]);
+		expect(classification.watchdogsFor("missing")).toEqual([]);
+		expect(classification.unclassified).toEqual(["scripts/x.ts"]);
+		expect(classification.excludedCount).toBe(1);
+		expect(classification.base).toBe("main");
+	});
+
+	test("aplica o orçamento por risco", () => {
+		expect(classification.budgetFor("alpha", 1)).toEqual({
+			selected: ["src/a.ts"],
+			overflow: ["src/b.ts"],
+		});
+		expect(classification.budgetFor("alpha", 40)).toEqual({
+			selected: ["src/a.ts", "src/b.ts"],
+			overflow: [],
+		});
+	});
+
+	test("soma churn e serializa no shape do classification.json", () => {
+		expect(classification.churnTotals).toEqual({ additions: 15, deletions: 2 });
+		expect(classification.toJSON()).toBe(data);
+	});
+});
+
+// ---------------------------------------------------------------------------
+// DocDiscoverer
+// ---------------------------------------------------------------------------
+
+describe("DocDiscoverer", () => {
+	test("sempre inclui docs e aplica os mapeamentos do projeto", () => {
+		const config = defineHoundsmanConfig({
+			...fakeHoundsmanConfig,
+			alwaysIncludeDocs: ["AGENTS.md"],
+			docMappings: [
+				[/^src\//, ["docs/DOMAIN.md"]],
+				[/\.test\.ts$/, ["docs/TESTS.md"]],
+			],
+		});
+		const docs = new DocDiscoverer(config).discover([
+			"src/alpha/a.ts",
+			"src/alpha/a.test.ts",
+			"scripts/foo.ts",
+		]);
+		expect(docs).toEqual(["AGENTS.md", "docs/DOMAIN.md", "docs/TESTS.md"]);
+	});
+
+	test("o adaptador discoverDocs delega para a classe", () => {
+		expect(discoverDocs(["src/alpha/a.ts"], fakeHoundsmanConfig)).toEqual([
+			"README.md",
+		]);
+	});
+});
+
+// ---------------------------------------------------------------------------
+// Finding / FindingsState
+// ---------------------------------------------------------------------------
+
+/** Finding mínimo para os testes de domínio. */
+function makeFinding(id: string, overrides: Partial<FindingState> = {}): FindingState {
+	return {
+		id,
+		fingerprint: `fp-${id}`,
+		watchdogIds: ["alpha"],
+		rule: "R",
+		severity: "blocking",
+		file: "src/a.ts",
+		line: 1,
+		message: "m",
+		action: "a",
+		anchor: null,
+		count: 1,
+		present: true,
+		decision: "pending",
+		execState: "pending",
+		createdAt: "2026-01-01T00:00:00.000Z",
+		updatedAt: "2026-01-01T00:00:00.000Z",
+		history: [],
+		...overrides,
+	};
+}
+
+describe("Finding / FindingsState", () => {
+	const file = emptyState("main");
+	file.findings.a = makeFinding("a");
+	file.findings.b = makeFinding("b", {
+		severity: "nit",
+		file: "src/z.ts",
+		present: false,
+		decision: "ignore",
+	});
+	file.order = ["a", "b"];
+
+	test("Finding expõe o estado e aplica updates", () => {
+		const state = makeFinding("x");
+		const finding = Finding.from(state);
+		expect(finding.id).toBe("x");
+		expect(finding.isDone).toBe(false);
+		expect(finding.toJSON()).toBe(state);
+
+		finding.apply({ decision: "execute", execState: "in_progress" }, "agora");
+		expect(finding.decision).toBe("execute");
+		expect(finding.execState).toBe("in_progress");
+		expect(state.updatedAt).toBe("agora");
+		expect(state.history).toHaveLength(1);
+	});
+
+	test("FindingsState lista, filtra e resume", () => {
+		const state = FindingsState.from(file);
+		expect(state.branch).toBe("main");
+		expect(state.list().map((f) => f.id)).toEqual(["a", "b"]);
+		expect(state.get("a")?.file).toBe("src/a.ts");
+		expect(state.get("missing")).toBeNull();
+		expect(state.present().map((f) => f.id)).toEqual(["a"]);
+		expect(state.filter({ severity: "nit", includeAbsent: true })).toHaveLength(1);
+		expect(state.summarize().total).toBe(2);
+		expect(state.summarize().present).toBe(1);
+		expect(state.toJSON()).toBe(file);
+	});
+
+	test("FindingsState aplica updates e delega sync/reorder", () => {
+		const state = FindingsState.from(emptyState("main"));
+		state.file.findings.a = makeFinding("a");
+		state.file.order = ["a"];
+
+		expect(state.apply("missing", { decision: "ignore" })).toBeNull();
+		const updated = state.apply("a", { decision: "execute" }, "agora");
+		expect(updated?.decision).toBe("execute");
+		expect(state.file.findings.a?.updatedAt).toBe("agora");
+
+		const result = state.sync(() => null);
+		expect(result.stale).toEqual(["a"]);
+	});
+
+	test("FindingsState.empty cria uma coleção vazia válida", () => {
+		const empty = FindingsState.empty("feature/x");
+		expect(empty.branch).toBe("feature/x");
+		expect(empty.list()).toEqual([]);
+		expect(empty.summarize().total).toBe(0);
+	});
+});

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

@@ -0,0 +1,320 @@
+/**
+ * Testes do envio da revisão ao GitHub (`core/github-review.ts`).
+ *
+ * Usam um runner fake do `gh` — nenhum teste toca a rede/repositório real.
+ */
+
+import { describe, expect, test } from "bun:test";
+import {
+	emptyState,
+	type FindingDecision,
+	type FindingExecState,
+	type FindingState,
+	type FindingsStateFile,
+} from "../core/findings-state";
+import {
+	buildCommentBody,
+	buildSubmitPreview,
+	type GhResult,
+	type GhRunner,
+	type PrTarget,
+	renderGeneralBody,
+	resolvePrTarget,
+	selectSubmitCandidates,
+	submitFindings,
+} from "../core/github-review";
+import type { Severity } from "../core/types";
+
+type FindingSpec = {
+	id: string;
+	severity?: Severity;
+	decision?: FindingDecision;
+	execState?: FindingExecState;
+	line?: number | null;
+	present?: boolean;
+	rule?: string;
+	file?: string;
+	commentId?: number;
+};
+
+function finding(spec: FindingSpec): FindingState {
+	return {
+		id: spec.id,
+		fingerprint: spec.id,
+		watchdogIds: ["alpha"],
+		rule: spec.rule ?? "Regra de teste",
+		severity: spec.severity ?? "blocking",
+		file: spec.file ?? "src/a.ts",
+		line: spec.line === undefined ? 3 : spec.line,
+		message: "mensagem",
+		action: "corrigir",
+		evidence: "const x = 1;",
+		anchor: null,
+		count: 1,
+		present: spec.present ?? true,
+		decision: spec.decision ?? "pending",
+		execState: spec.execState ?? "pending",
+		createdAt: "2026-01-01T00:00:00.000Z",
+		updatedAt: "2026-01-01T00:00:00.000Z",
+		history: [],
+		github: spec.commentId
+			? {
+					commentId: spec.commentId,
+					kind: "line",
+					pr: 1,
+					at: "2026-01-01T00:00:00.000Z",
+				}
+			: undefined,
+	};
+}
+
+function stateWith(findings: FindingState[]): FindingsStateFile {
+	const state = emptyState("feat/x");
+	for (const item of findings) state.findings[item.id] = item;
+	state.order = findings.map((item) => item.id);
+	return state;
+}
+
+const TARGET: PrTarget = { number: 7, repo: "acme/app", headSha: "abc" };
+
+function okComment(id: number): GhResult {
+	return {
+		ok: true,
+		code: 0,
+		stderr: "",
+		stdout: JSON.stringify({ id, html_url: `https://x/${id}` }),
+	};
+}
+
+/** Runner fake: o handler decide a resposta a partir dos args (os chamados ficam registrados). */
+function fakeRunner(handler: (args: string[]) => GhResult): {
+	runner: GhRunner;
+	calls: string[][];
+} {
+	const calls: string[][] = [];
+	const runner: GhRunner = (args) => {
+		calls.push(args);
+		return handler(args);
+	};
+	return { runner, calls };
+}
+
+/** Respostas por tipo de destino: geral (issues), arquivo (subject_type=file) e linha. */
+function endpointRunner(ids: { line?: number; file?: number; general?: number } = {}): {
+	runner: GhRunner;
+	calls: string[][];
+} {
+	return fakeRunner((args) => {
+		if (args[1].includes("/issues/")) return okComment(ids.general ?? 900);
+		if (args.includes("subject_type=file")) return okComment(ids.file ?? 800);
+		return okComment(ids.line ?? 700);
+	});
+}
+
+describe("selectSubmitCandidates", () => {
+	const state = stateWith([
+		finding({ id: "a", severity: "blocking", decision: "execute" }),
+		finding({ id: "b", severity: "attention", decision: "ignore" }),
+		finding({ id: "c", severity: "nit", line: null }),
+		finding({ id: "d", decision: "execute", present: false }),
+	]);
+
+	test("exclui ignore e ausentes", () => {
+		expect(selectSubmitCandidates(state).map((c) => c.id)).toEqual(["a", "c"]);
+	});
+
+	test("filtra por severidade e define a âncora", () => {
+		const blocking = selectSubmitCandidates(state, { severities: ["blocking"] });
+		expect(blocking.map((c) => c.id)).toEqual(["a"]);
+		expect(blocking[0].kind).toBe("line");
+		expect(selectSubmitCandidates(state, { severities: ["nit"] })[0].kind).toBe(
+			"file",
+		);
+	});
+
+	test("filtra por estado de execução", () => {
+		const exec = selectSubmitCandidates(state, { execStates: ["pending"] });
+		expect(exec.map((c) => c.id)).toEqual(["a", "c"]);
+		expect(selectSubmitCandidates(state, { execStates: ["done"] })).toEqual([]);
+	});
+
+	test("marca sent/skip e respeita includeSent", () => {
+		const sent = stateWith([finding({ id: "a", commentId: 99 })]);
+		const [only] = selectSubmitCandidates(sent);
+		expect(only.sent).toBe(true);
+		expect(only.skip).toBe(true);
+		expect(only.sentUrl).toBeUndefined();
+		expect(selectSubmitCandidates(sent, { includeSent: true })[0].skip).toBe(false);
+	});
+});
+
+describe("buildSubmitPreview", () => {
+	test("disponível: conta linha/arquivo", () => {
+		const state = stateWith([finding({ id: "a" }), finding({ id: "c", line: null })]);
+		const preview = buildSubmitPreview(state, { ok: true, target: TARGET });
+		expect(preview.available).toBe(true);
+		expect(preview.target).toEqual(TARGET);
+		expect(preview.totals).toMatchObject({
+			candidates: 2,
+			toSend: 2,
+			line: 1,
+			file: 1,
+			sent: 0,
+		});
+	});
+
+	test("indisponível propaga o motivo", () => {
+		const preview = buildSubmitPreview(stateWith([]), {
+			ok: false,
+			reason: "sem gh",
+		});
+		expect(preview.available).toBe(false);
+		expect(preview.reason).toBe("sem gh");
+	});
+});
+
+describe("corpo dos comentários", () => {
+	test("buildCommentBody inclui regra, ação e evidência", () => {
+		const body = buildCommentBody(finding({ id: "a", rule: "Nunca usar any" }));
+		expect(body).toContain("Nunca usar any");
+		expect(body).toContain("**Ação:** corrigir");
+		expect(body).toContain("const x = 1;");
+		expect(body).toContain("houndsman");
+	});
+
+	test("renderGeneralBody lista os findings sem linha", () => {
+		const body = renderGeneralBody([
+			finding({ id: "a", rule: "Regra X", line: null }),
+		]);
+		expect(body).toContain("Regra X");
+		expect(body).toContain("src/a.ts");
+	});
+});
+
+describe("resolvePrTarget", () => {
+	test("resolve número, repo e head", () => {
+		const runner: GhRunner = () => ({
+			ok: true,
+			code: 0,
+			stderr: "",
+			stdout: JSON.stringify({
+				number: 7,
+				url: "https://github.com/acme/app/pull/7",
+				headRefOid: "abc123",
+			}),
+		});
+		const result = resolvePrTarget(runner, "feat/x");
+		expect(result.ok).toBe(true);
+		if (result.ok) {
+			expect(result.target).toEqual({
+				number: 7,
+				repo: "acme/app",
+				headSha: "abc123",
+				url: "https://github.com/acme/app/pull/7",
+			});
+		}
+	});
+
+	test("fail-open sem gh", () => {
+		const runner: GhRunner = () => ({
+			ok: false,
+			code: 127,
+			stdout: "",
+			stderr: "command not found",
+		});
+		const result = resolvePrTarget(runner, "feat/x");
+		expect(result.ok).toBe(false);
+		if (!result.ok) expect(result.reason).toContain("gh não instalado");
+	});
+});
+
+describe("submitFindings", () => {
+	test("posta na linha e no arquivo; grava o vínculo", () => {
+		const state = stateWith([finding({ id: "a" }), finding({ id: "c", line: null })]);
+		const { runner } = endpointRunner({ line: 100, file: 150, general: 200 });
+		const outcome = submitFindings({ state, target: TARGET, runner });
+
+		expect(outcome.posted).toHaveLength(2);
+		expect(outcome.failed).toEqual([]);
+		expect(outcome.general).toBeUndefined();
+		expect(state.findings.a.github).toMatchObject({
+			commentId: 100,
+			kind: "line",
+			pr: 7,
+		});
+		expect(state.findings.c.github).toMatchObject({
+			commentId: 150,
+			kind: "file",
+			pr: 7,
+		});
+	});
+
+	test("linha fora do diff cai no comentário de arquivo", () => {
+		const state = stateWith([finding({ id: "a" })]);
+		const { runner } = fakeRunner((args) =>
+			args.includes("subject_type=file")
+				? okComment(150)
+				: {
+						ok: false,
+						code: 422,
+						stderr: "line must be part of the diff",
+						stdout: "",
+					},
+		);
+		const outcome = submitFindings({ state, target: TARGET, runner });
+
+		expect(outcome.failed).toEqual([]);
+		expect(outcome.general).toBeUndefined();
+		expect(state.findings.a.github).toMatchObject({
+			kind: "file",
+			commentId: 150,
+		});
+	});
+
+	test("o que não cola em linha nem arquivo vai para o comentário geral", () => {
+		const state = stateWith([finding({ id: "a" })]);
+		const { runner } = fakeRunner((args) =>
+			args[1].includes("/issues/")
+				? okComment(200)
+				: { ok: false, code: 422, stderr: "fora do diff", stdout: "" },
+		);
+		const outcome = submitFindings({ state, target: TARGET, runner });
+
+		expect(outcome.failed).toHaveLength(1);
+		expect(outcome.general?.ids).toEqual(["a"]);
+		expect(state.findings.a.github?.kind).toBe("comment");
+		expect(state.findings.a.github?.commentId).toBe(200);
+	});
+
+	test("pula já enviados (sem chamar o gh)", () => {
+		const state = stateWith([finding({ id: "a", commentId: 55 })]);
+		const { runner, calls } = endpointRunner();
+		const outcome = submitFindings({ state, target: TARGET, runner });
+
+		expect(calls).toHaveLength(0);
+		expect(outcome.skipped).toHaveLength(1);
+		expect(state.findings.a.github?.commentId).toBe(55);
+	});
+
+	test("manda commit_id e side=RIGHT na linha", () => {
+		const state = stateWith([finding({ id: "a", line: 9 })]);
+		const { runner, calls } = endpointRunner({ line: 100 });
+		submitFindings({ state, target: TARGET, runner });
+
+		const line = calls[0];
+		expect(line).toContain("line=9");
+		expect(line).toContain("side=RIGHT");
+		expect(line).toContain("commit_id=abc");
+		expect(line).toContain("path=src/a.ts");
+	});
+
+	test("finding sem linha usa subject_type=file", () => {
+		const state = stateWith([finding({ id: "a", line: null })]);
+		const { runner, calls } = endpointRunner({ file: 150 });
+		submitFindings({ state, target: TARGET, runner });
+
+		expect(calls[0]).toContain("subject_type=file");
+		expect(calls[0]).not.toContain("side=RIGHT");
+		expect(state.findings.a.github?.kind).toBe("file");
+	});
+});