finitemonkey 0.0.0 → 0.1.0-next.1

package/dist/finitemonkey.mjs

@@ -0,0 +1,1302 @@
+#!/usr/bin/env node
+
+// src/core/brand.ts
+import { isAbsolute, resolve } from "node:path";
+var toAbsolutePath = (path, base) => isAbsolute(path) || !base ? resolve(path) : resolve(base, path);
+
+// src/core/entry.ts
+import { fileURLToPath } from "node:url";
+var isEntryPoint = (moduleUrl, argv1, realpath, platform) => {
+  if (argv1 === void 0) return false;
+  const self = realpath(fileURLToPath(moduleUrl));
+  const invoked = realpath(argv1);
+  return platform === "win32" ? self.toLowerCase() === invoked.toLowerCase() : self === invoked;
+};
+
+// src/core/node-runtime.ts
+import { spawnSync } from "node:child_process";
+import { readFileSync, realpathSync } from "node:fs";
+
+// src/core/parsed.ts
+var accept = (value) => ({ ok: true, value });
+var reject = (error) => ({ ok: false, error });
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var parseJson = (text) => {
+  try {
+    return accept(JSON.parse(text));
+  } catch (error) {
+    return reject(error instanceof Error ? error.message : String(error));
+  }
+};
+var parseJsonObject = (text) => {
+  const parsed = parseJson(text);
+  if (!parsed.ok) return parsed;
+  return isRecord(parsed.value) ? accept(parsed.value) : reject("expected a JSON object");
+};
+var optionalString = (record, key) => {
+  const value = record[key];
+  return typeof value === "string" ? value : void 0;
+};
+
+// src/core/node-runtime.ts
+var SAFE_TOKEN = /^[A-Za-z0-9._-]+$/;
+var WINDOWS_NOT_FOUND = 9009;
+var errnoCode = (error) => {
+  if (!(error instanceof Error) || !("code" in error)) return void 0;
+  return typeof error.code === "string" ? error.code : void 0;
+};
+var spawnProbe = (command, args, timeout) => {
+  const options = { encoding: "utf8", timeout, windowsHide: true };
+  return process.platform === "win32" ? spawnSync([command, ...args].join(" "), { ...options, shell: true }) : spawnSync(command, [...args], options);
+};
+var nodeProbe = (command, args, timeoutMs) => {
+  if (![command, ...args].every((token) => SAFE_TOKEN.test(token))) {
+    return { found: false, ok: false, stdout: "", timedOut: false };
+  }
+  const result = spawnProbe(command, args, timeoutMs);
+  const code = errnoCode(result.error);
+  const stdout = result.stdout;
+  return {
+    found: code !== "ENOENT" && result.status !== WINDOWS_NOT_FOUND,
+    ok: result.error === void 0 && result.status === 0,
+    stdout: typeof stdout === "string" ? stdout.trim() : "",
+    timedOut: code === "ETIMEDOUT"
+  };
+};
+var nodeReadText = (path) => {
+  try {
+    return accept(readFileSync(path, "utf8"));
+  } catch (error) {
+    return reject(error instanceof Error ? error.message : String(error));
+  }
+};
+var nodeRealpath = (path) => {
+  try {
+    return realpathSync(path);
+  } catch {
+    return path;
+  }
+};
+var nodeRuntime = () => ({
+  nodeVersion: process.versions.node,
+  readText: nodeReadText,
+  probe: nodeProbe,
+  startTimer: (ms, onFire) => {
+    const timer = setTimeout(onFire, ms);
+    return () => {
+      clearTimeout(timer);
+    };
+  }
+});
+
+// src/doctor/system.ts
+var detectOs = ({ platform, env, runtime }) => {
+  if (platform === "darwin") return "macos";
+  if (platform === "win32") return "windows";
+  if (platform !== "linux") return "other";
+  if (env["WSL_DISTRO_NAME"] !== void 0 || env["WSL_INTEROP"] !== void 0) return "wsl";
+  const version = runtime.readText(toAbsolutePath("/proc/version"));
+  return version.ok && /microsoft/i.test(version.value) ? "wsl" : "linux";
+};
+var WSL_MOUNT = /^\/mnt\/[a-z](\/|$)/i;
+var SYNCED = /(OneDrive|Dropbox|iCloud ?Drive|Mobile Documents|Google ?Drive)/i;
+var NON_ASCII = /[^\x20-\x7e]/;
+var pathTraits = (path) => ({
+  spaces: path.includes(" "),
+  nonAscii: NON_ASCII.test(path),
+  synced: SYNCED.test(path)
+});
+var checkOs = (env) => {
+  const os = detectOs(env);
+  const findings = [
+    { check: "os", status: "ok", messageKey: `doctor.os.${os}`, params: { platform: env.platform } }
+  ];
+  if (os === "wsl" && WSL_MOUNT.test(env.cwd)) {
+    findings.push({
+      check: "path.wsl_mount",
+      status: "warn",
+      messageKey: "doctor.path.wsl_mount",
+      params: { path: env.cwd },
+      fixKey: "doctor.path.fix_wsl_mount"
+    });
+  }
+  return findings;
+};
+var checkPath = ({ cwd }) => {
+  const traits = pathTraits(cwd);
+  const chars = traits.spaces || traits.nonAscii ? {
+    check: "path.chars",
+    status: "warn",
+    messageKey: "doctor.path.chars",
+    params: { path: cwd },
+    fixKey: "doctor.path.fix_chars"
+  } : { check: "path.chars", status: "ok", messageKey: "doctor.path.plain", params: { path: cwd } };
+  const synced = traits.synced ? [
+    {
+      check: "path.synced",
+      status: "warn",
+      messageKey: "doctor.path.synced",
+      params: { path: cwd },
+      fixKey: "doctor.path.fix_synced"
+    }
+  ] : [];
+  return [chars, ...synced];
+};
+
+// src/doctor/tools.ts
+var MIN_NODE_MAJOR = 20;
+var MIN_GIT = { major: 2, minor: 38 };
+var PROBE_TIMEOUT_MS = { git: 5e3, claude: 8e3 };
+var parseGitVersion = (output) => {
+  const match = /(\d+)\.(\d+)/.exec(output);
+  if (match?.[1] === void 0 || match[2] === void 0) return void 0;
+  return { major: Number(match[1]), minor: Number(match[2]) };
+};
+var isOlder = (version, min) => version.major < min.major || version.major === min.major && version.minor < min.minor;
+var checkNode = ({ runtime }) => {
+  const version = runtime.nodeVersion.replace(/^v/, "");
+  const major = Number.parseInt(version.split(".")[0] ?? "", 10);
+  if (Number.isNaN(major) || major < MIN_NODE_MAJOR) {
+    return [
+      {
+        check: "node",
+        status: "fail",
+        messageKey: "doctor.node.old",
+        params: { version, min: MIN_NODE_MAJOR },
+        fixKey: "doctor.node.fix"
+      }
+    ];
+  }
+  return [{ check: "node", status: "ok", messageKey: "doctor.node.ok", params: { version } }];
+};
+var checkGit = ({ runtime }) => {
+  const result = runtime.probe("git", ["--version"], PROBE_TIMEOUT_MS.git);
+  if (!result.found || !result.ok) {
+    return [{ check: "git", status: "fail", messageKey: "doctor.git.missing", fixKey: "doctor.git.fix" }];
+  }
+  const parsed = parseGitVersion(result.stdout);
+  const version = parsed === void 0 ? result.stdout : `${String(parsed.major)}.${String(parsed.minor)}`;
+  if (parsed === void 0 || isOlder(parsed, MIN_GIT)) {
+    const min = `${String(MIN_GIT.major)}.${String(MIN_GIT.minor)}`;
+    return [
+      {
+        check: "git",
+        status: "warn",
+        messageKey: "doctor.git.old",
+        params: { version, min },
+        fixKey: "doctor.git.fix_old"
+      }
+    ];
+  }
+  return [{ check: "git", status: "ok", messageKey: "doctor.git.ok", params: { version } }];
+};
+var checkClaude = ({ runtime }) => {
+  const result = runtime.probe("claude", ["--version"], PROBE_TIMEOUT_MS.claude);
+  if (result.timedOut) {
+    return [
+      { check: "claude", status: "warn", messageKey: "doctor.claude.timeout", fixKey: "doctor.claude.fix_timeout" }
+    ];
+  }
+  if (!result.found || !result.ok) {
+    return [{ check: "claude", status: "warn", messageKey: "doctor.claude.missing", fixKey: "doctor.claude.fix" }];
+  }
+  const version = /\d+\.\d+\.\d+/.exec(result.stdout)?.[0] ?? result.stdout;
+  return [{ check: "claude", status: "ok", messageKey: "doctor.claude.ok", params: { version } }];
+};
+
+// src/doctor/run.ts
+var DOCTOR_SCHEMA = "finitemonkey/doctor@1";
+var CHECKS = [checkNode, checkGit, checkClaude, checkOs, checkPath];
+var doctorEnvFrom = (ctx) => ({
+  platform: ctx.platform,
+  env: ctx.env,
+  cwd: ctx.cwd,
+  runtime: ctx.runtime
+});
+var runChecks = (env, checks = CHECKS) => checks.flatMap((check) => check(env));
+var toItem = (ctx, finding) => ({
+  check: finding.check,
+  status: finding.status,
+  detail: ctx.t(finding.messageKey, finding.params),
+  ...finding.fixKey === void 0 ? {} : { fix: ctx.t(finding.fixKey, finding.params) }
+});
+var count = (items, status) => items.filter((item) => item.status === status).length;
+var buildReport = (ctx, findings) => {
+  const checks = findings.map((finding) => toItem(ctx, finding));
+  return {
+    schema: DOCTOR_SCHEMA,
+    checks,
+    summary: { ok: count(checks, "ok"), warn: count(checks, "warn"), fail: count(checks, "fail") }
+  };
+};
+
+// src/exit-codes.ts
+var ExitCode = {
+  Ok: 0,
+  CheckFailed: 1,
+  Usage: 2,
+  NotConfigured: 3,
+  NeedsPerson: 4,
+  Internal: 5
+};
+var EXIT_CODE_NAMES = [
+  "Ok",
+  "CheckFailed",
+  "Usage",
+  "NotConfigured",
+  "NeedsPerson",
+  "Internal"
+];
+var exitCodeDocs = {
+  0: "exit.ok",
+  1: "exit.check_failed",
+  2: "exit.usage",
+  3: "exit.not_configured",
+  4: "exit.needs_person",
+  5: "exit.internal"
+};
+
+// src/commands/doctor.ts
+var MARK = { ok: "ok  ", warn: "warn", fail: "FAIL" };
+var itemLines = (ctx, item) => [
+  `[${MARK[item.status]}] ${item.check}: ${item.detail}`,
+  ...item.fix !== void 0 && item.status !== "ok" ? [`       ${ctx.t("output.fix", { fix: item.fix })}`] : []
+];
+var doctorResult = (ctx, report) => {
+  const human = [
+    ctx.t("doctor.title", { version: ctx.version }),
+    ...report.checks.flatMap((item) => itemLines(ctx, item)),
+    ctx.t("doctor.summary", report.summary)
+  ];
+  const failed2 = report.checks.find((item) => item.status === "fail");
+  if (failed2 === void 0) return { ok: true, exitCode: ExitCode.Ok, data: report, human };
+  return {
+    ok: false,
+    exitCode: ExitCode.CheckFailed,
+    data: report,
+    human,
+    error: {
+      code: "doctor_failed",
+      message: ctx.t("error.doctor_failed", { count: report.summary.fail }),
+      fix: failed2.fix ?? "finitemonkey doctor"
+    }
+  };
+};
+var doctorCommand = {
+  path: ["doctor"],
+  summaryKey: "command.doctor.summary",
+  usage: "finitemonkey doctor [--json]",
+  status: "ready",
+  run: (ctx) => Promise.resolve(doctorResult(ctx, buildReport(ctx, runChecks(doctorEnvFrom(ctx)))))
+};
+
+// src/core/args.ts
+import { parseArgs } from "node:util";
+
+// src/core/problem.ts
+var usageProblem = (code, messageKey, fix, params = {}) => ({
+  code,
+  messageKey,
+  params,
+  fix,
+  exitCode: ExitCode.Usage
+});
+var FmError = class extends Error {
+  problem;
+  constructor(problem) {
+    super(problem.code);
+    this.name = "FmError";
+    this.problem = problem;
+  }
+};
+
+// src/core/args.ts
+var GLOBAL_OPTIONS = {
+  json: { type: "boolean" },
+  lang: { type: "string" },
+  yes: { type: "boolean", short: "y" },
+  "dry-run": { type: "boolean" },
+  version: { type: "boolean", short: "v" },
+  help: { type: "boolean", short: "h" }
+};
+var flag = (values, name) => values[name] === true;
+var looseArgs = (argv) => {
+  const { values, positionals } = parseArgs({
+    args: [...argv],
+    options: GLOBAL_OPTIONS,
+    strict: false,
+    allowPositionals: true
+  });
+  const lang = values.lang;
+  return {
+    positionals,
+    json: flag(values, "json"),
+    yes: flag(values, "yes"),
+    dryRun: flag(values, "dry-run"),
+    version: flag(values, "version"),
+    help: flag(values, "help"),
+    lang: typeof lang === "string" ? lang : void 0
+  };
+};
+var resolveCommand = (registry, positionals) => registry.filter((spec) => spec.path.every((part, index) => positionals[index] === part)).reduce(
+  (best, spec) => best === void 0 || spec.path.length > best.consumed ? { spec, consumed: spec.path.length } : best,
+  void 0
+);
+var strictArgs = (argv, spec) => {
+  const fix = `finitemonkey help ${spec.path.join(" ")}`;
+  let parsed;
+  try {
+    parsed = parseArgs({
+      args: [...argv],
+      options: { ...GLOBAL_OPTIONS, ...spec.options },
+      strict: true,
+      allowPositionals: true
+    });
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    return reject(usageProblem("invalid_arguments", "error.invalid_arguments", fix, { detail }));
+  }
+  const rest = parsed.positionals.slice(spec.path.length);
+  const max = spec.maxPositionals ?? 0;
+  const extra = rest[max];
+  if (extra !== void 0) {
+    return reject(usageProblem("unexpected_argument", "error.unexpected_argument", fix, { argument: extra }));
+  }
+  return accept({ values: parsed.values, positionals: rest });
+};
+var stringOption = (values, name) => {
+  const value = values[name];
+  return typeof value === "string" ? value : void 0;
+};
+
+// src/core/result.ts
+var SCHEMA_VERSION = 1;
+var success = (data, human = []) => ({
+  ok: true,
+  exitCode: ExitCode.Ok,
+  data,
+  human
+});
+var failureFrom = (t, problem, human) => ({
+  ok: false,
+  exitCode: problem.exitCode,
+  error: { code: problem.code, message: t(problem.messageKey, problem.params), fix: problem.fix },
+  ...problem.data === void 0 ? {} : { data: problem.data },
+  ...human === void 0 ? {} : { human }
+});
+var toEnvelope = (command, result) => ({
+  schemaVersion: SCHEMA_VERSION,
+  ok: result.ok,
+  command,
+  ...result.data === void 0 ? {} : { data: result.data },
+  ...result.ok ? {} : { error: result.error },
+  ...result.next === void 0 ? {} : { next: result.next }
+});
+
+// src/commands/types.ts
+var commandName = (spec) => spec.path.join(" ");
+
+// src/commands/help.ts
+var GLOBAL_FLAGS = [
+  { flag: "--json", key: "flag.json" },
+  { flag: "--lang <pt-BR|en|es>", key: "flag.lang" },
+  { flag: "--yes, -y", key: "flag.yes" },
+  { flag: "--dry-run", key: "flag.dry_run" },
+  { flag: "--version, -v", key: "flag.version" },
+  { flag: "--help, -h", key: "flag.help" }
+];
+var exitCodeHelp = (ctx) => EXIT_CODE_NAMES.map((name) => ({ code: ExitCode[name], name, summary: ctx.t(exitCodeDocs[ExitCode[name]]) }));
+var pad = (text, width) => text.padEnd(Math.max(width, text.length + 1));
+var describe = (ctx, spec) => ({
+  name: commandName(spec),
+  usage: spec.usage,
+  summary: ctx.t(spec.summaryKey),
+  status: spec.status,
+  options: Object.keys(spec.options ?? {}).map((name) => `--${name}`)
+});
+var summaryLine = (ctx, help) => help.status === "planned" ? `${help.summary} ${ctx.t("help.planned")}` : help.summary;
+var overview = (ctx, registry) => {
+  const commands = registry.map((spec) => describe(ctx, spec));
+  const flags = GLOBAL_FLAGS.map(({ flag: flag2, key }) => ({ flag: flag2, summary: ctx.t(key) }));
+  const width = Math.max(...commands.map(({ name }) => name.length)) + 2;
+  const flagWidth = Math.max(...flags.map(({ flag: flag2 }) => flag2.length)) + 2;
+  const exitCodes = exitCodeHelp(ctx);
+  const human = [
+    `finitemonkey ${ctx.version}`,
+    ctx.t("help.tagline"),
+    "",
+    `${ctx.t("help.usage")}: finitemonkey <${ctx.t("help.command")}> [flags]`,
+    "",
+    `${ctx.t("help.commands")}:`,
+    ...commands.map((help) => `  ${pad(help.name, width)}${summaryLine(ctx, help)}`),
+    "",
+    `${ctx.t("help.flags")}:`,
+    ...flags.map(({ flag: flag2, summary }) => `  ${pad(flag2, flagWidth)}${summary}`),
+    "",
+    `${ctx.t("help.exit_codes")}:`,
+    ...exitCodes.map(({ summary }) => `  ${summary}`),
+    "",
+    ctx.t("help.more")
+  ];
+  return success({ commands, flags, exitCodes }, human);
+};
+var helpFor = (ctx, spec) => {
+  const help = describe(ctx, spec);
+  const human = [
+    `${ctx.t("help.usage")}: ${help.usage}`,
+    "",
+    summaryLine(ctx, help),
+    ...help.options.length > 0 ? ["", `${ctx.t("help.options")}: ${help.options.join(", ")}`] : []
+  ];
+  return success({ command: help }, human);
+};
+var topicHelp = (ctx, registry, topic) => {
+  const resolved = resolveCommand(registry, topic);
+  if (resolved !== void 0) return helpFor(ctx, resolved.spec);
+  const problem = usageProblem("unknown_command", "error.unknown_command", "finitemonkey help", {
+    command: topic.join(" ")
+  });
+  return failureFrom(ctx.t, problem);
+};
+var helpCommand = {
+  path: ["help"],
+  summaryKey: "command.help.summary",
+  usage: "finitemonkey help [command]",
+  status: "ready",
+  maxPositionals: 3,
+  run: (ctx, args, registry) => Promise.resolve(
+    args.positionals.length === 0 ? overview(ctx, registry) : topicHelp(ctx, registry, args.positionals)
+  )
+};
+
+// src/hooks/events.ts
+var HOOK_EVENTS = [
+  "SessionStart",
+  "UserPromptSubmit",
+  "PreToolUse",
+  "PostToolUse",
+  "Stop",
+  "SubagentStart",
+  "SubagentStop",
+  "PreCompact",
+  "ConfigChange",
+  "Notification",
+  "SessionEnd"
+];
+var HOOK_POLICIES = {
+  SessionStart: { failClosed: false },
+  UserPromptSubmit: { failClosed: true },
+  PreToolUse: { failClosed: true },
+  PostToolUse: { failClosed: false },
+  Stop: { failClosed: true },
+  SubagentStart: { failClosed: false },
+  SubagentStop: { failClosed: true },
+  PreCompact: { failClosed: false },
+  ConfigChange: { failClosed: true },
+  Notification: { failClosed: false },
+  SessionEnd: { failClosed: false }
+};
+var squash = (value) => value.replace(/[-_\s]/g, "").toLowerCase();
+var parseHookEvent = (raw) => HOOK_EVENTS.find((event) => squash(event) === squash(raw));
+var DEFAULT_HOOK_DEADLINE_MS = 3e3;
+var parseDeadline = (raw) => {
+  const parsed = Number.parseInt(raw ?? "", 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_HOOK_DEADLINE_MS;
+};
+
+// src/hooks/handlers.ts
+var allow = () => ({ kind: "allow" });
+var DEFAULT_HANDLERS = {};
+
+// src/hooks/payload.ts
+var EMPTY_PAYLOAD = {
+  hookEventName: void 0,
+  sessionId: void 0,
+  cwd: void 0,
+  stopHookActive: false,
+  raw: {}
+};
+var parseHookPayload = (event, text, interactive) => {
+  if (interactive && text.trim() === "") return accept(EMPTY_PAYLOAD);
+  const parsed = parseJsonObject(text);
+  if (!parsed.ok) return reject(`stdin: ${parsed.error}`);
+  const payload = {
+    hookEventName: optionalString(parsed.value, "hook_event_name"),
+    sessionId: optionalString(parsed.value, "session_id"),
+    cwd: optionalString(parsed.value, "cwd"),
+    stopHookActive: parsed.value["stop_hook_active"] === true,
+    raw: parsed.value
+  };
+  if (payload.hookEventName !== void 0 && payload.hookEventName !== event) {
+    return reject(`payload is for ${payload.hookEventName}, not ${event}`);
+  }
+  return accept(payload);
+};
+
+// src/hooks/stdin.ts
+var readAll = (source) => new Promise((resolve2, reject2) => {
+  if (source.isTTY === true) {
+    resolve2("");
+    return;
+  }
+  const chunks = [];
+  source.setEncoding?.("utf8");
+  source.on("data", (chunk) => {
+    chunks.push(typeof chunk === "string" ? chunk : chunk.toString("utf8"));
+  });
+  source.on("end", () => {
+    resolve2(chunks.join(""));
+  });
+  source.on("error", reject2);
+});
+var DeadlineError = class extends Error {
+  ms;
+  constructor(ms) {
+    super(`deadline of ${String(ms)} ms exceeded`);
+    this.name = "DeadlineError";
+    this.ms = ms;
+  }
+};
+var withDeadline = (work, ms, startTimer) => new Promise((resolve2, reject2) => {
+  const cancel = startTimer(ms, () => {
+    reject2(new DeadlineError(ms));
+  });
+  work.then(
+    (value) => {
+      cancel();
+      resolve2(value);
+    },
+    (error) => {
+      cancel();
+      reject2(error instanceof Error ? error : new Error(String(error)));
+    }
+  );
+});
+
+// src/hooks/runner.ts
+var messageOf = (error) => error instanceof Error ? error.message : String(error);
+var decide = async (input, handlers) => {
+  let output = {};
+  for (const handler of handlers[input.event] ?? [allow]) {
+    const decision = await handler(input);
+    if (decision.kind === "block") return decision;
+    output = { ...output, ...decision.output };
+  }
+  return { kind: "allow", output };
+};
+var evaluate = async (event, options) => {
+  const text = await readAll(options.stdin);
+  const parsed = parseHookPayload(event, text, options.stdin.isTTY === true);
+  if (!parsed.ok) return { kind: "failed", payload: void 0, detail: parsed.error };
+  const payload = parsed.value;
+  try {
+    return { kind: "decided", payload, decision: await decide({ event, payload, cwd: options.cwd }, options.handlers) };
+  } catch (error) {
+    return { kind: "failed", payload, detail: messageOf(error) };
+  }
+};
+var ALLOW_STDOUT = `${JSON.stringify({ continue: true })}
+`;
+var allowed = (output) => ({
+  exitCode: 0,
+  stdout: `${JSON.stringify({ continue: true, ...output })}
+`,
+  stderr: "",
+  verdict: "allow"
+});
+var released = (event, detail, t) => ({
+  exitCode: 0,
+  stdout: ALLOW_STDOUT,
+  stderr: `finitemonkey: ${t("hook.stop_released", { event, detail })}
+`,
+  verdict: "stop_released"
+});
+var failed = (event, detail, t) => HOOK_POLICIES[event].failClosed ? {
+  exitCode: 2,
+  stdout: "",
+  stderr: `finitemonkey: ${t("hook.failed_closed", { event, detail })}
+`,
+  verdict: "failed_closed"
+} : {
+  exitCode: 0,
+  stdout: "",
+  stderr: `finitemonkey: ${t("hook.failed_open", { event, detail })}
+`,
+  verdict: "failed_open"
+};
+var conclude = (event, evaluation, t) => {
+  const stopActive = evaluation.payload?.stopHookActive === true;
+  if (evaluation.kind === "failed") {
+    return stopActive ? released(event, evaluation.detail, t) : failed(event, evaluation.detail, t);
+  }
+  const { decision } = evaluation;
+  if (decision.kind === "allow") return allowed(decision.output);
+  if (stopActive) return released(event, decision.reason, t);
+  return { exitCode: 2, stdout: "", stderr: `finitemonkey: ${decision.reason}
+`, verdict: "block" };
+};
+var runHook = async (event, options) => {
+  try {
+    return conclude(
+      event,
+      await withDeadline(evaluate(event, options), options.deadlineMs, options.startTimer),
+      options.t
+    );
+  } catch (error) {
+    return failed(event, messageOf(error), options.t);
+  }
+};
+
+// src/commands/hook.ts
+var hookCommand = {
+  path: ["hook"],
+  summaryKey: "command.hook.summary",
+  usage: `finitemonkey hook <${HOOK_EVENTS.join("|")}>`,
+  status: "ready",
+  maxPositionals: 1,
+  run: async (ctx, args) => {
+    const raw = args.positionals[0] ?? "";
+    const event = parseHookEvent(raw);
+    if (event === void 0) {
+      const params = { event: raw, events: HOOK_EVENTS.join(", ") };
+      return failureFrom(
+        ctx.t,
+        usageProblem("unknown_hook_event", "error.unknown_hook_event", "finitemonkey help hook", params)
+      );
+    }
+    const outcome = await runHook(event, {
+      stdin: ctx.io.stdin,
+      deadlineMs: parseDeadline(ctx.env["FINITEMONKEY_HOOK_DEADLINE_MS"]),
+      handlers: DEFAULT_HANDLERS,
+      cwd: ctx.cwd,
+      t: ctx.t,
+      startTimer: ctx.runtime.startTimer
+    });
+    const data = { event, verdict: outcome.verdict };
+    const output = { stdout: outcome.stdout, stderr: outcome.stderr };
+    if (outcome.exitCode === 0) return { ok: true, exitCode: 0, data, raw: output };
+    const message = outcome.stderr.trim();
+    return {
+      ok: false,
+      exitCode: 2,
+      data,
+      raw: output,
+      error: { code: "hook_blocked", message, fix: "finitemonkey doctor" }
+    };
+  }
+};
+
+// src/commands/i18n-check.ts
+import { join } from "node:path";
+
+// src/i18n/en.json
+var en_default = {
+  "command.init.summary": "Set up Finite Monkey in this project",
+  "command.doctor.summary": "Check the environment and say how to fix each problem",
+  "command.update.summary": "Update the files Finite Monkey generated",
+  "command.uninstall.summary": "Remove Finite Monkey from this project",
+  "command.i18n_check.summary": "Check that the pt-BR, en and es catalogs match",
+  "command.hook.summary": "Answer a Claude Code hook event (reads JSON on stdin)",
+  "command.version.summary": "Print the version",
+  "command.help.summary": "Show commands and flags",
+  "help.tagline": "Infinite monkeys not required.",
+  "help.usage": "Usage",
+  "help.command": "command",
+  "help.commands": "Commands",
+  "help.flags": "Flags",
+  "help.options": "Options",
+  "help.planned": "(not available yet)",
+  "help.more": "Run `finitemonkey help <command>` for details. Add --json for machine-readable output.",
+  "flag.json": "Print one JSON object (schemaVersion 1) instead of text",
+  "flag.lang": "Language for messages",
+  "flag.yes": "Answer yes to confirmations",
+  "flag.dry_run": "Show what would change without changing anything",
+  "flag.version": "Print the version",
+  "flag.help": "Show help",
+  "output.error": "error: {message}",
+  "output.fix": "fix: {fix}",
+  "output.next": "next: {next}",
+  "error.internal": "Finite Monkey failed unexpectedly: {detail}",
+  "error.invalid_arguments": "Invalid arguments: {detail}",
+  "error.unexpected_argument": 'Unexpected argument "{argument}"',
+  "error.unknown_command": 'Unknown command "{command}"',
+  "error.unknown_command_suggest": 'Unknown command "{command}". Did you mean "{suggestion}"?',
+  "error.not_implemented": '"{command}" is not available in this version yet',
+  "error.invalid_lang": 'Unsupported language "{lang}". Use one of: {languages}',
+  "error.i18n_catalog_unreadable": "Could not read catalog {file}: {detail}",
+  "error.i18n_mismatch": "{count} catalog problem(s) found",
+  "error.doctor_failed": "{count} check(s) failed",
+  "error.unknown_hook_event": 'Unknown hook event "{event}". Use one of: {events}',
+  "i18n.summary": "Languages: {languages}. Keys: {keys}.",
+  "i18n.ok": "All catalogs match.",
+  "i18n.fix": "Edit the catalogs in {file} so every language has the same keys and placeholders",
+  "i18n.problem.missing": "missing key",
+  "i18n.problem.extra": "key not in en.json",
+  "i18n.problem.placeholder": "placeholders differ (expected: {expected}; found: {actual})",
+  "i18n.problem.empty": "empty text",
+  "i18n.problem.not_string": "value is not text",
+  "doctor.title": "finitemonkey doctor ({version})",
+  "doctor.summary": "{ok} ok, {warn} warning(s), {fail} failure(s)",
+  "doctor.node.ok": "Node.js {version}",
+  "doctor.node.old": "Node.js {version} is older than the minimum {min}",
+  "doctor.node.fix": "Install Node.js 20 or newer from https://nodejs.org",
+  "doctor.git.ok": "git {version}",
+  "doctor.git.missing": "git was not found",
+  "doctor.git.fix": "Install git from https://git-scm.com/downloads",
+  "doctor.git.old": "git {version} is older than {min}; some commands will need a newer git",
+  "doctor.git.fix_old": "Update git to {min} or newer",
+  "doctor.claude.ok": "Claude Code {version}",
+  "doctor.claude.missing": "Claude Code was not found; the CLI works without it, the hooks need it",
+  "doctor.claude.fix": "Install Claude Code: npm install -g @anthropic-ai/claude-code",
+  "doctor.claude.timeout": "`claude --version` did not answer in time",
+  "doctor.claude.fix_timeout": "Run `claude --version` by hand and check that it answers",
+  "doctor.os.linux": "Linux",
+  "doctor.os.wsl": "Linux on WSL",
+  "doctor.os.macos": "macOS",
+  "doctor.os.windows": "Windows (native)",
+  "doctor.os.other": "Unrecognized system ({platform})",
+  "doctor.path.plain": "Project path has no spaces or accents",
+  "doctor.path.chars": "Project path has spaces or accents: {path}",
+  "doctor.path.fix_chars": "Finite Monkey handles this path; if another tool fails here, move the project to a path without spaces or accents",
+  "doctor.path.synced": "Project is inside a synced folder (OneDrive, Dropbox, iCloud or Google Drive): {path}",
+  "doctor.path.fix_synced": "Move the project out of the synced folder to avoid sync conflicts and slow git",
+  "doctor.path.wsl_mount": "Project is on a Windows drive mounted in WSL: {path}",
+  "doctor.path.fix_wsl_mount": "Move the project into the Linux home (for example ~/projects) for faster git and correct permissions",
+  "hook.failed_closed": "the {event} hook could not run ({detail}), so it blocked to stay safe. Run `finitemonkey doctor`",
+  "hook.failed_open": "the {event} hook could not run ({detail}); continuing without it. Run `finitemonkey doctor`",
+  "exit.ok": "0 ok: the command did what it was asked",
+  "exit.check_failed": "1 check failed: the command ran and found a problem",
+  "exit.usage": "2 usage error: unknown command, unknown flag, bad value or command not available yet",
+  "exit.not_configured": "3 not configured: setup or a prerequisite (node, git, files, permissions) is missing",
+  "exit.needs_person": "4 needs a person: a decision or approval is required before going on",
+  "exit.internal": "5 internal error: Finite Monkey itself failed; please report it",
+  "help.exit_codes": "Exit codes",
+  "hook.stop_released": "the {event} hook would block again ({detail}), but Claude Code is already continuing from a stop hook, so it lets the session stop. Run `finitemonkey doctor`",
+  "error.needs_confirmation": '"{command}" needs your decision before it changes anything: {question}'
+};
+
+// src/i18n/es.json
+var es_default = {
+  "command.init.summary": "Instala Finite Monkey en este proyecto",
+  "command.doctor.summary": "Revisa el entorno y dice cómo corregir cada problema",
+  "command.update.summary": "Actualiza los archivos que Finite Monkey generó",
+  "command.uninstall.summary": "Quita Finite Monkey de este proyecto",
+  "command.i18n_check.summary": "Revisa que los catálogos pt-BR, en y es coincidan",
+  "command.hook.summary": "Responde a un evento de hook de Claude Code (lee JSON de la entrada estándar)",
+  "command.version.summary": "Muestra la versión",
+  "command.help.summary": "Muestra comandos y opciones",
+  "help.tagline": "Infinite monkeys not required.",
+  "help.usage": "Uso",
+  "help.command": "comando",
+  "help.commands": "Comandos",
+  "help.flags": "Opciones globales",
+  "help.options": "Opciones",
+  "help.planned": "(aún no disponible)",
+  "help.more": "Ejecuta `finitemonkey help <comando>` para más detalles. Usa --json para una salida legible por máquina.",
+  "flag.json": "Imprime un objeto JSON (schemaVersion 1) en lugar de texto",
+  "flag.lang": "Idioma de los mensajes",
+  "flag.yes": "Responde sí a las confirmaciones",
+  "flag.dry_run": "Muestra qué cambiaría sin cambiar nada",
+  "flag.version": "Muestra la versión",
+  "flag.help": "Muestra la ayuda",
+  "output.error": "error: {message}",
+  "output.fix": "cómo corregir: {fix}",
+  "output.next": "siguiente paso: {next}",
+  "error.internal": "Finite Monkey falló de forma inesperada: {detail}",
+  "error.invalid_arguments": "Argumentos inválidos: {detail}",
+  "error.unexpected_argument": 'Argumento inesperado "{argument}"',
+  "error.unknown_command": 'Comando desconocido "{command}"',
+  "error.unknown_command_suggest": 'Comando desconocido "{command}". ¿Quisiste decir "{suggestion}"?',
+  "error.not_implemented": '"{command}" aún no está disponible en esta versión',
+  "error.invalid_lang": 'Idioma no soportado "{lang}". Usa uno de estos: {languages}',
+  "error.i18n_catalog_unreadable": "No se pudo leer el catálogo {file}: {detail}",
+  "error.i18n_mismatch": "{count} problema(s) en los catálogos",
+  "error.doctor_failed": "{count} revisión(es) fallaron",
+  "error.unknown_hook_event": 'Evento de hook desconocido "{event}". Usa uno de estos: {events}',
+  "i18n.summary": "Idiomas: {languages}. Claves: {keys}.",
+  "i18n.ok": "Todos los catálogos coinciden.",
+  "i18n.fix": "Edita los catálogos en {file} para que todos los idiomas tengan las mismas claves y los mismos marcadores",
+  "i18n.problem.missing": "falta la clave",
+  "i18n.problem.extra": "clave que no existe en en.json",
+  "i18n.problem.placeholder": "marcadores distintos (esperado: {expected}; encontrado: {actual})",
+  "i18n.problem.empty": "texto vacío",
+  "i18n.problem.not_string": "el valor no es texto",
+  "doctor.title": "finitemonkey doctor ({version})",
+  "doctor.summary": "{ok} ok, {warn} aviso(s), {fail} falla(s)",
+  "doctor.node.ok": "Node.js {version}",
+  "doctor.node.old": "Node.js {version} es más antiguo que el mínimo {min}",
+  "doctor.node.fix": "Instala Node.js 20 o más nuevo desde https://nodejs.org",
+  "doctor.git.ok": "git {version}",
+  "doctor.git.missing": "No se encontró git",
+  "doctor.git.fix": "Instala git desde https://git-scm.com/downloads",
+  "doctor.git.old": "git {version} es más antiguo que {min}; algunos comandos necesitarán un git más nuevo",
+  "doctor.git.fix_old": "Actualiza git a {min} o más nuevo",
+  "doctor.claude.ok": "Claude Code {version}",
+  "doctor.claude.missing": "No se encontró Claude Code; la CLI funciona sin él, los hooks lo necesitan",
+  "doctor.claude.fix": "Instala Claude Code: npm install -g @anthropic-ai/claude-code",
+  "doctor.claude.timeout": "`claude --version` no respondió a tiempo",
+  "doctor.claude.fix_timeout": "Ejecuta `claude --version` a mano y revisa que responda",
+  "doctor.os.linux": "Linux",
+  "doctor.os.wsl": "Linux en WSL",
+  "doctor.os.macos": "macOS",
+  "doctor.os.windows": "Windows (nativo)",
+  "doctor.os.other": "Sistema no reconocido ({platform})",
+  "doctor.path.plain": "La ruta del proyecto no tiene espacios ni acentos",
+  "doctor.path.chars": "La ruta del proyecto tiene espacios o acentos: {path}",
+  "doctor.path.fix_chars": "Finite Monkey maneja esta ruta; si otra herramienta falla aquí, mueve el proyecto a una ruta sin espacios ni acentos",
+  "doctor.path.synced": "El proyecto está en una carpeta sincronizada (OneDrive, Dropbox, iCloud o Google Drive): {path}",
+  "doctor.path.fix_synced": "Mueve el proyecto fuera de la carpeta sincronizada para evitar conflictos de sincronización y git lento",
+  "doctor.path.wsl_mount": "El proyecto está en un disco de Windows montado en WSL: {path}",
+  "doctor.path.fix_wsl_mount": "Mueve el proyecto a la home de Linux (por ejemplo ~/proyectos) para tener git rápido y permisos correctos",
+  "hook.failed_closed": "el hook {event} no pudo ejecutarse ({detail}) y bloqueó por seguridad. Ejecuta `finitemonkey doctor`",
+  "hook.failed_open": "el hook {event} no pudo ejecutarse ({detail}); se sigue sin él. Ejecuta `finitemonkey doctor`",
+  "exit.ok": "0 ok: el comando hizo lo que se pidió",
+  "exit.check_failed": "1 revisión fallida: el comando se ejecutó y encontró un problema",
+  "exit.usage": "2 error de uso: comando u opción desconocidos, valor inválido o comando aún no disponible",
+  "exit.not_configured": "3 no configurado: falta la instalación o un requisito previo (node, git, archivos, permisos)",
+  "exit.needs_person": "4 necesita a la persona: se requiere una decisión o aprobación antes de seguir",
+  "exit.internal": "5 error interno: el propio Finite Monkey falló; por favor, repórtalo",
+  "help.exit_codes": "Códigos de salida",
+  "hook.stop_released": "el hook {event} bloquearía otra vez ({detail}), pero Claude Code ya está continuando por un hook de parada, así que deja que la sesión termine. Ejecuta `finitemonkey doctor`",
+  "error.needs_confirmation": '"{command}" necesita tu decisión antes de cambiar algo: {question}'
+};
+
+// src/i18n/pt-BR.json
+var pt_BR_default = {
+  "command.init.summary": "Instala o Finite Monkey neste projeto",
+  "command.doctor.summary": "Confere o ambiente e diz como corrigir cada problema",
+  "command.update.summary": "Atualiza os arquivos que o Finite Monkey gerou",
+  "command.uninstall.summary": "Remove o Finite Monkey deste projeto",
+  "command.i18n_check.summary": "Confere se os catálogos pt-BR, en e es batem",
+  "command.hook.summary": "Responde a um evento de hook do Claude Code (lê JSON da entrada padrão)",
+  "command.version.summary": "Mostra a versão",
+  "command.help.summary": "Mostra comandos e opções",
+  "help.tagline": "Infinite monkeys not required.",
+  "help.usage": "Uso",
+  "help.command": "comando",
+  "help.commands": "Comandos",
+  "help.flags": "Opções globais",
+  "help.options": "Opções",
+  "help.planned": "(ainda não disponível)",
+  "help.more": "Rode `finitemonkey help <comando>` para detalhes. Use --json para saída legível por máquina.",
+  "flag.json": "Imprime um objeto JSON (schemaVersion 1) no lugar de texto",
+  "flag.lang": "Idioma das mensagens",
+  "flag.yes": "Responde sim às confirmações",
+  "flag.dry_run": "Mostra o que mudaria sem mudar nada",
+  "flag.version": "Mostra a versão",
+  "flag.help": "Mostra a ajuda",
+  "output.error": "erro: {message}",
+  "output.fix": "como corrigir: {fix}",
+  "output.next": "próximo passo: {next}",
+  "error.internal": "O Finite Monkey falhou de forma inesperada: {detail}",
+  "error.invalid_arguments": "Argumentos inválidos: {detail}",
+  "error.unexpected_argument": 'Argumento inesperado "{argument}"',
+  "error.unknown_command": 'Comando desconhecido "{command}"',
+  "error.unknown_command_suggest": 'Comando desconhecido "{command}". Você quis dizer "{suggestion}"?',
+  "error.not_implemented": '"{command}" ainda não está disponível nesta versão',
+  "error.invalid_lang": 'Idioma não suportado "{lang}". Use um destes: {languages}',
+  "error.i18n_catalog_unreadable": "Não foi possível ler o catálogo {file}: {detail}",
+  "error.i18n_mismatch": "{count} problema(s) nos catálogos",
+  "error.doctor_failed": "{count} verificação(ões) falharam",
+  "error.unknown_hook_event": 'Evento de hook desconhecido "{event}". Use um destes: {events}',
+  "i18n.summary": "Idiomas: {languages}. Chaves: {keys}.",
+  "i18n.ok": "Todos os catálogos batem.",
+  "i18n.fix": "Edite os catálogos em {file} para que todos os idiomas tenham as mesmas chaves e os mesmos marcadores",
+  "i18n.problem.missing": "chave faltando",
+  "i18n.problem.extra": "chave que não existe no en.json",
+  "i18n.problem.placeholder": "marcadores diferentes (esperado: {expected}; encontrado: {actual})",
+  "i18n.problem.empty": "texto vazio",
+  "i18n.problem.not_string": "valor não é texto",
+  "doctor.title": "finitemonkey doctor ({version})",
+  "doctor.summary": "{ok} ok, {warn} aviso(s), {fail} falha(s)",
+  "doctor.node.ok": "Node.js {version}",
+  "doctor.node.old": "Node.js {version} é mais antigo que o mínimo {min}",
+  "doctor.node.fix": "Instale o Node.js 20 ou mais novo em https://nodejs.org",
+  "doctor.git.ok": "git {version}",
+  "doctor.git.missing": "git não foi encontrado",
+  "doctor.git.fix": "Instale o git em https://git-scm.com/downloads",
+  "doctor.git.old": "git {version} é mais antigo que {min}; alguns comandos vão precisar de um git mais novo",
+  "doctor.git.fix_old": "Atualize o git para {min} ou mais novo",
+  "doctor.claude.ok": "Claude Code {version}",
+  "doctor.claude.missing": "Claude Code não foi encontrado; a CLI funciona sem ele, os hooks precisam dele",
+  "doctor.claude.fix": "Instale o Claude Code: npm install -g @anthropic-ai/claude-code",
+  "doctor.claude.timeout": "`claude --version` não respondeu a tempo",
+  "doctor.claude.fix_timeout": "Rode `claude --version` à mão e confira se ele responde",
+  "doctor.os.linux": "Linux",
+  "doctor.os.wsl": "Linux no WSL",
+  "doctor.os.macos": "macOS",
+  "doctor.os.windows": "Windows (nativo)",
+  "doctor.os.other": "Sistema não reconhecido ({platform})",
+  "doctor.path.plain": "O caminho do projeto não tem espaço nem acento",
+  "doctor.path.chars": "O caminho do projeto tem espaço ou acento: {path}",
+  "doctor.path.fix_chars": "O Finite Monkey lida com este caminho; se outra ferramenta falhar aqui, mova o projeto para um caminho sem espaço nem acento",
+  "doctor.path.synced": "O projeto está numa pasta sincronizada (OneDrive, Dropbox, iCloud ou Google Drive): {path}",
+  "doctor.path.fix_synced": "Mova o projeto para fora da pasta sincronizada para evitar conflito de sincronização e git lento",
+  "doctor.path.wsl_mount": "O projeto está num disco do Windows montado no WSL: {path}",
+  "doctor.path.fix_wsl_mount": "Mova o projeto para a home do Linux (por exemplo ~/projetos) para ter git rápido e permissões corretas",
+  "hook.failed_closed": "o hook {event} não conseguiu rodar ({detail}) e bloqueou por segurança. Rode `finitemonkey doctor`",
+  "hook.failed_open": "o hook {event} não conseguiu rodar ({detail}); seguindo sem ele. Rode `finitemonkey doctor`",
+  "exit.ok": "0 ok: o comando fez o que foi pedido",
+  "exit.check_failed": "1 verificação reprovada: o comando rodou e achou um problema",
+  "exit.usage": "2 erro de uso: comando ou opção desconhecidos, valor inválido ou comando ainda não disponível",
+  "exit.not_configured": "3 não configurado: falta instalação ou um pré-requisito (node, git, arquivos, permissões)",
+  "exit.needs_person": "4 precisa da pessoa: uma decisão ou aprovação é necessária antes de seguir",
+  "exit.internal": "5 erro interno: o próprio Finite Monkey falhou; por favor, reporte",
+  "help.exit_codes": "Códigos de saída",
+  "hook.stop_released": "o hook {event} bloquearia de novo ({detail}), mas o Claude Code já está continuando por causa de um hook de parada, então ele deixa a sessão parar. Rode `finitemonkey doctor`",
+  "error.needs_confirmation": '"{command}" precisa da sua decisão antes de mudar qualquer coisa: {question}'
+};
+
+// src/i18n/catalogs.ts
+var exact = (catalog) => catalog;
+var catalogs = {
+  en: exact(en_default),
+  "pt-BR": exact(pt_BR_default),
+  es: exact(es_default)
+};
+
+// src/i18n/languages.ts
+var LANGUAGES = ["en", "pt-BR", "es"];
+var SOURCE_LANG = "en";
+var normalizeLang = (raw) => {
+  if (raw === void 0) return void 0;
+  const base = (raw.trim().split(/[.@:]/)[0] ?? "").replace(/_/g, "-").toLowerCase();
+  if (base === "pt" || base.startsWith("pt-")) return "pt-BR";
+  if (base === "es" || base.startsWith("es-")) return "es";
+  if (base === "en" || base.startsWith("en-")) return "en";
+  return void 0;
+};
+var LANG_ENV_ORDER = ["FINITEMONKEY_LANG", "LC_ALL", "LC_MESSAGES", "LANG"];
+var detectLang = (flag2, env) => {
+  const fromFlag = normalizeLang(flag2);
+  if (fromFlag) return { lang: fromFlag, source: "flag" };
+  for (const name of LANG_ENV_ORDER) {
+    const lang = normalizeLang(env[name]);
+    if (lang) return { lang, source: name };
+  }
+  return { lang: SOURCE_LANG, source: "default" };
+};
+
+// src/i18n/translate.ts
+var PLACEHOLDER = /\{([a-zA-Z][a-zA-Z0-9_]*)\}/g;
+var interpolate = (template, params = {}) => template.replace(PLACEHOLDER, (match, name) => {
+  const value = params[name];
+  return value === void 0 ? match : String(value);
+});
+var placeholdersOf = (template) => [...new Set(Array.from(template.matchAll(PLACEHOLDER), (match) => match[1] ?? ""))].sort();
+var createTranslator = (lang, source = catalogs) => (key, params) => interpolate(source[lang][key] ?? source[SOURCE_LANG][key] ?? key, params);
+
+// src/i18n/check.ts
+var sameList = (a, b) => a.length === b.length && a.every((value, index) => value === b[index]);
+var valueProblems = (lang, catalog, reference) => Object.keys(catalog).sort().flatMap((key) => {
+  const value = catalog[key];
+  if (typeof value !== "string") return [{ lang, key, kind: "not_string" }];
+  const problems = [];
+  if (value.trim() === "") problems.push({ lang, key, kind: "empty" });
+  if (!(key in reference)) problems.push({ lang, key, kind: "extra" });
+  return problems;
+});
+var parityProblems = (lang, catalog, reference) => Object.keys(reference).sort().flatMap((key) => {
+  const value = catalog[key];
+  const source = reference[key];
+  if (value === void 0) return [{ lang, key, kind: "missing" }];
+  if (typeof value !== "string" || typeof source !== "string") return [];
+  const expected = placeholdersOf(source);
+  const actual = placeholdersOf(value);
+  return sameList(expected, actual) ? [] : [{ lang, key, kind: "placeholder", expected, actual }];
+});
+var checkCatalogs = (input) => {
+  const reference = input[SOURCE_LANG];
+  const problems = LANGUAGES.flatMap(
+    (lang) => lang === SOURCE_LANG ? valueProblems(lang, input[lang], reference) : [...valueProblems(lang, input[lang], reference), ...parityProblems(lang, input[lang], reference)]
+  );
+  return { languages: LANGUAGES, keys: Object.keys(reference).length, problems };
+};
+
+// src/commands/i18n-check.ts
+var unreadable = (dir, file, detail) => ({
+  code: "i18n_catalog_unreadable",
+  messageKey: "error.i18n_catalog_unreadable",
+  params: { file, detail },
+  fix: `finitemonkey i18n check --dir ${dir}`,
+  exitCode: ExitCode.NotConfigured
+});
+var readCatalog = (ctx, dir, lang) => {
+  const file = toAbsolutePath(join(dir, `${lang}.json`));
+  const text = ctx.runtime.readText(file);
+  if (!text.ok) return reject(unreadable(dir, file, text.error));
+  const parsed = parseJsonObject(text.value);
+  return parsed.ok ? parsed : reject(unreadable(dir, file, parsed.error));
+};
+var loadCatalogs = (ctx, dir) => {
+  const en = readCatalog(ctx, dir, "en");
+  if (!en.ok) return en;
+  const ptBR = readCatalog(ctx, dir, "pt-BR");
+  if (!ptBR.ok) return ptBR;
+  const es = readCatalog(ctx, dir, "es");
+  if (!es.ok) return es;
+  return accept({ en: en.value, "pt-BR": ptBR.value, es: es.value });
+};
+var describeProblem = (ctx, problem) => {
+  const kind = ctx.t(`i18n.problem.${problem.kind}`, {
+    expected: (problem.expected ?? []).join(", "),
+    actual: (problem.actual ?? []).join(", ")
+  });
+  return `  ${problem.lang}  ${problem.key}  ${kind}`;
+};
+var runI18nCheck = (ctx, dir) => {
+  const input = dir === void 0 ? accept(catalogs) : loadCatalogs(ctx, dir);
+  if (!input.ok) return failureFrom(ctx.t, input.error);
+  const report = checkCatalogs(input.value);
+  const data = { ...report, source: dir ?? "bundled" };
+  const summary = ctx.t("i18n.summary", { languages: report.languages.join(", "), keys: report.keys });
+  if (report.problems.length === 0) return success(data, [summary, ctx.t("i18n.ok")]);
+  return {
+    ok: false,
+    exitCode: ExitCode.CheckFailed,
+    data,
+    human: [summary, ...report.problems.map((problem) => describeProblem(ctx, problem))],
+    error: {
+      code: "i18n_mismatch",
+      message: ctx.t("error.i18n_mismatch", { count: report.problems.length }),
+      fix: ctx.t("i18n.fix", { file: dir ?? "src/i18n" })
+    }
+  };
+};
+var i18nCheckCommand = {
+  path: ["i18n", "check"],
+  summaryKey: "command.i18n_check.summary",
+  usage: "finitemonkey i18n check [--dir <path>]",
+  status: "ready",
+  options: { dir: { type: "string" } },
+  run: (ctx, args) => {
+    const dir = stringOption(args.values, "dir");
+    return Promise.resolve(runI18nCheck(ctx, dir === void 0 ? void 0 : toAbsolutePath(dir, ctx.cwd)));
+  }
+};
+
+// src/commands/planned.ts
+var planned = (name, summaryKey, options) => ({
+  path: [name],
+  summaryKey,
+  usage: `finitemonkey ${name}`,
+  status: "planned",
+  options,
+  maxPositionals: 8,
+  run: (ctx) => Promise.resolve(
+    failureFrom(ctx.t, {
+      code: "not_implemented",
+      messageKey: "error.not_implemented",
+      params: { command: name },
+      fix: "finitemonkey help",
+      exitCode: ExitCode.Usage,
+      data: { command: name, status: "planned" }
+    })
+  )
+});
+var initCommand = planned("init", "command.init.summary", {
+  preset: { type: "string" },
+  github: { type: "boolean" }
+});
+var updateCommand = planned("update", "command.update.summary", { check: { type: "boolean" } });
+var uninstallCommand = planned("uninstall", "command.uninstall.summary", {
+  purge: { type: "boolean" },
+  "keep-generated": { type: "boolean" }
+});
+
+// src/commands/version.ts
+var versionCommand = {
+  path: ["version"],
+  summaryKey: "command.version.summary",
+  usage: "finitemonkey version",
+  status: "ready",
+  run: (ctx) => {
+    const data = { version: ctx.version, node: ctx.runtime.nodeVersion, platform: ctx.platform };
+    return Promise.resolve(success(data, [ctx.version]));
+  }
+};
+
+// src/commands/index.ts
+var REGISTRY = [
+  initCommand,
+  doctorCommand,
+  updateCommand,
+  uninstallCommand,
+  i18nCheckCommand,
+  hookCommand,
+  versionCommand,
+  helpCommand
+];
+
+// src/core/suggest.ts
+var distance = (a, b) => {
+  const row = Array.from({ length: b.length + 1 }, (_, index) => index);
+  for (let i = 1; i <= a.length; i += 1) {
+    let diagonal = row[0] ?? 0;
+    row[0] = i;
+    for (let j = 1; j <= b.length; j += 1) {
+      const above = row[j] ?? 0;
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      row[j] = Math.min(above + 1, (row[j - 1] ?? 0) + 1, diagonal + cost);
+      diagonal = above;
+    }
+  }
+  return row[b.length] ?? 0;
+};
+var closest = (input, candidates) => {
+  const group = candidates.find((name) => name.startsWith(`${input} `));
+  if (group !== void 0) return group;
+  const limit = Math.max(1, Math.floor(input.length / 3));
+  let best;
+  for (const name of candidates) {
+    const score = distance(input, name.split(" ")[0] ?? name);
+    if (score <= limit && (best === void 0 || score < best.score)) best = { name, score };
+  }
+  return best?.name;
+};
+
+// src/core/dispatch.ts
+var unknownCommand = (registry, attempted) => {
+  const suggestion = closest(attempted, registry.map(commandName));
+  return suggestion === void 0 ? usageProblem("unknown_command", "error.unknown_command", "finitemonkey help", { command: attempted }) : usageProblem("unknown_command", "error.unknown_command_suggest", `finitemonkey ${suggestion}`, {
+    command: attempted,
+    suggestion
+  });
+};
+var failWith = (ctx, name, problem) => ({
+  name,
+  execute: () => Promise.resolve(failureFrom(ctx.t, problem))
+});
+var invoke = (ctx, argv, spec, registry) => {
+  const name = commandName(spec);
+  const args = strictArgs(argv, spec);
+  if (!args.ok) return failWith(ctx, name, args.error);
+  return { name, execute: () => spec.run(ctx, args.value, registry) };
+};
+var builtin = (registry, name) => registry.find((spec) => commandName(spec) === name);
+var dispatch = (ctx, argv, loose, registry) => {
+  const resolved = resolveCommand(registry, loose.positionals);
+  const attempted = loose.positionals[0];
+  if (resolved === void 0 && attempted !== void 0) {
+    return failWith(ctx, attempted, unknownCommand(registry, attempted));
+  }
+  const wanted = loose.version && !loose.help ? "version" : "help";
+  if (resolved === void 0 || loose.version && !loose.help) {
+    const spec = builtin(registry, wanted);
+    if (spec === void 0) return failWith(ctx, wanted, unknownCommand(registry, wanted));
+    return { name: wanted, execute: () => spec.run(ctx, { values: {}, positionals: [] }, registry) };
+  }
+  if (loose.help) return { name: "help", execute: () => Promise.resolve(helpFor(ctx, resolved.spec)) };
+  return invoke(ctx, argv, resolved.spec, registry);
+};
+
+// src/core/output.ts
+var ISSUES_URL = "https://github.com/gabrielvieiraf/finitemonkey/issues";
+var resultFromThrown = (thrown, t) => {
+  if (thrown instanceof FmError) return failureFrom(t, thrown.problem);
+  const detail = thrown instanceof Error ? thrown.message : String(thrown);
+  return failureFrom(t, {
+    code: "internal_error",
+    messageKey: "error.internal",
+    params: { detail },
+    fix: ISSUES_URL,
+    exitCode: ExitCode.Internal
+  });
+};
+var block = (items) => items.length > 0 ? `${items.join("\n")}
+` : "";
+var render = (ctx, command, result) => {
+  if (result.raw !== void 0) {
+    ctx.io.stdout.write(result.raw.stdout);
+    ctx.io.stderr.write(result.raw.stderr);
+    return;
+  }
+  if (ctx.json) {
+    ctx.io.stdout.write(`${JSON.stringify(toEnvelope(command, result))}
+`);
+    return;
+  }
+  ctx.io.stdout.write(block(result.human ?? []));
+  if (!result.ok) {
+    const { message, fix } = result.error;
+    ctx.io.stderr.write(block([ctx.t("output.error", { message }), ctx.t("output.fix", { fix })]));
+  }
+  if (result.next !== void 0) ctx.io.stdout.write(block([ctx.t("output.next", { next: result.next })]));
+};
+
+// src/core/run.ts
+var run = async (options) => {
+  const loose = looseArgs(options.argv);
+  const detected = detectLang(loose.lang, options.env);
+  const t = createTranslator(detected.lang);
+  const ctx = {
+    lang: detected.lang,
+    langSource: detected.source,
+    t,
+    json: loose.json,
+    yes: loose.yes,
+    dryRun: loose.dryRun,
+    cwd: options.cwd,
+    env: options.env,
+    platform: options.platform,
+    version: options.version,
+    io: options.io,
+    runtime: options.runtime
+  };
+  let name = loose.positionals[0] ?? "";
+  let result;
+  try {
+    if (loose.lang !== void 0 && normalizeLang(loose.lang) === void 0) {
+      const problem = usageProblem("invalid_lang", "error.invalid_lang", "finitemonkey --lang en", {
+        lang: loose.lang,
+        languages: LANGUAGES.join(", ")
+      });
+      result = failureFrom(t, problem);
+    } else {
+      const dispatched = dispatch(ctx, options.argv, loose, options.registry ?? REGISTRY);
+      name = dispatched.name;
+      result = await dispatched.execute();
+    }
+  } catch (thrown) {
+    result = resultFromThrown(thrown, t);
+  }
+  render(ctx, name, result);
+  return result.exitCode;
+};
+
+// src/core/version.ts
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+var UNKNOWN_VERSION = "0.0.0-unknown";
+var readPackageVersion = (readText, moduleUrl) => {
+  const text = readText(toAbsolutePath(fileURLToPath2(new URL("../package.json", moduleUrl))));
+  if (!text.ok) return UNKNOWN_VERSION;
+  const parsed = parseJson(text.value);
+  if (!parsed.ok || !isRecord(parsed.value)) return UNKNOWN_VERSION;
+  const version = parsed.value["version"];
+  return typeof version === "string" ? version : UNKNOWN_VERSION;
+};
+
+// src/cli.ts
+var flush = (stream) => new Promise((resolve2) => {
+  stream.write("", () => {
+    resolve2();
+  });
+});
+var main = async () => {
+  const runtime = nodeRuntime();
+  const code = await run({
+    argv: process.argv.slice(2),
+    env: process.env,
+    cwd: toAbsolutePath(process.cwd()),
+    platform: process.platform,
+    io: { stdout: process.stdout, stderr: process.stderr, stdin: process.stdin },
+    version: readPackageVersion(runtime.readText, import.meta.url),
+    runtime
+  });
+  await Promise.all([flush(process.stdout), flush(process.stderr)]);
+  process.exit(code);
+};
+if (isEntryPoint(import.meta.url, process.argv[1], nodeRealpath, process.platform)) await main();
+export {
+  main
+};