@payconductor/houndsman 0.6.0 → 0.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@payconductor/houndsman",
-	"version": "0.6.0",
+	"version": "0.7.0",
 	"description": "Orquestrador de revisão de Pull Requests: classifica o diff, despacha watchdogs especializados por domínio e consolida o relatório.",
 	"type": "module",
 	"license": "MIT",

package/src/cli/commands/server-command.ts

@@ -26,9 +26,15 @@ export class ServerCommand implements Command {
 		const parser = ArgParser.from(args);
 		const port = Number(parser.value("--port")) || 7331;
 		const host = parser.value("--host") ?? "127.0.0.1";
+		const editorPreference = parser.value("--editor");
 
 		const { startServer } = await import("../../server");
-		const { url } = startServer({ config: engine.config, port, host });
+		const { url } = startServer({
+			config: engine.config,
+			port,
+			host,
+			editorPreference,
+		});
 		context.out(`[houndsman] servidor em ${url}`);
 		context.out("[houndsman] Ctrl+C para encerrar.");
 		if (parser.has("--open")) openBrowser(url);

package/src/cli/help.ts

@@ -8,7 +8,7 @@ Comandos:
   hunt                Revisão nativa com IA (harness próprio): prepare + agentes + finalize
   findings <sub>      Triagem/correção dos findings (list · show · set · done · reset · sync · summary · batch · verify · submit · path)
   status [ping]       Mostra o status da run (ping renova o heartbeat da execução)
-  server              Sobe a UI local de triagem (--port, --host, --open)
+  server              Sobe a UI local de triagem (--port, --host, --open, --editor)
   setup               Cria a configuração inicial do projeto (config + skills)
   update              Sincroniza os arquivos auto-gerados (.houndsman/core)
   doctor              Valida a configuração, o ambiente e a credencial Jev

package/src/core/commands/findings.ts

@@ -657,18 +657,23 @@ function splitList(raw: string | undefined): string[] {
 		.filter(Boolean);
 }
 
-/** Seleção do envio a partir das flags (`--severity`, `--exec`, `--include-sent`). */
+/** Seleção do envio a partir das flags (`--severity`, `--decision`, `--exec`). */
 function submitSelection(parsed: ParsedArgs): SubmitSelection {
 	const severities = splitList(parsed.values["--severity"]).filter(
 		(value): value is Severity =>
 			(SEVERITY_ORDER as readonly string[]).includes(value),
 	);
+	const decisions = splitList(parsed.values["--decision"]).filter(
+		(value): value is FindingDecision =>
+			(FINDING_DECISIONS as readonly string[]).includes(value),
+	);
 	const execStates = splitList(parsed.values["--exec"]).filter(
 		(value): value is FindingExecState =>
 			(FINDING_EXEC_STATES as readonly string[]).includes(value),
 	);
 	return {
 		severities: severities.length > 0 ? severities : undefined,
+		decisions: decisions.length > 0 ? decisions : undefined,
 		execStates: execStates.length > 0 ? execStates : undefined,
 		includeSent: parsed.bools.has("--include-sent"),
 	};

package/src/core/defaults.ts

@@ -29,7 +29,7 @@ export const DEFAULT_AST_MAX_IMPACT_FILES = 200;
 export const DEFAULT_AI_PROVIDER = "deepseek" as const;
 
 /** Modelo default da camada de IA. */
-export const DEFAULT_AI_MODEL = "deepseek-v4.1-flash";
+export const DEFAULT_AI_MODEL = "deepseek-v4-pro";
 
 /** Concorrência default das chamadas de IA. */
 export const DEFAULT_AI_CONCURRENCY = 2;

package/src/core/git-runner.ts

@@ -16,20 +16,32 @@ export type GitResult = {
 /** 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),
+/**
+ * Cria um runner do git com diretório de trabalho fixo.
+ *
+ * O servidor roda a partir da raiz do repositório, mas o checkout pode ser
+ * disparado de outra sessão — o `cwd` garante que os comandos atinjam o repo
+ * certo. Sem `cwd`, herda o diretório do processo (default).
+ */
+export function createGitRunner(cwd?: string): GitRunner {
+	return (args) => {
+		const result = Bun.spawnSync(["git", "-c", "core.quotepath=false", ...args], {
+			cwd,
+			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),
+		};
 	};
-};
+}
+
+/** Runner padrão: `git -c core.quotepath=false <args>` a partir do cwd. */
+export const defaultGitRunner: GitRunner = createGitRunner();
 
 /** Executa e devolve o stdout; lança com o stderr quando o git falha. */
 export function runGit(args: string[], runner: GitRunner = defaultGitRunner): string {

package/src/core/github-review.ts

@@ -24,7 +24,12 @@ import {
 	type FindingsStateFile,
 } from "./findings-state";
 import { systemClock } from "./services/clock";
-import { defaultGhRunner, type GhResult, type GhRunner } from "./services/gh-client";
+import {
+	defaultGhRunner,
+	describeGhError,
+	type GhResult,
+	type GhRunner,
+} from "./services/gh-client";
 import { SEVERITY_EMOJI, SEVERITY_ORDER, type Severity } from "./types";
 
 export { type GhResult, type GhRunner, defaultGhRunner };
@@ -54,12 +59,7 @@ function repoFromUrl(url: string | undefined): string | null {
 
 /** Mensagem curta para um erro do `gh`. */
 function shortError(result: GhResult): string {
-	if (result.code === 127 || /not found|ENOENT/i.test(result.stderr)) {
-		return "gh não instalado.";
-	}
-	const last = result.stderr.split("\n").filter(Boolean).pop() ?? "";
-	if (/auth|login|logged/i.test(last)) return `gh sem autenticação (${last}).`;
-	return last || `gh saiu com código ${result.code}.`;
+	return describeGhError(result);
 }
 
 /**
@@ -118,6 +118,8 @@ export type SubmitCandidate = {
 	file: string;
 	line: number | null;
 	severity: Severity;
+	/** Decisão da triagem (`execute` = "a executar"/fila de correção). */
+	decision: FindingDecision;
 	execState: FindingExecState;
 	rule: string;
 	message: string;
@@ -159,6 +161,7 @@ export function selectSubmitCandidates(
 				file: finding.file,
 				line: finding.line,
 				severity: finding.severity,
+				decision: finding.decision,
 				execState: finding.execState,
 				rule: finding.rule,
 				message: finding.message,

package/src/core/services/gh-client.ts

@@ -10,29 +10,45 @@ export type GhResult = { ok: boolean; code: number; stdout: string; stderr: stri
 /** 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),
-		};
+/** Mensagem curta para um erro do `gh` (sem expor o stderr inteiro). */
+export function describeGhError(result: GhResult): string {
+	if (result.code === 127 || /not found|ENOENT/i.test(result.stderr)) {
+		return "gh não instalado.";
 	}
-};
+	const last = result.stderr.split("\n").filter(Boolean).pop() ?? "";
+	if (/auth|login|logged/i.test(last)) return `gh sem autenticação (${last}).`;
+	return last || `gh saiu com código ${result.code}.`;
+}
+
+/** Cria um runner do `gh` com diretório de trabalho fixo. */
+export function createGhRunner(cwd?: string): GhRunner {
+	return (args) => {
+		try {
+			const result = Bun.spawnSync(["gh", ...args], {
+				cwd,
+				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),
+			};
+		}
+	};
+}
+
+/** Runner padrão: `gh` a partir do cwd; ausência do binário → `ok:false`. */
+export const defaultGhRunner: GhRunner = createGhRunner();
 
 /** Superfície OO sobre o runner injetável. */
 export class GhClient {

package/src/server/client/App.tsx

@@ -7,18 +7,19 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from "preact/hooks";
 import { ArtifactsPanel } from "./ArtifactsPanel";
 import { AutoRefresh } from "./AutoRefresh";
+import { CommentsPanel } from "./CommentsPanel";
 import { Filters, type FiltersState } from "./Filters";
 import { FindingsList } from "./FindingsList";
-import { FileText, Layers, ListIcon, Refresh, Send } from "./icons";
+import { FileText, Layers, ListIcon, MessageSquare, Refresh, Send } from "./icons";
 import { ResumePanel } from "./ResumePanel";
-import { RunList } from "./RunList";
+import { Sidebar } from "./Sidebar";
 import { SubmitModal } from "./SubmitModal";
 import { SummaryBar } from "./SummaryBar";
 import { api, computeSummary } from "./utils/api";
 import { AUTO_REFRESH_MS, TAB_CAPTIONS } from "./utils/constants";
-import type { Finding, FindingsResponse, RunSummary } from "./utils/types";
+import type { EditorContext, Finding, FindingsResponse, RunSummary } from "./utils/types";
 
-type Tab = "resume" | "findings" | "artifacts";
+type Tab = "resume" | "findings" | "artifacts" | "comments";
 
 const TABS: { id: Tab; label: string; hint: string }[] = [
 	{
@@ -36,8 +37,20 @@ const TABS: { id: Tab; label: string; hint: string }[] = [
 		label: "Artefatos",
 		hint: "Arquivos brutos gerados pela revisão (manifesto, classificação, relatório…)",
 	},
+	{
+		id: "comments",
+		label: "Comentários",
+		hint: "Comentários da PR: threads de revisão e comentários gerais (carregados ao abrir a aba)",
+	},
 ];
 
+function TabIcon({ id }: { id: Tab }) {
+	if (id === "resume") return <FileText size={15} />;
+	if (id === "findings") return <ListIcon size={15} />;
+	if (id === "artifacts") return <Layers size={15} />;
+	return <MessageSquare size={15} />;
+}
+
 export function App() {
 	const [runs, setRuns] = useState<RunSummary[]>([]);
 	const [slug, setSlug] = useState<string | null>(null);
@@ -54,6 +67,8 @@ export function App() {
 	const [refreshing, setRefreshing] = useState(false);
 	const [syncing, setSyncing] = useState(false);
 	const [submitOpen, setSubmitOpen] = useState(false);
+	/** Editor detectado pelo servidor — base dos links de código. */
+	const [editor, setEditor] = useState<EditorContext>({ kind: "vscode" });
 	/** Refs espelhando estado volátil — o polling não deve recriar o intervalo. */
 	const lastSyncRef = useRef(lastSync);
 	const slugRef = useRef<string | null>(null);
@@ -116,6 +131,14 @@ export function App() {
 		reloadRuns();
 	}, [reloadRuns]);
 
+	useEffect(() => {
+		api<EditorContext>("/api/editor")
+			.then(setEditor)
+			.catch(() => {
+				// fail-open: mantém o fallback VS Code.
+			});
+	}, []);
+
 	useEffect(() => {
 		if (slug) loadFindings(slug);
 	}, [slug, loadFindings]);
@@ -194,7 +217,12 @@ export function App() {
 
 	return (
 		<div class="app">
-			<RunList runs={runs} slug={slug} onSelect={setSlug} />
+			<Sidebar
+				runs={runs}
+				slug={slug}
+				onSelect={setSlug}
+				onRefreshRuns={() => void reloadRuns()}
+			/>
 			<main class="main">
 				<header class="topbar">
 					<div class="segmented">
@@ -206,13 +234,7 @@ export function App() {
 								class={`seg-btn${tab === item.id ? " active" : ""}`}
 								onClick={() => setTab(item.id)}
 							>
-								{item.id === "resume" ? (
-									<FileText size={15} />
-								) : item.id === "findings" ? (
-									<ListIcon size={15} />
-								) : (
-									<Layers size={15} />
-								)}
+								<TabIcon id={item.id} />
 								{item.label}
 							</button>
 						))}
@@ -278,11 +300,15 @@ export function App() {
 							<FindingsList
 								slug={slug}
 								findings={findings}
+								editor={editor}
 								onUpdated={onUpdated}
 							/>
 						</>
 					)}
 					{slug && tab === "artifacts" && <ArtifactsPanel slug={slug} />}
+					{slug && tab === "comments" && (
+						<CommentsPanel slug={slug} editor={editor} />
+					)}
 					{!slug && !error && <p class="empty">Nenhuma execução para triar.</p>}
 				</div>
 				{slug && (

package/src/server/client/CommentsPanel.tsx

@@ -0,0 +1,255 @@
+/**
+ * Aba "Comentários": threads de revisão e comentários gerais da PR da run.
+ *
+ * O componente só é montado quando a aba é acessada — o carregamento (e a
+ * chamada ao `gh`) acontece no mount, nunca no carregamento da página.
+ */
+
+import { useCallback, useEffect, useMemo, useState } from "preact/hooks";
+import { Clock, CodeIcon, ExternalLink, GitHub, MessageSquare, Refresh } from "./icons";
+import { MarkdownText } from "./MarkdownText";
+import { api } from "./utils/api";
+import { editorFileLink, editorLabel, formatRunTime } from "./utils/format";
+import type {
+	EditorContext,
+	PrCommentsResponse,
+	PrCommentThread,
+	PrCommentView,
+} from "./utils/types";
+
+function CommentCard({
+	comment,
+	editor,
+	reply,
+}: {
+	comment: PrCommentView;
+	editor: EditorContext;
+	reply: boolean;
+}) {
+	const location = comment.path
+		? comment.line
+			? `${comment.path}:${comment.line}`
+			: comment.path
+		: null;
+	const href = comment.absFile
+		? editorFileLink(comment.absFile, comment.line, editor)
+		: null;
+	return (
+		<article class={`pr-comment${reply ? " reply" : ""}`}>
+			<header class="pr-comment-head">
+				<span class="pr-comment-author">{comment.author}</span>
+				{comment.authorType === "Bot" && <span class="tag">bot</span>}
+				<span class="run-when">
+					<Clock size={12} />
+					{formatRunTime(comment.createdAt)}
+				</span>
+				<span class="spacer" />
+				{comment.url && (
+					<a
+						class="pr-comment-link"
+						href={comment.url}
+						target="_blank"
+						rel="noreferrer"
+						title="Abrir o comentário no GitHub"
+					>
+						<GitHub size={12} /> GitHub
+					</a>
+				)}
+			</header>
+			<div class="pr-comment-body">
+				<MarkdownText text={comment.body} />
+			</div>
+			{location &&
+				(href ? (
+					<a
+						class="loc"
+						href={href}
+						title={`Abrir ${location} no ${editorLabel(editor)}`}
+					>
+						<CodeIcon size={13} />
+						{location}
+						<ExternalLink size={12} class="ext" />
+					</a>
+				) : (
+					<code class="loc static">
+						<CodeIcon size={13} />
+						{location}
+					</code>
+				))}
+		</article>
+	);
+}
+
+function ThreadCard({
+	thread,
+	editor,
+}: {
+	thread: PrCommentThread;
+	editor: EditorContext;
+}) {
+	const location = thread.line
+		? `${thread.path}:${thread.line}`
+		: thread.path || "arquivo";
+	const href = thread.absFile
+		? editorFileLink(thread.absFile, thread.line, editor)
+		: null;
+	return (
+		<section class="comment-thread">
+			<header class="comment-thread-head">
+				<CodeIcon size={13} />
+				<span class="comment-file">{location}</span>
+				<span class="spacer" />
+				{href && (
+					<a
+						class="icon-btn"
+						href={href}
+						title={`Abrir ${location} no ${editorLabel(editor)}`}
+					>
+						<ExternalLink size={13} />
+					</a>
+				)}
+				<span class="count">{thread.comments.length}</span>
+			</header>
+			{thread.comments.map((comment, index) => (
+				<CommentCard
+					key={comment.id}
+					comment={comment}
+					editor={editor}
+					reply={index > 0}
+				/>
+			))}
+		</section>
+	);
+}
+
+export function CommentsPanel({ slug, editor }: { slug: string; editor: EditorContext }) {
+	const [data, setData] = useState<PrCommentsResponse | null>(null);
+	const [loading, setLoading] = useState(true);
+	const [error, setError] = useState("");
+
+	const load = useCallback(
+		async (refresh = false) => {
+			setLoading(true);
+			setError("");
+			try {
+				const result = await api<PrCommentsResponse>(
+					`/api/runs/${slug}/comments${refresh ? "?refresh=1" : ""}`,
+				);
+				setData(result);
+			} catch (err) {
+				setError(String(err));
+			} finally {
+				setLoading(false);
+			}
+		},
+		[slug],
+	);
+
+	useEffect(() => {
+		setData(null);
+		void load();
+	}, [load]);
+
+	const groups = useMemo(() => {
+		const map = new Map<string, PrCommentThread[]>();
+		for (const thread of data?.threads ?? []) {
+			const key = thread.path || "(sem arquivo)";
+			const list = map.get(key) ?? [];
+			list.push(thread);
+			map.set(key, list);
+		}
+		return [...map.entries()];
+	}, [data]);
+
+	const empty =
+		data?.available && data.threads.length === 0 && data.issueComments.length === 0;
+
+	return (
+		<div class="comments">
+			<div class="comments-toolbar">
+				<div class="comments-counts">
+					<MessageSquare size={14} />
+					{data?.available ? (
+						<>
+							<span>
+								<b>{data.counts.threads}</b> threads
+							</span>
+							<span>
+								<b>{data.counts.inline}</b> inline
+							</span>
+							<span>
+								<b>{data.counts.issue}</b> gerais
+							</span>
+						</>
+					) : (
+						<span>Comentários da PR</span>
+					)}
+					{data?.target?.url && (
+						<a
+							class="pr-comment-link"
+							href={data.target.url}
+							target="_blank"
+							rel="noreferrer"
+						>
+							<GitHub size={12} /> PR #{data.target.number}
+						</a>
+					)}
+				</div>
+				<button
+					type="button"
+					class="btn"
+					disabled={loading}
+					title="Recarrega os comentários ignorando o cache de 60s"
+					onClick={() => void load(true)}
+				>
+					<Refresh size={14} class={loading ? "icon spin" : undefined} />
+					Atualizar
+				</button>
+			</div>
+
+			{loading && !data && <p class="empty">Carregando comentários da PR…</p>}
+			{error && <p class="error">{error}</p>}
+			{data && !data.available && (
+				<p class="empty">
+					Comentários indisponíveis
+					{data.reason ? `: ${data.reason}` : "."}
+				</p>
+			)}
+			{empty && <p class="empty">Nenhum comentário nesta PR.</p>}
+
+			{data?.available && groups.length > 0 && (
+				<section class="comment-group">
+					<h2 class="comment-group-title">Comentários de revisão</h2>
+					{groups.map(([path, threads]) => (
+						<div class="comment-file-group" key={path}>
+							<p class="comment-group-label">
+								{path} <span class="count">{threads.length}</span>
+							</p>
+							{threads.map((thread) => (
+								<ThreadCard
+									key={thread.id}
+									thread={thread}
+									editor={editor}
+								/>
+							))}
+						</div>
+					))}
+				</section>
+			)}
+
+			{data?.available && data.issueComments.length > 0 && (
+				<section class="comment-group">
+					<h2 class="comment-group-title">Comentários gerais</h2>
+					{data.issueComments.map((comment) => (
+						<CommentCard
+							key={comment.id}
+							comment={comment}
+							editor={editor}
+							reply={false}
+						/>
+					))}
+				</section>
+			)}
+		</div>
+	);
+}

package/src/server/client/FindingCard.tsx

@@ -21,8 +21,8 @@ import { MarkdownText } from "./MarkdownText";
 import { api } from "./utils/api";
 import { highlightCode, languageFromFile } from "./utils/code-highlight";
 import { DECISION_LABELS, DECISIONS, SEVERITY_LABELS } from "./utils/constants";
-import { vscodeFileLink } from "./utils/format";
-import type { Finding } from "./utils/types";
+import { editorFileLink, editorLabel } from "./utils/format";
+import type { EditorContext, Finding } from "./utils/types";
 
 /** Debounce do auto-save do comentário (ms). */
 const AUTOSAVE_MS = 700;
@@ -32,10 +32,12 @@ const SAVED_VISIBLE_MS = 1800;
 export function FindingCard({
 	slug,
 	finding,
+	editor,
 	onUpdated,
 }: {
 	slug: string;
 	finding: Finding;
+	editor: EditorContext;
 	onUpdated: (finding: Finding) => void;
 }) {
 	const isDone = finding.execState === "done";
@@ -104,7 +106,9 @@ export function FindingCard({
 	}, [comment, patch]);
 
 	const location = finding.line ? `${finding.file}:${finding.line}` : finding.file;
-	const href = finding.absFile ? vscodeFileLink(finding.absFile, finding.line) : null;
+	const href = finding.absFile
+		? editorFileLink(finding.absFile, finding.line, editor)
+		: null;
 	const highlighted = useMemo(
 		() =>
 			finding.evidence
@@ -132,7 +136,11 @@ export function FindingCard({
 				</button>
 				<span class="sev-badge">{SEVERITY_LABELS[finding.severity]}</span>
 				{href ? (
-					<a class="loc" href={href} title={`Abrir ${location} no VS Code`}>
+					<a
+						class="loc"
+						href={href}
+						title={`Abrir ${location} no ${editorLabel(editor)}`}
+					>
 						<CodeIcon size={13} />
 						{location}
 						<ExternalLink size={12} class="ext" />

package/src/server/client/FindingsList.tsx

@@ -6,15 +6,17 @@ import { useMemo } from "preact/hooks";
 import { FindingCard } from "./FindingCard";
 import { Alert } from "./icons";
 import { SEVERITY_LABELS, SEVERITY_ORDER } from "./utils/constants";
-import type { Finding, Severity } from "./utils/types";
+import type { EditorContext, Finding, Severity } from "./utils/types";
 
 export function FindingsList({
 	slug,
 	findings,
+	editor,
 	onUpdated,
 }: {
 	slug: string;
 	findings: Finding[];
+	editor: EditorContext;
 	onUpdated: (finding: Finding) => void;
 }) {
 	const grouped = useMemo(() => {
@@ -45,6 +47,7 @@ export function FindingsList({
 								key={finding.id}
 								slug={slug}
 								finding={finding}
+								editor={editor}
 								onUpdated={onUpdated}
 							/>
 						))}