@payconductor/houndsman 0.2.0 → 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/infrastructure.test.ts

@@ -0,0 +1,210 @@
+/**
+ * Infraestrutura (Fase 1 do refactor OO): git, gh, filesystem e layout da run.
+ *
+ * Testa as classes com runners injetáveis — sem tocar no git/gh reais.
+ */
+
+import { describe, expect, test } from "bun:test";
+import { mkdtempSync, readdirSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { GitResult, GitRunner } from "../core/git-runner";
+import { RunLayout } from "../core/run-layout";
+import { GhClient, type GhRunner } from "../core/services/gh-client";
+import { GitRepository } from "../core/services/git-repository";
+import { ProjectFiles } from "../core/services/project-files";
+
+/** Runner roteado por `args.join(" ")`, registrando as chamadas. */
+function fakeGit(routes: Record<string, GitResult>): {
+	calls: string[][];
+	runner: GitRunner;
+} {
+	const calls: string[][] = [];
+	const runner: GitRunner = (args) => {
+		calls.push(args);
+		return (
+			routes[args.join(" ")] ?? {
+				ok: false,
+				code: 1,
+				stdout: "",
+				stderr: "rota não mockada",
+			}
+		);
+	};
+	return { calls, runner };
+}
+
+describe("GitRepository", () => {
+	test("resolveSha apara o stdout", () => {
+		const { runner } = fakeGit({
+			"rev-parse HEAD": { ok: true, code: 0, stdout: "abc123\n", stderr: "" },
+		});
+		expect(new GitRepository(runner).resolveSha("HEAD")).toBe("abc123");
+	});
+
+	test("currentBranch devolve null quando falha ou está vazio", () => {
+		const empty = fakeGit({
+			"branch --show-current": { ok: true, code: 0, stdout: "\n", stderr: "" },
+		});
+		expect(new GitRepository(empty.runner).currentBranch()).toBeNull();
+
+		const failing = fakeGit({});
+		expect(new GitRepository(failing.runner).currentBranch()).toBeNull();
+	});
+
+	test("isAncestor usa o exit code sem lançar", () => {
+		const { runner } = fakeGit({
+			"merge-base --is-ancestor a b": {
+				ok: true,
+				code: 0,
+				stdout: "",
+				stderr: "",
+			},
+			"merge-base --is-ancestor b a": {
+				ok: false,
+				code: 1,
+				stdout: "",
+				stderr: "",
+			},
+		});
+		const git = new GitRepository(runner);
+		expect(git.isAncestor("a", "b")).toBe(true);
+		expect(git.isAncestor("b", "a")).toBe(false);
+	});
+
+	test("readFileAt devolve null quando o commit não tem o arquivo", () => {
+		const { runner } = fakeGit({
+			"show abc:src/a.ts": { ok: true, code: 0, stdout: "conteúdo", stderr: "" },
+		});
+		const git = new GitRepository(runner);
+		expect(git.readFileAt("abc", "src/a.ts")).toBe("conteúdo");
+		expect(git.readFileAt("abc", "src/missing.ts")).toBeNull();
+	});
+
+	test("diffNameStatus monta o intervalo base...head", () => {
+		const { calls, runner } = fakeGit({
+			"diff main...HEAD --name-status": {
+				ok: true,
+				code: 0,
+				stdout: "M\tsrc/a.ts\n",
+				stderr: "",
+			},
+		});
+		new GitRepository(runner).diffNameStatus("main", "HEAD");
+		expect(calls).toEqual([["diff", "main...HEAD", "--name-status"]]);
+	});
+
+	test("diffNumstat e collectDiffSince parseiam churn e patch", () => {
+		const patch = [
+			"diff --git a/src/a.ts b/src/a.ts",
+			"--- a/src/a.ts",
+			"+++ b/src/a.ts",
+			"@@ -1 +1 @@",
+			"-old",
+			"+new",
+		].join("\n");
+		const { runner } = fakeGit({
+			"diff from..to": { ok: true, code: 0, stdout: patch, stderr: "" },
+			"diff --numstat -z from..to": {
+				ok: true,
+				code: 0,
+				stdout: "1\t2\tsrc/a.ts\0",
+				stderr: "",
+			},
+		});
+		const diff = new GitRepository(runner).collectDiffSince("from", "to");
+		expect(diff.churn.get("src/a.ts")).toEqual({ additions: 1, deletions: 2 });
+		expect(diff.byFile.get("src/a.ts")).toContain("+new");
+	});
+});
+
+describe("GhClient", () => {
+	test("delega ao runner injetado", () => {
+		const calls: string[][] = [];
+		const runner: GhRunner = (args) => {
+			calls.push(args);
+			return { ok: true, code: 0, stdout: "ok", stderr: "" };
+		};
+		const result = new GhClient(runner).run(["auth", "status"]);
+		expect(result.stdout).toBe("ok");
+		expect(calls).toEqual([["auth", "status"]]);
+	});
+});
+
+describe("ProjectFiles", () => {
+	test("lê, escreve, lê JSON e resolve relativo ao cwd", () => {
+		const cwd = mkdtempSync(join(tmpdir(), "houndsman-files-"));
+		try {
+			const files = new ProjectFiles(cwd);
+			files.write("dir/a.txt", "conteúdo");
+			files.write("dir/b.json", JSON.stringify({ ok: true }));
+
+			expect(files.read("dir/a.txt")).toBe("conteúdo");
+			expect(files.read("dir/missing.txt")).toBeNull();
+			expect(files.readJson<{ ok: boolean }>("dir/b.json")).toEqual({ ok: true });
+			expect(files.readJson("dir/a.txt")).toBeNull();
+			expect(files.exists("dir/a.txt")).toBe(true);
+			expect(files.reader()("dir/a.txt")).toBe("conteúdo");
+		} finally {
+			rmSync(cwd, { recursive: true, force: true });
+		}
+	});
+
+	test("writeAtomic não deixa arquivo temporário", () => {
+		const cwd = mkdtempSync(join(tmpdir(), "houndsman-files-atomic-"));
+		try {
+			const files = new ProjectFiles(cwd);
+			files.writeAtomic("state.json", "{}");
+			expect(files.read("state.json")).toBe("{}");
+			expect(readdirSync(cwd)).toEqual(["state.json"]);
+		} finally {
+			rmSync(cwd, { recursive: true, force: true });
+		}
+	});
+});
+
+describe("RunLayout", () => {
+	test("centraliza os caminhos da run (slug normalizado)", () => {
+		const layout = new RunLayout(".houndsman/.runs", "feature/x");
+		expect(layout.slug).toBe("feature-x");
+		expect(layout.outDir.replace(/\\/g, "/")).toBe(".houndsman/.runs/feature-x");
+		expect(layout.briefsDir.replace(/\\/g, "/")).toBe(
+			".houndsman/.runs/feature-x/briefs",
+		);
+		expect(layout.findingsDir.replace(/\\/g, "/")).toBe(
+			".houndsman/.runs/feature-x/findings",
+		);
+		expect(layout.stateFile.replace(/\\/g, "/")).toBe(
+			".houndsman/.runs/feature-x/state.json",
+		);
+		expect(layout.runStatusFile.replace(/\\/g, "/")).toBe(
+			".houndsman/.runs/feature-x/run.json",
+		);
+		expect(layout.classificationFile.replace(/\\/g, "/")).toBe(
+			".houndsman/.runs/feature-x/classification.json",
+		);
+		expect(layout.domainReportFile("alpha").replace(/\\/g, "/")).toBe(
+			".houndsman/.runs/feature-x/review.alpha.md",
+		);
+		expect(layout.findingFile("alpha").replace(/\\/g, "/")).toBe(
+			".houndsman/.runs/feature-x/findings/alpha.json",
+		);
+		expect(layout.briefFile("alpha").replace(/\\/g, "/")).toBe(
+			".houndsman/.runs/feature-x/briefs/alpha.md",
+		);
+	});
+
+	test("contextPaths compartilha a pasta da run", () => {
+		const paths = new RunLayout(".houndsman/.runs", "main").contextPaths;
+		expect(paths.dir.replace(/\\/g, "/")).toBe(".houndsman/.runs/main");
+		expect(paths.context.replace(/\\/g, "/")).toBe(
+			".houndsman/.runs/main/context.json",
+		);
+		expect(paths.summary.replace(/\\/g, "/")).toBe(
+			".houndsman/.runs/main/context-summary.json",
+		);
+		expect(paths.brief.replace(/\\/g, "/")).toBe(
+			".houndsman/.runs/main/context-brief.md",
+		);
+	});
+});