@payconductor/houndsman 0.1.0 → 0.1.1

package/src/core/file-classifier.ts

@@ -7,7 +7,8 @@
 
 import { readFileSync } from "node:fs";
 import type { HoundsmanConfig } from "./config";
-import type { ClassifyRule, WatchdogDefinition } from "./types";
+import { churnToRecord, collectChurn, type DiffSource } from "./diff-source";
+import type { ChurnMap, ClassifyRule, WatchdogDefinition } from "./types";
 
 type FileStatus = "added" | "modified" | "deleted" | "renamed" | "copied" | "unknown";
 
@@ -22,6 +23,8 @@ export type ClassificationResult = {
 	watchdogs: Record<string, string[]>;
 	/** path → metadados (status, oldPath) */
 	files: Record<string, { status: FileStatus; oldPath?: string }>;
+	/** path → linhas adicionadas/removidas (churn do diff) */
+	churn: ChurnMap;
 	/** Arquivos não classificados (revisar manualmente) */
 	unclassified: string[];
 	/** Arquivos excluídos da revisão (gerados, locks, builds) */
@@ -167,6 +170,7 @@ export function parseEntries(raw: string): FileEntry[] {
 export function classifyEntries<TId extends string>(
 	entries: FileEntry[],
 	config: HoundsmanConfig<TId>,
+	churn: ChurnMap = {},
 ): ClassificationResult {
 	const watchdogFiles: Record<string, string[]> = {};
 	const files: ClassificationResult["files"] = {};
@@ -223,6 +227,7 @@ export function classifyEntries<TId extends string>(
 	return {
 		watchdogs,
 		files,
+		churn,
 		unclassified,
 		excluded,
 		deleted,
@@ -233,15 +238,58 @@ export function classifyEntries<TId extends string>(
 
 /**
  * Executa `git diff` entre base e head e classifica os arquivos alterados.
+ *
+ * `diff` (opcional) reaproveita um `DiffSource` já coletado — evita rodar o git
+ * de novo quando o chamador (ex.: `prepare`) precisa também do patch para o Jev.
  */
 export function classifyRange<TId extends string>(
 	base: string,
 	head: string,
 	config: HoundsmanConfig<TId>,
+	diff?: DiffSource,
 ): ClassificationResult {
 	const entries = parseEntries(runGitDiff(base, head));
-	const result = classifyEntries(entries, config);
+	const churn = diff?.churn ?? collectChurn(base, head);
+	const result = classifyEntries(entries, config, churnToRecord(churn));
 	result.base = base;
 	result.head = head;
 	return result;
 }
+
+// ---------------------------------------------------------------------------
+// Triage (PRs grandes)
+// ---------------------------------------------------------------------------
+
+/** Churn total (adições + remoções) de um arquivo; 0 quando ausente. */
+export function churnOf(filePath: string, churn: ChurnMap | undefined): number {
+	const entry = churn?.[filePath];
+	return entry ? entry.additions + entry.deletions : 0;
+}
+
+/** Ordena os arquivos por risco (churn desc; empate pelo caminho). */
+export function sortByRisk(files: readonly string[], churn?: ChurnMap): string[] {
+	return [...files].sort((a, b) => {
+		const delta = churnOf(b, churn) - churnOf(a, churn);
+		return delta !== 0 ? delta : a.localeCompare(b);
+	});
+}
+
+/** Resultado da aplicação do orçamento: o que revisar e o que ficou de fora. */
+export type BudgetSelection = { selected: string[]; overflow: string[] };
+
+/**
+ * Aplica o orçamento por brief: mantém os `maxFiles` de maior risco e devolve o
+ * restante em `overflow` (nunca descarta silenciosamente). `maxFiles` não-positivo
+ * ou não-finito desativa o orçamento.
+ */
+export function selectByBudget(
+	files: readonly string[],
+	churn: ChurnMap | undefined,
+	maxFiles: number,
+): BudgetSelection {
+	const ordered = sortByRisk(files, churn);
+	if (!Number.isFinite(maxFiles) || maxFiles <= 0 || ordered.length <= maxFiles) {
+		return { selected: ordered, overflow: [] };
+	}
+	return { selected: ordered.slice(0, maxFiles), overflow: ordered.slice(maxFiles) };
+}

package/src/core/finding-anchor.ts

@@ -0,0 +1,147 @@
+/**
+ * Identidade e reancoragem de findings (biblioteca).
+ *
+ * Um finding NÃO é identificado pela linha: a linha desloca após um auto-fix.
+ * A identidade é o `fingerprint` (arquivo + regra + âncora de conteúdo); a linha
+ * é apenas cache, recalculada varrendo o arquivo (`locateAnchor`).
+ *
+ * Âncora = linha ofensora normalizada + contexto (linha anterior/seguinte).
+ * Quando o fix altera a linha ofensora, a âncora some → o finding fica `stale`.
+ *
+ * Ocorrências byte-idênticas (mesmo snippet E mesmo contexto) compartilham o
+ * fingerprint: são tratadas como um grupo (limitação conhecida).
+ */
+
+import { createHash } from "node:crypto";
+
+/** Âncora de conteúdo de um finding (independente do número da linha). */
+export type FindingAnchor = {
+	/** Linha ofensora normalizada. */
+	snippet: string;
+	/** Linha anterior normalizada (ausente se a ofensora for a primeira). */
+	contextBefore?: string;
+	/** Linha seguinte normalizada (ausente se a ofensora for a última). */
+	contextAfter?: string;
+	/** Última linha conhecida (1-based) — cache, nunca identidade. */
+	line: number;
+};
+
+/** Resultado da localização de uma âncora no conteúdo atual. */
+export type AnchorLocation = {
+	/** Linha atual (1-based) ou null se a âncora não existe mais. */
+	line: number | null;
+	/** Nº de ocorrências da âncora no arquivo. */
+	occurrences: number;
+};
+
+/** Normaliza uma linha: colapsa espaços internos e apara as pontas. */
+export function normalizeLine(raw: string): string {
+	return raw.replace(/\s+/g, " ").trim();
+}
+
+/** Conteúdo → linhas normalizadas (uma por linha do arquivo). */
+export function normalizedLines(content: string): string[] {
+	return content.split(/\r?\n/).map(normalizeLine);
+}
+
+/** Marcador de contexto ausente (não confundir com linha vazia). */
+const ABSENT = "\u0001";
+
+/** Chave estável da âncora (snippet + contexto, SEM a linha). */
+function anchorKey(anchor: FindingAnchor): string {
+	return [
+		anchor.snippet,
+		anchor.contextBefore ?? ABSENT,
+		anchor.contextAfter ?? ABSENT,
+	].join("\u0000");
+}
+
+/** Hash estável (sha256 truncado) — base das identidades do motor. */
+export function hashKey(input: string): string {
+	return createHash("sha256").update(input).digest("hex").slice(0, 16);
+}
+
+/**
+ * Fingerprint do finding: `arquivo + regra + âncora`. Sem a linha — permanece
+ * estável após edições que deslocam o trecho. Sem âncora, cai no `fallback`
+ * (ex.: `message`). Ocorrências com a MESMA âncora compartilham o fingerprint.
+ */
+export function fingerprintOf(
+	file: string,
+	rule: string,
+	anchor: FindingAnchor | null,
+	fallback = "",
+): string {
+	const key = anchor ? anchorKey(anchor) : `fallback:${fallback}`;
+	return hashKey(`${file}\u0000${rule}\u0000${key}`);
+}
+
+/**
+ * Monta a âncora a partir do conteúdo: usa a `line` (1-based) quando válida;
+ * senão procura a linha que contém a `evidence`. Retorna null se não localizar
+ * (ex.: arquivo deletado/binário).
+ */
+export function buildAnchor(
+	content: string,
+	line: number | undefined,
+	evidence?: string,
+): FindingAnchor | null {
+	const lines = normalizedLines(content);
+
+	let index = -1;
+	if (line !== undefined && line >= 1 && line <= lines.length) {
+		index = line - 1;
+	} else if (evidence) {
+		const needle = normalizeLine(evidence);
+		if (needle) index = lines.findIndex((l) => l.includes(needle));
+	}
+	if (index < 0) return null;
+
+	const anchor: FindingAnchor = { snippet: lines[index], line: index + 1 };
+	if (index - 1 >= 0) anchor.contextBefore = lines[index - 1];
+	if (index + 1 < lines.length) anchor.contextAfter = lines[index + 1];
+	return anchor;
+}
+
+/** `true` se a linha `i` casa a âncora (snippet + contexto). */
+function matchesAt(lines: string[], i: number, anchor: FindingAnchor): boolean {
+	if (lines[i] !== anchor.snippet) return false;
+	if (anchor.contextBefore !== undefined && lines[i - 1] !== anchor.contextBefore) {
+		return false;
+	}
+	if (anchor.contextAfter !== undefined && lines[i + 1] !== anchor.contextAfter) {
+		return false;
+	}
+	return true;
+}
+
+/** Localiza a âncora no conteúdo atual (linha + nº de ocorrências). */
+export function locateAnchor(
+	content: string,
+	anchor: FindingAnchor | null,
+): AnchorLocation {
+	if (!anchor) return { line: null, occurrences: 0 };
+	const lines = normalizedLines(content);
+	let occurrences = 0;
+	let first = -1;
+	for (let i = 0; i < lines.length; i++) {
+		if (!matchesAt(lines, i, anchor)) continue;
+		occurrences++;
+		if (first < 0) first = i;
+	}
+	return { line: first < 0 ? null : first + 1, occurrences };
+}
+
+export type ReanchorStatus = "ok" | "moved" | "stale";
+
+/** Reancora um finding: recalcula a linha e classifica o deslocamento. */
+export function reanchor(
+	content: string,
+	anchor: FindingAnchor | null,
+	previousLine: number | null,
+): { status: ReanchorStatus; line: number | null } {
+	const { line } = locateAnchor(content, anchor);
+	if (line === null) return { status: "stale", line: null };
+	if (previousLine !== null && line === previousLine) return { status: "ok", line };
+	return { status: "moved", line };
+}