@payconductor/houndsman 0.5.0 → 0.7.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/server-editor.test.ts

@@ -0,0 +1,100 @@
+import { describe, expect, test } from "bun:test";
+import {
+	editorFileLink,
+	jetbrainsFileLink,
+	vscodeFileLink,
+} from "../server/client/utils/format";
+import { detectEditor, resolveEditor } from "../server/editor";
+
+describe("detecção de editor", () => {
+	test("VS Code pelo TERM_PROGRAM", () => {
+		expect(detectEditor({ TERM_PROGRAM: "vscode" }, "/work/app")).toMatchObject({
+			kind: "vscode",
+			project: "app",
+		});
+	});
+
+	test("VS Code pelas variáveis VSCODE_*", () => {
+		expect(detectEditor({ VSCODE_PID: "123" }, "/work/app")).toMatchObject({
+			kind: "vscode",
+			project: "app",
+		});
+	});
+
+	test("JetBrains pelo terminal e produto do bundle", () => {
+		expect(
+			detectEditor(
+				{
+					TERMINAL_EMULATOR: "JetBrains-JediTerm",
+					__CFBundleIdentifier: "com.jetbrains.pycharm",
+				},
+				"/work/app",
+			),
+		).toEqual({ kind: "jetbrains", project: "app", product: "pycharm" });
+	});
+
+	test("JetBrains por *_INITIAL_DIRECTORY", () => {
+		expect(
+			detectEditor({ WEBSTORM_INITIAL_DIRECTORY: "/work/app" }, "/work/app"),
+		).toEqual({ kind: "jetbrains", project: "app", product: "webstorm" });
+	});
+
+	test("produto JetBrains ambíguo cai em idea", () => {
+		expect(
+			detectEditor({ TERMINAL_EMULATOR: "JetBrains-JediTerm" }, "/work/app"),
+		).toEqual({ kind: "jetbrains", project: "app", product: "idea" });
+	});
+
+	test("sem pistas → none", () => {
+		expect(detectEditor({}, "/work/app")).toEqual({
+			kind: "none",
+			project: "app",
+		});
+	});
+
+	test("resolveEditor força vscode/jetbrains/none", () => {
+		expect(resolveEditor("vscode", {}, "/work/app")).toMatchObject({
+			kind: "vscode",
+		});
+		expect(resolveEditor("jetbrains", {}, "/work/app")).toMatchObject({
+			kind: "jetbrains",
+			product: "idea",
+		});
+		expect(
+			resolveEditor("none", { TERM_PROGRAM: "vscode" }, "/work/app"),
+		).toMatchObject({ kind: "none" });
+		expect(resolveEditor("desconhecido", {}, "/work/app")).toMatchObject({
+			kind: "none",
+		});
+	});
+});
+
+describe("links de editor", () => {
+	test("VS Code normaliza o drive e mantém a linha", () => {
+		expect(vscodeFileLink("C:\\repo\\src\\a.ts", 12)).toBe(
+			"vscode://file/c:/repo/src/a.ts:12",
+		);
+	});
+
+	test("JetBrains monta navigate/reference", () => {
+		const link = jetbrainsFileLink("C:\\repo\\src\\a.ts", 12, "app", "webstorm");
+		expect(link).toContain(
+			"jetbrains://webstorm/navigate/reference?project=app&path=",
+		);
+		expect(link ? decodeURIComponent(link) : "").toContain("C:/repo/src/a.ts:12");
+	});
+
+	test("editorFileLink respeita o tipo detectado", () => {
+		expect(editorFileLink("/repo/a.ts", 3, { kind: "vscode", project: "app" })).toBe(
+			"vscode://file//repo/a.ts:3",
+		);
+		expect(
+			editorFileLink("/repo/a.ts", 3, {
+				kind: "jetbrains",
+				project: "app",
+				product: "goland",
+			}),
+		).toContain("jetbrains://goland/");
+		expect(editorFileLink("/repo/a.ts", 3, { kind: "none" })).toBeNull();
+	});
+});