@payconductor/houndsman 0.5.0 → 0.7.0

package/src/tests/server.test.ts

@@ -1,7 +1,7 @@
 import { describe, expect, test } from "bun:test";
 import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
-import { join } from "node:path";
+import { join, resolve } from "node:path";
 import type { HoundsmanConfig } from "../core/config";
 import { buildStateFromFindings, fileReader } from "../core/findings-state";
 import { dedupeFindings, parseWatchdogReport } from "../core/report-builder";
@@ -10,6 +10,7 @@ import { SQLiteStorageProvider } from "../core/storage/sqlite/sqlite-storage";
 import type { RepoIdentity } from "../core/storage/types";
 import { createRequestHandler, startServer } from "../server";
 import { isSlug } from "../server/artifacts";
+import { clearPrCommentsCache } from "../server/pr-comments";
 import { fakeHoundsmanConfig } from "./fixtures/fake-project";
 
 /** Ambiente fake: banco temporário + review `main` com um finding. */
@@ -220,11 +221,12 @@ describe("server API", () => {
 			const body = (await res.json()) as {
 				available: boolean;
 				target: { number: number };
-				candidates: unknown[];
+				candidates: { decision: string }[];
 			};
 			expect(body.available).toBe(true);
 			expect(body.target.number).toBe(12);
 			expect(body.candidates).toHaveLength(1);
+			expect(body.candidates[0].decision).toBe("pending");
 		} finally {
 			env.cleanup();
 		}
@@ -445,3 +447,294 @@ describe("startServer", () => {
 		}
 	});
 });
+
+describe("server — editor, PRs e comentários", () => {
+	const gitOk = (stdout = "") => ({ ok: true, code: 0, stdout, stderr: "" });
+
+	test("GET /api/editor devolve o contexto injetado", async () => {
+		const env = makeEnv();
+		try {
+			const handler = createRequestHandler(env.config, {
+				storage: env.storage,
+				repo: env.repo,
+				editor: { kind: "jetbrains", project: "app", product: "webstorm" },
+			});
+			const body = await (await get(handler, "/api/editor")).json();
+			expect(body).toEqual({
+				kind: "jetbrains",
+				project: "app",
+				product: "webstorm",
+			});
+		} finally {
+			env.cleanup();
+		}
+	});
+
+	test("GET /api/prs lista PRs abertas e casa com a run da branch", async () => {
+		const env = makeEnv();
+		try {
+			env.storage.getOrCreateReview({
+				repo: env.repo,
+				branch: "feat/x",
+				slug: "feat-x",
+			});
+			const calls: string[][] = [];
+			const handler = createRequestHandler(env.config, {
+				storage: env.storage,
+				repo: env.repo,
+				gitRunner: (args) => {
+					if (args[0] === "status") return gitOk("");
+					if (args[0] === "branch") return gitOk("main\n");
+					return gitOk("");
+				},
+				ghRunner: (args) => {
+					calls.push(args);
+					return ghJson([
+						{
+							number: 7,
+							title: "Feat X",
+							headRefName: "feat/x",
+							baseRefName: "main",
+							author: { login: "ana" },
+							updatedAt: "2026-01-02T00:00:00Z",
+							isDraft: false,
+							reviewDecision: "APPROVED",
+							url: "https://github.com/acme/app/pull/7",
+						},
+						{
+							number: 8,
+							title: "Outra",
+							headRefName: "feat/y",
+							baseRefName: "main",
+							author: { login: "bia" },
+							updatedAt: "2026-01-03T00:00:00Z",
+							isDraft: true,
+							reviewDecision: "",
+							url: "https://github.com/acme/app/pull/8",
+						},
+					]);
+				},
+			});
+
+			const res = await get(handler, "/api/prs");
+			expect(res.status).toBe(200);
+			const body = (await res.json()) as {
+				available: boolean;
+				currentBranch: string;
+				worktree: { clean: boolean };
+				prs: { number: number; runSlug?: string }[];
+			};
+			expect(body.available).toBe(true);
+			expect(body.currentBranch).toBe("main");
+			expect(body.worktree.clean).toBe(true);
+			expect(body.prs.map((pr) => pr.number)).toEqual([8, 7]);
+			expect(body.prs.find((pr) => pr.number === 7)?.runSlug).toBe("feat-x");
+			expect(calls[0]).toEqual([
+				"pr",
+				"list",
+				"--state",
+				"open",
+				"--limit",
+				"50",
+				"--json",
+				"number,title,headRefName,baseRefName,author,updatedAt,isDraft,reviewDecision,url",
+			]);
+		} finally {
+			env.cleanup();
+		}
+	});
+
+	test("POST /api/prs/checkout bloqueia árvore suja sem chamar gh", async () => {
+		const env = makeEnv();
+		try {
+			let ghCalls = 0;
+			const handler = createRequestHandler(env.config, {
+				storage: env.storage,
+				repo: env.repo,
+				gitRunner: (args) =>
+					args[0] === "status" ? gitOk(" M src/alpha/f.ts\n") : gitOk(""),
+				ghRunner: () => {
+					ghCalls++;
+					return gitOk("");
+				},
+			});
+
+			const res = await handler(
+				new Request("http://localhost/api/prs/checkout", {
+					method: "POST",
+					headers: { "content-type": "application/json" },
+					body: JSON.stringify({ number: 7 }),
+				}),
+			);
+			const body = (await res.json()) as {
+				ok: boolean;
+				reason: string;
+				changes?: string[];
+			};
+			expect(body.ok).toBe(false);
+			expect(body.reason).toBe("dirty");
+			expect(body.changes).toEqual([" M src/alpha/f.ts"]);
+			expect(ghCalls).toBe(0);
+		} finally {
+			env.cleanup();
+		}
+	});
+
+	test("POST /api/prs/checkout usa gh pr checkout quando a árvore está limpa", async () => {
+		const env = makeEnv();
+		try {
+			const calls: string[][] = [];
+			const handler = createRequestHandler(env.config, {
+				storage: env.storage,
+				repo: env.repo,
+				gitRunner: (args) => {
+					if (args[0] === "status") return gitOk("");
+					if (args[0] === "branch") return gitOk("feat/x\n");
+					return gitOk("");
+				},
+				ghRunner: (args) => {
+					calls.push(args);
+					return gitOk("");
+				},
+			});
+
+			const res = await handler(
+				new Request("http://localhost/api/prs/checkout", {
+					method: "POST",
+					headers: { "content-type": "application/json" },
+					body: JSON.stringify({ number: 7 }),
+				}),
+			);
+			expect(await res.json()).toEqual({
+				ok: true,
+				number: 7,
+				branch: "feat/x",
+			});
+			expect(calls).toContainEqual(["pr", "checkout", "7"]);
+		} finally {
+			env.cleanup();
+		}
+	});
+
+	test("GET comments agrupa threads, usa cache e respeita ?refresh=1", async () => {
+		const env = makeEnv();
+		try {
+			clearPrCommentsCache();
+			let inlineCalls = 0;
+			let issueCalls = 0;
+			const handler = createRequestHandler(env.config, {
+				storage: env.storage,
+				repo: env.repo,
+				ghRunner: (args) => {
+					if (args[0] === "pr") {
+						return ghJson({
+							number: 12,
+							url: "https://github.com/acme/app/pull/12",
+							headRefOid: "deadbeef",
+						});
+					}
+					const path = args[args.length - 1];
+					if (path === "repos/acme/app/pulls/12/comments") {
+						inlineCalls++;
+						return ghJson([
+							[
+								{
+									id: 1,
+									body: "raiz",
+									path: "src/alpha/f.ts",
+									line: 2,
+									created_at: "2026-01-01T00:00:00Z",
+									html_url:
+										"https://github.com/acme/app/pull/12#discussion_r1",
+									user: { login: "ana", type: "User" },
+								},
+								{
+									id: 2,
+									body: "resposta",
+									path: "src/alpha/f.ts",
+									line: 2,
+									in_reply_to_id: 1,
+									created_at: "2026-01-01T00:01:00Z",
+									user: { login: "bia", type: "User" },
+								},
+							],
+						]);
+					}
+					if (path === "repos/acme/app/issues/12/comments") {
+						issueCalls++;
+						return ghJson([
+							[
+								{
+									id: 3,
+									body: "geral",
+									created_at: "2026-01-01T00:02:00Z",
+									user: { login: "copilot[bot]", type: "Bot" },
+								},
+							],
+						]);
+					}
+					return { ok: false, code: 404, stdout: "", stderr: "not found" };
+				},
+			});
+
+			const first = (await (
+				await get(handler, "/api/runs/main/comments")
+			).json()) as {
+				available: boolean;
+				counts: { threads: number; inline: number; issue: number };
+				threads: {
+					path: string;
+					absFile: string;
+					comments: { author: string }[];
+				}[];
+				issueComments: { authorType: string }[];
+			};
+			expect(first.available).toBe(true);
+			expect(first.counts).toEqual({ threads: 1, inline: 2, issue: 1 });
+			expect(first.threads[0].path).toBe("src/alpha/f.ts");
+			expect(first.threads[0].absFile).toBe(
+				resolve(env.repo.root, "src/alpha/f.ts"),
+			);
+			expect(first.threads[0].comments.map((c) => c.author)).toEqual([
+				"ana",
+				"bia",
+			]);
+			expect(first.issueComments[0].authorType).toBe("Bot");
+
+			await get(handler, "/api/runs/main/comments");
+			expect(inlineCalls).toBe(1);
+			expect(issueCalls).toBe(1);
+
+			await get(handler, "/api/runs/main/comments?refresh=1");
+			expect(inlineCalls).toBe(2);
+			expect(issueCalls).toBe(2);
+		} finally {
+			clearPrCommentsCache();
+			env.cleanup();
+		}
+	});
+
+	test("GET comments é fail-open quando o gh não está disponível", async () => {
+		const env = makeEnv();
+		try {
+			clearPrCommentsCache();
+			const handler = createRequestHandler(env.config, {
+				storage: env.storage,
+				repo: env.repo,
+				ghRunner: () => ({
+					ok: false,
+					code: 127,
+					stdout: "",
+					stderr: "gh: not found",
+				}),
+			});
+			const body = (await (
+				await get(handler, "/api/runs/main/comments")
+			).json()) as { available: boolean; reason: string };
+			expect(body.available).toBe(false);
+			expect(body.reason).toContain("gh");
+		} finally {
+			env.cleanup();
+		}
+	});
+});

package/src/tests/tool-contracts.test.ts

@@ -0,0 +1,82 @@
+/**
+ * Contract test das tools built-in: metadata, schema e erros estruturados.
+ */
+
+import { describe, expect, test } from "bun:test";
+import { AstService } from "../core/ast/service";
+import { Watchdog } from "../core/domain/watchdog";
+import { SilentReporter } from "../harness/agent/agent-reporter";
+import { AgentState } from "../harness/investigation/agent-state";
+import type { ToolContext } from "../harness/tools/agent-tool";
+import { BuiltinToolsModule } from "../harness/tools/builtin";
+import { ToolCache } from "../harness/tools/tool-cache";
+import { ToolCallBudget } from "../harness/tools/tool-call-budget";
+import { ToolMiddleware } from "../harness/tools/tool-middleware";
+import { ToolRegistry } from "../harness/tools/tool-registry";
+import { fakeAgentContext } from "./fixtures/fake-investigation";
+import { fakeHoundsmanConfig } from "./fixtures/fake-project";
+
+function registry(): ToolRegistry {
+	const value = new ToolRegistry();
+	value.registerModule(new BuiltinToolsModule());
+	return value;
+}
+
+function context(): ToolContext {
+	return {
+		repoRoot: process.cwd(),
+		watchdog: new Watchdog(fakeHoundsmanConfig.watchdogs.alpha),
+		diff: { byFile: new Map(), churn: new Map() },
+		ast: new AstService(fakeHoundsmanConfig),
+		state: new AgentState(),
+		budget: new ToolCallBudget(20, 10),
+		cache: new ToolCache(),
+		logger: new SilentReporter(),
+		agent: fakeAgentContext({ repoRoot: process.cwd() }),
+		rules: new Map(),
+	};
+}
+
+describe("contratos das tools", () => {
+	test("todas declaram metadata read-only e capabilities", () => {
+		for (const tool of registry().list()) {
+			expect(tool.metadata.name.length).toBeGreaterThan(0);
+			expect(tool.metadata.description.length).toBeGreaterThan(0);
+			expect(tool.metadata.readOnly).toBe(true);
+			expect(tool.metadata.capabilities.length).toBeGreaterThan(0);
+			expect(tool.metadata.cost).toBeGreaterThanOrEqual(1);
+		}
+	});
+
+	test("nenhuma tool devolve arquivo inteiro por padrão", () => {
+		// `read_file_range` exige faixa explícita.
+		const range = registry().get("read_file_range");
+		expect(range?.inputSchema.safeParse({ path: "a.ts" }).success).toBe(false);
+		// `file_outline` só devolve metadados (não tem parâmetro de corpo).
+		const outline = registry().get("file_outline");
+		expect(outline?.inputSchema.safeParse({ path: "a.ts" }).success).toBe(true);
+	});
+
+	test("tools de arquivo devolvem erro estruturado (não lançam)", async () => {
+		const middleware = new ToolMiddleware();
+		for (const [name, input] of [
+			["read_file_range", { path: "../x", startLine: 1, endLine: 2 }],
+			["file_outline", { path: "../x" }],
+			["imports_exports", { file: "../x" }],
+		] as const) {
+			const result = await registry().execute(name, input, context(), middleware);
+			expect(result.ok).toBe(false);
+			expect(typeof result.error).toBe("string");
+		}
+	});
+
+	test("rule_signals devolve erro quando a regra não existe", async () => {
+		const result = await registry().execute(
+			"rule_signals",
+			{ rule: "regra inexistente" },
+			context(),
+			new ToolMiddleware(),
+		);
+		expect(result.ok).toBe(false);
+	});
+});

package/src/tests/verify.test.ts

@@ -158,7 +158,7 @@ describe("JevVerifier", () => {
 		]);
 		expect(outcome.checked).toBe(0);
 		expect(outcome.skipped).toBe(1);
-		expect(outcome.reason).toContain("TYPESAFE_API_KEY");
+		expect(outcome.reason).toContain("HOUNDSMAN_TYPE_SAFE_API_KEY");
 	});
 
 	test("sem casos ⇒ vazio", async () => {

package/src/server/client/RunList.tsx

@@ -1,75 +0,0 @@
-/**
- * Sidebar: logo do houndsman + lista de execuções (mais recentes primeiro),
- * com data/hora, relação de findings presentes e badge de correção pronta.
- */
-
-import { BranchIcon, Clock, Sparkles } from "./icons";
-import { describeRunStatus } from "./utils/constants";
-import { formatRunTime } from "./utils/format";
-import type { RunSummary } from "./utils/types";
-
-export function RunList({
-	runs,
-	slug,
-	onSelect,
-}: {
-	runs: RunSummary[];
-	slug: string | null;
-	onSelect: (slug: string) => void;
-}) {
-	return (
-		<aside class="sidebar">
-			<div class="brand">
-				<img class="logo" src="/assets/logo.png" alt="" />
-				<div>
-					<h1>Houndsman</h1>
-					<p class="sub">Revisões e triagem</p>
-				</div>
-			</div>
-			<p class="section-label">Execuções</p>
-			<nav class="runs">
-				{runs.length === 0 && <p class="empty">Nenhuma run encontrada.</p>}
-				{runs.map((run) => {
-					const status = describeRunStatus(run);
-					const fixReady = status?.kind === "fix_done";
-					return (
-						<button
-							type="button"
-							title={`Abrir a run da branch ${run.branch}`}
-							class={`run${run.slug === slug ? " active" : ""}`}
-							onClick={() => onSelect(run.slug)}
-						>
-							<span class="run-top">
-								<BranchIcon size={14} class="run-icon" />
-								<span class="run-branch">{run.branch}</span>
-							</span>
-							<span class="run-meta">
-								<span class="run-when">
-									<Clock size={12} />
-									{formatRunTime(run.updatedAt) || "sem data"}
-								</span>
-								<span
-									class="run-count"
-									title={`${run.summary.present} de ${run.summary.total} findings presentes`}
-								>
-									{run.summary.present}/{run.summary.total}
-								</span>
-							</span>
-							{fixReady ? (
-								<span class="run-badge">
-									<Sparkles size={12} /> Correção pronta
-								</span>
-							) : (
-								status && (
-									<span class={`run-status status-${status.kind}`}>
-										{status.label}
-									</span>
-								)
-							)}
-						</button>
-					);
-				})}
-			</nav>
-		</aside>
-	);
-}