@payconductor/houndsman 0.13.0 → 0.16.0

package/src/tests/ai-core.test.ts

@@ -155,6 +155,52 @@ describe("temperature e providerOptions", () => {
 			deepseek: { thinking: { type: "disabled" } },
 		});
 	});
+
+	test("objetos estruturados desligam thinking por default", async () => {
+		const provider = new FakeModelProvider(() => ({ ok: true }));
+		const client = new AiClient({ project, provider });
+		await client.generateObject("business", {
+			prompt: "oi",
+			outputSchema: z.object({ ok: z.boolean() }),
+		});
+		expect(provider.requests[0]?.providerOptions).toEqual({
+			deepseek: { thinking: { type: "disabled" } },
+		});
+	});
+
+	test("thinking configurado pelo projeto vence o default", async () => {
+		const configured = new ProjectConfig({
+			...fakeHoundsmanConfig,
+			ai: { providerOptions: { deepseek: { thinking: { type: "enabled" } } } },
+		});
+		const provider = new FakeModelProvider(() => ({ ok: true }));
+		const client = new AiClient({ project: configured, provider });
+		await client.generateObject("business", {
+			prompt: "oi",
+			outputSchema: z.object({ ok: z.boolean() }),
+		});
+		expect(provider.requests[0]?.providerOptions).toEqual({
+			deepseek: { thinking: { type: "enabled" } },
+		});
+	});
+
+	test("resposta truncada falha e é registrada sem debitar o budget", async () => {
+		const provider = new FakeModelProvider(
+			() => ({ ok: true }),
+			"fake-model",
+			"length",
+		);
+		const client = new AiClient({ project, provider });
+		const result = await client.generateObject("brief", {
+			prompt: "oi",
+			outputSchema: z.object({ ok: z.boolean() }),
+			maxOutputTokens: 100,
+		});
+		expect(result.ok).toBe(false);
+		expect(client.recorder.total.calls).toBe(0);
+		expect(client.recorder.failures[0]?.finishReason).toBe("length");
+		expect(client.recorder.summary.attempts).toBe(1);
+	});
 });
 
 describe("avisos do AI SDK", () => {

package/src/tests/ai-features.test.ts

@@ -5,12 +5,15 @@
 import { describe, expect, test } from "bun:test";
 import { AiClient } from "../core/ai";
 import { AiBriefEnricher } from "../core/ai/features/brief-enricher";
+import { AiBusinessAnalyzer } from "../core/ai/features/business-analyzer";
+import { AiBusinessSummarizer } from "../core/ai/features/business-summarizer";
 import { AiClassifier } from "../core/ai/features/classifier";
 import { AiContextSummarizer } from "../core/ai/features/context-summarizer";
 import { AiPreAnalyzer } from "../core/ai/features/pre-analyzer";
 import { AiTechnicalSummarizer } from "../core/ai/features/technical-summarizer";
 import { AiVerifier } from "../core/ai/features/verifier";
 import { briefInstructions, briefPrompt } from "../core/ai/prompts/brief";
+import { businessInstructions } from "../core/ai/prompts/business";
 import { contextInstructions } from "../core/ai/prompts/context";
 import { technicalInstructions } from "../core/ai/prompts/technical";
 import { renderBrief } from "../core/brief";
@@ -116,8 +119,8 @@ describe("AiBriefEnricher", () => {
 				focus: [],
 				questions: [],
 				risks: [],
-				logic: ["nome vs comportamento"],
-				domain: ["transição de estado"],
+				logic: [{ statement: "nome vs comportamento" }],
+				domain: [{ statement: "transição de estado" }],
 			},
 		});
 		expect(markdown).toContain("Consistência lógica");
@@ -221,10 +224,98 @@ describe("AiPreAnalyzer", () => {
 });
 
 describe("idioma dos resumos", () => {
-	test("prompts de contexto e pontos técnicos exigem pt-BR", () => {
-		for (const instructions of [contextInstructions(), technicalInstructions()]) {
+	test("prompts de contexto, intenção e pontos técnicos exigem pt-BR", () => {
+		for (const instructions of [
+			contextInstructions(),
+			businessInstructions(),
+			technicalInstructions(),
+		]) {
 			expect(instructions).toContain("português do Brasil");
 			expect(instructions).toContain("pt-BR");
 		}
 	});
 });
+
+describe("AiBusinessSummarizer", () => {
+	const input = {
+		classification: {
+			files: { "src/alpha/a.ts": { status: "modified" as const } },
+			churn: { "src/alpha/a.ts": { additions: 3, deletions: 1 } },
+			watchdogs: { alpha: ["src/alpha/a.ts"] },
+		},
+		domains: [{ id: "alpha", name: "Alpha" }],
+		headSha: "abc123",
+	};
+
+	test("devolve o modelo com source ai", async () => {
+		const provider = new FakeModelProvider(() => ({
+			intent: "Entregar o split",
+			flows: [{ name: "Renovação", trigger: "job", files: ["src/alpha/a.ts"] }],
+			invariants: ["split sempre presente"],
+			contracts: [{ name: "AutomaticPix", sides: ["asaas", "processor"] }],
+			states: [],
+		}));
+		const summarizer = new AiBusinessSummarizer(new AiClient({ project, provider }));
+		const summary = await summarizer.summarize(input);
+		expect(summary?.source).toBe("ai");
+		expect(summary?.headSha).toBe("abc123");
+		expect(summary?.flows[0]?.name).toBe("Renovação");
+		expect(summary?.invariants).toEqual(["split sempre presente"]);
+	});
+
+	test("sem IA → null (fallback determinístico no chamador)", async () => {
+		const summarizer = new AiBusinessSummarizer(
+			new AiClient({ project, provider: null }),
+		);
+		expect(summarizer.enabled).toBe(false);
+		expect(await summarizer.summarize(input)).toBeNull();
+	});
+});
+
+describe("AiBusinessAnalyzer", () => {
+	test("gera candidatos do general e descarta arquivo fora do escopo", async () => {
+		const provider = new FakeModelProvider(() => ({
+			hypotheses: [
+				{
+					file: "src/alpha/a.ts",
+					kind: "domain",
+					statement: "renovação perde o split",
+					confidence: 0.9,
+				},
+				{
+					file: "src/outro.ts",
+					kind: "logic",
+					statement: "fora do escopo",
+					confidence: 0.9,
+				},
+				{
+					file: "src/alpha/a.ts",
+					kind: "logic",
+					statement: "confiança baixa",
+					confidence: 0.2,
+				},
+			],
+		}));
+		const analyzer = new AiBusinessAnalyzer(new AiClient({ project, provider }));
+		const candidates = await analyzer.analyze({
+			business: {
+				source: "deterministic",
+				flows: [],
+				invariants: [],
+				contracts: [],
+				states: [],
+			},
+			payload: {
+				classification: {
+					files: { "src/alpha/a.ts": { status: "modified" } },
+					churn: {},
+					watchdogs: {},
+				},
+			},
+		});
+		expect(candidates).toHaveLength(1);
+		expect(candidates[0]?.watchdogId).toBe("general");
+		expect(candidates[0]?.rule).toBe("Domínio: renovação perde o split");
+		expect(candidates[0]?.severity).toBe("attention");
+	});
+});

package/src/tests/baseline.test.ts

@@ -29,12 +29,6 @@ import { defineHoundsmanConfig } from "../core/config";
 import { defaultOptions, finalize, prepare, reviewContext } from "../core/orchestrator";
 import { displayPath } from "../core/paths";
 import { RESUME_MAX_CHARS } from "../core/renderers/resume-renderer";
-import {
-	type MergedFinding,
-	renderDomainReport,
-	renderReport,
-	type WatchdogReport,
-} from "../core/report-builder";
 import { resolveRepoIdentity } from "../core/storage/repo-identity";
 import { SQLiteStorageProvider } from "../core/storage/sqlite/sqlite-storage";
 import { defineWatchdog } from "../core/types";
@@ -157,112 +151,6 @@ describe("baseline — brief", () => {
 	});
 });
 
-// ---------------------------------------------------------------------------
-// Relatório
-// ---------------------------------------------------------------------------
-
-const reports: WatchdogReport[] = [
-	{
-		watchdogId: "alpha",
-		reviewedFiles: ["src/alpha/a.ts", "src/alpha/b.ts"],
-		skipped: ["src/alpha/c.ts"],
-		findings: [
-			{
-				rule: "Nunca usar `any`.",
-				severity: "blocking",
-				file: "src/alpha/a.ts",
-				line: 1,
-				message: "any detectado",
-				action: "tipar",
-				evidence: "export const a: any = 1;",
-				id: "id-alpha",
-			},
-			{
-				rule: "Promover: validar a entrada.",
-				severity: "attention",
-				file: "src/alpha/b.ts",
-				line: 2,
-				message: "sem validação",
-				action: "adicionar schema",
-				id: "id-beta",
-			},
-		],
-	},
-	{
-		watchdogId: "beta",
-		reviewedFiles: ["src/beta/x.test.ts"],
-		skipped: [],
-		findings: [],
-	},
-];
-
-const merged: MergedFinding[] = [
-	{ ...reports[0].findings[0], watchdogs: ["alpha"] },
-	{ ...reports[0].findings[1], watchdogs: ["alpha", "beta"] },
-];
-
-const reportContext = {
-	available: true,
-	source: {
-		number: 42,
-		title: "Entrega X",
-		url: "https://example.test/pull/42",
-		head: "feature/x",
-		base: "main",
-	},
-	objective: "Entregar X",
-	motivation: "Reduzir Y",
-	changeSummary: ["Faz A", "Remove B"],
-};
-
-describe("baseline — relatório", () => {
-	test("renderReport consolidado", () => {
-		const md = renderReport(
-			"feature/x",
-			reports,
-			merged,
-			{ classified: { alpha: ["src/alpha/a.ts", "src/alpha/b.ts"], beta: [] } },
-			reportContext,
-			[
-				{
-					watchdogId: "alpha",
-					rule: "Nunca usar `any`.",
-					severity: "blocking",
-					file: "src/alpha/a.ts",
-					confidence: 0.82,
-					questionKey: "alpha::rule-0",
-				},
-			],
-			(id) => (id === "alpha" ? "Alpha" : "Beta"),
-			[
-				{
-					id: "alpha",
-					name: "Alpha",
-					file: "review.alpha.md",
-					findings: 2,
-					reviewedFiles: 2,
-					expectedFiles: 2,
-				},
-			],
-		);
-
-		expect(normalizeArtifacts(md)).toMatchSnapshot();
-	});
-
-	test("renderDomainReport isolado", () => {
-		const md = renderDomainReport(
-			"feature/x",
-			reports[0],
-			merged,
-			2,
-			reportContext,
-			(id) => (id === "alpha" ? "Alpha" : "Beta"),
-		);
-
-		expect(normalizeArtifacts(md)).toMatchSnapshot();
-	});
-});
-
 // ---------------------------------------------------------------------------
 // Camada gerada pelo setup/update
 // ---------------------------------------------------------------------------
@@ -321,7 +209,7 @@ describe("baseline — camada gerada", () => {
 // ---------------------------------------------------------------------------
 
 describe("baseline — artefatos de prepare/finalize", () => {
-	test("gera classification, brief, manifest, review e state", async () => {
+	test("gera classification, brief, manifest, resumo e state", async () => {
 		const cwd = mkdtempSync(join(tmpdir(), "houndsman-baseline-run-"));
 		const originalCwd = process.cwd();
 		const originalHome = process.env.HOUNDSMAN_HOME;
@@ -388,9 +276,17 @@ describe("baseline — artefatos de prepare/finalize", () => {
 						.replaceAll(homeDisplay, "<cwd>"),
 				);
 
-			const prepared = await prepare(opts, "main", config, ctx);
+			const prepared = await prepare(ctx, config, opts);
 			expect(normalize(prepared.messages.join("\n"))).toMatchSnapshot();
 
+			// Instrumentação do prepare: etapas medidas sem alterar o manifesto.
+			const prepareReport = storage.readArtifact(review.id, "prepare-report.json");
+			expect(prepareReport?.kind).toBe("prepare");
+			const report = JSON.parse(prepareReport?.content ?? "{}") as {
+				stages?: { stage: string; durationMs: number }[];
+			};
+			expect((report.stages ?? []).length).toBeGreaterThan(0);
+
 			for (const name of ["classification.json", "manifest.json"]) {
 				const artifact = storage.readArtifact(review.id, name);
 				expect(normalize(artifact?.content ?? "")).toMatchSnapshot(name);
@@ -425,19 +321,32 @@ describe("baseline — artefatos de prepare/finalize", () => {
 					2,
 				)}\n`,
 			);
+			writeFileSync(
+				ctx.work.findingFile("general"),
+				`${JSON.stringify(
+					{
+						watchdogId: "general",
+						reviewedFiles: ["src/alpha/a.ts", "src/alpha/b.ts"],
+						skipped: [],
+						findings: [],
+					},
+					null,
+					2,
+				)}\n`,
+			);
 
-			const finalized = finalize(opts, "main", config, ctx);
+			const finalized = finalize(ctx, config, opts);
 			expect(normalize(finalized.messages.join("\n"))).toMatchSnapshot();
 
-			for (const name of ["review.md", "review.alpha.md"]) {
-				const artifact = storage.readArtifact(review.id, name);
-				expect(normalize(artifact?.content ?? "")).toMatchSnapshot(name);
-			}
+			// Único artefato humano: o resumo final (negócio, técnico, cobertura, conclusão).
 			const resume = storage.readArtifact(review.id, "review-resume.md");
 			expect(resume?.kind).toBe("resume");
 			expect(resume?.content).toContain("## Pontos técnicos");
 			expect(resume?.content).toContain("Remoções");
+			expect(resume?.content).toContain("## Cobertura por domínio");
+			expect(resume?.content).toContain("## Conclusão");
 			expect((resume?.content ?? "").length).toBeLessThanOrEqual(RESUME_MAX_CHARS);
+			expect(normalize(resume?.content ?? "")).toMatchSnapshot("review-resume.md");
 			expect(
 				normalize(JSON.stringify(storage.readFindings(review.id), null, 2)),
 			).toMatchSnapshot("state.json");
@@ -500,7 +409,7 @@ const REQUIRED_EXPORTS = [
 	"ProjectScaffolder",
 	"FixBatchBuilder",
 	"BriefRenderer",
-	"ReportRenderer",
+	"renderReviewResume",
 	"ManifestWriter",
 	"applyFindingUpdate",
 	"assetPath",
@@ -537,7 +446,6 @@ const REQUIRED_EXPORTS = [
 	"reanchor",
 	"relFromRoot",
 	"renderBrief",
-	"renderDomainReport",
 	"reorder",
 	"resolveConfigPath",
 	"resolveJevConcurrency",

package/src/tests/brief-scope.test.ts

@@ -0,0 +1,250 @@
+/**
+ * Brief — recorte do modelo de intenção e injeção dos hunks.
+ *
+ * Depois do `business-brief.md`, cada watchdog recebia o modelo inteiro e
+ * perseguia fluxos de outros domínios; o brief também não trazia o código
+ * alterado, forçando a releitura dos arquivos. Estes testes congelam o recorte.
+ */
+
+import { describe, expect, test } from "bun:test";
+import { renderBrief } from "../core/brief";
+import { generalWatchdog } from "../core/builtins";
+import type { BusinessSummary } from "../core/business-summary";
+import {
+	buildBriefSnippets,
+	generalFlowFiles,
+	shouldSliceGeneral,
+	truncatePatch,
+} from "../core/engine/prepare-pipeline";
+import { buildPrepareReport } from "../core/prepare-report";
+import type { WatchdogRenderArgs } from "../core/types";
+import { alphaWatchdog } from "./fixtures/fake-project";
+
+/** Modelo com um fluxo do domínio alpha e outro de fora. */
+const business: BusinessSummary = {
+	source: "ai",
+	intent: "Renovar assinaturas sem perder a credencial da conta.",
+	flows: [
+		{
+			name: "Alpha flow",
+			trigger: "webhook de renovação",
+			expected: "assinatura renovada",
+			files: ["src/alpha/a.ts"],
+		},
+		{
+			name: "Beta flow",
+			trigger: "job de cobrança",
+			expected: "cobrança criada",
+			files: ["src/beta/b.ts"],
+		},
+	],
+	invariants: ["A conta do pagador é preservada."],
+	contracts: [],
+	states: [],
+	openQuestions: ["Pergunta global?"],
+};
+
+const baseArgs: WatchdogRenderArgs = {
+	watchdogId: "alpha",
+	files: ["src/alpha/a.ts"],
+	statuses: { "src/alpha/a.ts": { status: "modified" } },
+	deleted: [],
+	branch: "feature/x",
+	outputPath: "findings/alpha.json",
+	outputFormatPath: "OUTPUT-FORMAT.md",
+	docs: [],
+	business,
+	businessSummaryPath: "/home/.houndsman/work/review/business-summary.json",
+	snippets: [
+		{
+			file: "src/alpha/a.ts",
+			snippet: "@@ -1 +1 @@\n-const a = 1;\n+const a: any = 1;",
+		},
+	],
+};
+
+describe("brief — recorte do modelo de intenção", () => {
+	test("watchdog de domínio vê só os fluxos dos seus arquivos", () => {
+		const markdown = renderBrief(alphaWatchdog, baseArgs);
+		expect(markdown).toContain("Alpha flow");
+		expect(markdown).not.toContain("Beta flow");
+		expect(markdown).toContain("1 fluxo(s) fora do seu domínio foram omitidos");
+		expect(markdown).toContain("não os investigue");
+	});
+
+	test("domínio não recebe o caminho canônico (evita leitura extra)", () => {
+		const markdown = renderBrief(alphaWatchdog, baseArgs);
+		expect(markdown).not.toContain("business-summary.json");
+	});
+
+	test("general recebe o modelo completo e o caminho canônico", () => {
+		const markdown = renderBrief(generalWatchdog, {
+			...baseArgs,
+			watchdogId: generalWatchdog.id,
+			files: ["src/alpha/a.ts", "src/beta/b.ts"],
+		});
+		expect(markdown).toContain("Alpha flow");
+		expect(markdown).toContain("Beta flow");
+		expect(markdown).toContain("Pergunta global?");
+		expect(markdown).toContain("business-summary.json");
+	});
+});
+
+describe("brief — trechos alterados", () => {
+	test("injeta o diff e proíbe reler o arquivo inteiro", () => {
+		const markdown = renderBrief(alphaWatchdog, baseArgs);
+		expect(markdown).toContain("## Trechos alterados (diff)");
+		expect(markdown).toContain("const a: any = 1;");
+		expect(markdown).toContain("não abra os arquivos");
+	});
+
+	test("sem trechos, a seção não aparece", () => {
+		const markdown = renderBrief(alphaWatchdog, {
+			...baseArgs,
+			snippets: undefined,
+		});
+		expect(markdown).not.toContain("## Trechos alterados (diff)");
+	});
+
+	test("renderiza propagação mecânica e lacunas de importadores", () => {
+		const markdown = renderBrief(alphaWatchdog, {
+			...baseArgs,
+			propagation: {
+				lines: ["await pay(charge, true);"],
+				files: ["src/alpha/a.ts", "src/alpha/b.ts"],
+				outliers: [
+					{ file: "src/alpha/c.ts", lines: ["await pay(charge, false);"] },
+				],
+			},
+			propagationGaps: [{ file: "src/alpha/a.ts", importers: ["src/beta/b.ts"] }],
+		});
+		expect(markdown).toContain("## Propagação mecânica");
+		expect(markdown).toContain("await pay(charge, true)");
+		expect(markdown).toContain("Outliers (revisar)");
+		expect(markdown).toContain("## Possível propagação incompleta");
+		expect(markdown).toContain("src/beta/b.ts");
+	});
+});
+
+describe("prepare-report", () => {
+	test("preserva etapas, uso de IA e falhas", () => {
+		const report = buildPrepareReport({
+			startedAt: "2026-10-25T00:00:00.000Z",
+			durationMs: 1_500,
+			stages: [
+				{ stage: "business", durationMs: 900 },
+				{ stage: "technical", durationMs: 300 },
+			],
+			ai: {
+				inputTokens: 10,
+				outputTokens: 5,
+				totalTokens: 15,
+				calls: 1,
+				attempts: 2,
+				failures: [
+					{
+						feature: "brief",
+						model: "deepseek-v4-pro",
+						durationMs: 12,
+						error: "Resposta truncada",
+						finishReason: "length",
+					},
+				],
+			},
+		});
+		expect(report.version).toBe(1);
+		expect(report.durationMs).toBe(1_500);
+		expect(report.stages.map((item) => item.stage)).toEqual([
+			"business",
+			"technical",
+		]);
+		expect(report.ai?.calls).toBe(1);
+		expect(report.ai?.attempts).toBe(2);
+		expect(report.ai?.failures[0]?.finishReason).toBe("length");
+	});
+});
+
+describe("prepare — orçamento de snippets", () => {
+	const patch = (chars: number) =>
+		Array.from(
+			{ length: Math.ceil(chars / 40) },
+			() => "+linha de codigo alterada",
+		).join("\n");
+
+	test("distribui o teto entre todos os arquivos (não só nos primeiros)", () => {
+		const files = Array.from({ length: 10 }, (_, i) => `src/f${i}.ts`);
+		const snippets = buildBriefSnippets(
+			files,
+			new Map(files.map((file) => [file, patch(2_000)])),
+			{ total: 10_000, perFile: 4_000 },
+		);
+		expect(snippets).toHaveLength(10);
+		// Todos começam com uma parte igual; o excedente vai para os primeiros.
+		expect(snippets[0]?.snippet.length).toBeGreaterThan(
+			snippets[9]?.snippet.length ?? 0,
+		);
+		expect(snippets.every((item) => item.snippet.length > 0)).toBe(true);
+	});
+
+	test("corta em linha inteira e sinaliza o trecho truncado", () => {
+		const cut = truncatePatch(patch(1_000), 120);
+		expect(cut.length).toBeLessThanOrEqual(120);
+		expect(cut).toContain("[trecho truncado");
+		expect(cut.startsWith("+linha de codigo")).toBe(true);
+		expect(truncatePatch("curto", 100)).toBe("curto");
+	});
+});
+
+describe("general — recorte por fluxo", () => {
+	const flowBusiness: BusinessSummary = {
+		source: "ai",
+		flows: [
+			{
+				name: "Renovação",
+				trigger: "job",
+				expected: "assinatura renovada",
+				files: ["./src/alpha/a.ts"],
+			},
+		],
+		invariants: [],
+		contracts: [],
+		states: [],
+	};
+
+	test("dispara por nº de arquivos ou por linhas alteradas", () => {
+		const manyFiles = Array.from({ length: 41 }, (_, i) => `src/f${i}.ts`);
+		expect(shouldSliceGeneral({ watchdogs: { general: manyFiles }, churn: {} })).toBe(
+			true,
+		);
+		expect(
+			shouldSliceGeneral({
+				watchdogs: { general: ["src/a.ts"] },
+				churn: { "src/a.ts": { additions: 1_200, deletions: 900 } },
+			}),
+		).toBe(true);
+		expect(
+			shouldSliceGeneral({
+				watchdogs: { general: ["src/a.ts"] },
+				churn: { "src/a.ts": { additions: 10, deletions: 5 } },
+			}),
+		).toBe(false);
+	});
+
+	test("prioriza os arquivos dos fluxos e limita o recorte", () => {
+		const files = [
+			"src/alpha/a.ts",
+			...Array.from({ length: 19 }, (_, i) => `src/f${i}.ts`),
+		];
+		const result = generalFlowFiles(
+			{
+				watchdogs: { general: files },
+				churn: { "src/f19.ts": { additions: 100, deletions: 0 } },
+			},
+			flowBusiness,
+			3,
+		);
+		expect(result.selected).toHaveLength(3);
+		expect(result.selected[0]).toBe("src/alpha/a.ts");
+		expect(result.overflow).toHaveLength(17);
+	});
+});