@payconductor/houndsman 0.4.0 → 0.6.0

package/src/tests/fixtures/fake-agent-tools.ts

@@ -0,0 +1,69 @@
+/**
+ * Tools fake para a suíte do harness.
+ */
+
+import { z } from "zod";
+import type {
+	AgentTool,
+	ToolContext,
+	ToolMetadata,
+	ToolResult,
+} from "../../harness/tools/agent-tool";
+
+/** Tool de eco (testa registry/middleware). */
+export class EchoTool implements AgentTool<{ value: string }, { value: string }> {
+	readonly metadata: ToolMetadata = {
+		name: "echo",
+		description: "Devolve o valor recebido.",
+		category: "context",
+		capabilities: ["read"],
+		readOnly: true,
+		cost: 1,
+		cacheTtlMs: 60_000,
+	};
+
+	readonly inputSchema = z.object({ value: z.string() });
+
+	async execute(
+		input: { value: string },
+		_context: ToolContext,
+	): Promise<ToolResult<{ value: string }>> {
+		return { ok: true, data: { value: input.value } };
+	}
+}
+
+/** Tool que produz evidência para o estado. */
+export class EvidenceTool implements AgentTool<{ file: string }, unknown> {
+	readonly metadata: ToolMetadata = {
+		name: "evidence",
+		description: "Produz uma evidência fake.",
+		category: "evidence",
+		capabilities: ["read"],
+		readOnly: true,
+		cost: 1,
+	};
+
+	readonly inputSchema = z.object({ file: z.string() });
+
+	async execute(
+		input: { file: string },
+		_context: ToolContext,
+	): Promise<ToolResult<unknown>> {
+		return {
+			ok: true,
+			data: { file: input.file },
+			evidence: [
+				{
+					id: "",
+					file: input.file,
+					startLine: 1,
+					endLine: 1,
+					snippet: "const x: any = 1;",
+					kind: "definition",
+					sourceTool: "evidence",
+					confidence: 0.9,
+				},
+			],
+		};
+	}
+}

package/src/tests/fixtures/fake-investigation.ts

@@ -0,0 +1,64 @@
+/**
+ * Fixtures de investigação/agente (sem rede, sem git).
+ */
+
+import { AstService } from "../../core/ast/service";
+import { Watchdog } from "../../core/domain/watchdog";
+import type { AgentContext } from "../../harness/agent/agent-context";
+import { SilentReporter } from "../../harness/agent/agent-reporter";
+import type { ReviewAgentDeps } from "../../harness/agent/review-agent";
+import { RuleAnalyzer } from "../../harness/investigation/rule-analyzer";
+import { BuiltinToolsModule } from "../../harness/tools/builtin";
+import { ToolRegistry } from "../../harness/tools/tool-registry";
+import type { FakeModelProvider } from "./fake-model-provider";
+import { fakeHoundsmanConfig } from "./fake-project";
+
+/** Contexto de agente para o watchdog `alpha`. */
+export function fakeAgentContext(overrides: Partial<AgentContext> = {}): AgentContext {
+	const watchdog = new Watchdog(fakeHoundsmanConfig.watchdogs.alpha);
+	const rules = new RuleAnalyzer().analyze(watchdog.rules);
+	return {
+		watchdog,
+		projectName: "Fake",
+		branch: "main",
+		files: ["src/alpha/a.ts"],
+		overflow: [],
+		deleted: [],
+		docs: [],
+		context: null,
+		ast: new Map(),
+		outputPath: "findings/alpha.json",
+		maxSteps: 4,
+		maxCalls: 8,
+		repoRoot: process.cwd(),
+		diff: { byFile: new Map(), churn: new Map() },
+		rules,
+		...overrides,
+	};
+}
+
+/** Registry com tools built-in. */
+export function builtinRegistry(): ToolRegistry {
+	const registry = new ToolRegistry();
+	registry.registerModule(new BuiltinToolsModule());
+	return registry;
+}
+
+/** Deps completas de um `ReviewAgent` com provider fake. */
+export function fakeAgentDeps(
+	provider: FakeModelProvider,
+	overrides: Partial<ReviewAgentDeps> = {},
+): ReviewAgentDeps {
+	const context = overrides.context ?? fakeAgentContext();
+	return {
+		context,
+		provider,
+		registry: builtinRegistry(),
+		reporter: new SilentReporter(),
+		maxOutputTokens: 512,
+		temperature: 0,
+		timeoutMs: 5_000,
+		ast: new AstService(fakeHoundsmanConfig),
+		...overrides,
+	};
+}

package/src/tests/fixtures/fake-model-provider.ts

@@ -0,0 +1,48 @@
+/**
+ * Provider de modelo fake — suíte sem rede.
+ */
+
+import type { AiUsage, ModelProvider, ModelRequest, ModelResponse } from "../../core/ai";
+
+/** Uso padrão de uma chamada fake. */
+export function fakeUsage(calls = 1): AiUsage {
+	return {
+		inputTokens: 10 * calls,
+		outputTokens: 5 * calls,
+		totalTokens: 15 * calls,
+		calls,
+	};
+}
+
+/** Handler roteirizado: recebe o request e o índice da chamada. */
+export type FakeHandler = (
+	request: ModelRequest<unknown>,
+	index: number,
+) => unknown | Promise<unknown>;
+
+/** Provider roteirizado. */
+export class FakeModelProvider implements ModelProvider {
+	readonly name = "deepseek" as const;
+	readonly modelId: string;
+	readonly requests: ModelRequest<unknown>[] = [];
+	calls = 0;
+
+	constructor(
+		private readonly handler: FakeHandler,
+		modelId = "fake-model",
+	) {
+		this.modelId = modelId;
+	}
+
+	async generate<T>(request: ModelRequest<T>): Promise<ModelResponse<T>> {
+		this.requests.push(request as ModelRequest<unknown>);
+		const index = this.calls++;
+		const output = await this.handler(request as ModelRequest<unknown>, index);
+		return {
+			output: output as T,
+			usage: fakeUsage(),
+			steps: 1,
+			finishReason: "stop",
+		};
+	}
+}