@payconductor/houndsman 0.4.0 → 0.5.0

package/src/server/client/SubmitModal.tsx

@@ -9,16 +9,16 @@
  */
 
 import { useCallback, useEffect, useMemo, useState } from "preact/hooks";
-import { api } from "./api";
-import { EXEC_STATES, SEVERITY_LABELS, SEVERITY_ORDER } from "./constants";
-import { ExternalLink, Send, Spinner } from "./icons";
+import { GitHub, Send, Spinner } from "./icons";
+import { api } from "./utils/api";
+import { EXEC_STATES, SEVERITY_LABELS, SEVERITY_ORDER } from "./utils/constants";
 import type {
 	ExecState,
 	Severity,
 	SubmitOutcome,
 	SubmitPreview,
 	SubmitResponse,
-} from "./types";
+} from "./utils/types";
 
 const EXEC_LABELS: Record<ExecState, string> = {
 	pending: "Pendente",
@@ -333,6 +333,27 @@ export function SubmitModal({
 															arquivo
 														</span>
 													)}
+													{candidate.sent &&
+														(candidate.sentUrl ? (
+															<a
+																class="sent-tag gh"
+																href={candidate.sentUrl}
+																target="_blank"
+																rel="noreferrer"
+																title="Já enviado ao GitHub — abrir comentário"
+															>
+																<GitHub size={12} />
+																enviado
+															</a>
+														) : (
+															<span
+																class="sent-tag gh"
+																title="Já enviado ao GitHub"
+															>
+																<GitHub size={12} />
+																enviado
+															</span>
+														))}
 												</div>
 											))}
 										</div>
@@ -389,22 +410,44 @@ export function SubmitModal({
 /** Resumo do resultado do envio. */
 function ResultView({ outcome }: { outcome: SubmitOutcome }) {
 	const generalUrl = outcome.general?.url;
+	const review = outcome.review;
+	const reviewUrl = review?.url;
 	return (
 		<>
 			<div class="submit-summary">
 				Enviados <b>{outcome.posted.length}</b> · falhas{" "}
 				<b>{outcome.failed.length}</b> · pulados <b>{outcome.skipped.length}</b>.
 			</div>
+			{review && (
+				<p class="submit-empty">
+					{review.created
+						? review.finalized
+							? `Revisão #${review.id} finalizada (${review.event}).`
+							: `Revisão #${review.id} criada, mas não finalizada.`
+						: `Comentários adicionados à revisão pendente #${review.id}.`}{" "}
+					{reviewUrl && (
+						<a
+							class="sent-tag gh"
+							href={reviewUrl}
+							target="_blank"
+							rel="noreferrer"
+						>
+							<GitHub size={12} /> abrir
+						</a>
+					)}
+					{review.error && <> ❌ {review.error}</>}
+				</p>
+			)}
 			{generalUrl && (
 				<p class="submit-empty">
 					Comentário geral:{" "}
 					<a
-						class="sent-tag"
+						class="sent-tag gh"
 						href={generalUrl}
 						target="_blank"
 						rel="noreferrer"
 					>
-						<ExternalLink size={12} /> abrir
+						<GitHub size={12} /> abrir
 					</a>
 				</p>
 			)}

package/src/server/client/SummaryBar.tsx

@@ -3,7 +3,7 @@
  * progresso da correção (feitos ÷ total).
  */
 
-import type { Summary } from "./types";
+import type { Summary } from "./utils/types";
 
 function Kpi({
 	label,

package/src/server/client/icons.tsx

@@ -51,6 +51,14 @@ export const ExternalLink = (p: IconProps) => (
 	</Svg>
 );
 
+/** Marca do GitHub (contorno) — usada em achados já publicados na PR. */
+export const GitHub = (p: IconProps) => (
+	<Svg {...p}>
+		<path d="M9 19c-4.3 1.3-4.3-2.2-6-2.7" />
+		<path d="M15 22v-3.9a3.4 3.4 0 0 0-.9-2.6c3-.3 6.1-1.5 6.1-6.8a5.3 5.3 0 0 0-1.4-3.7 4.9 4.9 0 0 0-.1-3.6s-1.1-.4-3.7 1.4a12.7 12.7 0 0 0-6.8 0C5.6 1 4.5 1.4 4.5 1.4a4.9 4.9 0 0 0-.1 3.6A5.3 5.3 0 0 0 3 8.7c0 5.2 3.1 6.4 6.1 6.8a3.4 3.4 0 0 0-.9 2.6V22" />
+	</Svg>
+);
+
 export const Sparkles = (p: IconProps) => (
 	<Svg {...p}>
 		<path d="M11 3.5l1.7 4.3 4.3 1.7-4.3 1.7L11 15.5 9.3 11.2 5 9.5l4.3-1.7z" />
@@ -126,6 +134,15 @@ export const Layers = (p: IconProps) => (
 	</Svg>
 );
 
+/** Documento com linhas — aba de resumo. */
+export const FileText = (p: IconProps) => (
+	<Svg {...p}>
+		<path d="M14 3H7a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h10a2 2 0 0 0 2-2V8z" />
+		<path d="M14 3v5h5" />
+		<path d="M9 13h6M9 17h4" />
+	</Svg>
+);
+
 /** Olho — "quem auditou o trecho" (watchdogs envolvidos). */
 export const Watch = (p: IconProps) => (
 	<Svg {...p}>

package/src/server/client/{constants.ts → utils/constants.ts}

@@ -39,15 +39,22 @@ export const RUN_STATUS_LABELS: Record<RunStatus, string> = {
 	fix_done: "Correção pronta",
 };
 
-/** Limiar de inatividade para exibir timeout (display-only; não é status). */
+/** Limiar de inatividade da correção para exibir timeout (display-only). */
 export const STATUS_TIMEOUT_MS = 10 * 60 * 1000;
 
+/** Revisão despacha subagentes em ondas longas — janela maior que a correção. */
+export const REVIEW_TIMEOUT_MS = 30 * 60 * 1000;
+
 /** Intervalo do polling da UI (o badge conta o tempo desde a última sync). */
 export const AUTO_REFRESH_MS = 10_000;
 
 export type RunStatusView = { kind: string; label: string; timeout: boolean };
 
-/** View do status de uma run — label; vira timeout quando ativo e sem ping recente. */
+/**
+ * View do status de uma run — timeout só existe quando há um heartbeat de
+ * execução (`reviewing`/`fixing`). `updatedAt` muda com triagem/sync e não
+ * serve para provar que a skill está rodando.
+ */
 export function describeRunStatus(
 	run: RunSummary,
 	now: number = Date.now(),
@@ -55,8 +62,16 @@ export function describeRunStatus(
 	const status = run.status;
 	if (!status) return null;
 	const active = status === "reviewing" || status === "fixing";
-	const updated = run.updatedAt ? Date.parse(run.updatedAt) : Number.NaN;
-	if (active && Number.isFinite(updated) && now - updated > STATUS_TIMEOUT_MS) {
+	if (!active) {
+		return { kind: status, label: RUN_STATUS_LABELS[status], timeout: false };
+	}
+
+	// Sem heartbeat não há execução conhecida: evita o falso "timeout".
+	const heartbeat = run.heartbeatAt ? Date.parse(run.heartbeatAt) : Number.NaN;
+	if (!Number.isFinite(heartbeat)) return null;
+
+	const timeoutMs = status === "reviewing" ? REVIEW_TIMEOUT_MS : STATUS_TIMEOUT_MS;
+	if (now - heartbeat > timeoutMs) {
 		return {
 			kind: "timeout",
 			label: status === "reviewing" ? "Timeout na revisão" : "Timeout na correção",
@@ -69,6 +84,7 @@ export function describeRunStatus(
 /** Ordem canônica dos tipos de artefato na lista da UI. */
 const KIND_ORDER: ArtifactKind[] = [
 	"review",
+	"resume",
 	"domain-review",
 	"verify",
 	"brief",
@@ -86,6 +102,7 @@ const KIND_ORDER: ArtifactKind[] = [
 const GROUP_BY_KIND: Record<ArtifactKind, { key: string; label: string; order: number }> =
 	{
 		review: { key: "report", label: "Relatórios", order: 0 },
+		resume: { key: "report", label: "Relatórios", order: 0 },
 		"domain-review": { key: "report", label: "Relatórios", order: 0 },
 		verify: { key: "verify", label: "Verificação", order: 1 },
 		brief: { key: "brief", label: "Briefs (auditoria)", order: 2 },
@@ -102,6 +119,7 @@ const GROUP_BY_KIND: Record<ArtifactKind, { key: string; label: string; order: n
 /** Rótulo curto do tipo (badge do item). */
 export const ARTIFACT_KIND_LABELS: Record<ArtifactKind, string> = {
 	review: "relatório",
+	resume: "resumo",
 	"domain-review": "domínio",
 	verify: "verify",
 	brief: "brief",
@@ -127,6 +145,8 @@ export function describeArtifact(meta: ArtifactMeta): string {
 	switch (meta.kind) {
 		case "review":
 			return "Relatório consolidado da revisão — o entregável.";
+		case "resume":
+			return "Resumo final da revisão: visão de negócio e pontos técnicos diretos (leitura humana).";
 		case "domain-review":
 			return "Relatório isolado do domínio: achados daquele watchdog.";
 		case "verify":
@@ -156,6 +176,14 @@ export function isJsonArtifact(meta: ArtifactMeta | undefined): boolean {
 	return meta.contentType.includes("json") || meta.name.toLowerCase().endsWith(".json");
 }
 
+/** `true` se o conteúdo deve ser renderizado como markdown. */
+export function isMarkdownArtifact(meta: ArtifactMeta | undefined): boolean {
+	if (!meta) return false;
+	return (
+		meta.contentType.includes("markdown") || meta.name.toLowerCase().endsWith(".md")
+	);
+}
+
 /** Agrupa os artefatos para a navegação lateral (ordem estável). */
 export function groupArtifacts(
 	items: ArtifactMeta[],
@@ -190,8 +218,9 @@ export function groupArtifacts(
 
 /** Legenda única de cada aba (explica o que a aba é; mostrada quando selecionada). */
 export const TAB_CAPTIONS = {
+	resume: "Resumo principal da revisão: o que muda em termos de negócio, números diretos (arquivos, churn, domínios) e os pontos técnicos que exigem ação.",
 	findings:
 		"Triagem dos achados da revisão: decida Executar, Ignorar ou deixe Pendente — o comentário orienta o auto-fix. Agente: houndsman findings list --decision pending --json · findings done <id>.",
 	artifacts:
-		"Artefatos persistidos da run: relatórios, briefs de auditoria, manifesto, classificação, Jev, contexto da PR e verificação. JSON com destaque de sintaxe.",
+		"Artefatos persistidos da run: relatórios, briefs de auditoria, manifesto, classificação, Jev, contexto da PR e verificação. JSON com destaque de sintaxe; markdown renderizado com highlight de código.",
 } as const;

package/src/server/client/utils/markdown.ts

@@ -0,0 +1,319 @@
+/**
+ * Markdown mínimo do cliente (campo `action` do finding e artefatos).
+ *
+ * Suporta o suficiente para instruções curtas e relatórios: parágrafos,
+ * quebras de linha, listas, blockquote, títulos, tabelas, blocos de código e
+ * formatação inline (`code`, **bold**, *itálico*, links). Sem lib externa e
+ * sem HTML cru.
+ */
+
+/** Alinhamento de coluna em tabela markdown. */
+export type MarkdownAlign = "left" | "center" | "right";
+
+export type MarkdownBlock =
+	| { type: "paragraph"; text: string }
+	| { type: "list"; ordered: boolean; items: string[] }
+	| { type: "code"; language: string | null; code: string }
+	| { type: "quote"; text: string }
+	| { type: "heading"; level: number; text: string }
+	| {
+			type: "table";
+			align: (MarkdownAlign | undefined)[];
+			header: string[];
+			rows: string[][];
+	  }
+	| { type: "hr" };
+
+export type InlineToken =
+	| { type: "text"; text: string }
+	| { type: "code"; text: string }
+	| { type: "strong"; text: string }
+	| { type: "em"; text: string }
+	| { type: "link"; text: string; url: string }
+	| { type: "path"; text: string };
+
+const FENCE = /^\s*```(\S*)\s*$/;
+const BULLET = /^\s*[-*+]\s+(.*)$/;
+const ORDERED = /^\s*\d+\.\s+(.*)$/;
+const QUOTE = /^\s*>\s?(.*)$/;
+const HEADING = /^(#{1,6})\s+(.*)$/;
+const HR = /^\s*(?:-{3,}|\*{3,}|_{3,})\s*$/;
+const TABLE_SEP = /^\s*\|?\s*:?-{2,}:?\s*(?:\|\s*:?-{2,}:?\s*)+\|?\s*$/;
+
+function isBlockStart(line: string): boolean {
+	return (
+		FENCE.test(line) ||
+		HEADING.test(line) ||
+		HR.test(line) ||
+		BULLET.test(line) ||
+		ORDERED.test(line) ||
+		QUOTE.test(line)
+	);
+}
+
+/** Quebra uma linha de tabela em células (remove os pipes das pontas). */
+function splitTableRow(line: string): string[] {
+	return line
+		.trim()
+		.replace(/^\|/, "")
+		.replace(/\|$/, "")
+		.split("|")
+		.map((cell) => cell.trim());
+}
+
+/** `true` quando há um cabeçalho seguido da linha separadora de tabela. */
+function isTableStart(lines: string[], index: number): boolean {
+	if (index + 1 >= lines.length) return false;
+	if (!lines[index].includes("|")) return false;
+	return TABLE_SEP.test(lines[index + 1]);
+}
+
+/** Alinhamentos declarados na linha separadora (`:---`, `:---:`, `---:`). */
+function parseAlignments(line: string): (MarkdownAlign | undefined)[] {
+	return splitTableRow(line).map((cell) => {
+		const left = cell.startsWith(":");
+		const right = cell.endsWith(":");
+		if (left && right) return "center";
+		if (right) return "right";
+		if (left) return "left";
+		return undefined;
+	});
+}
+
+/** Célula numérica ou razão (`12`, `3/4`) — colunas assim vão para a direita. */
+const NUMERIC_CELL = /^[\d\s/]+$/;
+
+/** Resolve o alinhamento: explícito > coluna só de números/barra > padrão. */
+function resolveAlignments(
+	align: (MarkdownAlign | undefined)[],
+	rows: string[][],
+): (MarkdownAlign | undefined)[] {
+	return align.map((value, column) => {
+		if (value) return value;
+		let filled = 0;
+		for (const row of rows) {
+			const cell = (row[column] ?? "").trim();
+			if (cell.length === 0) continue;
+			if (!NUMERIC_CELL.test(cell) || !/\d/.test(cell)) return undefined;
+			filled++;
+		}
+		return filled > 0 ? "right" : undefined;
+	});
+}
+
+/** Divide o texto em blocos simples (sem aninhamento profundo). */
+export function parseMarkdown(text: string): MarkdownBlock[] {
+	const lines = text.replace(/\r\n?/g, "\n").split("\n");
+	const blocks: MarkdownBlock[] = [];
+	let index = 0;
+
+	while (index < lines.length) {
+		const line = lines[index];
+		if (line.trim().length === 0) {
+			index++;
+			continue;
+		}
+
+		const fence = FENCE.exec(line);
+		if (fence) {
+			const language = fence[1] || null;
+			const code: string[] = [];
+			index++;
+			while (index < lines.length && !FENCE.test(lines[index])) {
+				code.push(lines[index]);
+				index++;
+			}
+			if (index < lines.length) index++;
+			blocks.push({ type: "code", language, code: code.join("\n") });
+			continue;
+		}
+
+		const heading = HEADING.exec(line);
+		if (heading) {
+			blocks.push({
+				type: "heading",
+				level: heading[1].length,
+				text: heading[2].trim(),
+			});
+			index++;
+			continue;
+		}
+
+		if (HR.test(line)) {
+			blocks.push({ type: "hr" });
+			index++;
+			continue;
+		}
+
+		if (isTableStart(lines, index)) {
+			const header = splitTableRow(line);
+			const align = parseAlignments(lines[index + 1]);
+			const rows: string[][] = [];
+			index += 2;
+			while (
+				index < lines.length &&
+				lines[index].trim().length > 0 &&
+				lines[index].includes("|")
+			) {
+				rows.push(splitTableRow(lines[index]));
+				index++;
+			}
+			blocks.push({
+				type: "table",
+				align: resolveAlignments(align, rows),
+				header,
+				rows,
+			});
+			continue;
+		}
+
+		if (BULLET.test(line)) {
+			const items: string[] = [];
+			while (index < lines.length) {
+				const item = BULLET.exec(lines[index]);
+				if (!item) break;
+				items.push(item[1]);
+				index++;
+			}
+			blocks.push({ type: "list", ordered: false, items });
+			continue;
+		}
+
+		if (ORDERED.test(line)) {
+			const items: string[] = [];
+			while (index < lines.length) {
+				const item = ORDERED.exec(lines[index]);
+				if (!item) break;
+				items.push(item[1]);
+				index++;
+			}
+			blocks.push({ type: "list", ordered: true, items });
+			continue;
+		}
+
+		if (QUOTE.test(line)) {
+			const quote: string[] = [];
+			while (index < lines.length) {
+				const item = QUOTE.exec(lines[index]);
+				if (!item) break;
+				quote.push(item[1]);
+				index++;
+			}
+			blocks.push({ type: "quote", text: quote.join("\n") });
+			continue;
+		}
+
+		const paragraph: string[] = [line];
+		index++;
+		while (
+			index < lines.length &&
+			lines[index].trim().length > 0 &&
+			!isBlockStart(lines[index]) &&
+			!isTableStart(lines, index)
+		) {
+			paragraph.push(lines[index]);
+			index++;
+		}
+		blocks.push({ type: "paragraph", text: paragraph.join("\n") });
+	}
+
+	return blocks;
+}
+
+/** Blocos de uma seção `## <título>` (sem o heading); vazio se ausente. */
+export function sectionBlocks(text: string, title: string): MarkdownBlock[] {
+	const wanted = title.trim().toLowerCase();
+	const blocks: MarkdownBlock[] = [];
+	let inside = false;
+	for (const block of parseMarkdown(text)) {
+		if (block.type === "heading") {
+			if (inside) break;
+			inside = block.level >= 2 && block.text.trim().toLowerCase() === wanted;
+			continue;
+		}
+		if (inside) blocks.push(block);
+	}
+	return blocks;
+}
+
+/** Extensão reconhecida como arquivo (evita destacar texto comum). */
+const FILE_EXTENSION =
+	/\.(?:[cm]?[jt]sx?|json|md|ya?ml|toml|css|scss|html?|py|go|rs|java|kt|cs|php|rb|sh|sql|txt|lock)$/i;
+
+/** Caminho/arquivo dentro de um texto corrido (`src/foo.ts`, `review.md`). */
+const PATH_TOKEN =
+	/(?:[\w.-]+[\\/])*[\w-]+\.(?:[cm]?[jt]sx?|json|md|ya?ml|toml|css|scss|html?|py|go|rs|java|kt|cs|php|rb|sh|sql|txt|lock)\b/g;
+
+/** `true` se o texto parece um caminho/arquivo (sem espaços e com extensão). */
+export function isFilePath(value: string): boolean {
+	const text = value.trim();
+	if (!text || /\s/.test(text)) return false;
+	if (/^(?:https?:|mailto:|#)/i.test(text)) return false;
+	const base = text.split(/[\\/]/).pop() ?? text;
+	if (FILE_EXTENSION.test(base)) return true;
+	return (
+		text.startsWith("./") ||
+		text.startsWith("../") ||
+		text.startsWith("/") ||
+		/^[A-Za-z]:[\\/]/.test(text)
+	);
+}
+
+/** Quebra texto corrido em tokens, destacando caminhos de arquivo. */
+function pushTextTokens(tokens: InlineToken[], text: string): void {
+	let last = 0;
+	for (const match of text.matchAll(PATH_TOKEN)) {
+		const index = match.index ?? 0;
+		if (index > last) {
+			tokens.push({ type: "text", text: text.slice(last, index) });
+		}
+		tokens.push({ type: "path", text: match[0] });
+		last = index + match[0].length;
+	}
+	if (last < text.length) {
+		tokens.push({ type: "text", text: text.slice(last) });
+	}
+}
+
+/** Tokeniza formatação inline preservando o texto e a ordem dos marcadores. */
+export function parseInline(text: string): InlineToken[] {
+	const tokens: InlineToken[] = [];
+	// Ordem importa: code/bold antes de itálico; `_` exige fronteira de palavra.
+	const pattern =
+		/`[^`\n]+`|\*\*[^*\n]+\*\*|__[^_\n]+__|\*[^*\n]+\*|(?<![\w])_[^_\n]+_(?![\w])|\[[^\]\n]+\]\([^)\s]+\)/g;
+	let last = 0;
+	for (const match of text.matchAll(pattern)) {
+		const start = match.index ?? 0;
+		if (start > last) {
+			pushTextTokens(tokens, text.slice(last, start));
+		}
+		const raw = match[0];
+		if (raw.startsWith("`")) {
+			tokens.push({ type: "code", text: raw.slice(1, -1) });
+		} else if (raw.startsWith("**") || raw.startsWith("__")) {
+			tokens.push({ type: "strong", text: raw.slice(2, -2) });
+		} else if (raw.startsWith("*") || raw.startsWith("_")) {
+			tokens.push({ type: "em", text: raw.slice(1, -1) });
+		} else {
+			const link = /^\[([^\]]+)\]\(([^)\s]+)\)$/.exec(raw);
+			if (link) {
+				tokens.push({ type: "link", text: link[1], url: link[2] });
+			} else {
+				pushTextTokens(tokens, raw);
+			}
+		}
+		last = start + raw.length;
+	}
+	if (last < text.length) {
+		pushTextTokens(tokens, text.slice(last));
+	}
+	return tokens;
+}
+
+/** URL segura para links de markdown (evita `javascript:` e afins). */
+export function safeUrl(url: string): string | null {
+	const value = url.trim();
+	if (/^(https?:|mailto:)/i.test(value)) return value;
+	if (value.startsWith("/") && !value.startsWith("//")) return value;
+	return null;
+}

package/src/server/client/{types.ts → utils/types.ts}

@@ -61,6 +61,7 @@ export type ArtifactKind =
 	| "context-summary"
 	| "finding-report"
 	| "review"
+	| "resume"
 	| "domain-review"
 	| "verify"
 	| "other";
@@ -77,6 +78,9 @@ export type RunSummary = {
 	slug: string;
 	branch: string;
 	updatedAt?: string;
+	startedAt?: string;
+	/** Último sinal de vida de uma execução ativa (revisão/correção). */
+	heartbeatAt?: string;
 	status?: RunStatus | null;
 	summary: Summary;
 };
@@ -87,6 +91,52 @@ export type FindingsResponse = {
 	summary: Summary;
 };
 
+/** Manifesto da run (subset consumido pela aba de resumo). */
+export type RunManifest = {
+	branch?: string;
+	base?: string;
+	head?: string;
+	generatedAt?: string;
+	churn?: { additions: number; deletions: number };
+	watchdogs?: {
+		id: string;
+		name: string;
+		files: string[];
+		overflow: number;
+		status: "pending" | "done";
+	}[];
+	context?: {
+		summarized: boolean;
+		source?: {
+			number?: number;
+			title?: string;
+			url?: string;
+			base?: string;
+			head?: string;
+		} | null;
+	};
+	excludedCount?: number;
+	deleted?: string[];
+	unclassified?: string[];
+};
+
+/** Detalhe da run (`GET /api/runs/:slug`). */
+export type RunDetail = {
+	slug: string;
+	branch: string;
+	manifest: RunManifest | null;
+	watchdogs: string[];
+	unclassified: string[];
+	deleted: string[];
+};
+
+/** `classification.json` — só o necessário para os cards do resumo. */
+export type ClassificationArtifact = {
+	files?: Record<string, { status: string; oldPath?: string }>;
+	churn?: Record<string, { additions: number; deletions: number }>;
+	watchdogs?: Record<string, string[]>;
+};
+
 /** Candidato ao envio da revisão (espelha `core/github-review.ts`). */
 export type SubmitCandidate = {
 	id: string;
@@ -134,6 +184,14 @@ export type SubmitOutcome = {
 	failed: { id: string; reason: string }[];
 	skipped: { id: string; reason: string }[];
 	general?: { commentId: number; url?: string; ids: string[] };
+	review?: {
+		id?: number;
+		url?: string;
+		created: boolean;
+		finalized: boolean;
+		event?: "COMMENT" | "REQUEST_CHANGES";
+		error?: string;
+	};
 };
 
 export type SubmitResponse = {