@payconductor/houndsman 0.2.0 → 0.4.0

package/src/core/git-runner.ts

@@ -0,0 +1,46 @@
+/**
+ * Execução do binário `git` (biblioteca) — única camada que fala com o processo.
+ *
+ * `core.quotepath=false` mantém paths literais (acentos/unicode). O runner é
+ * injetável nos testes; `GitRepository` é a superfície OO sobre estes helpers.
+ */
+
+/** Resultado cru de uma execução do git (nunca lança). */
+export type GitResult = {
+	ok: boolean;
+	code: number;
+	stdout: string;
+	stderr: string;
+};
+
+/** Executa `git` e devolve o resultado cru. Injetável nos testes. */
+export type GitRunner = (args: string[]) => GitResult;
+
+/** Runner padrão: `git -c core.quotepath=false <args>` a partir do cwd. */
+export const defaultGitRunner: GitRunner = (args) => {
+	const result = Bun.spawnSync(["git", "-c", "core.quotepath=false", ...args], {
+		stdout: "pipe",
+		stderr: "pipe",
+	});
+	const code = result.exitCode ?? 1;
+	return {
+		ok: code === 0,
+		code,
+		stdout: new TextDecoder().decode(result.stdout),
+		stderr: new TextDecoder().decode(result.stderr),
+	};
+};
+
+/** Executa e devolve o stdout; lança com o stderr quando o git falha. */
+export function runGit(args: string[], runner: GitRunner = defaultGitRunner): string {
+	const result = runner(args);
+	if (!result.ok) {
+		throw new Error(`git ${args.join(" ")} falhou: ${result.stderr.trim()}`);
+	}
+	return result.stdout;
+}
+
+/** Executa o git sem lançar (para sondagens como `merge-base`/`show`). */
+export function tryGit(args: string[], runner: GitRunner = defaultGitRunner): GitResult {
+	return runner(args);
+}

package/src/core/github-review.ts

@@ -20,40 +20,11 @@ import {
 	type FindingState,
 	type FindingsStateFile,
 } from "./findings-state";
+import { systemClock } from "./services/clock";
+import { defaultGhRunner, type GhResult, type GhRunner } from "./services/gh-client";
 import { SEVERITY_EMOJI, type Severity } from "./types";
 
-// ---------------------------------------------------------------------------
-// Runner do `gh` (injetável nos testes)
-// ---------------------------------------------------------------------------
-
-export type GhResult = { ok: boolean; code: number; stdout: string; stderr: string };
-
-/** Executa o `gh` e devolve o resultado cru (sem lançar). */
-export type GhRunner = (args: string[]) => GhResult;
-
-/** Runner padrão: `gh` a partir do cwd; ausência do binário → `ok:false`. */
-export const defaultGhRunner: GhRunner = (args) => {
-	try {
-		const result = Bun.spawnSync(["gh", ...args], {
-			stdout: "pipe",
-			stderr: "pipe",
-		});
-		const code = result.exitCode ?? 1;
-		return {
-			ok: code === 0,
-			code,
-			stdout: new TextDecoder().decode(result.stdout).trim(),
-			stderr: new TextDecoder().decode(result.stderr).trim(),
-		};
-	} catch (error) {
-		return {
-			ok: false,
-			code: 127,
-			stdout: "",
-			stderr: error instanceof Error ? error.message : String(error),
-		};
-	}
-};
+export { type GhResult, type GhRunner, defaultGhRunner };
 
 // ---------------------------------------------------------------------------
 // Alvo (PR + repositório)
@@ -371,7 +342,7 @@ export function submitFindings(options: {
 	now?: string;
 }): SubmitOutcome {
 	const { state, target, runner } = options;
-	const now = options.now ?? new Date().toISOString();
+	const now = options.now ?? systemClock();
 	const candidates = selectSubmitCandidates(state, options.selection);
 
 	const outcome: SubmitOutcome = { posted: [], failed: [], skipped: [] };

package/src/core/jev/jev-candidates.ts

@@ -36,6 +36,50 @@ export type JevCandidatesFile = {
 
 const SEVERITY_SET = new Set<string>(SEVERITY_ORDER);
 
+/** Serializa o artefato `candidates.json` (sempre com quebra de linha final). */
+export function serializeCandidates(data: JevCandidatesFile): string {
+	return `${JSON.stringify(data, null, 2)}\n`;
+}
+
+/** Valida/parseia o JSON bruto do artefato; null se inválido. */
+export function parseCandidates(
+	raw: unknown,
+	validIds: readonly string[] = [],
+): JevCandidatesFile | null {
+	if (typeof raw !== "object" || raw === null) return null;
+	const value = raw as Record<string, unknown>;
+	const idSet = validIds.length > 0 ? new Set(validIds) : null;
+	const isCandidate = (entry: unknown): entry is JevCandidate => {
+		if (typeof entry !== "object" || entry === null) return false;
+		const c = entry as Record<string, unknown>;
+		return (
+			typeof c.watchdogId === "string" &&
+			(idSet === null || idSet.has(c.watchdogId)) &&
+			typeof c.rule === "string" &&
+			typeof c.severity === "string" &&
+			SEVERITY_SET.has(c.severity) &&
+			typeof c.file === "string" &&
+			typeof c.confidence === "number" &&
+			typeof c.questionKey === "string"
+		);
+	};
+	const candidates = Array.isArray(value.candidates)
+		? value.candidates.filter(isCandidate)
+		: [];
+	return {
+		available: value.available === true,
+		reason: typeof value.reason === "string" ? value.reason : undefined,
+		model: typeof value.model === "string" ? value.model : undefined,
+		threshold: typeof value.threshold === "number" ? value.threshold : undefined,
+		analyzedFiles:
+			typeof value.analyzedFiles === "number" ? value.analyzedFiles : undefined,
+		candidates,
+		skipped: Array.isArray(value.skipped)
+			? (value.skipped as JevSkippedFile[])
+			: undefined,
+	};
+}
+
 /** Persistência do artefato `candidates.json` para um diretório de review. */
 export class JevCandidatesStore {
 	/** Limiar padrão de confiança (`noul`) para virar candidato. */
@@ -57,49 +101,19 @@ export class JevCandidatesStore {
 
 	/** Grava o `candidates.json` (sempre com candidatos válidos apenas). */
 	write(data: JevCandidatesFile): void {
-		writeFileSync(this.filePath, `${JSON.stringify(data, null, 2)}\n`);
+		writeFileSync(this.filePath, serializeCandidates(data));
 	}
 
 	/** Lê o `candidates.json`; null se ausente/inválido. */
 	read(): JevCandidatesFile | null {
 		if (!existsSync(this.filePath)) return null;
 		try {
-			const raw = JSON.parse(readFileSync(this.filePath, "utf8")) as Record<
-				string,
-				unknown
-			>;
-			const candidates = Array.isArray(raw.candidates)
-				? raw.candidates.filter((c) => this.isCandidate(c))
-				: [];
-			return {
-				available: raw.available === true,
-				reason: typeof raw.reason === "string" ? raw.reason : undefined,
-				model: typeof raw.model === "string" ? raw.model : undefined,
-				threshold: typeof raw.threshold === "number" ? raw.threshold : undefined,
-				analyzedFiles:
-					typeof raw.analyzedFiles === "number" ? raw.analyzedFiles : undefined,
-				candidates,
-				skipped: Array.isArray(raw.skipped)
-					? (raw.skipped as JevSkippedFile[])
-					: undefined,
-			};
+			return parseCandidates(
+				JSON.parse(readFileSync(this.filePath, "utf8")),
+				this.watchdogIdSet ? [...this.watchdogIdSet] : [],
+			);
 		} catch {
 			return null;
 		}
 	}
-
-	private isCandidate(value: unknown): value is JevCandidate {
-		if (typeof value !== "object" || value === null) return false;
-		const c = value as Record<string, unknown>;
-		return (
-			typeof c.watchdogId === "string" &&
-			(this.watchdogIdSet === null || this.watchdogIdSet.has(c.watchdogId)) &&
-			typeof c.rule === "string" &&
-			typeof c.severity === "string" &&
-			SEVERITY_SET.has(c.severity) &&
-			typeof c.file === "string" &&
-			typeof c.confidence === "number" &&
-			typeof c.questionKey === "string"
-		);
-	}
 }