@payconductor/houndsman 0.4.0 → 0.6.0

package/src/tests/harness-investigation.test.ts

@@ -0,0 +1,206 @@
+/**
+ * Investigação: planner, evidência, crítico e cobertura.
+ */
+
+import { afterAll, describe, expect, test } from "bun:test";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { AgentState } from "../harness/investigation/agent-state";
+import { EvidenceVerifier } from "../harness/investigation/evidence-verifier";
+import { FindingCritic } from "../harness/investigation/finding-critic";
+import { InvestigationPlanner } from "../harness/investigation/investigation-planner";
+import { RuleAnalyzer } from "../harness/investigation/rule-analyzer";
+
+const RULE = "Nunca usar `any`.";
+const analyses = new RuleAnalyzer().analyze([
+	{ severity: "suggestion", text: "Evitar console.log." },
+	{ severity: "blocking", text: RULE },
+	{ severity: "attention", text: "Validar entrada do usuário." },
+]);
+
+const dir = mkdtempSync(join(tmpdir(), "houndsman-evidence-"));
+const file = join(dir, "a.ts");
+writeFileSync(file, "const x: any = 1;\nconsole.log(x);\n");
+afterAll(() => rmSync(dir, { recursive: true, force: true }));
+
+function verifier(): EvidenceVerifier {
+	return new EvidenceVerifier({
+		allowedFiles: ["a.ts"],
+		readFile: (path) =>
+			path === "a.ts" ? "const x: any = 1;\nconsole.log(x);\n" : null,
+	});
+}
+
+describe("InvestigationPlanner", () => {
+	test("prioriza por severidade e calcula estimativa", () => {
+		const plan = new InvestigationPlanner().plan(
+			{ watchdogId: "alpha", files: ["a.ts"], symbols: [] },
+			analyses,
+		);
+		expect(plan.tasks[0]?.rule).toBe(RULE);
+		expect(plan.tasks[0]?.severity).toBe("blocking");
+		expect(plan.totalFiles).toBe(1);
+		expect(plan.estimatedToolCalls).toBeGreaterThan(0);
+	});
+
+	test("filtra arquivos por hint de path", () => {
+		const [analysis] = new RuleAnalyzer().analyze([
+			{
+				severity: "attention",
+				text: "Evitar: query no banco em rota.",
+				hints: { paths: ["^src/alpha/"] },
+			},
+		]);
+		const plan = new InvestigationPlanner().plan(
+			{
+				watchdogId: "alpha",
+				files: ["src/alpha/a.ts", "src/beta/b.ts"],
+				symbols: [],
+			},
+			analysis ? [analysis] : [],
+		);
+		expect(plan.tasks[0]?.files).toEqual(["src/alpha/a.ts"]);
+	});
+});
+
+describe("EvidenceVerifier", () => {
+	test("aceita snippet na linha e reancora quando deslocado", () => {
+		const state = new AgentState();
+		const exact = state.addEvidence({
+			file: "a.ts",
+			startLine: 1,
+			endLine: 1,
+			snippet: "const x: any = 1;",
+			kind: "definition",
+			sourceTool: "t",
+			confidence: 0.9,
+		});
+		const moved = state.addEvidence({
+			file: "a.ts",
+			startLine: 9,
+			endLine: 9,
+			snippet: "console.log(x);",
+			kind: "reference",
+			sourceTool: "t",
+			confidence: 0.7,
+		});
+		expect(verifier().verify(exact).valid).toBe(true);
+		const verdict = verifier().verify(moved);
+		expect(verdict.valid).toBe(true);
+		expect(verdict.startLine).toBe(2);
+	});
+
+	test("rejeita arquivo fora do domínio e snippet inexistente", () => {
+		const state = new AgentState();
+		const outside = state.addEvidence({
+			file: "b.ts",
+			startLine: 1,
+			endLine: 1,
+			snippet: "x",
+			kind: "definition",
+			sourceTool: "t",
+			confidence: 1,
+		});
+		const missing = state.addEvidence({
+			file: "a.ts",
+			startLine: 1,
+			endLine: 1,
+			snippet: "não existe",
+			kind: "definition",
+			sourceTool: "t",
+			confidence: 1,
+		});
+		expect(verifier().verify(outside).valid).toBe(false);
+		expect(verifier().verify(missing).valid).toBe(false);
+	});
+
+	test("draft sem evidência válida é inválido", () => {
+		const state = new AgentState();
+		const evidence = state.addEvidence({
+			file: "a.ts",
+			startLine: 1,
+			endLine: 1,
+			snippet: "const x: any = 1;",
+			kind: "definition",
+			sourceTool: "t",
+			confidence: 0.9,
+		});
+		const draft = {
+			rule: RULE,
+			severity: "blocking" as const,
+			file: "a.ts",
+			line: 1,
+			message: "m",
+			action: "a",
+			evidenceIds: [evidence.id],
+			confidence: 0.9,
+		};
+		expect(verifier().verifyDraft(draft, state).valid).toBe(true);
+		expect(
+			verifier().verifyDraft({ ...draft, evidenceIds: ["nope"] }, state).valid,
+		).toBe(false);
+	});
+});
+
+describe("FindingCritic", () => {
+	const state = new AgentState();
+	const evidence = state.addEvidence({
+		file: "a.ts",
+		startLine: 1,
+		endLine: 1,
+		snippet: "const x: any = 1;",
+		kind: "definition",
+		sourceTool: "t",
+		confidence: 0.9,
+	});
+	const critic = new FindingCritic({
+		knownRules: new Set([RULE]),
+		verifier: verifier(),
+	});
+	const draft = {
+		rule: RULE,
+		severity: "blocking" as const,
+		file: "a.ts",
+		line: 1,
+		message: "m",
+		action: "a",
+		evidenceIds: [evidence.id],
+		confidence: 0.9,
+	};
+
+	test("keep com evidência e confiança", () => {
+		expect(critic.reviewOne(draft, state).verdict).toBe("keep");
+	});
+
+	test("drop sem evidência, sem regra ou confiança baixa", () => {
+		expect(critic.reviewOne({ ...draft, evidenceIds: [] }, state).verdict).toBe(
+			"drop",
+		);
+		expect(critic.reviewOne({ ...draft, rule: "inexistente" }, state).verdict).toBe(
+			"drop",
+		);
+		expect(critic.reviewOne({ ...draft, confidence: 0.2 }, state).verdict).toBe(
+			"drop",
+		);
+	});
+
+	test("downgrade quando a confiança não sustenta a severidade", () => {
+		expect(critic.reviewOne({ ...draft, confidence: 0.5 }, state).verdict).toBe(
+			"downgrade",
+		);
+	});
+});
+
+describe("AgentState", () => {
+	test("cobertura e hipóteses sem duplicar", () => {
+		const state = new AgentState();
+		state.addHypothesis("a");
+		state.addHypothesis("a");
+		expect(state.hypotheses).toEqual(["a"]);
+		state.setCoverage(RULE, "skipped", "motivo");
+		expect(state.isCovered(RULE)).toBe(true);
+		state.setCoverage(RULE, "checked");
+		expect(state.coverageOf(RULE)?.status).toBe("checked");
+	});
+});

package/src/tests/harness-tools.test.ts

@@ -0,0 +1,148 @@
+/**
+ * Tools do harness: path guard, limites, cache, budget e redaction.
+ */
+
+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 { 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 { PathGuard } from "../harness/tools/path-guard";
+import { redactSecrets } from "../harness/tools/secret-redactor";
+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 { EchoTool } from "./fixtures/fake-agent-tools";
+import { fakeAgentContext } from "./fixtures/fake-investigation";
+import { fakeHoundsmanConfig } from "./fixtures/fake-project";
+
+const dir = mkdtempSync(join(tmpdir(), "houndsman-tools-"));
+mkdirSync(join(dir, "src/alpha"), { recursive: true });
+writeFileSync(
+	join(dir, "src/alpha/a.ts"),
+	"const x: any = 1;\nconsole.log(x);\nconst y = 2;\n",
+);
+afterAll(() => rmSync(dir, { recursive: true, force: true }));
+
+function context(): ToolContext {
+	const state = new AgentState();
+	return {
+		repoRoot: dir,
+		watchdog: new Watchdog(fakeHoundsmanConfig.watchdogs.alpha),
+		diff: { byFile: new Map(), churn: new Map() },
+		ast: new AstService(fakeHoundsmanConfig),
+		state,
+		budget: new ToolCallBudget(20, 10),
+		cache: new ToolCache(),
+		logger: new SilentReporter(),
+		agent: fakeAgentContext({ repoRoot: dir }),
+		rules: new Map(),
+	};
+}
+
+describe("PathGuard", () => {
+	test("bloqueia traversal, .git e .env", () => {
+		const guard = new PathGuard(dir);
+		expect(() => guard.resolvePath("../segredo")).toThrow();
+		expect(() => guard.resolvePath(".git/config")).toThrow();
+		expect(() => guard.resolvePath(".env")).toThrow();
+	});
+
+	test("aceita caminho interno", () => {
+		const guard = new PathGuard(dir);
+		expect(guard.resolvePath("src/alpha/a.ts")).toContain("a.ts");
+	});
+});
+
+describe("read_file_range", () => {
+	test("devolve faixa numerada + evidência com id", async () => {
+		const registry = new ToolRegistry();
+		registry.registerModule(new BuiltinToolsModule());
+		const middleware = new ToolMiddleware();
+		const ctx = context();
+		const result = await registry.execute(
+			"read_file_range",
+			{ path: "src/alpha/a.ts", startLine: 1, endLine: 2 },
+			ctx,
+			middleware,
+		);
+		expect(result.ok).toBe(true);
+		const data = result.data as { content: string };
+		expect(data.content).toContain("1\tconst x: any = 1;");
+		expect(data.content).toContain("2\tconsole.log(x);");
+		expect(result.evidence?.[0]?.id).toBeTruthy();
+		expect(ctx.state.evidence.size).toBe(1);
+	});
+
+	test("caminho fora do repo vira erro estruturado", async () => {
+		const registry = new ToolRegistry();
+		registry.registerModule(new BuiltinToolsModule());
+		const result = await registry.execute(
+			"read_file_range",
+			{ path: "../x", startLine: 1, endLine: 2 },
+			context(),
+			new ToolMiddleware(),
+		);
+		expect(result.ok).toBe(false);
+		expect(result.error).toContain("fora do repositório");
+	});
+});
+
+describe("ToolRegistry / middleware", () => {
+	test("nome duplicado falha no registro", () => {
+		const registry = new ToolRegistry();
+		registry.registerTool(new EchoTool());
+		expect(() => registry.registerTool(new EchoTool())).toThrow();
+	});
+
+	test("resultado em cache não consome budget", async () => {
+		const registry = new ToolRegistry();
+		registry.registerTool(new EchoTool());
+		const middleware = new ToolMiddleware();
+		const ctx = context();
+		await registry.execute("echo", { value: "a" }, ctx, middleware);
+		expect(ctx.budget.total).toBe(1);
+		await registry.execute("echo", { value: "a" }, ctx, middleware);
+		expect(ctx.budget.total).toBe(1);
+		await registry.execute("echo", { value: "b" }, ctx, middleware);
+		expect(ctx.budget.total).toBe(2);
+	});
+
+	test("input inválido vira erro (Zod)", async () => {
+		const registry = new ToolRegistry();
+		registry.registerTool(new EchoTool());
+		const result = await registry.execute(
+			"echo",
+			{ value: 1 },
+			context(),
+			new ToolMiddleware(),
+		);
+		expect(result.ok).toBe(false);
+		expect(result.error).toContain("input inválido");
+	});
+
+	test("budget esgotado interrompe", async () => {
+		const registry = new ToolRegistry();
+		registry.registerTool(new EchoTool());
+		const ctx = context();
+		ctx.budget = new ToolCallBudget(1, 1);
+		const middleware = new ToolMiddleware();
+		await registry.execute("echo", { value: "a" }, ctx, middleware);
+		const second = await registry.execute("echo", { value: "b" }, ctx, middleware);
+		expect(second.ok).toBe(false);
+		expect(second.error).toContain("Orçamento");
+	});
+});
+
+describe("redaction", () => {
+	test("remove tokens e chaves", () => {
+		expect(redactSecrets("token sk-abcdefgh123")).toContain("[REDACTED]");
+		expect(redactSecrets("api_key = segredo")).toContain("[REDACTED]");
+	});
+});

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);
+	});
+});