@payconductor/houndsman 0.4.0 → 0.6.0

package/src/core/file-classifier.ts

@@ -6,6 +6,7 @@
  */
 
 import { readFileSync } from "node:fs";
+import type { AstFacts } from "./ast/types";
 import type { HoundsmanConfig } from "./config";
 import { churnToRecord, collectChurn, type DiffSource } from "./diff-source";
 import { matchesClassifyRule } from "./domain/watchdog";
@@ -69,12 +70,13 @@ export function matchWatchdogs<TId extends string>(
 	watchdogs: Record<TId, WatchdogDefinition>,
 	watchdogIds: readonly TId[],
 	content?: string,
+	facts?: AstFacts,
 ): TId[] {
 	const ids: TId[] = [];
 	for (const id of watchdogIds) {
 		if (
 			watchdogs[id]?.classify?.some((rule) =>
-				matchesClassifyRule(filePath, rule, content),
+				matchesClassifyRule(filePath, rule, content, facts),
 			)
 		) {
 			ids.push(id);
@@ -88,6 +90,13 @@ export function isExcludedPath(filePath: string, patterns: readonly RegExp[]): b
 	return patterns.some((pattern) => pattern.test(filePath));
 }
 
+/** Id do watchdog de último recurso (primeiro declarado), se houver. */
+export function fallbackWatchdogId<TId extends string>(
+	config: HoundsmanConfig<TId>,
+): TId | undefined {
+	return config.watchdogIds.find((id) => config.watchdogs[id]?.fallback === true);
+}
+
 // ---------------------------------------------------------------------------
 // Parsing de `git diff --name-status`
 // ---------------------------------------------------------------------------
@@ -142,12 +151,15 @@ export function classifyEntries<TId extends string>(
 	entries: FileEntry[],
 	config: HoundsmanConfig<TId>,
 	churn: ChurnMap = {},
+	astFacts?: ReadonlyMap<string, AstFacts>,
 ): ClassificationResult {
 	const watchdogFiles: Record<string, string[]> = {};
 	const files: ClassificationResult["files"] = {};
 	const unclassified: string[] = [];
 	const excluded: string[] = [];
 	const deleted: string[] = [];
+	// Watchdog de último recurso: cobre apenas arquivos sem outro dono.
+	const fallbackId = fallbackWatchdogId(config);
 	// Leitura de conteúdo só é habilitada se algum watchdog declarar regra `content`.
 	const needsContent = hasContentRules(config.watchdogs, config.watchdogIds);
 
@@ -167,15 +179,23 @@ export function classifyEntries<TId extends string>(
 		}
 
 		const content = needsContent ? readFileContent(path) : undefined;
-		const ids: string[] = matchWatchdogs(
+		const facts = astFacts?.get(path);
+		const matched = matchWatchdogs(
 			path,
 			config.watchdogs,
 			config.watchdogIds,
 			content,
+			facts,
 		);
+		const ids = fallbackId ? matched.filter((id) => id !== fallbackId) : matched;
 
 		if (ids.length === 0) {
-			unclassified.push(path);
+			if (fallbackId) {
+				watchdogFiles[fallbackId] ??= [];
+				watchdogFiles[fallbackId].push(path);
+			} else {
+				unclassified.push(path);
+			}
 			continue;
 		}
 
@@ -218,10 +238,11 @@ export function classifyRange<TId extends string>(
 	head: string,
 	config: HoundsmanConfig<TId>,
 	diff?: DiffSource,
+	astFacts?: ReadonlyMap<string, AstFacts>,
 ): ClassificationResult {
 	const entries = parseEntries(runGit(["diff", `${base}...${head}`, "--name-status"]));
 	const churn = diff?.churn ?? collectChurn(base, head);
-	const result = classifyEntries(entries, config, churnToRecord(churn));
+	const result = classifyEntries(entries, config, churnToRecord(churn), astFacts);
 	result.base = base;
 	result.head = head;
 	return result;

package/src/core/findings-state.ts

@@ -76,6 +76,10 @@ export type GitHubLink = {
 	pr: number;
 	/** Quando foi enviado (ISO). */
 	at: string;
+	/** Node ID da thread de revisão (GraphQL) — base para resolver a conversa. */
+	threadId?: string;
+	/** Quando a thread foi marcada como resolvida no GitHub (ISO). */
+	resolvedAt?: string;
 };
 
 /** Marco da revisão que originou o estado: commit revisado + quando. */
@@ -283,6 +287,12 @@ export type BuildStateOptions = {
 	reviewed?: FindingsReviewed;
 	/** SHA usado para carimbar `foundAtSha` de findings novos/re-reportados. */
 	headSha?: string;
+	/**
+	 * Arquivos efetivamente revisados neste ciclo (união de `reviewedFiles`).
+	 * Quando presente, só findings ausentes desses arquivos viram `done` — o que
+	 * ficou fora do orçamento/skipped não pode ser dado como resolvido.
+	 */
+	reviewedPaths?: ReadonlySet<string>;
 	now?: string;
 };
 
@@ -303,14 +313,21 @@ export function buildStateFromFindings(
 
 	const result: Record<string, FindingState> = {};
 	// 1. Preserva o estado anterior (marca como ausente até provar o contrário).
+	const reviewedPaths = options.reviewedPaths;
 	for (const prev of Object.values(previous?.findings ?? {})) {
+		// Ausente do novo relatório ⇒ corrigido manualmente entre revisões (ou
+		// some junto com o trecho): vira `done`. `ignore` é decisão explícita de
+		// não corrigir — preserva o estado original. Arquivo fora da revisão
+		// (orçamento/skipped) também preserva: ausência não prova resolução.
+		const wasReviewed = !reviewedPaths || reviewedPaths.has(prev.file);
+		const resolvedByReview =
+			wasReviewed && prev.present && prev.decision !== "ignore";
+		const queuedAndGone =
+			wasReviewed && prev.decision === "execute" && prev.execState === "pending";
 		result[prev.id] = {
 			...prev,
 			present: false,
-			execState:
-				prev.execState === "pending" && prev.decision === "execute"
-					? "done"
-					: prev.execState,
+			execState: resolvedByReview || queuedAndGone ? "done" : prev.execState,
 			updatedAt: now,
 		};
 	}