@payconductor/houndsman 0.6.0 → 0.7.0

package/src/server/pr-inbox.ts

@@ -0,0 +1,202 @@
+/**
+ * Caixa de entrada de Pull Requests do repositório atual (servidor).
+ *
+ * Lista as PRs abertas via `gh` e executa o checkout somente quando a árvore
+ * de trabalho está limpa. Fail-open: sem `gh` (ou sem git), devolve o motivo e
+ * a UI degrada sem quebrar as demais abas.
+ */
+
+import { describeGhError, type GhRunner } from "../core/services/gh-client";
+import type { GitRepository } from "../core/services/git-repository";
+
+/** Estado da árvore de trabalho (base do bloqueio do checkout). */
+export type WorktreeState = {
+	/** `false` quando o `git status` falhou. */
+	available: boolean;
+	clean: boolean;
+	changes: number;
+	/** Amostra dos caminhos alterados (limitada para a UI). */
+	sample: string[];
+};
+
+/** PR aberta exibida na sidebar. */
+export type PrListItem = {
+	number: number;
+	title: string;
+	headRefName: string;
+	baseRefName: string;
+	author: string;
+	updatedAt?: string;
+	isDraft: boolean;
+	reviewDecision?: string;
+	url?: string;
+	/** Run local correspondente à branch, quando existir. */
+	runSlug?: string;
+};
+
+/** Resposta de `GET /api/prs`. */
+export type PrListResponse = {
+	available: boolean;
+	reason?: string;
+	currentBranch: string | null;
+	worktree: WorktreeState;
+	prs: PrListItem[];
+};
+
+/** Resultado do checkout de uma PR. */
+export type CheckoutResponse =
+	| { ok: true; number: number; branch: string | null }
+	| {
+			ok: false;
+			reason: "dirty" | "git" | "gh";
+			detail: string;
+			changes?: string[];
+	  };
+
+const PR_LIST_FIELDS =
+	"number,title,headRefName,baseRefName,author,updatedAt,isDraft,reviewDecision,url";
+
+type GhPrListItem = {
+	number?: number;
+	title?: string;
+	headRefName?: string;
+	baseRefName?: string;
+	author?: { login?: string; name?: string };
+	updatedAt?: string;
+	isDraft?: boolean;
+	reviewDecision?: string;
+	url?: string;
+};
+
+function toItem(
+	raw: GhPrListItem,
+	runSlugs: ReadonlyMap<string, string>,
+): PrListItem | null {
+	const number = Number(raw.number);
+	const headRefName = raw.headRefName?.trim();
+	if (!Number.isFinite(number) || number <= 0 || !headRefName) return null;
+	return {
+		number,
+		title: raw.title?.trim() || `PR #${number}`,
+		headRefName,
+		baseRefName: raw.baseRefName?.trim() || "",
+		author: raw.author?.login ?? raw.author?.name ?? "desconhecido",
+		updatedAt: raw.updatedAt,
+		isDraft: Boolean(raw.isDraft),
+		reviewDecision: raw.reviewDecision?.trim() || undefined,
+		url: raw.url,
+		runSlug: runSlugs.get(headRefName),
+	};
+}
+
+/** Acesso às PRs do repositório atual. */
+export class PrInbox {
+	constructor(
+		private readonly ghRunner: GhRunner,
+		private readonly git: GitRepository,
+	) {}
+
+	/** Estado da árvore de trabalho (`git status --porcelain`). */
+	worktree(): WorktreeState {
+		const result = this.git.tryRun(["status", "--porcelain"]);
+		if (!result.ok) {
+			return { available: false, clean: false, changes: 0, sample: [] };
+		}
+		const lines = result.stdout
+			.split("\n")
+			.map((line) => line.trimEnd())
+			.filter((line) => line.length > 0);
+		return {
+			available: true,
+			clean: lines.length === 0,
+			changes: lines.length,
+			sample: lines.slice(0, 20),
+		};
+	}
+
+	/** Lista as PRs abertas (limite 50) e o estado local do repositório. */
+	list(runSlugs: ReadonlyMap<string, string> = new Map()): PrListResponse {
+		const currentBranch = this.git.currentBranch();
+		const worktree = this.worktree();
+		const result = this.ghRunner([
+			"pr",
+			"list",
+			"--state",
+			"open",
+			"--limit",
+			"50",
+			"--json",
+			PR_LIST_FIELDS,
+		]);
+
+		if (!result.ok) {
+			return {
+				available: false,
+				reason: describeGhError(result),
+				currentBranch,
+				worktree,
+				prs: [],
+			};
+		}
+
+		let parsed: unknown;
+		try {
+			parsed = JSON.parse(result.stdout);
+		} catch {
+			return {
+				available: false,
+				reason: "Resposta inválida do gh (JSON malformado).",
+				currentBranch,
+				worktree,
+				prs: [],
+			};
+		}
+		if (!Array.isArray(parsed)) {
+			return {
+				available: false,
+				reason: "Resposta inesperada do gh (esperava uma lista de PRs).",
+				currentBranch,
+				worktree,
+				prs: [],
+			};
+		}
+
+		const prs = (parsed as GhPrListItem[])
+			.map((item) => toItem(item, runSlugs))
+			.filter((item): item is PrListItem => item !== null)
+			.sort((a, b) => (b.updatedAt ?? "").localeCompare(a.updatedAt ?? ""));
+
+		return { available: true, currentBranch, worktree, prs };
+	}
+
+	/**
+	 * Faz checkout da PR via `gh pr checkout`.
+	 *
+	 * A árvore precisa estar limpa: alterações locais não commitadas bloqueiam a
+	 * operação para não descartar trabalho do usuário.
+	 */
+	checkout(number: number): CheckoutResponse {
+		const worktree = this.worktree();
+		if (!worktree.available) {
+			return {
+				ok: false,
+				reason: "git",
+				detail: "Não foi possível ler o estado do git.",
+			};
+		}
+		if (!worktree.clean) {
+			return {
+				ok: false,
+				reason: "dirty",
+				detail: `${worktree.changes} alteração(ões) não commitada(s).`,
+				changes: worktree.sample,
+			};
+		}
+
+		const result = this.ghRunner(["pr", "checkout", String(number)]);
+		if (!result.ok) {
+			return { ok: false, reason: "gh", detail: describeGhError(result) };
+		}
+		return { ok: true, number, branch: this.git.currentBranch() };
+	}
+}

package/src/server/run-repository.ts

@@ -34,9 +34,11 @@ import {
 } from "../core/github-review";
 import { pingFindingsStatus } from "../core/run-status";
 import { systemClock } from "../core/services/clock";
+import { defaultGhRunner } from "../core/services/gh-client";
 import type { RepoIdentity, ReviewRecord, StorageProvider } from "../core/storage/types";
 import type { Severity } from "../core/types";
 import { isSlug } from "./artifacts";
+import { fetchPrComments, type PrCommentsResponse } from "./pr-comments";
 
 /** Item da lista de execuções (sidebar) — já ordenado do mais recente ao antigo. */
 export type RunListItem = {
@@ -78,10 +80,16 @@ export type ArtifactListItem = {
 export class RunRepository {
 	private readonly storage: StorageProvider;
 	private readonly repo: RepoIdentity;
+	private readonly ghRunner: GhRunner;
 
-	constructor(storage: StorageProvider, repo: RepoIdentity) {
+	constructor(
+		storage: StorageProvider,
+		repo: RepoIdentity,
+		ghRunner: GhRunner = defaultGhRunner,
+	) {
 		this.storage = storage;
 		this.repo = repo;
+		this.ghRunner = ghRunner;
 	}
 
 	/** `true` se o slug aponta para uma run do repositório atual. */
@@ -105,6 +113,15 @@ export class RunRepository {
 		});
 	}
 
+	/** Mapa branch → slug das runs (usado para casar PRs com execuções). */
+	branchIndex(): Map<string, string> {
+		return new Map(
+			this.storage
+				.listReviews(this.repo.key)
+				.map((review) => [review.branch, review.slug]),
+		);
+	}
+
 	/** Detalhe da run (null se o slug for inválido). */
 	detail(slug: string): RunDetail | null {
 		const review = this.findBySlug(slug);
@@ -273,6 +290,21 @@ export class RunRepository {
 		return { available: true, target: target.target, outcome };
 	}
 
+	/** Comentários da PR da run (null se o slug for inválido). */
+	comments(
+		slug: string,
+		options: { refresh?: boolean } = {},
+	): PrCommentsResponse | null {
+		const review = this.findBySlug(slug);
+		if (!review) return null;
+		return fetchPrComments({
+			runner: this.ghRunner,
+			branch: review.branch,
+			repoRoot: review.repoRoot,
+			refresh: options.refresh,
+		});
+	}
+
 	/** Lista os artefatos da run (sem conteúdo). */
 	artifacts(slug: string): ArtifactListItem[] | null {
 		const review = this.findBySlug(slug);

package/src/tests/ai-core.test.ts

@@ -16,8 +16,8 @@ const project = new ProjectConfig(fakeHoundsmanConfig);
 
 describe("config de IA", () => {
 	test("modelo default do DeepSeek é 4.1 flash", () => {
-		expect(DEFAULT_AI_MODEL).toBe("deepseek-v4.1-flash");
-		expect(project.aiModel).toBe("deepseek-v4.1-flash");
+		expect(DEFAULT_AI_MODEL).toBe("deepseek-v4-pro");
+		expect(project.aiModel).toBe("deepseek-v4-pro");
 	});
 });
 

package/src/tests/cli.test.ts

@@ -152,6 +152,39 @@ describe("cli smoke — imports dinâmicos", () => {
 		}
 	});
 
+	test("findings submit filtra pela decisão (a executar)", () => {
+		const project = makeProject();
+		try {
+			const pending = runCli(project.cwd, [
+				"findings",
+				"submit",
+				"--dry-run",
+				"--json",
+				"--branch",
+				"main",
+				"--decision",
+				"pending",
+			]);
+			expect(pending.code).toBe(0);
+			expect(JSON.parse(pending.stdout).totals.candidates).toBe(1);
+
+			const execute = runCli(project.cwd, [
+				"findings",
+				"submit",
+				"--dry-run",
+				"--json",
+				"--branch",
+				"main",
+				"--decision",
+				"execute",
+			]);
+			expect(execute.code).toBe(0);
+			expect(JSON.parse(execute.stdout).totals.candidates).toBe(0);
+		} finally {
+			project.cleanup();
+		}
+	});
+
 	test("doctor valida a config (import lazy de registry-check)", () => {
 		const project = makeProject();
 		try {

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

@@ -294,6 +294,15 @@ describe("selectSubmitCandidates", () => {
 		expect(selectSubmitCandidates(state, { execStates: ["done"] })).toEqual([]);
 	});
 
+	test("filtra pela decisão (a executar vs ainda pendente)", () => {
+		const execute = selectSubmitCandidates(state, { decisions: ["execute"] });
+		expect(execute.map((c) => c.id)).toEqual(["a"]);
+		expect(execute[0].decision).toBe("execute");
+		expect(
+			selectSubmitCandidates(state, { decisions: ["pending"] }).map((c) => c.id),
+		).toEqual(["c"]);
+	});
+
 	test("marca sent/skip e respeita includeSent", () => {
 		const sent = stateWith([finding({ id: "a", commentId: 99 })]);
 		const [only] = selectSubmitCandidates(sent);

package/src/tests/server-editor.test.ts

@@ -0,0 +1,100 @@
+import { describe, expect, test } from "bun:test";
+import {
+	editorFileLink,
+	jetbrainsFileLink,
+	vscodeFileLink,
+} from "../server/client/utils/format";
+import { detectEditor, resolveEditor } from "../server/editor";
+
+describe("detecção de editor", () => {
+	test("VS Code pelo TERM_PROGRAM", () => {
+		expect(detectEditor({ TERM_PROGRAM: "vscode" }, "/work/app")).toMatchObject({
+			kind: "vscode",
+			project: "app",
+		});
+	});
+
+	test("VS Code pelas variáveis VSCODE_*", () => {
+		expect(detectEditor({ VSCODE_PID: "123" }, "/work/app")).toMatchObject({
+			kind: "vscode",
+			project: "app",
+		});
+	});
+
+	test("JetBrains pelo terminal e produto do bundle", () => {
+		expect(
+			detectEditor(
+				{
+					TERMINAL_EMULATOR: "JetBrains-JediTerm",
+					__CFBundleIdentifier: "com.jetbrains.pycharm",
+				},
+				"/work/app",
+			),
+		).toEqual({ kind: "jetbrains", project: "app", product: "pycharm" });
+	});
+
+	test("JetBrains por *_INITIAL_DIRECTORY", () => {
+		expect(
+			detectEditor({ WEBSTORM_INITIAL_DIRECTORY: "/work/app" }, "/work/app"),
+		).toEqual({ kind: "jetbrains", project: "app", product: "webstorm" });
+	});
+
+	test("produto JetBrains ambíguo cai em idea", () => {
+		expect(
+			detectEditor({ TERMINAL_EMULATOR: "JetBrains-JediTerm" }, "/work/app"),
+		).toEqual({ kind: "jetbrains", project: "app", product: "idea" });
+	});
+
+	test("sem pistas → none", () => {
+		expect(detectEditor({}, "/work/app")).toEqual({
+			kind: "none",
+			project: "app",
+		});
+	});
+
+	test("resolveEditor força vscode/jetbrains/none", () => {
+		expect(resolveEditor("vscode", {}, "/work/app")).toMatchObject({
+			kind: "vscode",
+		});
+		expect(resolveEditor("jetbrains", {}, "/work/app")).toMatchObject({
+			kind: "jetbrains",
+			product: "idea",
+		});
+		expect(
+			resolveEditor("none", { TERM_PROGRAM: "vscode" }, "/work/app"),
+		).toMatchObject({ kind: "none" });
+		expect(resolveEditor("desconhecido", {}, "/work/app")).toMatchObject({
+			kind: "none",
+		});
+	});
+});
+
+describe("links de editor", () => {
+	test("VS Code normaliza o drive e mantém a linha", () => {
+		expect(vscodeFileLink("C:\\repo\\src\\a.ts", 12)).toBe(
+			"vscode://file/c:/repo/src/a.ts:12",
+		);
+	});
+
+	test("JetBrains monta navigate/reference", () => {
+		const link = jetbrainsFileLink("C:\\repo\\src\\a.ts", 12, "app", "webstorm");
+		expect(link).toContain(
+			"jetbrains://webstorm/navigate/reference?project=app&path=",
+		);
+		expect(link ? decodeURIComponent(link) : "").toContain("C:/repo/src/a.ts:12");
+	});
+
+	test("editorFileLink respeita o tipo detectado", () => {
+		expect(editorFileLink("/repo/a.ts", 3, { kind: "vscode", project: "app" })).toBe(
+			"vscode://file//repo/a.ts:3",
+		);
+		expect(
+			editorFileLink("/repo/a.ts", 3, {
+				kind: "jetbrains",
+				project: "app",
+				product: "goland",
+			}),
+		).toContain("jetbrains://goland/");
+		expect(editorFileLink("/repo/a.ts", 3, { kind: "none" })).toBeNull();
+	});
+});