agex 0.1.2 → 0.2.3

package/dist/cli.js

@@ -1,223 +1,451 @@
 #!/usr/bin/env node
 import {
-  proov,
+  AGENT_NAMES,
+  APPROVAL_POLICIES,
+  OUTPUT_MODES,
+  detectDefaultBranch,
+  isAgexError,
+  prove,
+  proveOptionsSchema,
   runAgent,
-  runReview
-} from "./chunk-H3CMLOXO.js";
-import "./chunk-2ZRS4JND.js";
+  runReview,
+  validate,
+  viewportStringSchema
+} from "./chunk-EN7TTESF.js";
 
-// src/commands/proov.ts
-function printHelp() {
-  console.log(`
-agex proov - Prove visual assertions with screenshots
-
-USAGE:
-  agex proov "<assertion>" [options]
-
-OPTIONS:
-  --agent, -a <name>    Agent to use: cursor (default), claude, codex
-  --url, -u <url>       URL to navigate to
-  --output, -o <dir>    Output directory (default: ./proov-results)
-  --video               Enable video recording (default)
-  --no-video            Disable video recording
-  --screenshots         Enable screenshots (default)
-  --no-screenshots      Disable screenshots
-  --model, -m <model>   Model to use
-  --timeout, -t <ms>    Timeout in milliseconds
-  --viewport <WxH>      Viewport size (default: 1920x1080)
-  --headless            Run headless (default)
-  --headed              Show browser window
-  --help, -h            Show this help
+// src/cli.ts
+import { defineCommand as defineCommand6, runMain } from "citty";
 
-EXAMPLES:
-  agex proov "prove the Google logo is on the homepage" --url https://google.com
-  agex proov "verify login button exists" --agent claude --url https://example.com
-`);
+// src/commands/browse.ts
+import { defineCommand } from "citty";
+import { execa } from "execa";
+async function installBrowser() {
+  console.log("[agex browse] Browser not found. Installing Chromium...");
+  await execa("npx", ["--yes", "playwright", "install", "chromium"], { stdio: "inherit" });
+  console.log("[agex browse] Browser installed successfully.");
 }
-function parseArgs(args) {
-  const options = {};
-  let assertion = "";
-  for (let i = 0; i < args.length; i++) {
-    const arg = args[i];
-    if (arg === "--agent" || arg === "-a") {
-      options.agent = args[++i];
-    } else if (arg === "--url" || arg === "-u") {
-      options.url = args[++i];
-    } else if (arg === "--output" || arg === "-o") {
-      options.outputDir = args[++i];
-    } else if (arg === "--video") {
-      options.video = true;
-    } else if (arg === "--no-video") {
-      options.video = false;
-    } else if (arg === "--model" || arg === "-m") {
-      options.model = args[++i];
-    } else if (arg === "--timeout" || arg === "-t") {
-      options.timeout = parseInt(args[++i], 10);
-    } else if (arg === "--viewport") {
-      const [width, height] = args[++i].split("x").map(Number);
-      options.viewport = { width, height };
-    } else if (arg === "--headless") {
-      options.headless = true;
-    } else if (arg === "--headed") {
-      options.headless = false;
-    } else if (arg === "--screenshots") {
-      options.screenshots = true;
-    } else if (arg === "--no-screenshots") {
-      options.screenshots = false;
-    } else if (arg === "--help" || arg === "-h") {
-      printHelp();
-      process.exit(0);
-    } else if (!arg.startsWith("-")) {
-      assertion = assertion ? `${assertion} ${arg}` : arg;
+async function runAgentBrowser(browserArgs) {
+  try {
+    const result = await execa("npx", ["--yes", "agent-browser", ...browserArgs], {
+      stdio: "pipe",
+      env: { ...process.env }
+    });
+    if (result.stdout) process.stdout.write(result.stdout);
+    if (result.stderr) process.stderr.write(result.stderr);
+    return { success: true, needsBrowserInstall: false };
+  } catch (error) {
+    const execaError = error;
+    const output = `${execaError.stdout ?? ""}${execaError.stderr ?? ""}`;
+    if (output.includes("Executable doesn't exist") || output.includes("npx playwright install")) {
+      return { success: false, needsBrowserInstall: true };
     }
+    if (execaError.stdout) process.stdout.write(execaError.stdout);
+    if (execaError.stderr) process.stderr.write(execaError.stderr);
+    return { success: false, needsBrowserInstall: false };
   }
-  return { assertion, options };
-}
-async function runProov(args) {
-  const { assertion, options } = parseArgs(args);
-  if (!assertion) {
-    console.error("Error: No assertion provided");
-    printHelp();
-    process.exit(1);
-  }
-  console.log("========================================");
-  console.log("agex proov");
-  console.log("========================================");
-  console.log(`Agent: ${options.agent ?? "cursor"}`);
-  console.log(`Task: ${assertion}`);
-  if (options.url) {
-    console.log(`URL: ${options.url}`);
-  }
-  console.log("========================================\n");
-  const result = await proov(assertion, options);
-  console.log("\n========================================");
-  if (result.verdict === "pass") {
-    console.log("\u2705 PASS");
-  } else if (result.verdict === "fail") {
-    console.log("\u274C FAIL");
-  } else {
-    console.log("\u23ED\uFE0F  SKIP");
-  }
-  console.log(`Reason: ${result.reason}`);
-  console.log(`Duration: ${result.durationMs}ms`);
-  console.log(`Output: ${result.outputDir}`);
-  console.log("========================================");
-  process.exit(result.verdict === "pass" ? 0 : 1);
 }
-
-// src/commands/run.ts
-function printHelp2() {
-  console.log(`
-agex run - Execute AI agent tasks
+var browse_default = defineCommand({
+  meta: {
+    name: "browse",
+    description: "Browser automation via agent-browser"
+  },
+  args: {
+    install: {
+      type: "boolean",
+      description: "Force reinstall browser",
+      default: false
+    },
+    _: {
+      type: "positional",
+      description: "agent-browser command and arguments",
+      required: false
+    }
+  },
+  async run({ args, rawArgs }) {
+    const browserArgs = rawArgs.filter((arg) => arg !== "--install");
+    if (browserArgs.length === 0) {
+      console.log(`
+agex browse - Browser automation via agent-browser
 
 USAGE:
-  agex run --agent <name> "<prompt>" [options]
+  agex browse <command> [options]
+
+COMMANDS:
+  All agent-browser commands are supported. Common ones:
+  
+  open <url>          Navigate to URL
+  snapshot [-i]       Get accessibility tree (use -i for interactive elements)
+  click @e1           Click element by ref
+  fill @e2 "text"     Fill input by ref
+  screenshot [path]   Take screenshot
+  close               Close browser
 
 OPTIONS:
-  --agent, -a <name>    Agent to use: cursor, claude, codex (required)
-  --model, -m <model>   Model to use
-  --prompt, -p <text>   Prompt (can also be positional)
-  --install             Run install command before agent
-  --install-command     Custom install command
-  --require-api-key     Require API key
-  --no-approve-mcps     Don't auto-approve MCPs
-  --no-browser          Disable browser
-  --no-stream           Disable streaming output
-  --mode <mode>         Output mode: text, json, debug
-  --approval <policy>   Approval policy
-  --timeout <ms>        Timeout in milliseconds
-  --help, -h            Show this help
+  --install           Force reinstall browser
 
 EXAMPLES:
-  agex run --agent cursor "build a landing page"
-  agex run --agent claude "refactor this function" --mode json
+  agex browse open https://example.com
+  agex browse snapshot -i
+  agex browse click @e1
+  agex browse fill @e2 "hello@example.com"
+  agex browse screenshot page.png
+  agex browse close
+
+For full documentation, run: npx agent-browser --help
+Or visit: https://github.com/vercel-labs/agent-browser
 `);
-}
-function parseArgs2(args) {
-  let agent;
-  let model;
-  let prompt = "";
-  let install = false;
-  let installCommand;
-  let timeoutMs;
-  let requireApiKey = false;
-  let approveMcps = true;
-  let browser = true;
-  let streamOutput = true;
-  let outputMode = "text";
-  let approvalPolicy;
-  for (let i = 0; i < args.length; i += 1) {
-    const arg = args[i];
-    if (arg === "--help" || arg === "-h") {
-      printHelp2();
-      process.exit(0);
-    } else if (arg === "--agent" || arg === "-a") {
-      agent = args[i + 1];
-      i += 1;
-    } else if (arg === "--model" || arg === "-m") {
-      model = args[i + 1];
-      i += 1;
-    } else if (arg === "--prompt" || arg === "-p") {
-      prompt = args[i + 1] ?? "";
-      i += 1;
-    } else if (arg === "--install") {
-      install = true;
-    } else if (arg === "--install-command") {
-      installCommand = args[i + 1];
-      i += 1;
-    } else if (arg === "--require-api-key") {
-      requireApiKey = true;
-    } else if (arg === "--no-approve-mcps") {
-      approveMcps = false;
-    } else if (arg === "--no-browser") {
-      browser = false;
-    } else if (arg === "--no-stream") {
-      streamOutput = false;
-    } else if (arg === "--mode") {
-      const value = args[i + 1];
-      if (value === "json" || value === "text" || value === "debug") {
-        outputMode = value;
+      return;
+    }
+    if (args.install) {
+      await installBrowser();
+      if (browserArgs.length === 0) {
+        return;
       }
-      i += 1;
-    } else if (arg === "--approval") {
-      approvalPolicy = args[i + 1];
-      i += 1;
-    } else if (arg === "--timeout") {
-      const value = Number(args[i + 1]);
-      if (!Number.isNaN(value)) {
-        timeoutMs = value;
+    }
+    const firstRun = await runAgentBrowser(browserArgs);
+    if (firstRun.success) {
+      return;
+    }
+    if (firstRun.needsBrowserInstall) {
+      await installBrowser();
+      try {
+        await execa("npx", ["--yes", "agent-browser", ...browserArgs], {
+          stdio: "inherit",
+          env: { ...process.env }
+        });
+      } catch (error) {
+        const exitCode = error.exitCode ?? 1;
+        process.exit(exitCode);
       }
-      i += 1;
-    } else {
-      prompt = prompt ? `${prompt} ${arg}` : arg;
+      return;
     }
+    process.exit(1);
   }
-  if (!agent) {
-    throw new Error("Missing --agent");
+});
+
+// src/commands/prove.ts
+import { defineCommand as defineCommand2 } from "citty";
+var prove_default = defineCommand2({
+  meta: {
+    name: "prove",
+    description: "Prove visual assertions with screenshots"
+  },
+  args: {
+    assertion: {
+      type: "positional",
+      description: "The assertion to prove",
+      required: true
+    },
+    agent: {
+      type: "string",
+      alias: "a",
+      description: "Agent to use: cursor (default), claude, codex",
+      default: "cursor"
+    },
+    url: {
+      type: "string",
+      alias: "u",
+      description: "URL to navigate to"
+    },
+    output: {
+      type: "string",
+      alias: "o",
+      description: "Output directory",
+      default: "./prove-results"
+    },
+    video: {
+      type: "boolean",
+      description: "Enable video recording",
+      default: true
+    },
+    screenshots: {
+      type: "boolean",
+      description: "Enable screenshots",
+      default: true
+    },
+    model: {
+      type: "string",
+      alias: "m",
+      description: "Model to use"
+    },
+    timeout: {
+      type: "string",
+      alias: "t",
+      description: "Timeout in milliseconds",
+      default: "300000"
+    },
+    viewport: {
+      type: "string",
+      description: "Viewport size (WxH)",
+      default: "1920x1080"
+    },
+    headless: {
+      type: "boolean",
+      description: "Run headless",
+      default: true
+    },
+    browser: {
+      type: "string",
+      alias: "b",
+      description: "Browser mode: mcp (default) or cli (agent-browser)",
+      default: "mcp"
+    }
+  },
+  async run({ args }) {
+    if (!AGENT_NAMES.includes(args.agent)) {
+      console.error(`Invalid agent: "${args.agent}". Must be one of: ${AGENT_NAMES.join(", ")}`);
+      process.exit(1);
+    }
+    const viewportResult = viewportStringSchema.safeParse(args.viewport);
+    if (!viewportResult.success) {
+      console.error(`Invalid viewport: "${args.viewport}". Use format "WIDTHxHEIGHT" (e.g. "1920x1080")`);
+      process.exit(1);
+    }
+    const options = {
+      agent: args.agent,
+      url: args.url,
+      outputDir: args.output,
+      video: args.video,
+      screenshots: args.screenshots,
+      model: args.model,
+      timeout: args.timeout ? parseInt(args.timeout, 10) : void 0,
+      viewport: viewportResult.data,
+      headless: args.headless
+    };
+    const validated = validate(proveOptionsSchema, options);
+    if (!validated.success) {
+      console.error(`Invalid options: ${validated.error}`);
+      process.exit(1);
+    }
+    console.log("========================================");
+    console.log("agex prove");
+    console.log("========================================");
+    console.log(`Workspace: ${process.cwd()}`);
+    console.log(`Agent: ${options.agent}`);
+    console.log(`Task: ${args.assertion}`);
+    if (options.url) {
+      console.log(`URL: ${options.url}`);
+    }
+    console.log("========================================\n");
+    try {
+      const result = await prove(args.assertion, options);
+      console.log("\n========================================");
+      if (result.verdict === "pass") {
+        console.log("\u2705 PASS");
+      } else if (result.verdict === "fail") {
+        console.log("\u274C FAIL");
+      } else {
+        console.log("\u23ED\uFE0F  SKIP");
+      }
+      console.log(`Reason: ${result.reason}`);
+      console.log(`Duration: ${result.durationMs}ms`);
+      console.log(`Output: ${result.outputDir}`);
+      console.log("========================================");
+      process.exit(result.verdict === "pass" ? 0 : 1);
+    } catch (err) {
+      if (isAgexError(err)) {
+        console.error(`Error [${err.code}]: ${err.message}`);
+      } else {
+        console.error(`Unexpected error: ${err instanceof Error ? err.message : String(err)}`);
+      }
+      process.exit(1);
+    }
   }
-  if (!prompt) {
-    throw new Error("Missing prompt");
+});
+
+// src/commands/prove-pr.ts
+import { defineCommand as defineCommand3 } from "citty";
+import { provePr } from "agex-prove-pr";
+var prove_pr_default = defineCommand3({
+  meta: {
+    name: "prove-pr",
+    description: "Prove PR changes work with screenshots and evidence"
+  },
+  args: {
+    base: {
+      type: "string",
+      description: "Base branch/commit to compare against (auto-detected if omitted)"
+    },
+    agent: {
+      type: "string",
+      alias: "a",
+      description: "Agent to use: cursor (default), claude, codex",
+      default: "cursor"
+    },
+    url: {
+      type: "string",
+      alias: "u",
+      description: "Dev server URL for visual testing"
+    },
+    output: {
+      type: "string",
+      alias: "o",
+      description: "Output directory",
+      default: "./prove-pr-results"
+    },
+    hypotheses: {
+      type: "string",
+      description: "Number of hypotheses to generate",
+      default: "5"
+    },
+    model: {
+      type: "string",
+      alias: "m",
+      description: "Model to use"
+    },
+    viewport: {
+      type: "string",
+      description: "Viewport size (WxH)",
+      default: "1920x1080"
+    },
+    hint: {
+      type: "string",
+      description: "Additional prompt hint for hypothesis generation"
+    },
+    timeout: {
+      type: "string",
+      alias: "t",
+      description: "Timeout in milliseconds",
+      default: "300000"
+    }
+  },
+  async run({ args }) {
+    if (!AGENT_NAMES.includes(args.agent)) {
+      console.error(`Invalid agent: "${args.agent}". Must be one of: ${AGENT_NAMES.join(", ")}`);
+      process.exit(1);
+    }
+    const viewportResult = viewportStringSchema.safeParse(args.viewport);
+    if (!viewportResult.success) {
+      console.error(`Invalid viewport: "${args.viewport}". Use format "WIDTHxHEIGHT" (e.g. "1920x1080")`);
+      process.exit(1);
+    }
+    const hypothesesCount = parseInt(args.hypotheses, 10);
+    if (isNaN(hypothesesCount) || hypothesesCount <= 0) {
+      console.error(`Invalid hypotheses count: "${args.hypotheses}". Must be a positive integer.`);
+      process.exit(1);
+    }
+    const request = {
+      baseRef: args.base,
+      agent: args.agent,
+      url: args.url,
+      outputDir: args.output,
+      hypothesesCount,
+      model: args.model,
+      viewport: viewportResult.data,
+      hint: args.hint,
+      timeoutMs: args.timeout ? parseInt(args.timeout, 10) : void 0
+    };
+    console.log("========================================");
+    console.log("agex prove-pr");
+    console.log("========================================");
+    console.log(`Base: ${request.baseRef || "(auto-detect)"}`);
+    console.log(`Agent: ${request.agent}`);
+    console.log(`Hypotheses: ${hypothesesCount}`);
+    if (request.url) console.log(`URL: ${request.url}`);
+    console.log(`Output: ${request.outputDir}`);
+    console.log("========================================\n");
+    try {
+      const result = await provePr(request);
+      console.log("\n========================================");
+      console.log("RESULTS");
+      console.log("========================================");
+      console.log(`\u2705 Passed: ${result.summary.pass}`);
+      console.log(`\u274C Failed: ${result.summary.fail}`);
+      console.log(`\u23ED\uFE0F  Skipped: ${result.summary.skip}`);
+      console.log(`Duration: ${(result.durationMs / 1e3).toFixed(1)}s`);
+      console.log(`Output: ${result.outputDir}`);
+      console.log("========================================");
+      process.exit(result.summary.fail === 0 ? 0 : 1);
+    } catch (err) {
+      if (isAgexError(err)) {
+        console.error(`Error [${err.code}]: ${err.message}`);
+      } else {
+        console.error(`Unexpected error: ${err instanceof Error ? err.message : String(err)}`);
+      }
+      process.exit(1);
+    }
   }
-  const quietOutput = outputMode === "json";
-  if (quietOutput) {
-    streamOutput = false;
+});
+
+// src/commands/review.ts
+import { defineCommand as defineCommand4 } from "citty";
+var review_default = defineCommand4({
+  meta: {
+    name: "review",
+    description: "Review code changes"
+  },
+  args: {
+    base: {
+      type: "string",
+      description: "Base branch/commit to compare against (auto-detected if omitted)"
+    },
+    agent: {
+      type: "string",
+      alias: "a",
+      description: "Agent to use: cursor, claude, codex",
+      required: true
+    },
+    model: {
+      type: "string",
+      alias: "m",
+      description: "Model to use"
+    },
+    worktree: {
+      type: "boolean",
+      description: "Include worktree changes",
+      default: true
+    },
+    hypotheses: {
+      type: "string",
+      description: "Number of hypotheses to generate"
+    },
+    hint: {
+      type: "string",
+      description: "Additional prompt hint"
+    },
+    timeout: {
+      type: "string",
+      alias: "t",
+      description: "Timeout in milliseconds",
+      default: "300000"
+    }
+  },
+  async run({ args }) {
+    if (!AGENT_NAMES.includes(args.agent)) {
+      console.error(`Invalid agent: "${args.agent}". Must be one of: ${AGENT_NAMES.join(", ")}`);
+      process.exit(1);
+    }
+    if (args.hypotheses) {
+      const h = parseInt(args.hypotheses, 10);
+      if (isNaN(h) || h <= 0) {
+        console.error(`Invalid hypotheses count: "${args.hypotheses}". Must be a positive integer.`);
+        process.exit(1);
+      }
+    }
+    try {
+      const base = args.base || detectDefaultBranch();
+      await runReview({
+        baseRef: base,
+        agent: args.agent,
+        model: args.model,
+        includeWorktree: args.worktree,
+        hypotheses: args.hypotheses ? parseInt(args.hypotheses, 10) : void 0,
+        promptHint: args.hint,
+        timeoutMs: args.timeout ? parseInt(args.timeout, 10) : void 0
+      });
+    } catch (err) {
+      if (isAgexError(err)) {
+        console.error(`Error [${err.code}]: ${err.message}`);
+      } else {
+        console.error(`Unexpected error: ${err instanceof Error ? err.message : String(err)}`);
+      }
+      process.exit(1);
+    }
   }
-  return {
-    agent,
-    model,
-    prompt,
-    install,
-    installCommand,
-    requireApiKey,
-    approveMcps,
-    browser,
-    streamOutput,
-    quietOutput,
-    outputMode,
-    approvalPolicy,
-    timeoutMs
-  };
-}
+});
+
+// src/commands/run.ts
+import { defineCommand as defineCommand5 } from "citty";
 function formatOutput(result, mode, wasStreamed) {
   switch (mode) {
     case "json":
@@ -233,155 +461,132 @@ ${JSON.stringify(result.json, null, 2)}`;
       return null;
   }
 }
-async function runRun(args) {
-  const request = parseArgs2(args);
-  const result = await runAgent(request);
-  const output = formatOutput(result, request.outputMode, request.streamOutput ?? true);
-  if (output !== null) {
-    process.stdout.write(`${output}
-`);
-  }
-}
-
-// src/commands/review.ts
-function printHelp3() {
-  console.log(`
-agex review - Review code changes
-
-USAGE:
-  agex review --base <ref> --agent <name> [options]
-
-OPTIONS:
-  --base <ref>          Base branch/commit to compare against (required)
-  --agent, -a <name>    Agent to use: cursor, claude, codex (required)
-  --model, -m <model>   Model to use
-  --no-worktree         Exclude worktree changes
-  --hypotheses <n>      Number of hypotheses to generate
-  --hint <text>         Additional prompt hint
-  --help, -h            Show this help
-
-EXAMPLES:
-  agex review --base main --agent cursor
-  agex review --base HEAD~3 --agent claude --hint "focus on security"
+var run_default = defineCommand5({
+  meta: {
+    name: "run",
+    description: "Execute AI agent tasks"
+  },
+  args: {
+    prompt: {
+      type: "positional",
+      description: "The prompt to execute",
+      required: true
+    },
+    agent: {
+      type: "string",
+      alias: "a",
+      description: "Agent to use: cursor, claude, codex (auto-detected if not specified)"
+    },
+    model: {
+      type: "string",
+      alias: "m",
+      description: "Model to use"
+    },
+    install: {
+      type: "boolean",
+      description: "Run install command before agent",
+      default: false
+    },
+    installCommand: {
+      type: "string",
+      description: "Custom install command"
+    },
+    requireApiKey: {
+      type: "boolean",
+      description: "Require API key",
+      default: false
+    },
+    approveMcps: {
+      type: "boolean",
+      description: "Auto-approve MCPs",
+      default: true
+    },
+    browser: {
+      type: "boolean",
+      description: "Enable browser",
+      default: true
+    },
+    stream: {
+      type: "boolean",
+      description: "Enable streaming output",
+      default: true
+    },
+    mode: {
+      type: "string",
+      description: "Output mode: text, json, debug",
+      default: "text"
+    },
+    approval: {
+      type: "string",
+      description: "Approval policy: never, on-request, on-failure, untrusted"
+    },
+    timeout: {
+      type: "string",
+      description: "Timeout in milliseconds",
+      default: "300000"
+    }
+  },
+  async run({ args }) {
+    if (args.agent && !AGENT_NAMES.includes(args.agent)) {
+      console.error(`Invalid agent: "${args.agent}". Must be one of: ${AGENT_NAMES.join(", ")}`);
+      process.exit(1);
+    }
+    if (!OUTPUT_MODES.includes(args.mode)) {
+      console.error(`Invalid mode: "${args.mode}". Must be one of: ${OUTPUT_MODES.join(", ")}`);
+      process.exit(1);
+    }
+    if (args.approval && !APPROVAL_POLICIES.includes(args.approval)) {
+      console.error(`Invalid approval policy: "${args.approval}". Must be one of: ${APPROVAL_POLICIES.join(", ")}`);
+      process.exit(1);
+    }
+    const outputMode = args.mode;
+    const quietOutput = outputMode === "json";
+    const streamOutput = quietOutput ? false : args.stream;
+    const request = {
+      agent: args.agent,
+      prompt: args.prompt,
+      model: args.model,
+      install: args.install,
+      installCommand: args.installCommand,
+      requireApiKey: args.requireApiKey,
+      approveMcps: args.approveMcps,
+      browser: args.browser,
+      streamOutput,
+      quietOutput,
+      approvalPolicy: args.approval,
+      timeoutMs: args.timeout ? parseInt(args.timeout, 10) : void 0
+    };
+    try {
+      const result = await runAgent(request);
+      const output = formatOutput(result, outputMode, streamOutput);
+      if (output !== null) {
+        process.stdout.write(`${output}
 `);
-}
-function parseArgs3(args) {
-  let baseRef = "";
-  let agent;
-  let model;
-  let includeWorktree = true;
-  let hypotheses;
-  let promptHint;
-  for (let i = 0; i < args.length; i += 1) {
-    const arg = args[i];
-    if (arg === "--help" || arg === "-h") {
-      printHelp3();
-      process.exit(0);
-    } else if (arg === "--base") {
-      baseRef = args[i + 1] ?? "";
-      i += 1;
-    } else if (arg === "--agent" || arg === "-a") {
-      agent = args[i + 1];
-      i += 1;
-    } else if (arg === "--model" || arg === "-m") {
-      model = args[i + 1];
-      i += 1;
-    } else if (arg === "--no-worktree") {
-      includeWorktree = false;
-    } else if (arg === "--hypotheses") {
-      const value = Number(args[i + 1]);
-      if (!Number.isNaN(value)) {
-        hypotheses = value;
       }
-      i += 1;
-    } else if (arg === "--hint") {
-      promptHint = args[i + 1];
-      i += 1;
+    } catch (err) {
+      if (isAgexError(err)) {
+        console.error(`Error [${err.code}]: ${err.message}`);
+      } else {
+        console.error(`Unexpected error: ${err instanceof Error ? err.message : String(err)}`);
+      }
+      process.exit(1);
     }
   }
-  if (!baseRef) {
-    throw new Error("Missing --base");
-  }
-  if (!agent) {
-    throw new Error("Missing --agent");
-  }
-  return {
-    baseRef,
-    agent,
-    model,
-    includeWorktree,
-    hypotheses,
-    promptHint
-  };
-}
-async function runReview2(args) {
-  const request = parseArgs3(args);
-  await runReview(request);
-}
+});
 
 // src/cli.ts
-var VERSION = "0.1.0";
-var COMMANDS = {
-  proov: {
-    description: "Prove visual assertions with screenshots",
-    run: runProov
-  },
-  run: {
-    description: "Execute AI agent tasks",
-    run: runRun
+var main = defineCommand6({
+  meta: {
+    name: "agex",
+    version: "0.1.2",
+    description: "AI-powered automation toolkit"
   },
-  review: {
-    description: "Review code changes",
-    run: runReview2
-  }
-};
-function printHelp4() {
-  console.log(`
-agex - AI-powered automation toolkit
-
-VERSION: ${VERSION}
-
-USAGE:
-  agex <command> [options]
-
-COMMANDS:
-  proov    ${COMMANDS.proov.description}
-  run      ${COMMANDS.run.description}
-  review   ${COMMANDS.review.description}
-
-EXAMPLES:
-  agex proov "prove google has a logo" --url https://google.com
-  agex run --agent cursor "build a landing page"
-  agex review --base main --agent cursor
-
-Run 'agex <command> --help' for command-specific options.
-`);
-}
-function printVersion() {
-  console.log(`agex v${VERSION}`);
-}
-async function main() {
-  const args = process.argv.slice(2);
-  if (args.length === 0 || args[0] === "--help" || args[0] === "-h") {
-    printHelp4();
-    process.exit(0);
-  }
-  if (args[0] === "--version" || args[0] === "-v") {
-    printVersion();
-    process.exit(0);
+  subCommands: {
+    browse: browse_default,
+    prove: prove_default,
+    "prove-pr": prove_pr_default,
+    review: review_default,
+    run: run_default
   }
-  const command = args[0];
-  const commandArgs = args.slice(1);
-  if (!(command in COMMANDS)) {
-    console.error(`Unknown command: ${command}`);
-    console.error(`Run 'agex --help' for available commands.`);
-    process.exit(1);
-  }
-  try {
-    await COMMANDS[command].run(commandArgs);
-  } catch (error) {
-    console.error("Error:", error instanceof Error ? error.message : error);
-    process.exit(1);
-  }
-}
-main();
+});
+runMain(main);