@payconductor/houndsman 0.4.0 → 0.6.0

package/README.md

@@ -26,8 +26,13 @@ diferente das PRs. O motor só coordena a caçada — as regras são problema se
 
 - **Bun** — runtime obrigatório.
 - **git** — o diff usa `git diff <base>...<head>`.
-- Opcionais: **`gh`** (contexto da PR) e **`TYPESAFE_API_KEY`** (pré-análise Jev). A revisão
-  funciona normalmente sem eles; o `houndsman doctor` valida a credencial Jev quando presente.
+- **gh** (Opcional) — Obtém contexto da PR e dispara comentários para o GitHub
+- **`HOUNDSMAN_TYPE_SAFE_API_KEY`** (opcional) — pré-análise Jev.
+- **`HOUNDSMAN_DEEP_SEEK_API_KEY`** (opcional) — IA própria do `hunt` nativo e das features de IA.
+- **`HOUNDSMAN_OPENAI_API_KEY`** / **`HOUNDSMAN_ANTHROPIC_API_KEY`** (opcional) — apenas se
+  `ai.provider` for `openai`/`anthropic`.
+
+> Coloque as chaves em um `.env` na raiz do projeto; o Bun carrega automaticamente.
 
 ### 2. Instale o CLI (global)
 
@@ -48,13 +53,14 @@ Cria a camada `.houndsman/`, que é **autocontida** (não instala nada no seu pr
 | Caminho | Dono | O que é |
 |---|---|---|
 | `houndsman.config.ts` | você | Configuração do projeto (um objeto de dados) |
-| `.houndsman/watchdogs/` | você | Suas regras — começa com **1 watchdog de exemplo** |
+| `.houndsman/watchdogs/` | você | Suas regras — começa com um watchdog `default` (fallback) e um `example` |
 | `.houndsman/exclusions.ts` | você | Arquivos que nunca entram na revisão |
 | `.houndsman/doc-mappings.ts` | você | path → documentação de contexto |
 | `.houndsman/core/**` | auto | Tipos + docs do skill (sincronizados por `houndsman update`) |
 
-> O `setup` já cria a camada inicial com um watchdog de exemplo — troque o exemplo pelas
-> regras reais do seu projeto (ou use `/houndsman train`).
+> O `setup` já cria a camada inicial com um watchdog `default` (fallback, cobre arquivos sem
+> domínio) e um `example` — troque o exemplo pelas regras reais do seu projeto (ou use
+> `/houndsman train`).
 
 ### 4. Escreva suas regras
 
@@ -78,6 +84,20 @@ O skill orquestra tudo e persiste o relatório no storage global (SQLite em
 `<HOUNDSMAN_HOME>/houndsman.db`); a UI lê os artefatos direto do storage. Não precisa rodar
 nenhum script à mão.
 
+### 7. Revisão nativa (opcional) — `houndsman hunt`
+
+Além do skill, o houndsman tem um **harness próprio**: o `hunt` roda o agente de revisão
+dentro do CLI, com tools read-only, investigação por evidência e a mesma saída `review.md`.
+
+```bash
+bun run houndsman hunt --dry-run     # inspeciona watchdogs/arquivos, sem IA
+HOUNDSMAN_DEEP_SEEK_API_KEY=... bun run houndsman hunt
+bun run houndsman hunt --resume      # preserva findings válidos do staging
+bun run houndsman hunt --fail-on-blocking
+```
+
+Detalhes (catálogo de tools, máquina de estados, custos e segurança): [`docs/HARNESS.md`](docs/HARNESS.md).
+
 ---
 
 ## O fluxo de trabalho
@@ -95,62 +115,38 @@ nenhum script à mão.
 
 O skill tem **4 capabilities**, todas em `/houndsman`:
 
-- **`hunt`** — revisa a PR (default: `/houndsman` = `/houndsman hunt`).
+- **`hunt`** — revisa a PR.
 - **`train`** — mantém/atualiza as regras dos watchdogs.
-- **`fix`** — corrige os findings marcados (`/houndsman fix`).
-- **`verify`** — confere se as violações foram resolvidas (`/houndsman verify`), sem re-revisar.
+- **`fix`** — corrige os findings marcados.
+- **`verify`** — confere se as violações foram resolvidas, sem re-revisar.
 
-- Revisão normal: `/houndsman` ou `/houndsman hunt` (a branch é detectada; base default `main`).
 - Revisar outra branch: `/houndsman hunt feature/minha-branch`.
-- Validar e triar na UI: `houndsman server --open` — marque os achados a executar (`execute`).
-- Manual (sem skill): `houndsman context` → `houndsman --base main` → *(subagentes)* →
-  `houndsman --finalize`.
-- CI: `houndsman --finalize --fail-on-blocking` (exit 1 se houver bloqueantes).
+- Validar na UI: `houndsman server --open` — marque os findings a executar (`execute`).
 
 ---
 
-## Triando os findings (opcional)
+## Validando os findings (opcional)
 
-Depois do `--finalize`, cada finding tem um `id` curto e um `fingerprint` de **conteúdo**
-no storage global. Você decide o que fazer com cada um — pela
-**UI local** ou pelo **agente** (auto-fix) — sem abrir o JSON à mão:
+Você decide o que fazer com cada finding pela **UI local**, informando se quer `Executar` ou `Ignorar`
 
 ```bash
 bun run houndsman server --open     # UI: triar, comentar, marcar feito, ler artefatos
 ```
 
-- **decision:** `pending` · `execute` · `ignore` (+ comentário).
-- **execState:** `pending` · `in_progress` · `done` · `stale`.
-
-**Auto-fix pelo agente** — as linhas mudam depois do fix, e o motor reancora por conteúdo:
-
-```bash
-bun run houndsman findings batch --json     # grupo atual (agrupamento automático) + outros
-# ... o agente corrige apenas esse grupo ...
-bun run houndsman findings sync             # reancora por conteúdo
-bun run houndsman findings done <id>
-bun run houndsman findings verify           # confere o que resolveu (barato, sem re-revisar)
-```
-
-> A partir da 2ª revisão o `hunt` é **incremental**: revisa só os arquivos que mudaram desde
-> o último `--finalize` e **carrega** os findings dos arquivos inalterados. `--full` força
-> o review completo.
-
-> A identidade do finding é o **conteúdo** (fingerprint), não a linha: itens deslocados
-> pelo fix não se perdem. O estado mora no storage global (`<HOUNDSMAN_HOME>/houndsman.db`).
+> A partir da 2ª revisão o `hunt` é **incremental**: revisa apenas os arquivos que mudaram desde
+> a última revisão. `--full` força o review completo.
 
 ---
 
 ## Mantendo a configuração
 
 - **Persistência** → por default, SQLite global em `<HOUNDSMAN_HOME>/houndsman.db`
-  (`HOUNDSMAN_HOME` sobrescreve o diretório de dados). Para voltar ao backend de arquivos,
-  troque só o provider — a interface `StorageProvider` é a mesma:
+  (`HOUNDSMAN_HOME` sobrescreve o diretório de dados). Caso queira storage base em arquivos, na config, troque provider para `file`:
 
   ```ts
   export const houndsmanConfig = {
     // ...
-    storage: { provider: "file", path: "./houndsman-runs" },
+    storage: { provider: "file", path: "./houndsman/runs" },
   };
   ```
 
@@ -165,8 +161,6 @@ bun run houndsman findings verify           # confere o que resolveu (barato, se
 
   O `update` reescreve **só** `.houndsman/core/**` e `.houndsman/.gitignore`. Seus arquivos
   (`watchdogs/`, `exclusions.ts`, `doc-mappings.ts`, `houndsman.config.ts`) nunca são tocados.
-- **Recomeçar a camada do zero** → `houndsman setup --force` (sobrescreve só os arquivos do
-  usuário; sem `--force` o `setup` é idempotente).
 
 ---
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@payconductor/houndsman",
-	"version": "0.4.0",
+	"version": "0.6.0",
 	"description": "Orquestrador de revisão de Pull Requests: classifica o diff, despacha watchdogs especializados por domínio e consolida o relatório.",
 	"type": "module",
 	"license": "MIT",
@@ -51,14 +51,22 @@
 		"ci:check:fix": "biome check --fix",
 		"ci:fix": "bun run ci:check:fix && bun run ci:format:fix",
 		"ci:format": "biome format",
-		"ci:format:fix": "biome format --fix"
+		"ci:format:fix": "biome format --fix",
+		"grammars:sync": "bun run ./scripts/sync-grammars.ts"
 	},
 	"dependencies": {
+		"@ai-sdk/deepseek": "3.0.67",
+		"ai": "7.0.143",
 		"axios": "^1.12.2",
-		"preact": "^11.0.1"
+		"chalk": "^6.0.1",
+		"ora": "^9.4.1",
+		"preact": "^11.0.1",
+		"web-tree-sitter": "0.27.1",
+		"zod": "4.6.7"
 	},
 	"devDependencies": {
 		"@biomejs/biome": "2.2.4",
+		"@vscode/tree-sitter-wasm": "0.3.1",
 		"bun-types": "^1.3.14",
 		"typescript": "^7.0.2"
 	}

package/src/cli/commands/command.ts

@@ -6,13 +6,18 @@
  */
 
 import type { HoundsmanEngine } from "../../core/engine/houndsman-engine";
+import type { LoggerLike } from "../../core/logging";
 
 /** Contexto de execução de um comando. */
 export type CliContext = {
 	cwd: string;
 	/** Carrega a config do projeto e devolve o engine (lazy). */
 	engine: () => Promise<HoundsmanEngine>;
+	/** Logger único do CLI (cores/spinner/progresso). */
+	logger: LoggerLike;
+	/** @deprecated use `logger.info`. */
 	out: (message: string) => void;
+	/** @deprecated use `logger.error`. */
 	err: (message: string) => void;
 };
 

package/src/cli/commands/doctor-command.ts

@@ -1,60 +1,152 @@
-/** Comando `doctor` (alias `check`) — valida config, ambiente e credencial Jev. */
+/** Comando `doctor` (alias `check`) — valida config, ambiente e credenciais. */
 
+import type { AiClient } from "../../core/ai/ai-client";
+import { ArgParser } from "../../core/arg-parser";
+import type { AiProviderKind } from "../../core/config";
+import { ENV_NAMES, env } from "../../core/env";
 import { checkRegistry } from "../../core/registry-check";
 import { storageLocation } from "../../core/storage/paths";
 import type { CliContext, Command } from "./command";
 
+/** Chave de ambiente esperada por provider. */
+function keyFor(provider: AiProviderKind): string | undefined {
+	switch (provider) {
+		case "deepseek":
+			return env.deepSeekApiKey;
+		case "openai":
+			return env.openAiApiKey;
+		case "anthropic":
+			return env.anthropicApiKey;
+		default:
+			return undefined;
+	}
+}
+
+/** Nome da variável de ambiente por provider. */
+function envNameFor(provider: AiProviderKind): string {
+	switch (provider) {
+		case "openai":
+			return ENV_NAMES.openAiApiKey;
+		case "anthropic":
+			return ENV_NAMES.anthropicApiKey;
+		default:
+			return ENV_NAMES.deepSeekApiKey;
+	}
+}
+
 export class DoctorCommand implements Command {
 	readonly name = "doctor";
 
-	async run(_args: string[], context: CliContext): Promise<number> {
+	async run(args: string[], context: CliContext): Promise<number> {
+		const parser = ArgParser.from(args);
+		const noPing = parser.has("--no-ping");
 		const engine = await context.engine();
-		context.out("→ Validando configuração do projeto...");
+		const { logger } = context;
+
+		logger.step("Validando configuração do projeto...");
 		const { problems, warnings, jevQuestions } = checkRegistry(engine.config);
 
 		if (problems.length > 0) {
-			context.err("\n❌ Problemas na configuração de revisão:\n");
-			for (const problem of problems) context.err(`  - ${problem}`);
+			logger.error("Problemas na configuração de revisão:");
+			for (const problem of problems) logger.error(`  - ${problem}`);
 			return 1;
 		}
-		context.out(
-			`  ✅ ${engine.config.watchdogIds.length} watchdogs, ${jevQuestions} pergunta(s) Jev.`,
+		logger.success(
+			`${engine.config.watchdogIds.length} watchdogs, ${jevQuestions} pergunta(s) Jev.`,
 		);
 
 		if (warnings.length > 0) {
-			context.out(`\n⚠️  ${warnings.length} aviso(s) (não bloqueantes):`);
-			for (const warning of warnings) context.out(`  - ${warning}`);
-		}
-
-		context.out("\n→ Ambiente:");
-		context.out(`  ${Bun.which("git") ? "✅" : "❌"} git`);
-		context.out(`  ${Bun.which("gh") ? "✅" : "⚠️ "} gh (opcional — contexto da PR)`);
-		context.out("\n→ Persistência:");
-		context.out(`  provider: ${engine.storage.kind}`);
-		context.out(`  ${storageLocation(engine.config)}`);
-		context.out(`  repo: ${engine.repo.key}`);
-		await this.reportJevCredential(context);
+			logger.warn(`${warnings.length} aviso(s) (não bloqueantes):`);
+			for (const warning of warnings) logger.bullet(warning);
+		}
+
+		logger.step("Ambiente:");
+		logger.bullet(`${Bun.which("git") ? "✅" : "❌"} git`);
+		logger.bullet(`${Bun.which("gh") ? "✅" : "⚠️ "} gh (opcional — contexto da PR)`);
+		const ast = await engine.ast.check();
+		logger.bullet(`${ast.ok ? "✅" : "⚠️ "} AST: ${ast.detail}`);
+
+		const provider = engine.ai.projectConfig.aiProvider;
+		const key = keyFor(provider);
+		logger.bullet(
+			`${key ? "✅" : "⚠️ "} ${envNameFor(provider)} (provider ${provider})`,
+		);
+		logger.bullet(
+			`IA: provider=${provider}, model=${engine.ai.modelId}, ` +
+				`disponível=${engine.ai.available ? "sim" : "não"}`,
+		);
+
+		await this.reportAiCredential(context, engine.ai, provider, key, noPing);
+		await this.reportJevCredential(context, noPing);
+
+		logger.step("Persistência:");
+		logger.bullet(`provider: ${engine.storage.kind}`);
+		logger.bullet(storageLocation(engine.config));
+		logger.bullet(`repo: ${engine.repo.key}`);
 		return 0;
 	}
 
+	/**
+	 * Valida a credencial do provider de IA com um ping mínimo. Fail-open:
+	 * problemas de credencial são diagnóstico e não alteram o exit code.
+	 */
+	private async reportAiCredential(
+		context: CliContext,
+		ai: AiClient,
+		provider: AiProviderKind,
+		key: string | undefined,
+		noPing: boolean,
+	): Promise<void> {
+		if (!key) {
+			context.logger.warn(
+				`IA: ${provider} sem credencial — features de IA ficam fail-open.`,
+			);
+			return;
+		}
+		if (noPing) {
+			context.logger.info("IA: validação pulada (--no-ping).");
+			return;
+		}
+		context.logger.step("Validando credencial de IA...");
+		const check = await ai.validateCredential();
+		if (check.ok) {
+			context.logger.success(
+				`IA: credencial válida (modelo ${check.model ?? provider}).`,
+			);
+		} else if (check.kind === "invalid") {
+			context.logger.error(`IA: credencial inválida — ${check.detail}`);
+		} else {
+			context.logger.warn(`IA: não foi possível validar — ${check.detail}`);
+		}
+	}
+
 	/**
 	 * Reporta o estado da credencial Jev: presença e validade (chamada mínima).
 	 * Fail-open — nunca altera o exit code (`doctor` é diagnóstico).
 	 */
-	private async reportJevCredential(context: CliContext): Promise<void> {
+	private async reportJevCredential(
+		context: CliContext,
+		noPing: boolean,
+	): Promise<void> {
 		const { JevClient } = await import("../../core/jev");
 		const client = new JevClient();
 		if (!client.isConfigured()) {
-			context.out("  ⚠️  TYPESAFE_API_KEY (opcional — pré-análise Jev)");
+			context.logger.warn(
+				`${ENV_NAMES.typeSafeApiKey} (opcional — pré-análise Jev)`,
+			);
+			return;
+		}
+		if (noPing) {
+			context.logger.info("Jev: validação pulada (--no-ping).");
 			return;
 		}
 		const check = await client.validateCredential();
 		if (check.ok) {
-			context.out(`  ✅ Jev: credencial válida (modelo ${check.model}).`);
+			context.logger.success(`Jev: credencial válida (modelo ${check.model}).`);
 		} else if (check.kind === "invalid") {
-			context.out(`  ❌ Jev: credencial inválida — ${check.detail}`);
+			context.logger.error(`Jev: credencial inválida — ${check.detail}`);
 		} else {
-			context.out(`  ⚠️  Jev: não foi possível validar — ${check.detail}`);
+			context.logger.warn(`Jev: não foi possível validar — ${check.detail}`);
 		}
 	}
 }

package/src/cli/commands/hunt-command.ts

@@ -0,0 +1,25 @@
+/** Comando `hunt` — revisão nativa com IA (harness próprio). */
+
+import { HuntHarness } from "../../harness";
+import { parseHuntArgs } from "../../harness/hunt/hunt-options";
+import type { CliContext, Command } from "./command";
+
+/** Executa o harness nativo. */
+export class HuntCommand implements Command {
+	readonly name = "hunt";
+
+	async run(args: string[], context: CliContext): Promise<number> {
+		const options = parseHuntArgs(args);
+		const engine = await context.engine();
+		try {
+			const harness = await HuntHarness.from(engine, options, context.logger);
+			const result = await harness.run();
+			for (const message of result.messages) context.logger.info(message);
+			if (result.status === "failed") return 1;
+			if (options.failOnBlocking && result.blockers > 0) return 1;
+			return 0;
+		} finally {
+			engine.close();
+		}
+	}
+}

package/src/cli/commands/status-command.ts

@@ -0,0 +1,46 @@
+/** Comando `status` — mostra o status da run ou renova o heartbeat (`status ping`). */
+
+import { pingStatus, readStatus } from "../../core/commands/status";
+import { ArgParser } from "../arg-parser";
+import type { CliContext, Command } from "./command";
+
+export class StatusCommand implements Command {
+	readonly name = "status";
+
+	async run(args: string[], context: CliContext): Promise<number> {
+		const parser = ArgParser.from(args);
+		const action = parser.command();
+		const branch = parser.value("--branch");
+
+		if (action && action !== "ping" && action !== "show") {
+			context.err(
+				`Ação desconhecida em 'status': '${action}'. Use 'status' ou 'status ping'.`,
+			);
+			return 1;
+		}
+
+		const engine = await context.engine();
+		const result =
+			action === "ping"
+				? pingStatus(engine.storage, engine.repo, branch)
+				: readStatus(engine.storage, engine.repo, branch);
+
+		if (action === "ping") {
+			context.out(
+				result.heartbeatAt
+					? `Heartbeat atualizado — ${result.branch} · ${result.status ?? "sem status"} · ${result.heartbeatAt}`
+					: `Sem execução ativa — ${result.branch} · ${result.status ?? "sem status"}.`,
+			);
+		} else {
+			context.out(
+				[
+					`Branch: ${result.branch}`,
+					`Status: ${result.status ?? "—"}`,
+					`Heartbeat: ${result.heartbeatAt ?? "—"}`,
+					`Atualizado: ${result.updatedAt}`,
+				].join("\n"),
+			);
+		}
+		return 0;
+	}
+}

package/src/cli/help.ts

@@ -5,7 +5,9 @@ Comandos:
   (nenhum)            Prepara a revisão (classification + briefs + manifesto)
   --finalize          Consolida os findings em review.md
   context             Coleta o contexto da PR via gh (Passo 0)
+  hunt                Revisão nativa com IA (harness próprio): prepare + agentes + finalize
   findings <sub>      Triagem/correção dos findings (list · show · set · done · reset · sync · summary · batch · verify · submit · path)
+  status [ping]       Mostra o status da run (ping renova o heartbeat da execução)
   server              Sobe a UI local de triagem (--port, --host, --open)
   setup               Cria a configuração inicial do projeto (config + skills)
   update              Sincroniza os arquivos auto-gerados (.houndsman/core)
@@ -21,8 +23,16 @@ Flags:
   --clean             Descarta findings brutos do staging anterior
   --full              Força review completo (ignora o modo incremental)
   --no-jev            Desativa a pré-análise Jev
+  --no-ast            Desativa a análise estrutural (tree-sitter)
+  --no-ai             Desativa as features de IA do fluxo normal
   --fail-on-blocking  Exit 1 se houver bloqueantes (com --finalize)
 
+Flags do hunt:
+  --base <b> · --head <ref> · --branch <nome> · --watchdog <id>
+  --full · --clean · --no-ast · --with-jev
+  --resume · --allow-partial · --dry-run · --fail-on-blocking
+  --max-calls <n> · --concurrency <n> · --provider <p> · --model <m>
+
 Flags de findings:
   --decision <d>      pending | execute | ignore
   --exec <e>          pending | in_progress | done | stale
@@ -40,8 +50,15 @@ Flags de findings:
   --fail-on-persisting (verify) Exit 1 se algum blocking persistir
   --include-sent      (submit) Reenvia findings já enviados à PR
   --dry-run           (submit) Só a prévia do envio, sem postar
+  --no-ping           (doctor) Pula a validação de rede das credenciais
 
 Persistência:
   Runs, findings e artefatos ficam no storage global (SQLite em
   <HOUNDSMAN_HOME>/houndsman.db). Use storage.provider: "file" na config para
-  voltar ao backend de arquivos. Nada é gravado em .houndsman/.runs.`;
+  voltar ao backend de arquivos. Nada é gravado em .houndsman/.runs.
+
+Ambiente (o Bun carrega .env automaticamente):
+  HOUNDSMAN_TYPE_SAFE_API_KEY   Pré-análise Jev (opcional)
+  HOUNDSMAN_DEEP_SEEK_API_KEY   IA (provider deepseek, opcional)
+  HOUNDSMAN_OPENAI_API_KEY     IA (provider openai, opcional)
+  HOUNDSMAN_ANTHROPIC_API_KEY  IA (provider anthropic, opcional)`;

package/src/cli/index.ts

@@ -15,6 +15,7 @@
  *   --finalize           Passo 3 — consolidar os findings em review.md
  *   context              Passo 0 — coletar o contexto da PR via `gh`
  *   findings <sub>       Triagem/correção dos findings (list/set/done/sync/batch/verify/submit/...)
+ *   status [ping]        Mostra o status da run; `ping` renova o heartbeat da execução
  *   server               Sobe a UI local de triagem (Bun.serve)
  *   setup                Cria a configuração inicial do projeto (config + skills)
  *   update               Sincroniza os arquivos auto-gerados (.houndsman/core)
@@ -23,21 +24,24 @@
  *   watchdog <id>        Contexto de um watchdog (`--rules`, `--json`)
  *
  * Flags: `--base <b>` · `--head <ref>` · `--branch <b>` · `--config <path>` ·
- *   `--clean` · `--full` · `--no-jev` · `--fail-on-blocking`.
+ *   `--clean` · `--full` · `--no-jev` · `--no-ast` · `--fail-on-blocking`.
  */
 
 import { loadConfig } from "../core/config-loader";
 import { HoundsmanEngine } from "../core/engine/houndsman-engine";
+import { logger } from "../core/logging";
 import { ArgParser } from "./arg-parser";
 import type { CliContext } from "./commands/command";
 import { ContextCommand } from "./commands/context-command";
 import { DoctorCommand } from "./commands/doctor-command";
 import { FindingsCommand } from "./commands/findings-command";
 import { HelpCommand } from "./commands/help-command";
+import { HuntCommand } from "./commands/hunt-command";
 import { CommandRegistry } from "./commands/registry";
 import { ReviewCommand } from "./commands/review-command";
 import { ServerCommand } from "./commands/server-command";
 import { SetupCommand, TestCommand, UpdateCommand } from "./commands/setup-command";
+import { StatusCommand } from "./commands/status-command";
 import { WatchdogCommand } from "./commands/watchdog-command";
 import { HELP } from "./help";
 
@@ -51,8 +55,10 @@ function buildRegistry(): CommandRegistry {
 	return new CommandRegistry()
 		.register(new ReviewCommand(), { fallback: true })
 		.register(new HelpCommand())
+		.register(new HuntCommand())
 		.register(new ContextCommand())
 		.register(new FindingsCommand())
+		.register(new StatusCommand())
 		.register(new WatchdogCommand())
 		.register(new ServerCommand())
 		.register(new SetupCommand())
@@ -74,15 +80,16 @@ export async function main(): Promise<void> {
 	const command = registry.resolve(commandName);
 
 	if (!command) {
-		console.error(`Subcomando desconhecido: '${commandName}'.\n`);
-		console.error(HELP);
+		logger.error(`Subcomando desconhecido: '${commandName}'.\n`);
+		logger.info(HELP);
 		process.exit(1);
 	}
 
 	const context: CliContext = {
 		cwd: process.cwd(),
-		out: (message) => console.log(message),
-		err: (message) => console.error(message),
+		logger,
+		out: (message) => logger.info(message),
+		err: (message) => logger.error(message),
 		engine: async () => {
 			const { config } = await loadConfig({
 				configPath: parser.value("--config"),
@@ -97,7 +104,7 @@ export async function main(): Promise<void> {
 
 if (import.meta.main) {
 	await main().catch((error) => {
-		console.error(error instanceof Error ? error.message : String(error));
+		logger.error(error instanceof Error ? error.message : String(error));
 		process.exit(1);
 	});
 }