prowl-tools 0.1.3

package/dist/index.js

@@ -0,0 +1,1366 @@
+#!/usr/bin/env node
+import {
+  DEFAULT_FLAKY_THRESHOLD,
+  analyzePage,
+  generateHunt,
+  printCiSummary,
+  rankFlaky,
+  readHuntHistory,
+  runHunt,
+  runSuite,
+  updateBacklogFromSuite
+} from "./chunk-T7YLXF6X.js";
+import {
+  CONFIG_DIR,
+  listHunts,
+  loadConfig,
+  loadHuntMeta,
+  loadHuntTags,
+  resolveViewport
+} from "./chunk-NXXGJOBG.js";
+
+// src/cli/program.ts
+import { Command as Command13 } from "commander";
+
+// package.json
+var package_default = {
+  name: "prowl-tools",
+  version: "0.1.3",
+  description: "CLI-first QA testing tool for deterministic Playwright flows.",
+  type: "module",
+  license: "Apache-2.0",
+  author: "Michael Tookes",
+  repository: {
+    type: "git",
+    url: "https://github.com/prowl-tools/prowl.git"
+  },
+  homepage: "https://prowl.tools",
+  bugs: {
+    url: "https://github.com/prowl-tools/prowl/issues"
+  },
+  keywords: [
+    "testing",
+    "qa",
+    "playwright",
+    "yaml",
+    "e2e",
+    "browser-testing",
+    "automation",
+    "web-testing",
+    "cli"
+  ],
+  main: "dist/lib.cjs",
+  module: "dist/lib.js",
+  types: "dist/lib.d.ts",
+  exports: {
+    ".": {
+      import: {
+        types: "./dist/lib.d.ts",
+        default: "./dist/lib.js"
+      },
+      require: {
+        types: "./dist/lib.d.cts",
+        default: "./dist/lib.cjs"
+      }
+    }
+  },
+  bin: {
+    prowl: "dist/index.js"
+  },
+  files: [
+    "dist",
+    "examples",
+    "LICENSE",
+    "README.md",
+    "NOTICE"
+  ],
+  engines: {
+    node: ">=20.0.0"
+  },
+  scripts: {
+    build: "tsup",
+    lint: "eslint .",
+    test: "vitest run",
+    "test:watch": "vitest"
+  },
+  dependencies: {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    chalk: "^5.3.0",
+    commander: "^12.1.0",
+    dotenv: "^16.6.1",
+    ora: "^8.1.1",
+    pixelmatch: "^7.1.0",
+    playwright: "^1.50.1",
+    pngjs: "^7.0.0",
+    yaml: "^2.6.1",
+    zod: "^3.23.8"
+  },
+  devDependencies: {
+    "@types/node": "^22.13.1",
+    "@types/pngjs": "^6.0.5",
+    "@typescript-eslint/eslint-plugin": "^7.18.0",
+    "@typescript-eslint/parser": "^7.18.0",
+    eslint: "^8.57.1",
+    tsup: "^8.3.5",
+    typescript: "^5.7.3",
+    vitest: "^2.1.8"
+  }
+};
+
+// src/cli/commands/run.ts
+import { Command } from "commander";
+import chalk3 from "chalk";
+
+// src/cli/output.ts
+import chalk from "chalk";
+function describeStep(step) {
+  if ("navigate" in step) return `navigate "${step.navigate}"`;
+  if ("click" in step) {
+    if (typeof step.click === "string") return `click "${step.click}"`;
+    return `click "${step.click.selector}"`;
+  }
+  if ("fill" in step) {
+    if ("selector" in step.fill && "value" in step.fill) {
+      return `fill "${step.fill.selector}"`;
+    }
+    const label = Object.keys(step.fill)[0];
+    return `fill "${label}"`;
+  }
+  if ("type" in step) return `type "${truncate(step.type, 20)}"`;
+  if ("selectOption" in step) return `selectOption "${step.selectOption.selector}"`;
+  if ("select" in step) {
+    const label = Object.keys(step.select)[0];
+    return `select "${label}"`;
+  }
+  if ("onDialog" in step) return `onDialog ${step.onDialog.action}`;
+  if ("setInputFiles" in step) return `setInputFiles "${step.setInputFiles.selector}"`;
+  if ("runHunt" in step) {
+    const name = typeof step.runHunt === "string" ? step.runHunt : step.runHunt.name;
+    return `runHunt "${name}"`;
+  }
+  if ("press" in step) return `press "${step.press.key}"`;
+  if ("assert" in step) {
+    const a = step.assert;
+    if (a.visible) return `assert visible "${a.visible}"`;
+    if (a.notVisible) return `assert notVisible "${a.notVisible}"`;
+    if (a.urlIncludes) return `assert urlIncludes "${a.urlIncludes}"`;
+    if (a.urlEquals) return `assert urlEquals "${a.urlEquals}"`;
+    return "assert";
+  }
+  if ("wait" in step) {
+    if (typeof step.wait === "string") return `wait "${step.wait}"`;
+    return `wait "${step.wait.for}"`;
+  }
+  if ("waitForSelector" in step) return `waitForSelector "${step.waitForSelector.selector}"`;
+  if ("waitForUrl" in step) return `waitForUrl "${step.waitForUrl.value}"`;
+  if ("waitForNetworkIdle" in step) return "waitForNetworkIdle";
+  if ("hover" in step) return `hover "${step.hover.selector}"`;
+  if ("scroll" in step) return `scroll ${step.scroll.direction} ${step.scroll.amount ?? 500}px`;
+  if ("scrollTo" in step) return `scrollTo "${step.scrollTo.selector}"`;
+  if ("screenshot" in step) return `screenshot "${step.screenshot.name ?? "auto"}"`;
+  if ("if" in step) {
+    if (step.if.visible !== void 0) return `if visible "${step.if.visible}"`;
+    if (step.if.notVisible !== void 0) return `if notVisible "${step.if.notVisible}"`;
+    return "if condition unspecified";
+  }
+  if ("repeat" in step) {
+    if (step.repeat.times !== void 0) return `repeat ${step.repeat.times} times`;
+    if (step.repeat.while?.visible !== void 0) {
+      return `repeat while visible "${step.repeat.while.visible}"`;
+    }
+    if (step.repeat.while?.notVisible !== void 0) {
+      return `repeat while not visible "${step.repeat.while.notVisible}"`;
+    }
+    return "repeat while condition unspecified";
+  }
+  if ("mockRoute" in step) return `mockRoute "${step.mockRoute.url}"`;
+  if ("unmockRoute" in step) return `unmockRoute "${step.unmockRoute.url}"`;
+  if ("evalScript" in step) {
+    if (typeof step.evalScript === "string") return `evalScript "${truncate(step.evalScript, 40)}"`;
+    const asLabel = step.evalScript.as ? ` as ${step.evalScript.as}` : "";
+    return `evalScript "${truncate(step.evalScript.expression, 40)}"${asLabel}`;
+  }
+  if ("runScript" in step) return `runScript "${step.runScript.file}"`;
+  if ("assertScreenshot" in step) {
+    const th = step.assertScreenshot.threshold !== void 0 ? ` (threshold: ${step.assertScreenshot.threshold})` : "";
+    return `assertScreenshot "${step.assertScreenshot.name}"${th}`;
+  }
+  return "unknown step";
+}
+function truncate(text, max) {
+  if (text.length <= max) return text;
+  return text.slice(0, max - 1) + "\u2026";
+}
+function printHuntHeader(huntName) {
+  console.log(`
+  ${chalk.cyan("\u25CF")} ${chalk.bold("Running hunt:")} ${huntName}`);
+}
+function printStepResult(result, step, _index) {
+  const label = step ? describeStep(step) : result.type;
+  const duration = chalk.gray(`(${result.durationMs}ms)`);
+  if (result.status === "pass") {
+    console.log(`    ${chalk.green("\u2713")} ${label} ${duration}`);
+  } else {
+    const error = result.error ? chalk.gray(` \u2014 ${result.error}`) : "";
+    console.log(`    ${chalk.red("\u2717")} ${label} ${duration}${error}`);
+  }
+}
+function printHuntSummary(result, runDir) {
+  const passed = result.steps.filter((s) => s.status === "pass").length;
+  const total = result.steps.length;
+  const status = result.status === "pass" ? chalk.green.bold("PASS") : chalk.red.bold("FAIL");
+  const stepCount = chalk.gray(`${passed}/${total} steps`);
+  const duration = chalk.gray(`(${result.durationMs}ms)`);
+  console.log(`
+  ${status} ${chalk.bold(result.hunt)} ${duration} ${stepCount}`);
+  console.log(`  ${chalk.gray("Artifacts:")} ${runDir}
+`);
+}
+
+// src/cli/mascot.ts
+import chalk2 from "chalk";
+var FIGLET_LOGO = [
+  " ____  ____   ___  _    _ _     ___    _",
+  "|  _ \\|  _ \\ / _ \\| |  | | |   / _ \\  / \\",
+  "| |_) | |_) | | | | |  | | |  | | | |/ _ \\",
+  "|  __/|  _ <| |_| | |/\\| | |__| |_| / ___ \\",
+  "|_|   |_| \\_\\\\___/|_/  \\_\\____\\\\__\\_\\_/   \\_\\"
+];
+function welcomeBanner() {
+  const logo = FIGLET_LOGO.map((line) => chalk2.cyan(line)).join("\n");
+  return `
+${logo}
+
+  ${chalk2.gray("QA testing for the web")}
+`;
+}
+function resultMascot(state, huntName) {
+  const isPassing = state === "pass";
+  const icon = isPassing ? "\u2713" : "\u2717";
+  const label = isPassing ? "PASS" : "FAIL";
+  const color = isPassing ? chalk2.green : chalk2.red;
+  const content = `  ${icon} ${label}  ${huntName} `;
+  const innerWidth = content.length;
+  const top = `  \u250C${"\u2500".repeat(innerWidth)}\u2510`;
+  const mid = `  \u2502${content}\u2502`;
+  const bot = `  \u2514${"\u2500".repeat(innerWidth)}\u2518`;
+  return color(`${top}
+${mid}
+${bot}`);
+}
+
+// src/cli/commands/run.ts
+function buildRunCommand() {
+  const command = new Command("run").argument("<hunt-name>", "Hunt name or path (e.g. homepage or admin/users-crud)").option("--url <target>", "Override target URL").option("--headed", "Show browser window").option("--slow-mo <ms>", "Slow down Playwright actions", (value) => Number(value)).option("--trace", "Capture Playwright trace").option("--browser <engine>", "Browser engine: chromium, firefox, or webkit").option("--channel <name>", "Browser channel: chrome, msedge, chrome-beta, etc.").option("--viewport <size>", "Viewport size: WxH (e.g. 1920x1080) or preset (mobile, tablet, desktop)").option("--include-tags <tags>", "Only run hunts matching these tags (comma-separated)").option("--exclude-tags <tags>", "Skip hunts matching these tags (comma-separated)").option("--junit", "Generate JUnit XML report").option("--config <path>", "Custom config path").option("--json", "Output results as JSON").action(async (huntName, options) => {
+    try {
+      if (options.includeTags || options.excludeTags) {
+        const { configDir } = loadConfig(options.config);
+        const tags = loadHuntTags(huntName, configDir);
+        const includeTags = options.includeTags ? options.includeTags.split(",").map((t) => t.trim()) : void 0;
+        const excludeTags = options.excludeTags ? options.excludeTags.split(",").map((t) => t.trim()) : void 0;
+        if (includeTags && !includeTags.some((t) => tags.includes(t))) {
+          if (options.json) {
+            console.log(JSON.stringify({ status: "skipped", hunt: huntName, reason: "no matching include tags" }));
+          } else {
+            console.log(chalk3.yellow(`  Skipped "${huntName}" \u2014 no matching include tags`));
+          }
+          return;
+        }
+        if (excludeTags && excludeTags.some((t) => tags.includes(t))) {
+          if (options.json) {
+            console.log(JSON.stringify({ status: "skipped", hunt: huntName, reason: "matched exclude tags" }));
+          } else {
+            console.log(chalk3.yellow(`  Skipped "${huntName}" \u2014 matched exclude tags`));
+          }
+          return;
+        }
+      }
+      if (!options.json) {
+        printHuntHeader(huntName);
+      }
+      const { result, runDir } = await runHunt({
+        huntName,
+        urlOverride: options.url,
+        headed: Boolean(options.headed),
+        slowMo: Number.isFinite(options.slowMo) ? options.slowMo : void 0,
+        trace: Boolean(options.trace),
+        browser: options.browser,
+        channel: options.channel,
+        viewport: options.viewport,
+        junit: Boolean(options.junit),
+        configPath: options.config,
+        onStep: options.json ? void 0 : (stepResult, step, index) => {
+          printStepResult(stepResult, step, index);
+        }
+      });
+      if (options.json) {
+        console.log(JSON.stringify(result, null, 2));
+      } else {
+        console.log(resultMascot(result.status, huntName));
+        printHuntSummary(result, runDir);
+      }
+      process.exitCode = result.exitCode;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Run failed";
+      if (options.json) {
+        console.log(JSON.stringify({ status: "fail", exitCode: 1, hunt: huntName, error: message }));
+      } else {
+        console.log(resultMascot("fail", huntName));
+        console.error(`
+  Error: ${message}
+`);
+      }
+      process.exitCode = 1;
+    }
+  });
+  return command;
+}
+
+// src/cli/commands/init.ts
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import { Command as Command2 } from "commander";
+import chalk4 from "chalk";
+function getPackageRoot() {
+  const currentFile = fileURLToPath(import.meta.url);
+  let dir = path.dirname(currentFile);
+  const root = path.parse(dir).root;
+  while (dir !== root) {
+    if (fs.existsSync(path.join(dir, "package.json"))) {
+      return dir;
+    }
+    dir = path.dirname(dir);
+  }
+  if (fs.existsSync(path.join(root, "package.json"))) {
+    return root;
+  }
+  throw new Error("Cannot find package root. Reinstall prowl-tools.");
+}
+function copyFile(source, destination) {
+  fs.mkdirSync(path.dirname(destination), { recursive: true });
+  fs.copyFileSync(source, destination);
+}
+function buildInitCommand() {
+  const command = new Command2("init").option("--force", `Overwrite existing ${CONFIG_DIR} directory`).action((options) => {
+    const root = process.cwd();
+    const prowlDir = path.join(root, CONFIG_DIR);
+    if (fs.existsSync(prowlDir) && !options.force) {
+      console.error(
+        chalk4.red(
+          `${CONFIG_DIR} already exists. Run with --force to reinitialize prowl configuration without deleting existing files.`
+        )
+      );
+      process.exitCode = 1;
+      return;
+    }
+    const packageRoot = getPackageRoot();
+    const examplesDir = path.join(packageRoot, "examples");
+    const exampleConfig = path.join(examplesDir, "config.yml");
+    const exampleHuntsDir = path.join(examplesDir, "hunts");
+    if (!fs.existsSync(exampleConfig) || !fs.existsSync(exampleHuntsDir)) {
+      console.error(chalk4.red("Examples not found in package. Reinstall prowl-tools."));
+      process.exitCode = 1;
+      return;
+    }
+    copyFile(exampleConfig, path.join(prowlDir, "config.yml"));
+    const huntFiles = fs.readdirSync(exampleHuntsDir).filter((f) => f.endsWith(".yml"));
+    for (const huntFile of huntFiles) {
+      copyFile(
+        path.join(exampleHuntsDir, huntFile),
+        path.join(prowlDir, "hunts", huntFile)
+      );
+    }
+    const gitignore = [
+      "# Run artifacts (screenshots, logs, reports)",
+      "runs/",
+      "",
+      "# Auth state (tokens, cookies)",
+      "auth-state.json",
+      "",
+      "# Environment variables (credentials)",
+      ".env",
+      ""
+    ].join("\n");
+    fs.writeFileSync(path.join(prowlDir, ".gitignore"), gitignore);
+    console.log(welcomeBanner());
+    console.log(chalk4.green(`  Initialized ${CONFIG_DIR} directory.`));
+    console.log(chalk4.gray("  Run ") + chalk4.bold("prowl run hello") + chalk4.gray(" to get started."));
+    console.log(chalk4.gray("  Browse hunt templates at ") + chalk4.cyan("https://hub.prowl.tools") + "\n");
+  });
+  return command;
+}
+
+// src/cli/commands/login.ts
+import path2 from "path";
+import readline from "readline";
+import chalk5 from "chalk";
+import { Command as Command3 } from "commander";
+import { chromium } from "playwright";
+function resolvePath(configDir, inputPath) {
+  if (path2.isAbsolute(inputPath)) {
+    return inputPath;
+  }
+  const projectRoot = path2.dirname(configDir);
+  return path2.join(projectRoot, inputPath);
+}
+function waitForEnter(prompt) {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    rl.question(prompt, () => {
+      rl.close();
+      resolve();
+    });
+  });
+}
+function buildLoginCommand() {
+  const command = new Command3("login").option("--url <target>", "Override target URL").option("--config <path>", "Custom config path").action(async (options) => {
+    let browser = null;
+    let context = null;
+    try {
+      const { config, configDir } = loadConfig(options.config);
+      const targetUrl = options.url ?? config.target.url;
+      const storageStatePath = config.auth.storageStatePath ? resolvePath(configDir, config.auth.storageStatePath) : resolvePath(configDir, ".prowl/auth-state.json");
+      browser = await chromium.launch({ headless: false });
+      context = await browser.newContext();
+      const page = await context.newPage();
+      await page.goto(targetUrl);
+      console.log(chalk5.green("Browser opened. Log in manually."));
+      await waitForEnter("Press Enter to save auth state and close the browser... ");
+      await context.storageState({ path: storageStatePath });
+      console.log(chalk5.green(`Saved auth state to ${storageStatePath}`));
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Login failed";
+      console.error(chalk5.red(`Error: ${message}`));
+      process.exitCode = 1;
+    } finally {
+      if (context) {
+        await context.close();
+      }
+      if (browser) {
+        await browser.close();
+      }
+    }
+  });
+  return command;
+}
+
+// src/cli/commands/list.ts
+import { Command as Command4 } from "commander";
+import chalk6 from "chalk";
+function buildListCommand() {
+  const command = new Command4("list").option("--config <path>", "Custom config path").option("--json", "Output as JSON array").action((options) => {
+    try {
+      const { configDir } = loadConfig(options.config);
+      const hunts = listHunts(configDir);
+      if (hunts.length === 0) {
+        const huntsPath = `${configDir}/hunts`;
+        console.log(chalk6.yellow(`No hunts found in ${huntsPath}.`));
+        return;
+      }
+      const metas = hunts.map((name) => ({
+        name,
+        ...loadHuntMeta(name, configDir)
+      }));
+      if (options.json) {
+        console.log(JSON.stringify(metas, null, 2));
+        return;
+      }
+      const maxName = Math.max(...metas.map((m) => m.name.length));
+      metas.forEach((m) => {
+        const padded = m.name.padEnd(maxName);
+        const desc = m.description ? `  ${truncate(m.description, 40)}` : "";
+        const tags = m.tags.length > 0 ? chalk6.gray(`  [${m.tags.join(", ")}]`) : "";
+        console.log(`  ${padded}${desc}${tags}`);
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "List failed";
+      console.error(chalk6.red(`Error: ${message}`));
+      process.exitCode = 1;
+    }
+  });
+  return command;
+}
+
+// src/cli/commands/watch.ts
+import fs2 from "fs";
+import chalk7 from "chalk";
+import { Command as Command5 } from "commander";
+
+// src/cli/watch-utils.ts
+import path3 from "path";
+function getWatchTargets(configDir, huntName) {
+  return [
+    path3.join(configDir, "hunts", `${huntName}.yml`),
+    path3.join(configDir, "config.yml"),
+    path3.join(configDir, ".env")
+  ];
+}
+function createDebouncer(delayMs, fn) {
+  let timer;
+  return {
+    trigger: () => {
+      if (timer) {
+        clearTimeout(timer);
+      }
+      timer = setTimeout(() => {
+        timer = void 0;
+        fn();
+      }, delayMs);
+    },
+    cancel: () => {
+      if (timer) {
+        clearTimeout(timer);
+        timer = void 0;
+      }
+    }
+  };
+}
+
+// src/cli/commands/watch.ts
+function buildWatchCommand() {
+  const command = new Command5("watch").argument("<hunt-name>", "Hunt name or path (e.g. homepage or admin/users-crud)").option("--url <target>", "Override target URL").option("--headed", "Show browser window").option("--slow-mo <ms>", "Slow down Playwright actions", (value) => Number(value)).option("--trace", "Capture Playwright trace").option("--config <path>", "Custom config path").action(async (huntName, options) => {
+    const { configDir } = loadConfig(options.config);
+    const watchTargets = getWatchTargets(configDir, huntName);
+    let running = false;
+    let pending = false;
+    let stopped = false;
+    const runOnce = async () => {
+      if (stopped) {
+        return;
+      }
+      if (running) {
+        pending = true;
+        return;
+      }
+      running = true;
+      do {
+        pending = false;
+        try {
+          printHuntHeader(huntName);
+          const { result, runDir } = await runHunt({
+            huntName,
+            urlOverride: options.url,
+            headed: Boolean(options.headed),
+            slowMo: Number.isFinite(options.slowMo) ? options.slowMo : void 0,
+            trace: Boolean(options.trace),
+            configPath: options.config,
+            onStep(stepResult, step, index) {
+              printStepResult(stepResult, step, index);
+            }
+          });
+          printHuntSummary(result, runDir);
+        } catch (error) {
+          const message = error instanceof Error ? error.message : "Run failed";
+          console.error(chalk7.red(`Error: ${message}`));
+        }
+      } while (pending && !stopped);
+      running = false;
+    };
+    const debounced = createDebouncer(300, () => {
+      void runOnce();
+    });
+    const unwatch = [];
+    for (const target of watchTargets) {
+      fs2.watchFile(target, { interval: 150 }, (curr, prev) => {
+        if (curr.mtimeMs === prev.mtimeMs && curr.size === prev.size) {
+          return;
+        }
+        console.log(chalk7.gray(`Change detected: ${target}`));
+        debounced.trigger();
+      });
+      unwatch.push(() => fs2.unwatchFile(target));
+    }
+    const stop = () => {
+      if (stopped) {
+        return;
+      }
+      stopped = true;
+      debounced.cancel();
+      unwatch.forEach((dispose) => dispose());
+      process.off("SIGINT", stop);
+      console.log(chalk7.yellow("\nWatch stopped."));
+      process.exit(0);
+    };
+    process.on("SIGINT", stop);
+    console.log(chalk7.gray(`Watching hunt: ${huntName}`));
+    console.log(chalk7.gray(`Files: ${watchTargets.join(", ")}`));
+    await runOnce();
+  });
+  return command;
+}
+
+// src/cli/commands/ci.ts
+import { Command as Command6 } from "commander";
+import chalk8 from "chalk";
+function parseTagList(value, flag) {
+  if (value === void 0) return void 0;
+  const tags = value.split(",").map((tag) => tag.trim()).filter(Boolean);
+  if (tags.length === 0) {
+    throw new Error(`${flag} requires at least one non-empty tag`);
+  }
+  return tags;
+}
+function printFailureDetails(results) {
+  for (const hunt of results) {
+    if (hunt.status === "fail" && hunt.error) {
+      console.error(`  ${chalk8.red("Error")} ${hunt.hunt}: ${hunt.error}`);
+    }
+  }
+}
+function buildCiCommand() {
+  const command = new Command6("ci").description("Run all hunts and produce a combined pass/fail result for CI pipelines").option("--config <path>", "Custom config path").option("--url <target>", "Override target URL").option("--headed", "Show browser window").option("--slow-mo <ms>", "Slow down Playwright actions", (value) => Number(value)).option("--trace", "Capture Playwright traces").option("--browser <engine>", "Browser engine: chromium, firefox, or webkit").option("--channel <name>", "Browser channel: chrome, msedge, chrome-beta, etc.").option("--viewport <size>", "Viewport size: WxH (e.g. 1920x1080) or preset (mobile, tablet, desktop)").option("--junit", "Generate JUnit XML reports").option("--include-tags <tags>", "Only run hunts matching these tags (comma-separated)").option("--exclude-tags <tags>", "Skip hunts matching these tags (comma-separated)").option("--json", "Output results as JSON").option("--parallel <count>", "Run hunts in parallel with N workers", (value) => {
+    const n = Number(value);
+    if (!Number.isInteger(n) || n < 1) {
+      throw new Error("--parallel must be a positive integer");
+    }
+    return n;
+  }).action(async (options) => {
+    const includeTags = parseTagList(options.includeTags, "--include-tags");
+    const excludeTags = parseTagList(options.excludeTags, "--exclude-tags");
+    const parallel = options.parallel;
+    const isParallel = parallel !== void 0 && parallel > 1;
+    const showProgress = !options.json && !isParallel;
+    const { result, resultPath } = await runSuite({
+      configPath: options.config,
+      urlOverride: options.url,
+      headed: Boolean(options.headed),
+      slowMo: Number.isFinite(options.slowMo) ? options.slowMo : void 0,
+      trace: Boolean(options.trace),
+      browser: options.browser,
+      channel: options.channel,
+      viewport: options.viewport,
+      junit: Boolean(options.junit),
+      includeTags,
+      excludeTags,
+      parallel,
+      hooks: {
+        onHuntStart: showProgress ? (huntName) => printHuntHeader(huntName) : void 0,
+        onStep: showProgress ? (stepResult, step, index) => printStepResult(stepResult, step, index) : void 0,
+        onHuntSuccess: showProgress ? (huntName, runResult, runDir) => {
+          console.log(resultMascot(runResult.status, huntName));
+          printHuntSummary(runResult, runDir);
+        } : void 0,
+        onHuntFailure: showProgress ? (huntName, message) => {
+          console.log(resultMascot("fail", huntName));
+          console.error(`
+  Error: ${message}
+`);
+        } : void 0,
+        onHuntSkipped: options.json ? void 0 : (huntName, reason) => {
+          const why = reason === "include" ? "no matching include tags" : "matched exclude tags";
+          console.log(chalk8.yellow(`  \u25CB Skipped "${huntName}" \u2014 ${why}`));
+        }
+      }
+    });
+    if (result.status === "no-hunts") {
+      if (options.json) {
+        console.log(JSON.stringify(result, null, 2));
+      } else {
+        console.log(chalk8.yellow("\n  No hunts found. Create hunts in .prowl/hunts/\n"));
+      }
+      process.exitCode = 2;
+      return;
+    }
+    if (options.json) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      printCiSummary(result.hunts, result.durationMs, result.flaky, result.clusters);
+      if (!showProgress) {
+        printFailureDetails(result.hunts);
+      }
+      if (resultPath) {
+        console.log(`
+  CI Result: ${chalk8.gray(resultPath)}
+`);
+      }
+      if (result.status === "all-skipped") {
+        console.log(chalk8.yellow("  All hunts were skipped by tag filters.\n"));
+      }
+    }
+    if (result.status === "fail") {
+      process.exitCode = 1;
+    } else if (result.status === "all-skipped") {
+      process.exitCode = 2;
+    } else {
+      process.exitCode = 0;
+    }
+  });
+  return command;
+}
+
+// src/cli/commands/update-baselines.ts
+import fs3 from "fs";
+import path4 from "path";
+import { Command as Command7 } from "commander";
+import chalk9 from "chalk";
+function buildUpdateBaselinesCommand() {
+  const command = new Command7("update-baselines").description("Accept current screenshots as new visual regression baselines").option("--run <dir>", "Specific run directory to use").option("--name <name>", "Update only a specific baseline by name").option("--config <path>", "Custom config path").option("-y, --yes", "Skip confirmation prompt").action(async (options) => {
+    try {
+      const { configDir } = loadConfig(options.config);
+      const baselinesDir = path4.join(configDir, "baselines");
+      fs3.mkdirSync(baselinesDir, { recursive: true });
+      let runDir;
+      if (options.run) {
+        runDir = path4.isAbsolute(options.run) ? options.run : path4.resolve(options.run);
+      } else {
+        const runsDir = path4.join(configDir, "runs");
+        if (!fs3.existsSync(runsDir)) {
+          console.error(chalk9.red("  No runs directory found. Run a hunt first."));
+          process.exitCode = 1;
+          return;
+        }
+        const entries = fs3.readdirSync(runsDir).filter((e) => fs3.statSync(path4.join(runsDir, e)).isDirectory()).sort().reverse();
+        if (entries.length === 0) {
+          console.error(chalk9.red("  No run directories found. Run a hunt first."));
+          process.exitCode = 1;
+          return;
+        }
+        runDir = path4.join(runsDir, entries[0]);
+      }
+      const screenshotsDir = path4.join(runDir, "screenshots");
+      if (!fs3.existsSync(screenshotsDir)) {
+        console.error(chalk9.red(`  No screenshots found in ${runDir}`));
+        process.exitCode = 1;
+        return;
+      }
+      const screenshots = fs3.readdirSync(screenshotsDir).filter((f) => f.endsWith("-current.png"));
+      if (screenshots.length === 0) {
+        console.log(chalk9.yellow("  No assertScreenshot results found in this run."));
+        return;
+      }
+      const nameFilter = options.name;
+      const filtered = nameFilter ? screenshots.filter((f) => f === `${nameFilter}-current.png`) : screenshots;
+      if (filtered.length === 0) {
+        console.log(chalk9.yellow(`  No screenshot matching "${nameFilter}" found.`));
+        return;
+      }
+      let updated = 0;
+      for (const file of filtered) {
+        const baselineName = file.replace("-current.png", ".png");
+        const sourcePath = path4.join(screenshotsDir, file);
+        const destPath = path4.join(baselinesDir, baselineName);
+        const exists = fs3.existsSync(destPath);
+        fs3.copyFileSync(sourcePath, destPath);
+        updated++;
+        const status = exists ? chalk9.yellow("updated") : chalk9.green("created");
+        console.log(`  ${status} ${baselineName}`);
+      }
+      console.log(chalk9.green(`
+  ${updated} baseline(s) updated in ${baselinesDir}
+`));
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Update baselines failed";
+      console.error(`
+  Error: ${message}
+`);
+      process.exitCode = 1;
+    }
+  });
+  return command;
+}
+
+// src/cli/commands/analyze.ts
+import { Command as Command8 } from "commander";
+import chalk10 from "chalk";
+import { chromium as chromium2, firefox, webkit } from "playwright";
+var ENGINES = { chromium: chromium2, firefox, webkit };
+function parseViewportFlag(value) {
+  const match = /^(\d+)x(\d+)$/i.exec(value);
+  if (match) {
+    return { width: Number(match[1]), height: Number(match[2]) };
+  }
+  return value;
+}
+function buildAnalyzeCommand() {
+  const command = new Command8("analyze").argument("<url>", "URL to analyze").description("Analyze a page to discover interactive elements and selectors").option("--json", "Output as JSON").option("--browser <engine>", "Browser engine: chromium, firefox, or webkit").option("--channel <name>", "Browser channel: chrome, msedge, etc.").option("--viewport <size>", "Viewport size: WxH or preset (mobile, tablet, desktop)").option("--headed", "Show browser window").option("--config <path>", "Custom config path").action(async (url, options) => {
+    try {
+      const engine = options.browser ?? "chromium";
+      const channel = options.channel;
+      const viewport = options.viewport ? resolveViewport(parseViewportFlag(options.viewport)) : { width: 1280, height: 720 };
+      const browserEngine = ENGINES[engine];
+      const browser = await browserEngine.launch({
+        headless: !options.headed,
+        channel
+      });
+      const context = await browser.newContext({ viewport });
+      const page = await context.newPage();
+      try {
+        await page.goto(url, { waitUntil: "networkidle" });
+        const result = await analyzePage(page);
+        if (options.json) {
+          console.log(JSON.stringify(result, null, 2));
+        } else {
+          console.log(`
+  ${chalk10.bold("Page Analysis:")} ${result.title}`);
+          console.log(`  ${chalk10.gray("URL:")} ${result.url}
+`);
+          if (result.forms.length > 0) {
+            console.log(chalk10.bold("  Forms:"));
+            for (const form of result.forms) {
+              const method = form.method ? chalk10.cyan(form.method) : "";
+              const action = form.action ? chalk10.gray(form.action) : "";
+              console.log(`    [${form.index}] ${method} ${action} (${form.fieldCount} fields)`);
+            }
+            console.log();
+          }
+          if (result.elements.length > 0) {
+            console.log(chalk10.bold("  Interactive Elements:"));
+            for (const el of result.elements) {
+              const tag = chalk10.cyan(el.tag);
+              const type = el.type ? chalk10.gray(`[${el.type}]`) : "";
+              const bestSelector = el.selectors.testId ?? el.selectors.label ?? el.selectors.ariaLabel ?? el.selectors.css ?? el.selectors.name ?? "";
+              const selectorStr = bestSelector ? chalk10.yellow(bestSelector) : chalk10.gray("(no selector)");
+              const req = el.required ? chalk10.red(" *") : "";
+              const form = el.formGroup !== void 0 ? chalk10.gray(` form[${el.formGroup}]`) : "";
+              console.log(`    ${tag}${type} ${selectorStr}${req}${form}`);
+            }
+            console.log();
+          }
+          if (result.links.length > 0) {
+            console.log(chalk10.bold("  Links:"));
+            for (const link of result.links.slice(0, 20)) {
+              const text = link.text || chalk10.gray("(no text)");
+              console.log(`    ${text} ${chalk10.gray("\u2192")} ${chalk10.blue(link.href)}`);
+            }
+            if (result.links.length > 20) {
+              console.log(chalk10.gray(`    ... and ${result.links.length - 20} more`));
+            }
+            console.log();
+          }
+          console.log(chalk10.gray(`  ${result.elements.length} elements, ${result.forms.length} forms, ${result.links.length} links
+`));
+        }
+      } finally {
+        await context.close();
+        await browser.close();
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Analysis failed";
+      if (options.json) {
+        console.log(JSON.stringify({ error: message }));
+      } else {
+        console.error(`
+  Error: ${message}
+`);
+      }
+      process.exitCode = 1;
+    }
+  });
+  return command;
+}
+
+// src/cli/commands/generate.ts
+import fs4 from "fs";
+import path5 from "path";
+import { Command as Command9 } from "commander";
+import chalk11 from "chalk";
+import ora from "ora";
+async function readStdin() {
+  if (process.stdin.isTTY) return null;
+  return new Promise((resolve) => {
+    let data = "";
+    process.stdin.setEncoding("utf-8");
+    process.stdin.on("data", (chunk) => {
+      data += chunk;
+    });
+    process.stdin.on("end", () => resolve(data || null));
+    setTimeout(() => resolve(data || null), 100);
+  });
+}
+function buildGenerateCommand() {
+  const command = new Command9("generate").description("Generate a hunt file from page analysis and intent using AI").option("--url <url>", "URL to analyze and generate for").option("--intent <description>", "What to test (required)").option("--output <name>", "Hunt file name (saved to .prowl/hunts/)").option("--stdout", "Print YAML to stdout instead of saving").option("--browser <engine>", "Browser engine for analysis").option("--viewport <size>", "Viewport for analysis").option("--config <path>", "Custom config path").action(async (options) => {
+    try {
+      const intent = options.intent;
+      if (!intent) {
+        console.error(chalk11.red("  --intent is required"));
+        process.exitCode = 1;
+        return;
+      }
+      let analysis;
+      const stdinData = await readStdin();
+      if (stdinData) {
+        try {
+          analysis = JSON.parse(stdinData);
+        } catch {
+          console.error(chalk11.red("  Failed to parse piped JSON input"));
+          process.exitCode = 1;
+          return;
+        }
+      }
+      if (!analysis && !options.url) {
+        console.error(chalk11.red("  Either --url or piped analysis JSON is required"));
+        process.exitCode = 1;
+        return;
+      }
+      const spinner = ora("Generating hunt...").start();
+      try {
+        const yamlStr = await generateHunt({
+          url: options.url,
+          analysis,
+          intent,
+          browser: options.browser,
+          viewport: options.viewport
+        });
+        spinner.succeed("Hunt generated");
+        if (options.stdout) {
+          console.log(yamlStr);
+        } else if (options.output) {
+          let configDir;
+          try {
+            const { loadConfig: loadConfig2 } = await import("./loader-5RDNTJHH.js");
+            const result = loadConfig2(options.config);
+            configDir = result.configDir;
+          } catch {
+            configDir = path5.join(process.cwd(), ".prowl");
+          }
+          const huntsDir = path5.join(configDir, "hunts");
+          fs4.mkdirSync(huntsDir, { recursive: true });
+          const fileName = options.output.endsWith(".yml") ? options.output : `${options.output}.yml`;
+          const filePath = path5.join(huntsDir, fileName);
+          fs4.writeFileSync(filePath, yamlStr + "\n", "utf-8");
+          console.log(chalk11.green(`  Saved to ${filePath}`));
+        } else {
+          console.log(yamlStr);
+        }
+      } catch (error) {
+        spinner.fail("Generation failed");
+        throw error;
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Generation failed";
+      console.error(`
+  Error: ${message}
+`);
+      process.exitCode = 1;
+    }
+  });
+  return command;
+}
+
+// src/cli/commands/history.ts
+import { Command as Command10 } from "commander";
+import chalk12 from "chalk";
+function buildHistoryCommand() {
+  const command = new Command10("history").argument("<hunt-name>", "Hunt name or path (e.g. homepage or admin/users-crud)").description("Show run history for a hunt").option("--config <path>", "Custom config path").option("--limit <n>", "Show the last N runs (default: 20)", (value) => {
+    const n = Number(value);
+    if (!Number.isInteger(n) || n < 1) {
+      throw new Error("--limit must be a positive integer");
+    }
+    return n;
+  }).option("--json", "Output as JSON").action((huntName, options) => {
+    try {
+      const { configDir } = loadConfig(options.config);
+      const entries = readHuntHistory(configDir, huntName);
+      const limit = options.limit ?? 20;
+      const recent = entries.slice(-limit);
+      if (options.json) {
+        console.log(JSON.stringify(recent, null, 2));
+        return;
+      }
+      if (recent.length === 0) {
+        console.log(
+          chalk12.yellow(
+            `
+  No history found for "${huntName}". Run it at least once with \`prowl run ${huntName}\`.
+`
+          )
+        );
+        return;
+      }
+      console.log();
+      console.log(`  ${chalk12.bold(huntName)} \u2014 last ${recent.length} of ${entries.length} runs`);
+      console.log();
+      console.log(formatTable(recent));
+      console.log();
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "history failed";
+      if (options.json) {
+        console.log(JSON.stringify({ error: message }));
+      } else {
+        console.error(chalk12.red(`Error: ${message}`));
+      }
+      process.exitCode = 1;
+    }
+  });
+  return command;
+}
+function formatTable(entries) {
+  const headers = ["Status", "Started", "Duration"];
+  const rows = entries.map((entry) => [
+    formatStatus(entry.status),
+    entry.startedAt,
+    formatDuration(entry.durationMs)
+  ]);
+  const widths = headers.map(
+    (header, index) => Math.max(
+      stripAnsi(header).length,
+      ...rows.map((row) => stripAnsi(row[index]).length)
+    )
+  );
+  const headerLine = `  ${headers.map((h, i) => pad(h, widths[i])).join("  ")}`;
+  const rule = `  ${widths.map((w) => "-".repeat(w)).join("  ")}`;
+  const body = rows.map((row) => `  ${row.map((cell, i) => pad(cell, widths[i])).join("  ")}`).join("\n");
+  return `${headerLine}
+${rule}
+${body}`;
+}
+function formatStatus(status) {
+  return status === "pass" ? chalk12.green("pass") : chalk12.red("fail");
+}
+function formatDuration(ms) {
+  if (ms < 1e3) {
+    return `${ms}ms`;
+  }
+  return `${(ms / 1e3).toFixed(2)}s`;
+}
+function pad(value, width) {
+  const bareLength = stripAnsi(value).length;
+  if (bareLength >= width) {
+    return value;
+  }
+  return `${value}${" ".repeat(width - bareLength)}`;
+}
+function stripAnsi(value) {
+  return value.replace(/\[[0-9;]*m/g, "");
+}
+
+// src/cli/commands/flaky.ts
+import { Command as Command11 } from "commander";
+import chalk13 from "chalk";
+function buildFlakyCommand() {
+  const command = new Command11("flaky").description("Rank hunts by flake score (pass/fail oscillation) from run history").option("--config <path>", "Custom config path").option("--limit <n>", "Only score the most recent N runs per hunt", (value) => {
+    const n = Number(value);
+    if (!Number.isInteger(n) || n < 1) {
+      throw new Error("--limit must be a positive integer");
+    }
+    return n;
+  }).option("--threshold <value>", "Flaky threshold 0-1 (overrides config)", (value) => {
+    const n = Number(value);
+    if (!Number.isFinite(n) || n < 0 || n > 1) {
+      throw new Error("--threshold must be a number between 0 and 1");
+    }
+    return n;
+  }).option("--json", "Output as JSON").action((options) => {
+    try {
+      const { config, configDir } = loadConfig(options.config);
+      const threshold = options.threshold ?? config.reliability?.flakyThreshold ?? DEFAULT_FLAKY_THRESHOLD;
+      const scores = rankFlaky(configDir, {
+        lastN: options.limit,
+        threshold
+      });
+      if (options.json) {
+        console.log(JSON.stringify(scores, null, 2));
+        return;
+      }
+      if (scores.length === 0) {
+        console.log(
+          chalk13.yellow(
+            "\n  No run history found. Run hunts with `prowl run` or `prowl ci` first.\n"
+          )
+        );
+        return;
+      }
+      console.log();
+      console.log(`  ${chalk13.bold("Flake scores")} (threshold ${threshold})`);
+      console.log();
+      console.log(formatTable2(scores));
+      console.log();
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "flaky failed";
+      if (options.json) {
+        console.log(JSON.stringify({ error: message }));
+      } else {
+        console.error(chalk13.red(`Error: ${message}`));
+      }
+      process.exitCode = 1;
+    }
+  });
+  return command;
+}
+function formatTable2(scores) {
+  const headers = ["Hunt", "Score", "Runs", "Flaky"];
+  const rows = scores.map((s) => [
+    s.hunt,
+    s.score.toFixed(2),
+    String(s.runs),
+    s.flaky ? chalk13.red("yes") : chalk13.green("no")
+  ]);
+  const widths = headers.map(
+    (header, index) => Math.max(stripAnsi2(header).length, ...rows.map((row) => stripAnsi2(row[index]).length))
+  );
+  const headerLine = `  ${headers.map((h, i) => pad2(h, widths[i])).join("  ")}`;
+  const rule = `  ${widths.map((w) => "-".repeat(w)).join("  ")}`;
+  const body = rows.map((row) => `  ${row.map((cell, i) => pad2(cell, widths[i])).join("  ")}`).join("\n");
+  return `${headerLine}
+${rule}
+${body}`;
+}
+function pad2(value, width) {
+  const bareLength = stripAnsi2(value).length;
+  return bareLength >= width ? value : `${value}${" ".repeat(width - bareLength)}`;
+}
+function stripAnsi2(value) {
+  return value.replace(/\x1b\[[0-9;]*m/g, "");
+}
+
+// src/cli/commands/mcp.ts
+import { Command as Command12 } from "commander";
+
+// src/mcp/server.ts
+import { z as z2 } from "zod";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/mcp/tools.ts
+import path6 from "path";
+function listHuntsTool(configPath) {
+  const { configDir } = loadConfig(configPath);
+  return { hunts: listHunts(configDir) };
+}
+async function runSuiteTool(args = {}, options = {}) {
+  const { configPath: resolvedConfigPath, configDir, config } = loadConfig(options.configPath);
+  const projectRoot = options.projectRoot ?? path6.dirname(configDir);
+  const suite = await runSuite({
+    configPath: resolvedConfigPath,
+    includeTags: args.includeTags,
+    excludeTags: args.excludeTags,
+    parallel: args.parallel
+  });
+  const bugLogCfg = config.bugLog ?? {};
+  const logBugs = args.logBugs ?? bugLogCfg.enabled ?? true;
+  const backlogPath = bugLogCfg.backlogPath ? path6.resolve(projectRoot, bugLogCfg.backlogPath) : void 0;
+  const resolvedPath = bugLogCfg.resolvedPath ? path6.resolve(projectRoot, bugLogCfg.resolvedPath) : backlogPath ? path6.join(path6.dirname(backlogPath), "resolved.md") : void 0;
+  const bugs = logBugs ? updateBacklogFromSuite(suite, { projectRoot, backlogPath, resolvedPath }) : { created: [], regressions: [], skipped: [], backlogPath: null };
+  const { status, totalHunts, passed, failed, skipped } = suite.result;
+  return {
+    status,
+    totalHunts,
+    passed,
+    failed,
+    skipped,
+    resultPath: suite.resultPath,
+    bugs: {
+      created: bugs.created,
+      regressions: bugs.regressions,
+      alreadyOpen: bugs.skipped,
+      backlogPath: bugs.backlogPath
+    }
+  };
+}
+async function runHuntTool(args, configPath) {
+  const { result, runDir } = await runHunt({
+    huntName: args.hunt,
+    ...configPath ? { configPath } : {}
+  });
+  return { ...result, runDir };
+}
+
+// src/mcp/projects.ts
+import fs5 from "fs";
+import os from "os";
+import path7 from "path";
+import yaml from "yaml";
+import { z } from "zod";
+var projectEntrySchema = z.object({
+  root: z.string().min(1),
+  /** Optional override; defaults to <root>/.prowl/config.yml (legacy: .prowlqa/). */
+  configPath: z.string().min(1).optional()
+}).strict();
+var projectRegistrySchema = z.object({
+  projects: z.record(z.string().min(1), projectEntrySchema)
+}).strict();
+function defaultRegistryPath() {
+  return path7.join(os.homedir(), ".prowl", "projects.yml");
+}
+function legacyRegistryPath() {
+  return path7.join(os.homedir(), ".prowlqa", "projects.yml");
+}
+function resolveProjectConfigPath(root) {
+  const preferred = path7.join(root, ".prowl", "config.yml");
+  if (fs5.existsSync(preferred)) return preferred;
+  const legacy = path7.join(root, ".prowlqa", "config.yml");
+  if (fs5.existsSync(legacy)) return legacy;
+  return preferred;
+}
+function resolveRegistryRelativePath(registry, inputPath) {
+  return path7.isAbsolute(inputPath) ? inputPath : path7.resolve(path7.dirname(registry.registryPath), inputPath);
+}
+function resolveRegistryPath(explicitPath) {
+  if (explicitPath) return path7.resolve(explicitPath);
+  const envPath = process.env.PROWL_PROJECTS ?? process.env.PROWLQA_PROJECTS;
+  if (envPath) return path7.resolve(envPath);
+  const fallback = defaultRegistryPath();
+  if (fs5.existsSync(fallback)) return fallback;
+  const legacy = legacyRegistryPath();
+  return fs5.existsSync(legacy) ? legacy : null;
+}
+function loadProjectRegistry(explicitPath) {
+  const registryPath = resolveRegistryPath(explicitPath);
+  if (!registryPath) return null;
+  if (!fs5.existsSync(registryPath)) {
+    throw new Error(`Project registry not found at ${registryPath}`);
+  }
+  const raw = fs5.readFileSync(registryPath, "utf-8");
+  const parsed = yaml.parse(raw) ?? {};
+  const validated = projectRegistrySchema.parse(parsed);
+  return { projects: validated.projects, registryPath };
+}
+function resolveProject(registry, name) {
+  const entry = registry.projects[name];
+  if (!entry) {
+    const known = Object.keys(registry.projects).sort().join(", ") || "(none)";
+    throw new Error(`Unknown project "${name}". Registered projects: ${known}`);
+  }
+  const root = resolveRegistryRelativePath(registry, entry.root);
+  const configPath = entry.configPath ? resolveRegistryRelativePath(registry, entry.configPath) : resolveProjectConfigPath(root);
+  return { name, root, configPath };
+}
+function listRegisteredProjects(registry) {
+  if (!registry) return [];
+  return Object.entries(registry.projects).map(([name, entry]) => ({
+    name,
+    root: resolveRegistryRelativePath(registry, entry.root)
+  }));
+}
+
+// src/mcp/server.ts
+function textResult(data) {
+  return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function safeStringify(value) {
+  try {
+    return JSON.stringify(value) ?? "undefined";
+  } catch {
+    return "[unserializable]";
+  }
+}
+async function toolResult(toolName, args, action) {
+  try {
+    return textResult(await action());
+  } catch (error) {
+    throw new Error(`${toolName} failed for args=${safeStringify(args)}: ${errorMessage(error)}`, {
+      cause: error
+    });
+  }
+}
+var PROJECT_ARG_DESCRIPTION = "Registered project name to target (from the registry). Omit to use the current working directory.";
+function buildMcpServer(options = {}) {
+  const registry = options.registry ?? null;
+  const server = new McpServer({ name: "prowl", version: package_default.version });
+  const projectFor = (project) => {
+    if (!project) return null;
+    if (!registry) {
+      throw new Error(
+        `No project registry is configured, so project "${project}" cannot be resolved. Start the server with \`prowl mcp --projects <path>\` (or set PROWL_PROJECTS).`
+      );
+    }
+    return resolveProject(registry, project);
+  };
+  const configPathFor = (project) => {
+    return projectFor(project)?.configPath;
+  };
+  server.registerTool(
+    "list_projects",
+    {
+      description: "List the projects registered with this server. Empty when no registry is configured.",
+      inputSchema: z2.object({}).strict()
+    },
+    async (args) => toolResult("list_projects", args, () => ({ projects: listRegisteredProjects(registry) }))
+  );
+  server.registerTool(
+    "list_hunts",
+    {
+      description: "List all hunts in the target project, in run order.",
+      inputSchema: {
+        project: z2.string().min(1).describe(PROJECT_ARG_DESCRIPTION).optional()
+      }
+    },
+    async (args) => toolResult("list_hunts", args, () => listHuntsTool(configPathFor(args.project)))
+  );
+  server.registerTool(
+    "run_suite",
+    {
+      description: "Run all hunts and, by default, log any failures as deduplicated bug tickets in the project backlog. Returns pass/fail/skip counts and the QA-NNN ticket ids created.",
+      inputSchema: {
+        project: z2.string().min(1).describe(PROJECT_ARG_DESCRIPTION).optional(),
+        includeTags: z2.array(z2.string()).optional(),
+        excludeTags: z2.array(z2.string()).optional(),
+        parallel: z2.number().int().min(1).optional(),
+        logBugs: z2.boolean().optional()
+      }
+    },
+    async (args) => toolResult("run_suite", args, () => {
+      const project = projectFor(args.project);
+      return runSuiteTool(args, { configPath: project?.configPath, projectRoot: project?.root });
+    })
+  );
+  server.registerTool(
+    "run_hunt",
+    {
+      description: "Run a single hunt by name and return its full result.",
+      inputSchema: {
+        hunt: z2.string().min(1),
+        project: z2.string().min(1).describe(PROJECT_ARG_DESCRIPTION).optional()
+      }
+    },
+    async (args) => toolResult("run_hunt", args, () => runHuntTool(args, configPathFor(args.project)))
+  );
+  return server;
+}
+async function startMcpServer(options = {}) {
+  const registry = loadProjectRegistry(options.registryPath);
+  const server = buildMcpServer({ registry });
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+
+// src/cli/commands/mcp.ts
+function errorMessage2(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function buildMcpCommand() {
+  return new Command12("mcp").description("Start an MCP server (stdio) exposing Prowl tools to AI agents").option(
+    "--projects <path>",
+    "Path to a project registry (YAML) so tools can target multiple repos by name"
+  ).action(async (options) => {
+    try {
+      await startMcpServer({ registryPath: options.projects });
+    } catch (error) {
+      console.error(`Failed to start MCP server: ${errorMessage2(error)}`);
+      process.exit(1);
+    }
+  });
+}
+
+// src/cli/program.ts
+var CLI_VERSION = package_default.version;
+function buildProgram() {
+  const program2 = new Command13();
+  program2.name("prowl").description("CLI-first QA testing tool for deterministic Playwright flows").version(CLI_VERSION);
+  program2.addCommand(buildRunCommand());
+  program2.addCommand(buildCiCommand());
+  program2.addCommand(buildWatchCommand());
+  program2.addCommand(buildInitCommand());
+  program2.addCommand(buildLoginCommand());
+  program2.addCommand(buildListCommand());
+  program2.addCommand(buildUpdateBaselinesCommand());
+  program2.addCommand(buildAnalyzeCommand());
+  program2.addCommand(buildGenerateCommand());
+  program2.addCommand(buildHistoryCommand());
+  program2.addCommand(buildFlakyCommand());
+  program2.addCommand(buildMcpCommand());
+  return program2;
+}
+
+// src/cli/index.ts
+var program = buildProgram();
+program.parseAsync(process.argv).catch((error) => {
+  const message = error instanceof Error ? error.message : "Command failed";
+  console.error(message);
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map