@payconductor/houndsman 0.7.0 → 0.10.0

package/src/server/client/App.tsx

@@ -8,6 +8,7 @@ import { useCallback, useEffect, useMemo, useRef, useState } from "preact/hooks"
 import { ArtifactsPanel } from "./ArtifactsPanel";
 import { AutoRefresh } from "./AutoRefresh";
 import { CommentsPanel } from "./CommentsPanel";
+import { DeleteRunModal } from "./DeleteRunModal";
 import { Filters, type FiltersState } from "./Filters";
 import { FindingsList } from "./FindingsList";
 import { FileText, Layers, ListIcon, MessageSquare, Refresh, Send } from "./icons";
@@ -17,7 +18,13 @@ 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 { EditorContext, Finding, FindingsResponse, RunSummary } from "./utils/types";
+import type {
+	DeleteRunResponse,
+	EditorContext,
+	Finding,
+	FindingsResponse,
+	RunSummary,
+} from "./utils/types";
 
 type Tab = "resume" | "findings" | "artifacts" | "comments";
 
@@ -67,6 +74,7 @@ export function App() {
 	const [refreshing, setRefreshing] = useState(false);
 	const [syncing, setSyncing] = useState(false);
 	const [submitOpen, setSubmitOpen] = useState(false);
+	const [deleteOpen, setDeleteOpen] = 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. */
@@ -212,8 +220,28 @@ export function App() {
 
 	const summary = useMemo(() => computeSummary(data?.findings ?? []), [data]);
 
-	const branch =
-		data?.branch ?? runs.find((run) => run.slug === slug)?.branch ?? slug ?? "";
+	const selectedRun = runs.find((run) => run.slug === slug) ?? null;
+	const branch = data?.branch ?? selectedRun?.branch ?? slug ?? "";
+
+	/** Após excluir: limpa a seleção e escolhe a próxima run da lista. */
+	const afterDelete = useCallback((result: DeleteRunResponse) => {
+		setDeleteOpen(false);
+		setData(null);
+		setSlug(null);
+		if (result.warning) {
+			setError(
+				`Execução excluída, mas o worktree não foi removido: ${result.warning}`,
+			);
+		} else {
+			setError("");
+		}
+		api<{ runs: RunSummary[] }>("/api/runs")
+			.then(({ runs: list }) => {
+				setRuns(list);
+				setSlug(list[0]?.slug ?? null);
+			})
+			.catch((err) => setError(String(err)));
+	}, []);
 
 	return (
 		<div class="app">
@@ -231,11 +259,12 @@ export function App() {
 								type="button"
 								key={item.id}
 								title={item.hint}
+								aria-label={item.label}
 								class={`seg-btn${tab === item.id ? " active" : ""}`}
 								onClick={() => setTab(item.id)}
 							>
 								<TabIcon id={item.id} />
-								{item.label}
+								<span class="seg-label">{item.label}</span>
 							</button>
 						))}
 					</div>
@@ -290,7 +319,7 @@ export function App() {
 							branch={branch}
 							findings={data.findings}
 							summary={summary}
-							onOpenArtifacts={() => setTab("artifacts")}
+							onRequestDelete={() => setDeleteOpen(true)}
 						/>
 					)}
 					{slug && tab === "findings" && data && (
@@ -312,13 +341,23 @@ export function App() {
 					{!slug && !error && <p class="empty">Nenhuma execução para triar.</p>}
 				</div>
 				{slug && (
-					<SubmitModal
-						slug={slug}
-						branch={branch}
-						open={submitOpen}
-						onClose={() => setSubmitOpen(false)}
-						onSubmitted={afterSubmit}
-					/>
+					<>
+						<SubmitModal
+							slug={slug}
+							branch={branch}
+							open={submitOpen}
+							onClose={() => setSubmitOpen(false)}
+							onSubmitted={afterSubmit}
+						/>
+						<DeleteRunModal
+							slug={slug}
+							branch={branch}
+							worktreePath={selectedRun?.worktreePath}
+							open={deleteOpen}
+							onClose={() => setDeleteOpen(false)}
+							onDeleted={afterDelete}
+						/>
+					</>
 				)}
 			</main>
 		</div>

package/src/server/client/DeleteRunModal.tsx

@@ -0,0 +1,163 @@
+/**
+ * Modal "Excluir execução": confirma a remoção definitiva da run.
+ *
+ * Apaga a review, findings, histórico de triagem, artefatos e o staging local.
+ * Quando a run tem worktree, oferece removê-lo junto (alterações não commitadas
+ * nele são descartadas).
+ */
+
+import { useEffect, useState } from "preact/hooks";
+import { Spinner, Trash } from "./icons";
+import { api } from "./utils/api";
+import type { DeleteRunResponse } from "./utils/types";
+
+export function DeleteRunModal({
+	slug,
+	branch,
+	worktreePath,
+	open,
+	onClose,
+	onDeleted,
+}: {
+	slug: string;
+	branch: string;
+	worktreePath?: string;
+	open: boolean;
+	onClose: () => void;
+	onDeleted: (result: DeleteRunResponse) => void;
+}) {
+	const [removeWorktree, setRemoveWorktree] = useState(Boolean(worktreePath));
+	const [deleting, setDeleting] = useState(false);
+	const [error, setError] = useState("");
+
+	useEffect(() => {
+		if (!open) return;
+		setRemoveWorktree(Boolean(worktreePath));
+		setDeleting(false);
+		setError("");
+	}, [open, worktreePath]);
+
+	useEffect(() => {
+		if (!open) return;
+		const onKey = (event: KeyboardEvent) => {
+			if (event.key === "Escape" && !deleting) onClose();
+		};
+		document.addEventListener("keydown", onKey);
+		return () => document.removeEventListener("keydown", onKey);
+	}, [open, deleting, onClose]);
+
+	if (!open) return null;
+
+	const confirm = async () => {
+		setDeleting(true);
+		setError("");
+		try {
+			const suffix = removeWorktree && worktreePath ? "?worktree=1" : "";
+			const result = await api<DeleteRunResponse>(`/api/runs/${slug}${suffix}`, {
+				method: "DELETE",
+			});
+			if (!result.deleted) throw new Error("A execução não foi encontrada.");
+			onDeleted(result);
+		} catch (err) {
+			setError(err instanceof Error ? err.message : String(err));
+		} finally {
+			setDeleting(false);
+		}
+	};
+
+	return (
+		<div class="modal-layer">
+			<button
+				type="button"
+				class="modal-backdrop"
+				aria-label="Fechar"
+				title="Fechar"
+				onClick={() => {
+					if (!deleting) onClose();
+				}}
+			/>
+			<div
+				class="modal"
+				role="dialog"
+				aria-modal="true"
+				aria-label="Excluir execução"
+			>
+				<header class="modal-head">
+					<div>
+						<h2 class="modal-title">Excluir execução</h2>
+						<p class="modal-sub">
+							Esta ação é permanente e apaga a revisão de{" "}
+							<code>{branch}</code>.
+						</p>
+					</div>
+					<button
+						type="button"
+						class="modal-close"
+						title="Fechar"
+						disabled={deleting}
+						onClick={onClose}
+					>
+						×
+					</button>
+				</header>
+
+				<div class="modal-body">
+					<p class="modal-warn">
+						Serão removidos os findings, o histórico de triagem, todos os
+						artefatos (briefs, classificação, manifesto, relatório, verify) e
+						o staging local desta run. O envio já feito ao GitHub não é
+						desfeito.
+					</p>
+
+					{worktreePath && (
+						<label class="modal-check">
+							<input
+								type="checkbox"
+								checked={removeWorktree}
+								disabled={deleting}
+								onChange={(event) =>
+									setRemoveWorktree(event.currentTarget.checked)
+								}
+							/>
+							<span>
+								Excluir também o worktree desta execução. Alterações não
+								commitadas nele serão perdidas.
+								<br />
+								<code>{worktreePath}</code>
+							</span>
+						</label>
+					)}
+
+					{error && <p class="error">{error}</p>}
+				</div>
+
+				<footer class="modal-foot">
+					<span class="submit-label">Run: {branch}</span>
+					<div class="submit-actions">
+						<button
+							type="button"
+							class="btn"
+							disabled={deleting}
+							onClick={onClose}
+						>
+							Cancelar
+						</button>
+						<button
+							type="button"
+							class="btn danger"
+							disabled={deleting}
+							onClick={() => void confirm()}
+						>
+							{deleting ? (
+								<Spinner size={15} class="icon spin" />
+							) : (
+								<Trash size={15} />
+							)}
+							{deleting ? "Excluindo…" : "Excluir execução"}
+						</button>
+					</div>
+				</footer>
+			</div>
+		</div>
+	);
+}

package/src/server/client/PrsSection.tsx

@@ -0,0 +1,296 @@
+/**
+ * Seção `PRs` da sidebar: lista as PRs abertas via `gh`, abre a run local da
+ * branch, cria worktree dedicado e faz checkout quando a árvore está limpa.
+ *
+ * A seção fica montada mesmo quando outra está ativa — o fetch só ocorre na
+ * primeira ativação (`active`), preservando filtros e estados ao alternar.
+ */
+
+import { useCallback, useEffect, useRef, useState } from "preact/hooks";
+import { BranchIcon, Clock, GitHub, GitPullRequest, Refresh, Spinner } from "./icons";
+import type { SidebarSectionContext } from "./sidebar-sections";
+import { api } from "./utils/api";
+import { formatRunTime } from "./utils/format";
+import type {
+	CheckoutResponse,
+	PrListItem,
+	PrListResponse,
+	WorktreeState,
+} from "./utils/types";
+
+const REVIEW_LABELS: Record<string, string> = {
+	APPROVED: "aprovada",
+	CHANGES_REQUESTED: "mudanças",
+	REVIEW_REQUIRED: "revisão pendente",
+};
+
+function PrItem({
+	pr,
+	currentBranch,
+	worktree,
+	busy,
+	confirming,
+	onConfirm,
+	onCancel,
+	onCheckout,
+	onSelectRun,
+}: {
+	pr: PrListItem;
+	currentBranch: string | null;
+	worktree: WorktreeState;
+	busy: boolean;
+	confirming: boolean;
+	onConfirm: (number: number) => void;
+	onCancel: () => void;
+	onCheckout: (pr: PrListItem) => void;
+	onSelectRun: (slug: string) => void;
+}) {
+	const isCurrent = currentBranch === pr.headRefName;
+	const runSlug = pr.runSlug;
+	const review = pr.reviewDecision ? REVIEW_LABELS[pr.reviewDecision] : undefined;
+	// O título da PR às vezes repete o nome da branch; nesse caso só o
+	// indicador `head → base` fica visível.
+	const showTitle = pr.title.trim() !== pr.headRefName.trim();
+	return (
+		<article class={`pr${isCurrent ? " current" : ""}`}>
+			<div class="pr-head">
+				<GitPullRequest size={14} class="pr-icon" />
+				<span class="pr-number">#{pr.number}</span>
+				{pr.isDraft && <span class="tag">draft</span>}
+				{isCurrent && <span class="pr-current">atual</span>}
+				{pr.worktreePath && (
+					<span
+						class="pr-worktree-badge"
+						title={`Worktree: ${pr.worktreePath}`}
+					>
+						<BranchIcon size={10} />
+						worktree
+					</span>
+				)}
+				<span class="spacer" />
+				{pr.updatedAt && (
+					<span class="run-when">
+						<Clock size={12} />
+						{formatRunTime(pr.updatedAt)}
+					</span>
+				)}
+			</div>
+			{showTitle && <p class="pr-title">{pr.title}</p>}
+			<p class="pr-meta">
+				<span class="pr-branch">{pr.headRefName}</span>
+				<span class="pr-arrow">→</span>
+				<span>{pr.baseRefName || "—"}</span>
+				<span>· {pr.author}</span>
+			</p>
+			{review && <p class={`pr-review pr-review-${pr.reviewDecision}`}>{review}</p>}
+			<div class="pr-actions">
+				{runSlug && (
+					<button
+						type="button"
+						class="pr-btn"
+						title="Abrir a run local desta branch"
+						onClick={() => onSelectRun(runSlug)}
+					>
+						Abrir run
+					</button>
+				)}
+				{pr.url && (
+					<a
+						class="pr-btn"
+						href={pr.url}
+						target="_blank"
+						rel="noreferrer"
+						title="Abrir a PR no GitHub"
+					>
+						<GitHub size={12} /> GitHub
+					</a>
+				)}
+				{confirming ? (
+					<>
+						<button
+							type="button"
+							class="pr-btn danger"
+							disabled={busy}
+							title="Confirmar checkout da PR"
+							onClick={() => onCheckout(pr)}
+						>
+							{busy ? <Spinner size={12} class="icon spin" /> : "Confirmar"}
+						</button>
+						<button
+							type="button"
+							class="pr-btn"
+							disabled={busy}
+							onClick={onCancel}
+						>
+							Cancelar
+						</button>
+					</>
+				) : (
+					<button
+						type="button"
+						class="pr-btn"
+						disabled={!worktree.clean || busy}
+						title={
+							worktree.clean
+								? `Fazer checkout da branch ${pr.headRefName}`
+								: "Há alterações não commitadas — faça commit ou stash antes"
+						}
+						onClick={() => onConfirm(pr.number)}
+					>
+						Checkout
+					</button>
+				)}
+			</div>
+		</article>
+	);
+}
+
+export function PrsSection({ active, onSelect, onRefreshRuns }: SidebarSectionContext) {
+	const [data, setData] = useState<PrListResponse | null>(null);
+	const [loading, setLoading] = useState(false);
+	const [error, setError] = useState("");
+	const [notice, setNotice] = useState("");
+	const [busy, setBusy] = useState<number | null>(null);
+	const [confirming, setConfirming] = useState<number | null>(null);
+	const requested = useRef(false);
+
+	const loadPrs = useCallback(async () => {
+		setLoading(true);
+		setError("");
+		try {
+			setData(await api<PrListResponse>("/api/prs"));
+		} catch (err) {
+			setError(String(err));
+		} finally {
+			setLoading(false);
+		}
+	}, []);
+
+	useEffect(() => {
+		if (!active || requested.current) return;
+		requested.current = true;
+		void loadPrs();
+	}, [active, loadPrs]);
+
+	const checkout = useCallback(
+		async (pr: PrListItem) => {
+			setBusy(pr.number);
+			setError("");
+			setNotice("");
+			try {
+				const result = await api<CheckoutResponse>("/api/prs/checkout", {
+					method: "POST",
+					headers: { "content-type": "application/json" },
+					body: JSON.stringify({ number: pr.number }),
+				});
+				if (!result.ok) {
+					if (result.reason === "dirty") {
+						setData((current) =>
+							current
+								? {
+										...current,
+										worktree: {
+											...current.worktree,
+											clean: false,
+											changes:
+												result.changes?.length ??
+												current.worktree.changes,
+											sample:
+												result.changes ?? current.worktree.sample,
+										},
+									}
+								: current,
+						);
+					}
+					setError(
+						result.reason === "dirty"
+							? `Checkout bloqueado: ${result.detail}`
+							: result.detail,
+					);
+					return;
+				}
+				setConfirming(null);
+				setNotice(
+					`Checkout de #${pr.number} concluído${
+						result.branch ? ` — ${result.branch}` : ""
+					}.`,
+				);
+				await loadPrs();
+				onRefreshRuns();
+				if (pr.runSlug) onSelect(pr.runSlug);
+			} catch (err) {
+				setError(String(err));
+			} finally {
+				setBusy(null);
+			}
+		},
+		[loadPrs, onRefreshRuns, onSelect],
+	);
+
+	const openCount = data?.available ? data.prs.length : null;
+
+	return (
+		<>
+			<div class="pr-toolbar">
+				<p class="section-label">
+					{openCount === null
+						? "PRs abertas"
+						: `${openCount} ${openCount === 1 ? "aberta" : "abertas"}`}
+				</p>
+				<button
+					type="button"
+					class="icon-btn"
+					title="Atualizar lista de PRs"
+					disabled={loading}
+					onClick={() => void loadPrs()}
+				>
+					<Refresh size={13} class={loading ? "icon spin" : undefined} />
+				</button>
+			</div>
+
+			{error && <p class="error">{error}</p>}
+			{notice && <p class="pr-notice">{notice}</p>}
+			{data && !data.available && (
+				<p class="empty">
+					GitHub indisponível
+					{data.reason ? `: ${data.reason}` : "."}
+				</p>
+			)}
+			{data && !data.worktree.available && (
+				<p class="empty">Não foi possível ler o estado do git.</p>
+			)}
+			{data?.worktree.available && !data.worktree.clean && (
+				<p class="pr-warning">
+					{data.worktree.changes} alteração(ões) não commitada(s) — checkout
+					bloqueado até limpar a árvore.
+				</p>
+			)}
+			{data?.currentBranch && (
+				<p class="pr-current-branch">
+					Branch atual: <code>{data.currentBranch}</code>
+				</p>
+			)}
+
+			<nav class="prs" aria-label="Pull requests abertas">
+				{loading && !data && <p class="empty">Carregando PRs…</p>}
+				{data?.available && data.prs.length === 0 && (
+					<p class="empty">Nenhuma PR aberta.</p>
+				)}
+				{data?.prs.map((pr) => (
+					<PrItem
+						key={pr.number}
+						pr={pr}
+						currentBranch={data.currentBranch}
+						worktree={data.worktree}
+						busy={busy !== null}
+						confirming={confirming === pr.number}
+						onConfirm={setConfirming}
+						onCancel={() => setConfirming(null)}
+						onCheckout={checkout}
+						onSelectRun={onSelect}
+					/>
+				))}
+			</nav>
+		</>
+	);
+}

package/src/server/client/ResumePanel.tsx

@@ -1,21 +1,19 @@
 /**
  * Aba "Resumo" (inicial): visão principal da revisão.
  *
- * O texto narrativo vem do artefato `review-resume.md` (Resumo de negócio); os
- * números viram cards a partir do `classification.json`/`manifest.json` e o
- * card de domínios resume os achados por severidade em cada watchdog — assim a
- * UI mostra os mesmos dados do resumo de forma mais organizada, sem duplicar o
- * texto.
+ * O texto narrativo vem do artefato `review-resume.md` e é exibido por inteiro
+ * (resumo de negócio + pontos técnicos); os números viram cards a partir do
+ * `classification.json`/`manifest.json` e o card de domínios resume os achados
+ * por severidade em cada watchdog.
  */
 
 import type { ComponentChildren } from "preact";
 import { useEffect, useMemo, useState } from "preact/hooks";
-import { ExternalLink, Layers } from "./icons";
-import { MarkdownBlocks } from "./MarkdownText";
+import { ExternalLink, Trash } from "./icons";
+import { MarkdownText } from "./MarkdownText";
 import { api } from "./utils/api";
 import { SEVERITY_LABELS, SEVERITY_ORDER } from "./utils/constants";
 import { formatRunTime } from "./utils/format";
-import { sectionBlocks } from "./utils/markdown";
 import type {
 	ClassificationArtifact,
 	Finding,
@@ -79,13 +77,13 @@ export function ResumePanel({
 	branch,
 	findings,
 	summary,
-	onOpenArtifacts,
+	onRequestDelete,
 }: {
 	slug: string;
 	branch: string;
 	findings: Finding[];
 	summary: Summary;
-	onOpenArtifacts: () => void;
+	onRequestDelete: () => void;
 }) {
 	const [resume, setResume] = useState("");
 	const [detail, setDetail] = useState<RunDetail | null>(null);
@@ -126,7 +124,6 @@ export function ResumePanel({
 	}, [slug]);
 
 	const manifest: RunManifest | null = detail?.manifest ?? null;
-	const business = useMemo(() => sectionBlocks(resume, "Resumo de negócio"), [resume]);
 	const status =
 		summary.bySeverity.blocking > 0
 			? STATUS_VIEW.blocking
@@ -241,12 +238,12 @@ export function ResumePanel({
 					<span class={`resume-status ${status.tone}`}>{status.label}</span>
 					<button
 						type="button"
-						class="btn"
-						title="Ver os artefatos brutos da revisão"
-						onClick={onOpenArtifacts}
+						class="btn danger"
+						title="Excluir esta execução, seus findings e artefatos locais"
+						onClick={onRequestDelete}
 					>
-						<Layers size={14} />
-						Ver artefatos
+						<Trash size={14} />
+						Excluir
 					</button>
 				</div>
 			</section>
@@ -295,16 +292,16 @@ export function ResumePanel({
 
 			<div class="resume-grid">
 				<section class="resume-card">
-					<h3 class="resume-card-title">Resumo de negócio</h3>
+					<h3 class="resume-card-title">Resumo da revisão</h3>
 					{loading ? (
 						<p class="empty">Carregando resumo…</p>
-					) : business.length > 0 ? (
+					) : resume.trim().length > 0 ? (
 						<div class="resume-narrative">
-							<MarkdownBlocks blocks={business} />
+							<MarkdownText text={resume} />
 						</div>
 					) : (
 						<p class="empty">
-							O resumo narrativo ainda não foi gerado para esta run. Rode o{" "}
+							O resumo ainda não foi gerado para esta run. Rode o{" "}
 							<code>--finalize</code> para criar{" "}
 							<code>review-resume.md</code>.
 						</p>