@payconductor/houndsman 0.11.0 → 0.13.0

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

@@ -1,212 +0,0 @@
-/**
- * `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/rule-analyzer.test.ts

@@ -1,61 +0,0 @@
-/**
- * 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

@@ -1,82 +0,0 @@
-/**
- * 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);
-	});
-});