@payconductor/houndsman 0.5.0 → 0.6.0

package/src/tests/hunt-command.test.ts

@@ -0,0 +1,212 @@
+/**
+ * `hunt` — parser de flags, dry-run e fluxo completo com provider fake.
+ */
+
+import { afterAll, describe, expect, test } from "bun:test";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { defineHoundsmanConfig } from "../core/config";
+import { HoundsmanEngine } from "../core/engine/houndsman-engine";
+import { SilentLogger } from "../core/logging";
+import { defineWatchdog } from "../core/types";
+import { HuntHarness } from "../harness/hunt/hunt-harness";
+import { parseHuntArgs } from "../harness/hunt/hunt-options";
+import { FakeModelProvider } from "./fixtures/fake-model-provider";
+
+const RULE = "Nunca usar `any`.";
+
+const configBase = defineHoundsmanConfig({
+	projectName: "Hunt",
+	watchdogs: {
+		alpha: defineWatchdog({
+			id: "alpha",
+			name: "Alpha",
+			description: "Watchdog do hunt.",
+			scope: "src/alpha/**",
+			classify: [{ value: "^src/alpha/" }],
+			rules: [{ severity: "blocking", text: RULE }],
+			contextFiles: [],
+		}),
+	},
+	exclusions: [],
+	docMappings: [],
+});
+
+describe("parseHuntArgs", () => {
+	test("flags e defaults", () => {
+		const options = parseHuntArgs([
+			"--base",
+			"origin/main",
+			"--head",
+			"abc",
+			"--watchdog",
+			"alpha",
+			"--full",
+			"--no-ast",
+			"--resume",
+			"--allow-partial",
+			"--dry-run",
+			"--fail-on-blocking",
+			"--max-calls",
+			"7",
+			"--concurrency",
+			"3",
+			"--model",
+			"m",
+		]);
+		expect(options.base).toBe("origin/main");
+		expect(options.head).toBe("abc");
+		expect(options.watchdog).toBe("alpha");
+		expect(options.full).toBe(true);
+		expect(options.noAst).toBe(true);
+		expect(options.noJev).toBe(true);
+		expect(options.resume).toBe(true);
+		expect(options.allowPartial).toBe(true);
+		expect(options.dryRun).toBe(true);
+		expect(options.failOnBlocking).toBe(true);
+		expect(options.maxCalls).toBe(7);
+		expect(options.concurrency).toBe(3);
+		expect(options.model).toBe("m");
+	});
+});
+
+// ---------------------------------------------------------------------------
+// Repo git temporário
+// ---------------------------------------------------------------------------
+
+const cwd = mkdtempSync(join(tmpdir(), "houndsman-hunt-"));
+const originalCwd = process.cwd();
+const originalHome = process.env.HOUNDSMAN_HOME;
+const originalKey = process.env.HOUNDSMAN_DEEP_SEEK_API_KEY;
+let base = "";
+
+function git(args: string[]): string {
+	const result = Bun.spawnSync(["git", ...args], {
+		cwd,
+		stdout: "pipe",
+		stderr: "pipe",
+	});
+	if (result.exitCode !== 0) {
+		throw new Error(`git ${args.join(" ")}: ${result.stderr.toString()}`);
+	}
+	return result.stdout.toString();
+}
+
+function setupRepo(): void {
+	git(["init", "-b", "main"]);
+	git(["config", "user.email", "hunt@example.test"]);
+	git(["config", "user.name", "Hunt"]);
+	git(["config", "commit.gpgsign", "false"]);
+	mkdirSync(join(cwd, "src", "alpha"), { recursive: true });
+	writeFileSync(join(cwd, "src/alpha/a.ts"), "export const a = 1;\n");
+	git(["add", "."]);
+	git(["commit", "-m", "initial"]);
+	base = git(["rev-parse", "HEAD"]).trim();
+	writeFileSync(join(cwd, "src/alpha/a.ts"), "export const a: any = 1;\n");
+	git(["add", "-A"]);
+	git(["commit", "-m", "change"]);
+	process.env.HOUNDSMAN_HOME = join(cwd, ".home");
+	process.chdir(cwd);
+}
+
+function engine(): HoundsmanEngine {
+	return new HoundsmanEngine({
+		...configBase,
+		storage: { provider: "sqlite", path: join(cwd, "houndsman.db") },
+	});
+}
+
+setupRepo();
+afterAll(() => {
+	process.chdir(originalCwd);
+	if (originalHome === undefined) delete process.env.HOUNDSMAN_HOME;
+	else process.env.HOUNDSMAN_HOME = originalHome;
+	if (originalKey === undefined) delete process.env.HOUNDSMAN_DEEP_SEEK_API_KEY;
+	else process.env.HOUNDSMAN_DEEP_SEEK_API_KEY = originalKey;
+	rmSync(cwd, { recursive: true, force: true });
+});
+
+describe("hunt", () => {
+	test("dry-run lista watchdogs sem chamar IA", async () => {
+		const instance = engine();
+		try {
+			const harness = await HuntHarness.from(
+				instance,
+				parseHuntArgs(["--base", base, "--head", "HEAD", "--dry-run"]),
+				new SilentLogger(),
+			);
+			const result = await harness.run();
+			expect(result.status).toBe("dry-run");
+			expect(result.messages.join("\n")).toContain("alpha");
+		} finally {
+			instance.close();
+		}
+	});
+
+	test("sem chave e sem --dry-run falha com mensagem clara", async () => {
+		delete process.env.HOUNDSMAN_DEEP_SEEK_API_KEY;
+		const instance = engine();
+		try {
+			await expect(
+				HuntHarness.from(
+					instance,
+					parseHuntArgs(["--base", base, "--head", "HEAD"]),
+					new SilentLogger(),
+				),
+			).rejects.toThrow(/hunt exige IA configurada/);
+		} finally {
+			instance.close();
+		}
+	});
+
+	test("provider fake investiga, grava findings e finaliza", async () => {
+		const provider = new FakeModelProvider(async (request, index) => {
+			if (index === 0) return { hypotheses: ["any"] };
+			if (index === 1) return { taskIds: ["rule-0"] };
+			const tool = request.tools?.read_file_range;
+			if (!tool) throw new Error("read_file_range ausente");
+			const parsed = JSON.parse(
+				await tool.execute({ path: "src/alpha/a.ts", startLine: 1, endLine: 1 }),
+			) as { evidence?: { id: string }[] };
+			return {
+				findingDrafts: [
+					{
+						rule: RULE,
+						severity: "blocking",
+						file: "src/alpha/a.ts",
+						line: 1,
+						message: "any detectado",
+						action: "tipar",
+						evidenceIds: [parsed.evidence?.[0]?.id].filter(Boolean),
+						confidence: 0.9,
+					},
+				],
+				coverage: [{ rule: RULE, status: "checked" }],
+			};
+		});
+		const instance = engine();
+		try {
+			const harness = await HuntHarness.from(
+				instance,
+				parseHuntArgs(["--base", base, "--head", "HEAD"]),
+				new SilentLogger(),
+				provider,
+			);
+			const result = await harness.run();
+			expect(result.status).toBe("completed");
+			expect(result.blockers).toBe(1);
+			const review = instance.storage.readArtifact(result.reviewId, "review.md");
+			expect(review?.content).toContain("any detectado");
+			const transcript = instance.storage.readArtifact(
+				result.reviewId,
+				"harness-transcript.json",
+			);
+			expect(transcript?.content).toContain("VERIFY");
+			const usage = instance.storage.readArtifact(result.reviewId, "ai-usage.json");
+			expect(usage?.content).toContain('"calls"');
+		} finally {
+			instance.close();
+		}
+	});
+});

package/src/tests/logger.test.ts

@@ -0,0 +1,83 @@
+/**
+ * Logger único: cor opcional, spinner em não-TTY e tabela.
+ */
+
+import { describe, expect, test } from "bun:test";
+import { Logger, SilentLogger } from "../core/logging";
+
+function memoryStream(): { stream: NodeJS.WritableStream; text: () => string } {
+	let content = "";
+	const stream = {
+		write(chunk: string) {
+			content += chunk;
+			return true;
+		},
+		isTTY: false,
+	} as unknown as NodeJS.WritableStream;
+	return { stream, text: () => content };
+}
+
+describe("Logger", () => {
+	test("escreve texto puro quando color=false e sem TTY", () => {
+		const out = memoryStream();
+		const err = memoryStream();
+		const logger = new Logger({
+			stdout: out.stream,
+			stderr: err.stream,
+			color: false,
+			isTTY: false,
+		});
+		logger.info("info");
+		logger.success("ok");
+		logger.warn("aviso");
+		logger.error("falhou");
+		logger.step("passo");
+		const text = `${out.text()}${err.text()}`;
+		expect(text).toContain("info");
+		expect(text).toContain("ok");
+		expect(text).toContain("aviso");
+		expect(text).toContain("falhou");
+		expect(text).toContain("passo");
+		expect(text).not.toContain("\u001b[");
+	});
+
+	test("spinner é nulo em não-TTY", () => {
+		const out = memoryStream();
+		const logger = new Logger({ stdout: out.stream, isTTY: false });
+		expect(logger.spinner("x")).toBeNull();
+	});
+
+	test("quiet suprime info/sucesso mas não erro", () => {
+		const out = memoryStream();
+		const err = memoryStream();
+		const logger = new Logger({
+			stdout: out.stream,
+			stderr: err.stream,
+			quiet: true,
+			color: false,
+		});
+		logger.info("info");
+		logger.success("ok");
+		logger.error("erro");
+		expect(out.text()).toBe("");
+		expect(err.text()).toContain("erro");
+	});
+
+	test("tabela alinha colunas", () => {
+		const out = memoryStream();
+		const logger = new Logger({ stdout: out.stream, color: false });
+		logger.table([
+			["id", "findings"],
+			["alpha", "2"],
+		]);
+		expect(out.text()).toContain("id");
+		expect(out.text()).toContain("alpha");
+	});
+
+	test("SilentLogger não escreve e executa withSpinner", async () => {
+		const logger = new SilentLogger();
+		logger.info("x");
+		const result = await logger.withSpinner("x", async () => 42);
+		expect(result).toBe(42);
+	});
+});

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

@@ -111,12 +111,12 @@ function makeRepo(): Repo {
 // ---------------------------------------------------------------------------
 
 describe("ReviewScopeResolver", () => {
-	test("mesmo commit revisado vira no-op (sem tocar no git)", () => {
+	test("mesmo commit revisado vira no-op (sem tocar no git)", async () => {
 		const sha = "a".repeat(40);
-		const scope = new ReviewScopeResolver(options(), fakeHoundsmanConfig).resolve(
-			stateWith(sha),
-			sha,
-		);
+		const scope = await new ReviewScopeResolver(
+			options(),
+			fakeHoundsmanConfig,
+		).resolve(stateWith(sha), sha);
 
 		expect(scope.kind).toBe("noop");
 		if (scope.kind !== "noop") throw new Error("esperava noop");
@@ -124,12 +124,12 @@ describe("ReviewScopeResolver", () => {
 		expect(scope.headSha).toBe(sha);
 	});
 
-	test("`--full` re-revisa o mesmo commit", () => {
+	test("`--full` re-revisa o mesmo commit", async () => {
 		const repo = makeRepo();
 		const originalCwd = process.cwd();
 		try {
 			process.chdir(repo.cwd);
-			const scope = new ReviewScopeResolver(
+			const scope = await new ReviewScopeResolver(
 				options({ base: repo.base, full: true }),
 				fakeHoundsmanConfig,
 			).resolve(stateWith(repo.head), repo.head);
@@ -144,7 +144,7 @@ describe("ReviewScopeResolver", () => {
 		}
 	});
 
-	test("delta revisa só os arquivos alterados e carrega o resto", () => {
+	test("delta revisa só os arquivos alterados e carrega o resto", async () => {
 		const repo = makeRepo();
 		const originalCwd = process.cwd();
 		try {
@@ -153,7 +153,7 @@ describe("ReviewScopeResolver", () => {
 				abcdef1234: findingState({ file: "src/alpha/keep.ts" }),
 				fedcba4321: findingState({ file: "src/alpha/a.ts" }),
 			});
-			const scope = new ReviewScopeResolver(
+			const scope = await new ReviewScopeResolver(
 				options({ base: repo.base }),
 				fakeHoundsmanConfig,
 			).resolve(previous, repo.head);
@@ -172,13 +172,13 @@ describe("ReviewScopeResolver", () => {
 		}
 	});
 
-	test("histórico reescrito (HEAD sem ancestrais comuns) cai no completo", () => {
+	test("histórico reescrito (HEAD sem ancestrais comuns) cai no completo", async () => {
 		const repo = makeRepo();
 		const originalCwd = process.cwd();
 		try {
 			process.chdir(repo.cwd);
 			// `repo.head` não é ancestral de `repo.base` → revisão completa.
-			const scope = new ReviewScopeResolver(
+			const scope = await new ReviewScopeResolver(
 				options({ base: repo.base }),
 				fakeHoundsmanConfig,
 			).resolve(stateWith(repo.head), repo.base);

package/src/tests/rule-analyzer.test.ts

@@ -0,0 +1,61 @@
+/**
+ * RuleAnalyzer — polaridade, categoria, sinais e hints.
+ */
+
+import { describe, expect, test } from "bun:test";
+import { RuleAnalyzer } from "../harness/investigation/rule-analyzer";
+
+const analyzer = new RuleAnalyzer();
+
+describe("RuleAnalyzer", () => {
+	test("detecta polaridade explícita", () => {
+		const [avoid, promote] = analyzer.analyze([
+			{ severity: "blocking", text: "Evitar: chamar banco diretamente em rotas." },
+			{ severity: "attention", text: "Promover: usar `logger` estruturado." },
+		]);
+		expect(avoid?.intent).toBe("avoid");
+		expect(promote?.intent).toBe("promote");
+	});
+
+	test("classifica categoria por keywords", () => {
+		const [data, tests] = analyzer.analyze([
+			{
+				severity: "attention",
+				text: "Evitar: query direta no banco sem migration.",
+			},
+			{ severity: "nit", text: "Promover: cobertura de teste no handler." },
+		]);
+		expect(data?.category).toBe("data");
+		expect(tests?.category).toBe("tests");
+	});
+
+	test("extrai sinais de backticks e hints (confiança alta)", () => {
+		const [analysis] = analyzer.analyze([
+			{
+				severity: "blocking",
+				text: "Evitar: usar `db.query` fora do service.",
+				hints: {
+					symbols: ["OrderService"],
+					imports: ["db"],
+					checks: ["symbol_context"],
+				},
+			},
+		]);
+		expect(analysis?.confidence).toBe("high");
+		expect(analysis?.signals.some((signal) => signal.value === "OrderService")).toBe(
+			true,
+		);
+		expect(analysis?.signals.some((signal) => signal.value === "db")).toBe(true);
+		expect(analysis?.checks.some((check) => check.tool === "symbol_context")).toBe(
+			true,
+		);
+	});
+
+	test("keywords ignoram stopwords", () => {
+		const [analysis] = analyzer.analyze([
+			{ severity: "nit", text: "Nunca usar any em produção" },
+		]);
+		expect(analysis?.keywords).not.toContain("nunca");
+		expect(analysis?.keywords).toContain("produção");
+	});
+});

package/src/tests/tool-contracts.test.ts

@@ -0,0 +1,82 @@
+/**
+ * Contract test das tools built-in: metadata, schema e erros estruturados.
+ */
+
+import { describe, expect, test } from "bun:test";
+import { AstService } from "../core/ast/service";
+import { Watchdog } from "../core/domain/watchdog";
+import { SilentReporter } from "../harness/agent/agent-reporter";
+import { AgentState } from "../harness/investigation/agent-state";
+import type { ToolContext } from "../harness/tools/agent-tool";
+import { BuiltinToolsModule } from "../harness/tools/builtin";
+import { ToolCache } from "../harness/tools/tool-cache";
+import { ToolCallBudget } from "../harness/tools/tool-call-budget";
+import { ToolMiddleware } from "../harness/tools/tool-middleware";
+import { ToolRegistry } from "../harness/tools/tool-registry";
+import { fakeAgentContext } from "./fixtures/fake-investigation";
+import { fakeHoundsmanConfig } from "./fixtures/fake-project";
+
+function registry(): ToolRegistry {
+	const value = new ToolRegistry();
+	value.registerModule(new BuiltinToolsModule());
+	return value;
+}
+
+function context(): ToolContext {
+	return {
+		repoRoot: process.cwd(),
+		watchdog: new Watchdog(fakeHoundsmanConfig.watchdogs.alpha),
+		diff: { byFile: new Map(), churn: new Map() },
+		ast: new AstService(fakeHoundsmanConfig),
+		state: new AgentState(),
+		budget: new ToolCallBudget(20, 10),
+		cache: new ToolCache(),
+		logger: new SilentReporter(),
+		agent: fakeAgentContext({ repoRoot: process.cwd() }),
+		rules: new Map(),
+	};
+}
+
+describe("contratos das tools", () => {
+	test("todas declaram metadata read-only e capabilities", () => {
+		for (const tool of registry().list()) {
+			expect(tool.metadata.name.length).toBeGreaterThan(0);
+			expect(tool.metadata.description.length).toBeGreaterThan(0);
+			expect(tool.metadata.readOnly).toBe(true);
+			expect(tool.metadata.capabilities.length).toBeGreaterThan(0);
+			expect(tool.metadata.cost).toBeGreaterThanOrEqual(1);
+		}
+	});
+
+	test("nenhuma tool devolve arquivo inteiro por padrão", () => {
+		// `read_file_range` exige faixa explícita.
+		const range = registry().get("read_file_range");
+		expect(range?.inputSchema.safeParse({ path: "a.ts" }).success).toBe(false);
+		// `file_outline` só devolve metadados (não tem parâmetro de corpo).
+		const outline = registry().get("file_outline");
+		expect(outline?.inputSchema.safeParse({ path: "a.ts" }).success).toBe(true);
+	});
+
+	test("tools de arquivo devolvem erro estruturado (não lançam)", async () => {
+		const middleware = new ToolMiddleware();
+		for (const [name, input] of [
+			["read_file_range", { path: "../x", startLine: 1, endLine: 2 }],
+			["file_outline", { path: "../x" }],
+			["imports_exports", { file: "../x" }],
+		] as const) {
+			const result = await registry().execute(name, input, context(), middleware);
+			expect(result.ok).toBe(false);
+			expect(typeof result.error).toBe("string");
+		}
+	});
+
+	test("rule_signals devolve erro quando a regra não existe", async () => {
+		const result = await registry().execute(
+			"rule_signals",
+			{ rule: "regra inexistente" },
+			context(),
+			new ToolMiddleware(),
+		);
+		expect(result.ok).toBe(false);
+	});
+});

package/src/tests/verify.test.ts

@@ -158,7 +158,7 @@ describe("JevVerifier", () => {
 		]);
 		expect(outcome.checked).toBe(0);
 		expect(outcome.skipped).toBe(1);
-		expect(outcome.reason).toContain("TYPESAFE_API_KEY");
+		expect(outcome.reason).toContain("HOUNDSMAN_TYPE_SAFE_API_KEY");
 	});
 
 	test("sem casos ⇒ vazio", async () => {