@jmoak/vibrissa 0.1.0

package/dist/cli.js

@@ -0,0 +1,726 @@
+#!/usr/bin/env node
+import {
+  ConsoleResultsDisplay,
+  McpSession,
+  PrettyConsoleResultsDisplay,
+  Runner,
+  defaultRunCasesOptions,
+  resolveRootDir,
+  resolveServerConfig
+} from "./chunk-FTVETYUK.js";
+
+// src/cli/args.ts
+import path from "path";
+function takeFlag(argv2, name) {
+  const index = argv2.indexOf(name);
+  if (index === -1) return void 0;
+  return argv2[index + 1];
+}
+function hasFlag(argv2, name) {
+  return argv2.includes(name);
+}
+function takeAllFlags(argv2, name) {
+  const values = [];
+  for (let i = 0; i < argv2.length; i++) {
+    if (argv2[i] === name && argv2[i + 1] !== void 0) {
+      values.push(argv2[i + 1]);
+      i++;
+    }
+  }
+  return values;
+}
+function splitCommandLine(input) {
+  const tokens = [];
+  let current = "";
+  let quote = null;
+  for (let i = 0; i < input.length; i++) {
+    const ch = input[i];
+    if (quote) {
+      if (ch === quote) quote = null;
+      else current += ch;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      continue;
+    }
+    if (/\s/.test(ch)) {
+      if (current) {
+        tokens.push(current);
+        current = "";
+      }
+      continue;
+    }
+    current += ch;
+  }
+  if (current) tokens.push(current);
+  if (tokens.length === 0) throw new Error("Empty --server command");
+  return { cmd: tokens[0], args: tokens.slice(1) };
+}
+function parseEnvPairs(pairs) {
+  const env = {};
+  for (const pair of pairs) {
+    const eq = pair.indexOf("=");
+    if (eq <= 0) throw new Error(`Invalid --env value "${pair}" (expected KEY=VALUE)`);
+    env[pair.slice(0, eq)] = pair.slice(eq + 1);
+  }
+  return env;
+}
+function parseArgValue(raw) {
+  if (raw === "true") return true;
+  if (raw === "false") return false;
+  if (raw === "null") return null;
+  if (/^-?\d+(\.\d+)?$/.test(raw)) return Number(raw);
+  if (raw.startsWith("{") && raw.endsWith("}") || raw.startsWith("[") && raw.endsWith("]") || raw.startsWith('"') && raw.endsWith('"')) {
+    try {
+      return JSON.parse(raw);
+    } catch {
+      return raw;
+    }
+  }
+  return raw;
+}
+function parseToolArgs(argv2) {
+  const json = takeFlag(argv2, "--args");
+  const pairs = takeAllFlags(argv2, "--arg");
+  let args = {};
+  if (json !== void 0) {
+    let parsed;
+    try {
+      parsed = JSON.parse(json);
+    } catch (err) {
+      throw new Error(`Invalid --args JSON: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      throw new Error("--args must be a JSON object");
+    }
+    args = { ...parsed };
+  }
+  for (const pair of pairs) {
+    const eq = pair.indexOf("=");
+    if (eq <= 0) throw new Error(`Invalid --arg value "${pair}" (expected key=value)`);
+    args[pair.slice(0, eq)] = parseArgValue(pair.slice(eq + 1));
+  }
+  return args;
+}
+function resolvePathFromCwd(value) {
+  return path.isAbsolute(value) ? value : path.resolve(process.cwd(), value);
+}
+function printJson(value) {
+  console.log(JSON.stringify(value, null, 2));
+}
+
+// src/cli/format.ts
+var RESET = "\x1B[0m";
+var BOLD = "\x1B[1m";
+var DIM = "\x1B[2m";
+var FG_CYAN = "\x1B[36m";
+var FG_GRAY = "\x1B[90m";
+var FG_GREEN = "\x1B[32m";
+var FG_RED = "\x1B[31m";
+var FG_YELLOW = "\x1B[33m";
+function color(text, code2) {
+  return `${code2}${text}${RESET}`;
+}
+function formatToolList(tools) {
+  if (tools.length === 0) return "No tools registered on this server.";
+  const lines = [
+    color(`${tools.length} tool${tools.length === 1 ? "" : "s"}`, BOLD + FG_CYAN),
+    ""
+  ];
+  for (const tool of tools) {
+    lines.push(`${color("\u25B8", FG_GREEN)} ${color(tool.name, BOLD + FG_CYAN)}`);
+    if (tool.description) lines.push(`  ${color(tool.description, FG_GRAY)}`);
+    const schema = tool.inputSchema;
+    if (schema && typeof schema === "object" && !Array.isArray(schema)) {
+      const props = typeof schema.properties === "object" && schema.properties !== null ? Object.keys(schema.properties) : [];
+      const required = Array.isArray(schema.required) ? schema.required.filter((v) => typeof v === "string") : [];
+      if (props.length > 0) {
+        const rendered = props.map((name) => required.includes(name) ? `${name}*` : name).join(", ");
+        lines.push(`  ${color(`args: ${rendered}`, DIM)}`);
+      }
+    }
+    lines.push("");
+  }
+  return lines.join("\n").trimEnd();
+}
+function formatCallHeader(tool, args) {
+  return `${color("call", FG_CYAN)} ${color(tool, BOLD)} ${color(JSON.stringify(args), FG_GRAY)}`;
+}
+function formatSuccessBanner(text) {
+  return color(text, FG_GREEN);
+}
+function formatErrorBanner(text) {
+  return color(text, FG_RED);
+}
+function formatWarnBanner(text) {
+  return color(text, FG_YELLOW);
+}
+
+// src/cli/resolve.ts
+import path3 from "path";
+
+// src/config.ts
+import fs from "fs";
+import path2 from "path";
+function stripJsonComments(input) {
+  let result = "";
+  let inString = false;
+  let stringQuote = null;
+  let escaped = false;
+  let inBlockComment = false;
+  let inLineComment = false;
+  for (let i = 0; i < input.length; i++) {
+    const char = input[i];
+    const next = i + 1 < input.length ? input[i + 1] : "";
+    if (inLineComment) {
+      if (char === "\n") {
+        inLineComment = false;
+        result += char;
+      }
+      continue;
+    }
+    if (inBlockComment) {
+      if (char === "*" && next === "/") {
+        inBlockComment = false;
+        i++;
+      }
+      continue;
+    }
+    if (!inString && char === "/" && next === "*") {
+      inBlockComment = true;
+      i++;
+      continue;
+    }
+    if (!inString && char === "/" && next === "/") {
+      inLineComment = true;
+      i++;
+      continue;
+    }
+    if (inString) {
+      result += char;
+      if (!escaped && char === stringQuote) {
+        inString = false;
+        stringQuote = null;
+      }
+      escaped = !escaped && char === "\\";
+      continue;
+    }
+    if (char === '"' || char === "'" || char === "`") {
+      inString = true;
+      stringQuote = char;
+      result += char;
+      escaped = false;
+      continue;
+    }
+    result += char;
+  }
+  return result;
+}
+function loadConfigObjectFromPath(configPath) {
+  const raw = fs.readFileSync(configPath, "utf8");
+  const json = JSON.parse(stripJsonComments(raw));
+  return json;
+}
+function loadConfigFile(cwd, explicitPath) {
+  if (explicitPath) {
+    const abs = path2.isAbsolute(explicitPath) ? explicitPath : path2.join(cwd, explicitPath);
+    if (!fs.existsSync(abs)) throw new Error(`Config not found: ${abs}`);
+    return {
+      config: loadConfigObjectFromPath(abs),
+      rootDir: path2.dirname(abs),
+      configPath: abs
+    };
+  }
+  const candidates = ["vibrissa.json", "vibrissa.jsonc"];
+  for (const name of candidates) {
+    const file = path2.join(cwd, name);
+    if (fs.existsSync(file)) {
+      return {
+        config: loadConfigObjectFromPath(file),
+        rootDir: path2.dirname(file),
+        configPath: file
+      };
+    }
+  }
+  const pkgPath = path2.join(cwd, "package.json");
+  if (fs.existsSync(pkgPath)) {
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+    if (pkg?.vibrissa && typeof pkg.vibrissa === "object") {
+      return {
+        config: pkg.vibrissa,
+        rootDir: path2.dirname(pkgPath),
+        configPath: pkgPath
+      };
+    }
+  }
+  return void 0;
+}
+function resolveOptions(cwd, explicitPath) {
+  const loaded = loadConfigFile(cwd, explicitPath);
+  const fileConfig = loaded?.config;
+  const rootDir = loaded?.rootDir ?? path2.resolve(cwd);
+  const resolved = {
+    ...defaultRunCasesOptions,
+    ...fileConfig,
+    server: {
+      ...defaultRunCasesOptions.server,
+      ...fileConfig?.server ?? {}
+    },
+    rootDir
+  };
+  return resolved;
+}
+
+// src/cli/resolve.ts
+function parseCommonFlags(argv2) {
+  const configPath = takeFlag(argv2, "--config");
+  const serverRaw = takeFlag(argv2, "--server");
+  const serverCwd = takeFlag(argv2, "--server-cwd");
+  const timeoutRaw = takeFlag(argv2, "--timeout");
+  const env = parseEnvPairs(takeAllFlags(argv2, "--env"));
+  let serverCmd;
+  let serverArgs;
+  if (serverRaw !== void 0) {
+    const split = splitCommandLine(serverRaw);
+    serverCmd = split.cmd;
+    serverArgs = split.args;
+  }
+  return {
+    configPath,
+    serverCmd,
+    serverArgs,
+    serverCwd,
+    env: Object.keys(env).length > 0 ? env : void 0,
+    timeoutMs: timeoutRaw !== void 0 && Number.isFinite(Number(timeoutRaw)) ? Number(timeoutRaw) : void 0,
+    json: hasFlag(argv2, "--json")
+  };
+}
+function mergeCliOptions(flags, overrides = {}) {
+  const resolved = resolveOptions(process.cwd(), flags.configPath);
+  const serverCwd = flags.serverCwd ? path3.isAbsolute(flags.serverCwd) ? flags.serverCwd : resolvePathFromCwd(flags.serverCwd) : void 0;
+  return {
+    ...resolved,
+    ...overrides,
+    server: {
+      ...resolved.server,
+      ...overrides.server ?? {},
+      ...flags.serverCmd ? { cmd: flags.serverCmd } : {},
+      ...flags.serverArgs ? { args: flags.serverArgs } : {},
+      ...serverCwd ? { cwd: serverCwd } : {},
+      env: {
+        ...resolved.server.env ?? {},
+        ...overrides.server?.env ?? {},
+        ...flags.env ?? {}
+      }
+    },
+    ...typeof flags.timeoutMs === "number" ? { timeoutMs: flags.timeoutMs } : {}
+  };
+}
+function openSessionOptions(flags) {
+  const options = mergeCliOptions(flags);
+  return {
+    options,
+    server: resolveServerConfig(options),
+    rootDir: resolveRootDir(options),
+    timeoutMs: options.timeoutMs
+  };
+}
+
+// src/cli/call.ts
+async function callCommand(argv2) {
+  const tool = argv2[0] && !argv2[0].startsWith("--") ? argv2[0] : void 0;
+  if (!tool) {
+    console.error(`Usage: vib-test call <tool> [--args '{"key":"value"}'] [--arg key=value]`);
+    return 1;
+  }
+  const flags = parseCommonFlags(argv2.slice(1));
+  const args = parseToolArgs(argv2.slice(1));
+  const { server, timeoutMs } = openSessionOptions(flags);
+  const spawnTimeoutMs = Math.max(2e3, Math.min(1e4, timeoutMs));
+  const session = await McpSession.start(server, spawnTimeoutMs);
+  try {
+    if (!flags.json) console.log(formatCallHeader(tool, args));
+    const outcome = await session.callTool(tool, args, timeoutMs);
+    if (outcome.kind === "error") {
+      if (flags.json) {
+        printJson({ ok: false, error: outcome.error });
+      } else {
+        const label = outcome.error.codeName ? ` [${outcome.error.codeName}]` : "";
+        console.error(
+          formatErrorBanner(`error${label} (${outcome.error.kind}): ${outcome.error.message}`)
+        );
+      }
+      return 1;
+    }
+    if (flags.json) printJson({ ok: true, result: outcome.result });
+    else {
+      console.log(formatSuccessBanner("ok"));
+      printJson(outcome.result);
+    }
+    return 0;
+  } finally {
+    await session.close();
+  }
+}
+
+// src/cli/init.ts
+import fs2 from "fs";
+import path4 from "path";
+function writeFile(pathName, contents, force) {
+  if (fs2.existsSync(pathName) && !force) return "skipped";
+  fs2.mkdirSync(path4.dirname(pathName), { recursive: true });
+  fs2.writeFileSync(pathName, contents, "utf8");
+  return "wrote";
+}
+function detectServerCommand(dir) {
+  const distCandidates = ["dist/index.js", "build/index.js", "src/index.js"];
+  for (const candidate of distCandidates) {
+    if (fs2.existsSync(path4.join(dir, candidate))) {
+      return { cmd: "node", args: [candidate] };
+    }
+  }
+  return { cmd: "node", args: ["dist/index.js"] };
+}
+function schemaRef(fromFile, rootDir, schemaName) {
+  const local = path4.join(rootDir, "node_modules", "vibrissa", "schema", schemaName);
+  if (fs2.existsSync(local)) {
+    return path4.relative(path4.dirname(fromFile), local).replace(/\\/g, "/");
+  }
+  return `https://unpkg.com/vibrissa/schema/${schemaName}`;
+}
+async function initCommand(argv2) {
+  const flags = parseCommonFlags(argv2);
+  const dir = resolvePathFromCwd(takeFlag(argv2, "--dir") ?? ".");
+  const force = hasFlag(argv2, "--force");
+  const serverOverride = flags.serverCmd ? { cmd: flags.serverCmd, args: flags.serverArgs ?? [] } : detectServerCommand(dir);
+  const configPath = path4.join(dir, "vibrissa.json");
+  const casesDir = path4.join(dir, "tests", "integration");
+  const samplePath = path4.join(casesDir, "echo.basic.json");
+  const config = {
+    $schema: schemaRef(configPath, dir, "vibrissa.schema.json"),
+    server: {
+      cmd: serverOverride.cmd,
+      args: serverOverride.args,
+      cwd: "."
+    },
+    globs: ["tests/integration/**/*.json"],
+    timeoutMs: 15e3,
+    failFast: false
+  };
+  const sample = {
+    $schema: schemaRef(samplePath, dir, "case.schema.json"),
+    name: "echo basic",
+    tool: "echo",
+    args: { text: "hello", uppercase: true },
+    expect: {
+      content: [{ type: "text", text: "HELLO" }]
+    }
+  };
+  const configStatus = writeFile(configPath, `${JSON.stringify(config, null, 2)}
+`, force);
+  fs2.mkdirSync(casesDir, { recursive: true });
+  const sampleStatus = writeFile(samplePath, `${JSON.stringify(sample, null, 2)}
+`, force);
+  const pkgPath = path4.join(dir, "package.json");
+  let pkgNote = "no package.json found (skipped script)";
+  if (fs2.existsSync(pkgPath)) {
+    const pkg = JSON.parse(fs2.readFileSync(pkgPath, "utf8"));
+    pkg.scripts ??= {};
+    if (!pkg.scripts["test:integration"] || force) {
+      pkg.scripts["test:integration"] = "vib-test run";
+      fs2.writeFileSync(pkgPath, `${JSON.stringify(pkg, null, 2)}
+`, "utf8");
+      pkgNote = "added scripts.test:integration";
+    } else {
+      pkgNote = "scripts.test:integration already present";
+    }
+  }
+  console.log(formatSuccessBanner("vibrissa init"));
+  console.log(`  config:  ${configStatus.padEnd(7)} ${configPath}`);
+  console.log(`  sample:  ${sampleStatus.padEnd(7)} ${samplePath}`);
+  console.log(`  package: ${pkgNote}`);
+  console.log("");
+  console.log("Next:");
+  console.log("  1. vib-test tools");
+  console.log("  2. vib-test call <tool> --arg key=value");
+  console.log("  3. vib-test record <tool> --arg key=value");
+  console.log("  4. vib-test run");
+  console.log("  5. vib-test inspect   # open MCP Inspector with this server");
+  if (configStatus === "skipped" || sampleStatus === "skipped") {
+    console.log(
+      formatWarnBanner("Some files already existed; re-run with --force to replace them.")
+    );
+  }
+  return 0;
+}
+
+// src/cli/inspect.ts
+import { spawn } from "child_process";
+async function inspectCommand(argv2) {
+  const dash = argv2.indexOf("--");
+  const ownArgs = dash === -1 ? argv2 : argv2.slice(0, dash);
+  const passthrough = dash === -1 ? [] : argv2.slice(dash + 1);
+  const flags = parseCommonFlags(ownArgs);
+  const { server } = openSessionOptions(flags);
+  const cliMode = hasFlag(ownArgs, "--cli") || passthrough[0] === "--cli";
+  const rest2 = passthrough[0] === "--cli" ? passthrough.slice(1) : passthrough;
+  const inspectorArgs = [
+    "--yes",
+    "@modelcontextprotocol/inspector",
+    ...cliMode ? ["--cli"] : [],
+    server.cmd,
+    ...server.args ?? [],
+    ...rest2
+  ];
+  console.log(
+    formatSuccessBanner(
+      `Opening MCP Inspector for: ${server.cmd} ${(server.args ?? []).join(" ")}`.trim()
+    )
+  );
+  console.log(
+    formatWarnBanner(
+      "Inspector = visual exploration \xB7 Vibrissa tools/call/record/run = the regression loop"
+    )
+  );
+  const child = spawn("npx", inspectorArgs, {
+    cwd: server.cwd ?? process.cwd(),
+    env: { ...process.env, ...server.env ?? {} },
+    stdio: "inherit",
+    shell: process.platform === "win32"
+  });
+  return await new Promise((resolve) => {
+    child.on("error", (err) => {
+      console.error(`Failed to launch MCP Inspector: ${err.message}`);
+      resolve(1);
+    });
+    child.on("exit", (code2, signal) => {
+      if (signal) {
+        resolve(1);
+        return;
+      }
+      resolve(code2 ?? 1);
+    });
+  });
+}
+
+// src/cli/record.ts
+import fs3 from "fs";
+import path5 from "path";
+function slugify(input) {
+  return input.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 48);
+}
+function defaultOutPath(rootDir, tool, name) {
+  const dir = path5.join(rootDir, "tests", "integration");
+  return path5.join(dir, `${slugify(name) || slugify(tool) || "case"}.json`);
+}
+function caseSchemaRef(outPath, rootDir) {
+  const localSchema = path5.join(rootDir, "node_modules", "vibrissa", "schema", "case.schema.json");
+  if (fs3.existsSync(localSchema)) {
+    return path5.relative(path5.dirname(outPath), localSchema).replace(/\\/g, "/");
+  }
+  return "https://unpkg.com/vibrissa/schema/case.schema.json";
+}
+async function recordCommand(argv2) {
+  const tool = argv2[0] && !argv2[0].startsWith("--") ? argv2[0] : void 0;
+  if (!tool) {
+    console.error(
+      `Usage: vib-test record <tool> [--args '{"key":"value"}'] [--out path] [--name "..."] [--partial]`
+    );
+    return 1;
+  }
+  const rest2 = argv2.slice(1);
+  const flags = parseCommonFlags(rest2);
+  const args = parseToolArgs(rest2);
+  const name = takeFlag(rest2, "--name") ?? `${tool} recorded`;
+  const outFlag = takeFlag(rest2, "--out");
+  const partial = hasFlag(rest2, "--partial");
+  const force = hasFlag(rest2, "--force");
+  const { server, rootDir, timeoutMs } = openSessionOptions(flags);
+  const outPath = outFlag ? resolvePathFromCwd(outFlag) : defaultOutPath(rootDir, tool, name);
+  if (fs3.existsSync(outPath) && !force) {
+    console.error(formatErrorBanner(`Refusing to overwrite ${outPath} (pass --force to replace)`));
+    return 1;
+  }
+  const spawnTimeoutMs = Math.max(2e3, Math.min(1e4, timeoutMs));
+  const session = await McpSession.start(server, spawnTimeoutMs);
+  try {
+    if (!flags.json) console.log(formatCallHeader(tool, args));
+    const outcome = await session.callTool(tool, args, timeoutMs);
+    const testCase = {
+      $schema: caseSchemaRef(outPath, rootDir),
+      name,
+      tool,
+      args
+    };
+    if (outcome.kind === "error") {
+      testCase.expectError = {
+        ...outcome.error.codeName ? { code: outcome.error.codeName } : {},
+        message: { $regex: escapeRegex(outcome.error.message.slice(0, 80)) }
+      };
+      if (!flags.json) {
+        console.log(
+          formatWarnBanner(
+            `Captured ${outcome.error.kind} error into expectError (${outcome.error.codeName ?? "tool"})`
+          )
+        );
+      }
+    } else {
+      const expect = outcome.result;
+      testCase.expect = partial ? { $partial: true, ...expect } : expect;
+      if (!flags.json) console.log(formatSuccessBanner("Captured result into expect"));
+    }
+    fs3.mkdirSync(path5.dirname(outPath), { recursive: true });
+    fs3.writeFileSync(outPath, `${JSON.stringify(testCase, null, 2)}
+`, "utf8");
+    if (flags.json) printJson({ ok: true, path: outPath, case: testCase });
+    else console.log(`${formatSuccessBanner("wrote")} ${outPath}`);
+    return 0;
+  } finally {
+    await session.close();
+  }
+}
+function escapeRegex(input) {
+  return input.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/cli/run.ts
+import path6 from "path";
+async function runCommand(argv2) {
+  const flags = parseCommonFlags(argv2);
+  const casesGlob = takeFlag(argv2, "--cases");
+  const failFast = hasFlag(argv2, "--fail-fast");
+  const allowEmpty = hasFlag(argv2, "--allow-empty");
+  let display;
+  if (hasFlag(argv2, "--pretty")) display = "pretty";
+  if (hasFlag(argv2, "--no-pretty")) display = "plain";
+  const displayFlag = takeFlag(argv2, "--display");
+  if (displayFlag === "plain" || displayFlag === "pretty") display = displayFlag;
+  const options = mergeCliOptions(flags, {
+    ...display ? { display } : {},
+    ...casesGlob ? {
+      globs: [
+        path6.isAbsolute(casesGlob) ? casesGlob : resolvePathFromCwd(casesGlob).replace(/\\/g, "/")
+      ]
+    } : {},
+    ...failFast ? { failFast: true } : {},
+    ...allowEmpty ? { allowEmpty: true } : {}
+  });
+  const runner = new Runner(
+    options,
+    options.display === "pretty" ? new PrettyConsoleResultsDisplay() : new ConsoleResultsDisplay()
+  );
+  return runner.run();
+}
+
+// src/cli/tools.ts
+async function toolsCommand(argv2) {
+  const flags = parseCommonFlags(argv2);
+  const { server, timeoutMs } = openSessionOptions(flags);
+  const spawnTimeoutMs = Math.max(2e3, Math.min(1e4, timeoutMs));
+  const session = await McpSession.start(server, spawnTimeoutMs);
+  try {
+    const tools = await session.listTools();
+    if (flags.json) printJson(tools);
+    else console.log(formatToolList(tools));
+    return 0;
+  } finally {
+    await session.close();
+  }
+}
+
+// src/cli.ts
+var COMMANDS = /* @__PURE__ */ new Set(["run", "tools", "call", "record", "init", "inspect"]);
+function printHelp() {
+  console.log(
+    [
+      "vib-test \u2014 JSON-driven MCP integration runner + authoring loop",
+      "",
+      "Usage:",
+      "  vib-test run [options]                 Run JSON cases (default)",
+      "  vib-test tools [options]               List tools on the server",
+      "  vib-test call <tool> [options]         Call a tool and print the result",
+      "  vib-test record <tool> [options]       Call a tool and write a case file",
+      "  vib-test init [options]                Scaffold vibrissa.json + sample case",
+      "  vib-test inspect [options] [-- ...]    Open MCP Inspector with this server",
+      "",
+      "Shared options:",
+      "  --config <path>       vibrissa.json / .jsonc / package.json#vibrissa",
+      '  --server "<cmd ...>"  Override server command',
+      "  --server-cwd <dir>    Working directory for the server process",
+      "  --env KEY=VALUE       Extra env var (repeatable)",
+      "  --timeout <ms>        Per-call / spawn timeout",
+      "  --json                Machine-readable output (tools/call/record)",
+      "",
+      "run options:",
+      "  --cases <glob>        Case glob (relative to shell cwd)",
+      "  --fail-fast           Stop on first failure",
+      "  --allow-empty         Exit 0 when no cases match",
+      "  --pretty / --no-pretty",
+      "",
+      "call / record options:",
+      "  --args '{...}'        JSON object of tool arguments",
+      "  --arg key=value       Tool argument (repeatable; JSON-ish values ok)",
+      "",
+      "record options:",
+      "  --out <path>          Case file path (default: tests/integration/<name>.json)",
+      "  --name <string>       Case name",
+      '  --partial             Wrap expect in "$partial": true',
+      "  --force               Overwrite an existing case file",
+      "",
+      "init options:",
+      "  --dir <path>          Target directory (default: .)",
+      "  --force               Overwrite existing scaffold files",
+      "",
+      "inspect options:",
+      "  --cli                 Use Inspector CLI mode",
+      "  -- ...                Extra args forwarded after the server command",
+      "",
+      "Workflow:",
+      "  init \u2192 tools \u2192 call \u2192 record \u2192 run \u2192 inspect (when you want the UI)"
+    ].join("\n")
+  );
+}
+var argv = process.argv.slice(2);
+if (argv.includes("-h") || argv.includes("--help")) {
+  printHelp();
+  process.exit(0);
+}
+var command = "run";
+var rest = argv;
+if (argv[0] && COMMANDS.has(argv[0])) {
+  command = argv[0];
+  rest = argv.slice(1);
+}
+var code = 1;
+try {
+  switch (command) {
+    case "run":
+      code = await runCommand(rest);
+      break;
+    case "tools":
+      code = await toolsCommand(rest);
+      break;
+    case "call":
+      code = await callCommand(rest);
+      break;
+    case "record":
+      code = await recordCommand(rest);
+      break;
+    case "init":
+      code = await initCommand(rest);
+      break;
+    case "inspect":
+      code = await inspectCommand(rest);
+      break;
+    default:
+      printHelp();
+      code = 1;
+  }
+} catch (err) {
+  const message = err instanceof Error ? err.message : String(err);
+  console.error(message);
+  code = 1;
+}
+process.exit(code);
+//# sourceMappingURL=cli.js.map