@halecraft/verify 1.0.0

package/dist/index.js

@@ -0,0 +1,1796 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/config.ts
+import { existsSync } from "fs";
+import { join, resolve } from "path";
+import { pathToFileURL } from "url";
+function defineConfig(config) {
+  return config;
+}
+function defineTask(task) {
+  return task;
+}
+var CONFIG_FILES = [
+  "verify.config.ts",
+  "verify.config.mts",
+  "verify.config.js",
+  "verify.config.mjs"
+];
+function findConfigFile(cwd) {
+  for (const filename of CONFIG_FILES) {
+    const filepath = join(cwd, filename);
+    if (existsSync(filepath)) {
+      return filepath;
+    }
+  }
+  return null;
+}
+async function loadConfig(configPath) {
+  const absolutePath = resolve(configPath);
+  if (!existsSync(absolutePath)) {
+    return null;
+  }
+  const fileUrl = pathToFileURL(absolutePath).href;
+  const module = await import(fileUrl);
+  if (!module.default) {
+    throw new Error(`Config file ${configPath} must have a default export`);
+  }
+  return module.default;
+}
+async function loadConfigFromCwd(cwd, configPath) {
+  if (configPath) {
+    return loadConfig(configPath);
+  }
+  const foundPath = findConfigFile(cwd);
+  if (!foundPath) {
+    return null;
+  }
+  return loadConfig(foundPath);
+}
+function mergeOptions(configOptions, cliOptions) {
+  return {
+    logs: cliOptions?.logs ?? configOptions?.logs ?? "failed",
+    format: cliOptions?.format ?? configOptions?.format ?? "human",
+    filter: cliOptions?.filter ?? configOptions?.filter,
+    cwd: cliOptions?.cwd ?? configOptions?.cwd ?? process.cwd(),
+    noColor: cliOptions?.noColor ?? configOptions?.noColor ?? false,
+    topLevelOnly: cliOptions?.topLevelOnly ?? configOptions?.topLevelOnly ?? false,
+    noTty: cliOptions?.noTty ?? configOptions?.noTty ?? false
+  };
+}
+
+// src/discovery.ts
+import { existsSync as existsSync2, readdirSync, statSync } from "fs";
+import { join as join2, relative } from "path";
+var DEFAULT_PATTERNS = ["packages/*", "apps/*"];
+function findMatchingDirs(rootDir, patterns) {
+  const results = [];
+  for (const pattern of patterns) {
+    if (pattern.endsWith("/*")) {
+      const parentDir = pattern.slice(0, -2);
+      const parentPath = join2(rootDir, parentDir);
+      if (existsSync2(parentPath) && statSync(parentPath).isDirectory()) {
+        const entries = readdirSync(parentPath);
+        for (const entry of entries) {
+          const entryPath = join2(parentPath, entry);
+          if (statSync(entryPath).isDirectory()) {
+            results.push(entryPath);
+          }
+        }
+      }
+    } else {
+      const dirPath = join2(rootDir, pattern);
+      if (existsSync2(dirPath) && statSync(dirPath).isDirectory()) {
+        results.push(dirPath);
+      }
+    }
+  }
+  return results;
+}
+function getPackageName(packageDir) {
+  const packageJsonPath = join2(packageDir, "package.json");
+  if (!existsSync2(packageJsonPath)) {
+    return null;
+  }
+  try {
+    const content = __require(packageJsonPath);
+    return content.name ?? null;
+  } catch {
+    return null;
+  }
+}
+async function discoverPackages(rootDir, options = {}) {
+  const patterns = options.patterns ?? DEFAULT_PATTERNS;
+  const matchingDirs = findMatchingDirs(rootDir, patterns);
+  const packages = [];
+  for (const dir of matchingDirs) {
+    const name = getPackageName(dir);
+    if (!name) continue;
+    if (options.filter && options.filter.length > 0) {
+      const matches = options.filter.some(
+        (f) => name === f || name.includes(f) || relative(rootDir, dir).includes(f)
+      );
+      if (!matches) continue;
+    }
+    const configPath = findConfigFile(dir);
+    const config = configPath ? await loadConfig(configPath) : null;
+    packages.push({
+      name,
+      path: relative(rootDir, dir),
+      absolutePath: dir,
+      config
+    });
+  }
+  return packages;
+}
+async function hasPackageChanged(_packagePath, _baseBranch = "main") {
+  return true;
+}
+
+// src/init/detect.ts
+import { existsSync as existsSync3, readFileSync } from "fs";
+import { join as join3 } from "path";
+var TOOL_PATTERNS = [
+  // Biome
+  {
+    pattern: /\bbiome\s+(check|lint|format)/,
+    binary: "biome",
+    getArgs: (match, content) => {
+      const biomeMatch = content.match(/biome\s+([^&|;]+)/);
+      return biomeMatch ? biomeMatch[1].trim() : "check .";
+    },
+    parser: "biome"
+  },
+  // ESLint
+  {
+    pattern: /\beslint\b/,
+    binary: "eslint",
+    getArgs: (_, content) => {
+      const eslintMatch = content.match(/eslint\s+([^&|;]+)/);
+      return eslintMatch ? eslintMatch[1].trim() : ".";
+    }
+  },
+  // Prettier
+  {
+    pattern: /\bprettier\b/,
+    binary: "prettier",
+    getArgs: (_, content) => {
+      const prettierMatch = content.match(/prettier\s+([^&|;]+)/);
+      return prettierMatch ? prettierMatch[1].trim() : "--check .";
+    }
+  },
+  // TypeScript
+  {
+    pattern: /\btsc\b/,
+    binary: "tsc",
+    getArgs: (_, content) => {
+      const tscMatch = content.match(/tsc\s+([^&|;]+)/);
+      return tscMatch ? tscMatch[1].trim() : "--noEmit";
+    },
+    parser: "tsc"
+  },
+  // tsgo
+  {
+    pattern: /\btsgo\b/,
+    binary: "tsgo",
+    getArgs: (_, content) => {
+      const tsgoMatch = content.match(/tsgo\s+([^&|;]+)/);
+      return tsgoMatch ? tsgoMatch[1].trim() : "--noEmit";
+    },
+    parser: "tsc"
+  },
+  // Vitest
+  {
+    pattern: /\bvitest\b/,
+    binary: "vitest",
+    getArgs: (_, content) => {
+      if (content.includes("vitest run")) return "run";
+      if (content.includes("vitest watch")) return "run";
+      return "run";
+    },
+    parser: "vitest"
+  },
+  // Jest
+  {
+    pattern: /\bjest\b/,
+    binary: "jest",
+    getArgs: () => ""
+  },
+  // Mocha
+  {
+    pattern: /\bmocha\b/,
+    binary: "mocha",
+    getArgs: () => ""
+  },
+  // tsup
+  {
+    pattern: /\btsup\b/,
+    binary: "tsup",
+    getArgs: (_, content) => {
+      const tsupMatch = content.match(/tsup\s+([^&|;]+)/);
+      return tsupMatch ? tsupMatch[1].trim() : "";
+    }
+  },
+  // esbuild
+  {
+    pattern: /\besbuild\b/,
+    binary: "esbuild",
+    getArgs: (_, content) => {
+      const esbuildMatch = content.match(/esbuild\s+([^&|;]+)/);
+      return esbuildMatch ? esbuildMatch[1].trim() : "";
+    }
+  }
+];
+var SCRIPT_NAME_PATTERNS = [
+  // Format/Lint patterns
+  {
+    pattern: /^(lint|eslint|biome|prettier|format)$/i,
+    key: "format",
+    name: "Format & Lint",
+    category: "format"
+  },
+  {
+    pattern: /^(lint:fix|format:fix|fix)$/i,
+    key: "format",
+    name: "Format & Lint",
+    category: "format"
+  },
+  {
+    pattern: /^verify:format$/i,
+    key: "format",
+    name: "Format",
+    category: "format"
+  },
+  // Type checking patterns
+  {
+    pattern: /^(typecheck|type-check|tsc|types|check-types)$/i,
+    key: "types",
+    name: "Type Check",
+    category: "types"
+  },
+  {
+    pattern: /^verify:types$/i,
+    key: "types",
+    name: "Types",
+    category: "types"
+  },
+  // Test patterns
+  {
+    pattern: /^(test|tests|vitest|jest|mocha|ava)$/i,
+    key: "test",
+    name: "Tests",
+    category: "logic"
+  },
+  {
+    pattern: /^test:(unit|integration|e2e)$/i,
+    key: "test",
+    name: "Tests",
+    category: "logic"
+  },
+  {
+    pattern: /^verify:logic$/i,
+    key: "logic",
+    name: "Logic Tests",
+    category: "logic"
+  },
+  // Build patterns
+  {
+    pattern: /^(build|compile)$/i,
+    key: "build",
+    name: "Build",
+    category: "build"
+  }
+];
+function readPackageJson(cwd) {
+  const packageJsonPath = join3(cwd, "package.json");
+  if (!existsSync3(packageJsonPath)) {
+    return null;
+  }
+  try {
+    const content = readFileSync(packageJsonPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function binaryExists(cwd, binary) {
+  return existsSync3(join3(cwd, "node_modules", ".bin", binary));
+}
+function extractOptimizedCommand(cwd, scriptContent) {
+  for (const tool of TOOL_PATTERNS) {
+    const match = scriptContent.match(tool.pattern);
+    if (match && binaryExists(cwd, tool.binary)) {
+      const args = tool.getArgs(match, scriptContent);
+      const command = args ? `./node_modules/.bin/${tool.binary} ${args}` : `./node_modules/.bin/${tool.binary}`;
+      return { command, parser: tool.parser };
+    }
+  }
+  return null;
+}
+function detectFromPackageJson(cwd) {
+  const pkg = readPackageJson(cwd);
+  if (!pkg?.scripts) {
+    return [];
+  }
+  const detected = [];
+  const seenKeys = /* @__PURE__ */ new Set();
+  for (const [scriptName, scriptContent] of Object.entries(pkg.scripts)) {
+    if (scriptContent.includes("run-s") || scriptContent.includes("run-p") || scriptContent.includes("npm-run-all")) {
+      continue;
+    }
+    for (const { pattern, key, name, category } of SCRIPT_NAME_PATTERNS) {
+      if (pattern.test(scriptName)) {
+        const uniqueKey = seenKeys.has(key) ? `${key}-${scriptName}` : key;
+        if (!seenKeys.has(uniqueKey)) {
+          seenKeys.add(uniqueKey);
+          const optimized = extractOptimizedCommand(cwd, scriptContent);
+          detected.push({
+            key: uniqueKey,
+            name,
+            scriptName,
+            command: optimized?.command ?? `npm run ${scriptName}`,
+            category,
+            parser: optimized?.parser
+          });
+        }
+        break;
+      }
+    }
+  }
+  const categoryOrder = {
+    format: 0,
+    types: 1,
+    logic: 2,
+    build: 3,
+    other: 4
+  };
+  detected.sort((a, b) => categoryOrder[a.category] - categoryOrder[b.category]);
+  const hasFormatTask = detected.some((t) => t.category === "format");
+  if (hasFormatTask) {
+    for (const task of detected) {
+      if (task.category !== "format" && task.category !== "other") {
+        task.reportingDependsOn = ["format"];
+      }
+    }
+  }
+  return detected;
+}
+function detectPackageManager(cwd) {
+  if (existsSync3(join3(cwd, "pnpm-lock.yaml"))) {
+    return "pnpm";
+  }
+  if (existsSync3(join3(cwd, "yarn.lock"))) {
+    return "yarn";
+  }
+  return "npm";
+}
+function getRunCommand(packageManager, scriptName) {
+  switch (packageManager) {
+    case "pnpm":
+      return `pnpm ${scriptName}`;
+    case "yarn":
+      return `yarn ${scriptName}`;
+    default:
+      return `npm run ${scriptName}`;
+  }
+}
+function detectTasks(cwd) {
+  const packageManager = detectPackageManager(cwd);
+  const tasks = detectFromPackageJson(cwd);
+  return tasks.map((task) => {
+    if (task.command.startsWith("./")) {
+      return task;
+    }
+    return {
+      ...task,
+      command: getRunCommand(packageManager, task.scriptName)
+    };
+  });
+}
+
+// src/init/generate.ts
+function getOutputFormat(filePath) {
+  if (filePath.endsWith(".mts")) return "mts";
+  if (filePath.endsWith(".mjs")) return "mjs";
+  if (filePath.endsWith(".js")) return "js";
+  return "ts";
+}
+function generateImport(format) {
+  return `import { defineConfig } from "@halecraft/verify"`;
+}
+function generateTask(task, indent) {
+  const parts = [`key: "${task.key}"`, `run: "${task.command}"`];
+  if (task.parser) {
+    parts.push(`parser: "${task.parser}"`);
+  }
+  if (task.reportingDependsOn && task.reportingDependsOn.length > 0) {
+    const deps = task.reportingDependsOn.map((d) => `"${d}"`).join(", ");
+    parts.push(`reportingDependsOn: [${deps}]`);
+  }
+  return `${indent}{ ${parts.join(", ")} }`;
+}
+function generateSkeleton(format) {
+  const importStatement = generateImport(format);
+  return `${importStatement}
+
+export default defineConfig({
+  tasks: [
+    // Add your verification tasks here
+    // Example:
+    // { key: "format", run: "pnpm lint" },
+    // { key: "types", run: "pnpm typecheck" },
+    // { key: "test", run: "pnpm test" },
+  ],
+})
+`;
+}
+function generateConfigContent(tasks, format) {
+  if (tasks.length === 0) {
+    return generateSkeleton(format);
+  }
+  const importStatement = generateImport(format);
+  const indent = "    ";
+  const taskLines = tasks.map((task) => generateTask(task, indent));
+  return `${importStatement}
+
+export default defineConfig({
+  tasks: [
+${taskLines.join(",\n")},
+  ],
+})
+`;
+}
+function getDefaultConfigPath() {
+  return "verify.config.ts";
+}
+
+// src/init/prompts.ts
+function shouldSkipPrompts(options) {
+  return options.yes || !options.isTTY;
+}
+async function promptForTasks(detectedTasks, options) {
+  if (detectedTasks.length === 0) {
+    if (!shouldSkipPrompts(options)) {
+      console.log(
+        "\n\u26A0\uFE0F  No verification scripts detected in package.json.\n   A skeleton config will be created.\n"
+      );
+    }
+    return { tasks: [], cancelled: false };
+  }
+  if (shouldSkipPrompts(options)) {
+    console.log(`
+\u2713 Auto-selecting ${detectedTasks.length} detected task(s)
+`);
+    return { tasks: detectedTasks, cancelled: false };
+  }
+  try {
+    const { checkbox } = await import("@inquirer/prompts");
+    console.log("\n\u{1F50D} Detected verification scripts in package.json:\n");
+    const choices = detectedTasks.map((task) => ({
+      name: `${task.name} (${task.command})`,
+      value: task,
+      checked: true
+      // Pre-select all by default
+    }));
+    const selected = await checkbox({
+      message: "Select tasks to include in your config:",
+      choices,
+      instructions: false
+    });
+    if (selected.length === 0) {
+      console.log(
+        "\n\u26A0\uFE0F  No tasks selected. A skeleton config will be created.\n"
+      );
+    }
+    return { tasks: selected, cancelled: false };
+  } catch (error) {
+    if (error instanceof Error && (error.message.includes("User force closed") || error.name === "ExitPromptError")) {
+      return { tasks: [], cancelled: true };
+    }
+    throw error;
+  }
+}
+
+// src/init/write.ts
+import { existsSync as existsSync4, writeFileSync } from "fs";
+import { resolve as resolve2 } from "path";
+function checkConfigExists(cwd, configPath) {
+  const absolutePath = resolve2(cwd, configPath);
+  return {
+    exists: existsSync4(absolutePath),
+    path: absolutePath
+  };
+}
+function writeConfigFile(cwd, configPath, content) {
+  const absolutePath = resolve2(cwd, configPath);
+  writeFileSync(absolutePath, content, "utf-8");
+}
+function printExistsWarning(path) {
+  console.error(`
+\u26A0\uFE0F  Config file already exists: ${path}`);
+  console.error("   Use --force to overwrite.\n");
+}
+function printSuccess(options) {
+  const { configPath, tasks, hasOptimizedCommands, removableScripts } = options;
+  console.log(`
+\u2705 Created ${configPath}`);
+  console.log("");
+  console.log("   Quick start:");
+  console.log("   $ verify              # Run all verifications");
+  console.log("   $ verify --top-level  # Show only top-level tasks");
+  console.log("   $ verify format       # Run only 'format' task");
+  console.log("");
+  if (hasOptimizedCommands) {
+    console.log(
+      "   \u26A1 Performance: Using direct tool paths for faster execution"
+    );
+    console.log(
+      "      (avoids ~250ms overhead per command from package manager)"
+    );
+    console.log("");
+  }
+  if (removableScripts.length > 0) {
+    console.log("   \u{1F4A1} Optional cleanup:");
+    console.log(
+      "      You can remove these scripts from package.json if you only"
+    );
+    console.log("      run them via 'verify' (keeps package.json cleaner):");
+    for (const script of removableScripts) {
+      console.log(`        - "${script}"`);
+    }
+    console.log("");
+  }
+  const tasksWithParsers = tasks.filter((t) => t.parser);
+  if (tasksWithParsers.length > 0) {
+    console.log("   \u{1F4CA} Rich output: Parsers detected for detailed summaries:");
+    for (const task of tasksWithParsers) {
+      console.log(`        - ${task.key}: ${task.parser}`);
+    }
+    console.log("");
+  }
+  console.log("   \u{1F4D6} Docs: https://github.com/halecraft/verify");
+  console.log("");
+}
+
+// src/init/index.ts
+async function runInit(options) {
+  const configPath = options.config ?? getDefaultConfigPath();
+  const format = getOutputFormat(configPath);
+  const fileCheck = checkConfigExists(options.cwd, configPath);
+  if (fileCheck.exists && !options.force) {
+    printExistsWarning(fileCheck.path);
+    return {
+      success: false,
+      error: "Config file already exists. Use --force to overwrite."
+    };
+  }
+  const detectedTasks = detectTasks(options.cwd);
+  const isTTY = process.stdout.isTTY ?? false;
+  const promptOptions = {
+    yes: options.yes,
+    isTTY
+  };
+  if (!shouldSkipPrompts(promptOptions)) {
+    console.log("\n\u{1F680} Initializing @halecraft/verify config...\n");
+  }
+  const promptResult = await promptForTasks(detectedTasks, promptOptions);
+  if (promptResult.cancelled) {
+    console.log("\n\u274C Cancelled.\n");
+    return {
+      success: false,
+      error: "User cancelled"
+    };
+  }
+  const content = generateConfigContent(promptResult.tasks, format);
+  const hasOptimizedCommands = promptResult.tasks.some(
+    (t) => t.command.startsWith("./node_modules/.bin/")
+  );
+  const removableScripts = promptResult.tasks.filter((t) => t.command.startsWith("./node_modules/.bin/")).map((t) => t.scriptName);
+  try {
+    writeConfigFile(options.cwd, configPath, content);
+    printSuccess({
+      configPath,
+      tasks: promptResult.tasks,
+      hasOptimizedCommands,
+      removableScripts
+    });
+    return {
+      success: true,
+      configPath
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Failed to write config file";
+    console.error(`
+\u274C Error: ${message}
+`);
+    return {
+      success: false,
+      error: message
+    };
+  }
+}
+
+// src/parsers/biome.ts
+var biomeParser = {
+  id: "biome",
+  parse(output, exitCode) {
+    const filesMatch = output.match(
+      /Checked\s+(\d+)\s+files?\s+in\s+[\d.]+(?:ms|s)/i
+    );
+    const fileCount = filesMatch ? Number.parseInt(filesMatch[1], 10) : void 0;
+    const warningMatch = output.match(/Found\s+(\d+)\s+warning/i);
+    const warnings = warningMatch ? Number.parseInt(warningMatch[1], 10) : 0;
+    if (exitCode === 0) {
+      const filesPart = fileCount ? `passed ${fileCount} files` : "passed";
+      const warningSuffix = warnings > 0 ? `, ${warnings} warning${warnings === 1 ? "" : "s"}` : "";
+      return {
+        summary: `${filesPart}${warningSuffix}`,
+        metrics: { errors: 0, warnings, total: fileCount }
+      };
+    }
+    const summaryMatch = output.match(
+      /Found\s+(\d+)\s+error(?:s)?(?:\s+and\s+(\d+)\s+warning(?:s)?)?/i
+    );
+    if (summaryMatch) {
+      const errors2 = Number.parseInt(summaryMatch[1], 10);
+      const parsedWarnings = summaryMatch[2] ? Number.parseInt(summaryMatch[2], 10) : warnings;
+      const fileSuffix = fileCount ? ` in ${fileCount} files` : "";
+      return {
+        summary: `${errors2} error${errors2 === 1 ? "" : "s"}${parsedWarnings > 0 ? `, ${parsedWarnings} warning${parsedWarnings === 1 ? "" : "s"}` : ""}${fileSuffix}`,
+        metrics: { errors: errors2, warnings: parsedWarnings, total: fileCount }
+      };
+    }
+    const errorLines = output.match(/^\s*error\[/gm);
+    const warningLines = output.match(/^\s*warning\[/gm);
+    const errors = errorLines ? errorLines.length : 0;
+    const countedWarnings = warningLines ? warningLines.length : warnings;
+    if (errors > 0 || countedWarnings > 0) {
+      const fileSuffix = fileCount ? ` in ${fileCount} files` : "";
+      return {
+        summary: `${errors} error${errors === 1 ? "" : "s"}${countedWarnings > 0 ? `, ${countedWarnings} warning${countedWarnings === 1 ? "" : "s"}` : ""}${fileSuffix}`,
+        metrics: { errors, warnings: countedWarnings, total: fileCount }
+      };
+    }
+    if (fileCount) {
+      return {
+        summary: `passed ${fileCount} files`,
+        metrics: { errors: 0, warnings: 0, total: fileCount }
+      };
+    }
+    return null;
+  }
+};
+
+// src/parsers/generic.ts
+var genericParser = {
+  id: "generic",
+  parse(_output, exitCode) {
+    return {
+      summary: exitCode === 0 ? "passed" : `failed (exit code ${exitCode})`
+    };
+  }
+};
+
+// src/parsers/gotest.ts
+var gotestParser = {
+  id: "gotest",
+  parse(output, exitCode) {
+    const okMatches = output.match(/^ok\s+\S+/gm);
+    const failMatches = output.match(/^FAIL\s+\S+/gm);
+    const passed = okMatches ? okMatches.length : 0;
+    const failed = failMatches ? failMatches.length : 0;
+    const total = passed + failed;
+    if (total === 0) {
+      if (output.includes("no test files")) {
+        return {
+          summary: "no test files",
+          metrics: { passed: 0, failed: 0, total: 0 }
+        };
+      }
+      return null;
+    }
+    const durationMatch = output.match(/(?:PASS|FAIL)\s*$[\s\S]*?(\d+\.?\d*s)/m);
+    const duration = durationMatch ? durationMatch[1] : void 0;
+    if (exitCode === 0) {
+      return {
+        summary: `${passed} package${passed === 1 ? "" : "s"} passed${duration ? ` in ${duration}` : ""}`,
+        metrics: { passed, failed: 0, total: passed, duration }
+      };
+    }
+    return {
+      summary: `${failed}/${total} package${total === 1 ? "" : "s"} failed`,
+      metrics: { passed, failed, total, duration }
+    };
+  }
+};
+
+// src/parsers/tsc.ts
+var tscParser = {
+  id: "tsc",
+  parse(output, exitCode) {
+    const filesMatch = output.match(/^Files:\s+(\d+)/m);
+    const fileCount = filesMatch ? Number.parseInt(filesMatch[1], 10) : void 0;
+    if (exitCode === 0) {
+      const filesPart = fileCount ? `passed ${fileCount} files` : "passed";
+      return {
+        summary: filesPart,
+        metrics: { errors: 0, total: fileCount }
+      };
+    }
+    const errorMatches = output.match(/error TS\d+:/g);
+    const errorCount = errorMatches ? errorMatches.length : 0;
+    if (errorCount === 0) {
+      return null;
+    }
+    const fileSuffix = fileCount ? ` in ${fileCount} files` : "";
+    return {
+      summary: `${errorCount} type error${errorCount === 1 ? "" : "s"}${fileSuffix}`,
+      metrics: { errors: errorCount, total: fileCount }
+    };
+  }
+};
+
+// src/parsers/vitest.ts
+function stripAnsi(str) {
+  return str.replace(/\x1b\[[0-9;]*m/g, "");
+}
+var vitestParser = {
+  id: "vitest",
+  parse(output, exitCode) {
+    const cleanOutput = stripAnsi(output);
+    const testsMatch = cleanOutput.match(/Tests\s+(\d+)\s+passed\s*\((\d+)\)/m);
+    const durationMatch = cleanOutput.match(/Duration\s+([\d.]+(?:ms|s))\b/m);
+    if (!testsMatch) {
+      return null;
+    }
+    const passed = Number.parseInt(testsMatch[1], 10);
+    const total = Number.parseInt(testsMatch[2], 10);
+    const duration = durationMatch ? durationMatch[1] : void 0;
+    return {
+      summary: exitCode === 0 ? `passed ${passed}/${total} tests` : `passed ${passed}/${total} tests (some failed)`,
+      metrics: {
+        passed,
+        total,
+        failed: total - passed,
+        duration
+      }
+    };
+  }
+};
+
+// src/parsers/index.ts
+var ParserRegistry = class {
+  parsers = /* @__PURE__ */ new Map();
+  constructor() {
+    this.register(genericParser);
+    this.register(vitestParser);
+    this.register(tscParser);
+    this.register(biomeParser);
+    this.register(gotestParser);
+  }
+  /**
+   * Register a custom parser
+   */
+  register(parser) {
+    this.parsers.set(parser.id, parser);
+  }
+  /**
+   * Get a parser by ID
+   */
+  get(id) {
+    return this.parsers.get(id);
+  }
+  /**
+   * Auto-detect parser based on command
+   */
+  detectParser(cmd) {
+    const cmdLower = cmd.toLowerCase();
+    if (cmdLower.includes("vitest") || cmdLower.includes("jest")) {
+      return "vitest";
+    }
+    if (cmdLower.includes("tsc") || cmdLower.includes("tsgo")) {
+      return "tsc";
+    }
+    if (cmdLower.includes("biome") || cmdLower.includes("eslint")) {
+      return "biome";
+    }
+    if (cmdLower.includes("go test") || cmdLower.includes("go") && cmdLower.includes("test")) {
+      return "gotest";
+    }
+    return "generic";
+  }
+  /**
+   * Parse output using the specified or auto-detected parser
+   */
+  parse(output, exitCode, parserId, cmd) {
+    const id = parserId ?? (cmd ? this.detectParser(cmd) : "generic");
+    const parser = this.parsers.get(id) ?? genericParser;
+    const result = parser.parse(output, exitCode);
+    if (result) {
+      return result;
+    }
+    const fallback = genericParser.parse(output, exitCode);
+    if (!fallback) {
+      throw new Error("genericParser unexpectedly returned null");
+    }
+    return fallback;
+  }
+};
+var defaultRegistry = new ParserRegistry();
+
+// src/spinner.ts
+var SPINNER_FRAMES = ["\u25DC", "\u25E0", "\u25DD", "\u25DE", "\u25E1", "\u25DF"];
+var SPINNER_INTERVAL = 80;
+var SpinnerManager = class {
+  frames = SPINNER_FRAMES;
+  frameIndex = 0;
+  interval = null;
+  /**
+   * Start the spinner animation
+   * @param onTick - Callback called on each frame update
+   */
+  start(onTick) {
+    if (this.interval) return;
+    this.interval = setInterval(() => {
+      this.frameIndex = (this.frameIndex + 1) % this.frames.length;
+      onTick();
+    }, SPINNER_INTERVAL);
+  }
+  /**
+   * Stop the spinner animation
+   */
+  stop() {
+    if (this.interval) {
+      clearInterval(this.interval);
+      this.interval = null;
+    }
+  }
+  /**
+   * Get the current spinner frame character
+   */
+  getFrame() {
+    return this.frames[this.frameIndex];
+  }
+  /**
+   * Check if spinner is currently running
+   */
+  isRunning() {
+    return this.interval !== null;
+  }
+};
+
+// src/reporter.ts
+var ansi = {
+  reset: "\x1B[0m",
+  dim: "\x1B[2m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  cyan: "\x1B[36m",
+  bold: "\x1B[1m"
+};
+var cursor = {
+  hide: "\x1B[?25l",
+  show: "\x1B[?25h",
+  moveUp: (n) => `\x1B[${n}A`,
+  moveToStart: "\x1B[0G",
+  clearLine: "\x1B[2K"
+};
+function shouldUseColors(options) {
+  if (options.noColor) return false;
+  if (options.format === "json") return false;
+  if (!process.stdout.isTTY) return false;
+  if ("NO_COLOR" in process.env) return false;
+  if (process.env.TERM === "dumb") return false;
+  return true;
+}
+var BaseReporter = class {
+  colorEnabled;
+  stream;
+  taskDepths = /* @__PURE__ */ new Map();
+  constructor(options = {}) {
+    this.colorEnabled = shouldUseColors(options);
+    this.stream = options.format === "json" ? process.stderr : process.stdout;
+  }
+  /**
+   * Apply ANSI color code to string (if colors enabled)
+   */
+  c(code, s) {
+    return this.colorEnabled ? `${code}${s}${ansi.reset}` : s;
+  }
+  /**
+   * Get success mark (✓ or OK)
+   */
+  okMark() {
+    return this.colorEnabled ? this.c(ansi.green, "\u2713") : "OK";
+  }
+  /**
+   * Get failure mark (✗ or FAIL)
+   */
+  failMark() {
+    return this.colorEnabled ? this.c(ansi.red, "\u2717") : "FAIL";
+  }
+  /**
+   * Get suppressed mark (⊘ or SUPPRESSED)
+   */
+  suppressedMark() {
+    return this.colorEnabled ? this.c(ansi.yellow, "\u2298") : "SUPPRESSED";
+  }
+  /**
+   * Get arrow symbol (→ or ->)
+   */
+  arrow() {
+    return this.colorEnabled ? this.c(ansi.cyan, "\u2192") : "->";
+  }
+  /**
+   * Get indentation string for a given depth
+   */
+  getIndent(depth) {
+    return "  ".repeat(depth);
+  }
+  /**
+   * Get task depth from path
+   */
+  getTaskDepth(path) {
+    return this.taskDepths.get(path) ?? 0;
+  }
+  /**
+   * Recursively collect task depths from verification tree
+   */
+  collectTaskDepths(nodes, parentPath, depth) {
+    for (const node of nodes) {
+      const path = parentPath ? `${parentPath}:${node.key}` : node.key;
+      this.taskDepths.set(path, depth);
+      if (node.children) {
+        this.collectTaskDepths(node.children, path, depth + 1);
+      }
+    }
+  }
+  /**
+   * Extract summary from task result
+   */
+  extractSummary(result) {
+    if (result.summaryLine) {
+      const colonIndex = result.summaryLine.indexOf(": ");
+      if (colonIndex !== -1) {
+        return result.summaryLine.slice(colonIndex + 2);
+      }
+      return result.summaryLine;
+    }
+    return result.ok ? "passed" : "failed";
+  }
+  /**
+   * Flatten nested task results into a single array
+   */
+  flattenResults(results) {
+    const flat = [];
+    for (const r of results) {
+      flat.push(r);
+      if (r.children) {
+        flat.push(...this.flattenResults(r.children));
+      }
+    }
+    return flat;
+  }
+  /**
+   * Output task logs
+   */
+  outputLogs(results, logsMode) {
+    if (logsMode === "none") return;
+    const flatResults = this.flattenResults(results);
+    for (const r of flatResults) {
+      if (r.children) continue;
+      if (logsMode === "failed" && r.ok) continue;
+      if (r.suppressed) continue;
+      const status = r.ok ? this.c(ansi.green, "OK") : this.c(ansi.red, "FAIL");
+      this.stream.write(
+        `
+${this.c(ansi.bold, "====")} ${this.c(ansi.bold, r.path.toUpperCase())} ${status} ${this.c(ansi.bold, "====")}
+`
+      );
+      this.stream.write(r.output || "(no output)\n");
+    }
+  }
+  /**
+   * Output final summary
+   */
+  outputSummary(result) {
+    const finalMessage = result.ok ? this.c(ansi.green, "\n== verification: All correct ==") : this.c(ansi.red, "\n== verification: Failed ==");
+    this.stream.write(`${finalMessage}
+`);
+  }
+};
+var LiveDashboardReporter = class extends BaseReporter {
+  topLevelOnly;
+  tasks = /* @__PURE__ */ new Map();
+  taskOrder = [];
+  spinner;
+  lineCount = 0;
+  constructor(options = {}) {
+    super(options);
+    this.topLevelOnly = options.topLevelOnly ?? false;
+    this.spinner = new SpinnerManager();
+    const cleanup = () => {
+      this.spinner.stop();
+      this.stream.write(cursor.show);
+      process.exit(130);
+    };
+    process.on("SIGINT", cleanup);
+    process.on("SIGTERM", cleanup);
+  }
+  /**
+   * Initialize task list from verification nodes
+   */
+  onStart(tasks) {
+    this.collectTasks(tasks, "", 0);
+    this.stream.write(cursor.hide);
+    this.spinner.start(() => this.redraw());
+  }
+  /**
+   * Recursively collect tasks from verification tree
+   */
+  collectTasks(nodes, parentPath, depth) {
+    for (const node of nodes) {
+      const path = parentPath ? `${parentPath}:${node.key}` : node.key;
+      this.tasks.set(path, {
+        key: node.key,
+        path,
+        depth,
+        status: "pending"
+      });
+      this.taskOrder.push(path);
+      this.taskDepths.set(path, depth);
+      if (node.children) {
+        this.collectTasks(node.children, path, depth + 1);
+      }
+    }
+  }
+  /**
+   * Get display key - shows :key for nested, key for root
+   */
+  getDisplayKey(task) {
+    if (task.depth === 0) {
+      return task.key;
+    }
+    return `:${task.key}`;
+  }
+  /**
+   * Check if task should be displayed based on topLevelOnly flag
+   */
+  shouldDisplay(task) {
+    if (this.topLevelOnly) return task.depth === 0;
+    return true;
+  }
+  /**
+   * Format a single task line
+   */
+  formatLine(task) {
+    const indent = this.getIndent(task.depth);
+    const displayKey = this.getDisplayKey(task);
+    if (task.status === "running") {
+      const spinnerChar = this.c(ansi.dim, `(${this.spinner.getFrame()})`);
+      return `${indent}${this.arrow()} verifying ${this.c(ansi.bold, displayKey)} ${spinnerChar}`;
+    }
+    if (task.status === "completed" && task.result) {
+      const duration = this.c(ansi.dim, `${task.result.durationMs}ms`);
+      if (task.result.suppressed) {
+        const reason = task.result.suppressedBy ? `${task.result.suppressedBy} failed` : "dependency failed";
+        return `${indent}${this.suppressedMark()} suppressed ${this.c(ansi.bold, displayKey)} ${this.c(ansi.dim, `(${reason}, ${duration})`)}`;
+      }
+      const summary = this.extractSummary(task.result);
+      if (task.result.ok) {
+        return ` ${indent}${this.okMark()} verified ${this.c(ansi.bold, displayKey)} ${this.c(ansi.dim, `(${summary}, ${duration})`)}`;
+      }
+      return `${indent}${this.failMark()}    failed ${this.c(ansi.bold, displayKey)} ${this.c(ansi.dim, `(${summary}, ${duration})`)}`;
+    }
+    return "";
+  }
+  /**
+   * Redraw all visible task lines
+   */
+  redraw() {
+    if (this.lineCount > 0) {
+      this.stream.write(cursor.moveUp(this.lineCount));
+    }
+    const lines = [];
+    for (const path of this.taskOrder) {
+      const task = this.tasks.get(path);
+      if (!task) continue;
+      if (!this.shouldDisplay(task)) continue;
+      if (task.status === "pending") continue;
+      const line = this.formatLine(task);
+      if (line) {
+        lines.push(line);
+      }
+    }
+    for (const line of lines) {
+      this.stream.write(`${cursor.clearLine}${cursor.moveToStart}${line}
+`);
+    }
+    this.lineCount = lines.length;
+  }
+  onTaskStart(path, _key) {
+    const task = this.tasks.get(path);
+    if (task) {
+      task.status = "running";
+    }
+  }
+  onTaskComplete(result) {
+    const task = this.tasks.get(result.path);
+    if (task) {
+      task.status = "completed";
+      task.result = result;
+    }
+    this.redraw();
+  }
+  onFinish() {
+    this.spinner.stop();
+    this.redraw();
+    this.stream.write(cursor.show);
+  }
+};
+var SequentialReporter = class extends BaseReporter {
+  topLevelOnly;
+  constructor(options = {}) {
+    super(options);
+    this.topLevelOnly = options.topLevelOnly ?? false;
+  }
+  onStart(tasks) {
+    this.collectTaskDepths(tasks, "", 0);
+  }
+  /**
+   * Check if task should be displayed based on topLevelOnly flag
+   */
+  shouldDisplay(path) {
+    if (this.topLevelOnly) return this.getTaskDepth(path) === 0;
+    return true;
+  }
+  onTaskStart(path, _key) {
+    if (!this.shouldDisplay(path)) return;
+    this.stream.write(`${this.arrow()} verifying ${this.c(ansi.bold, path)}
+`);
+  }
+  onTaskComplete(result) {
+    if (!this.shouldDisplay(result.path)) return;
+    const duration = this.c(ansi.dim, `${result.durationMs}ms`);
+    if (result.suppressed) {
+      const reason = result.suppressedBy ? `${result.suppressedBy} failed` : "dependency failed";
+      this.stream.write(
+        `${this.suppressedMark()} suppressed ${this.c(ansi.bold, result.path)} ${this.c(ansi.dim, `(${reason}, ${duration})`)}
+`
+      );
+      return;
+    }
+    const mark = result.ok ? this.okMark() : this.failMark();
+    const verb = result.ok ? "verified" : "failed";
+    const summary = this.extractSummary(result);
+    this.stream.write(
+      `${mark} ${verb} ${this.c(ansi.bold, result.path)} ${this.c(ansi.dim, `(${summary}, ${duration})`)}
+`
+    );
+  }
+  onFinish() {
+  }
+};
+var JSONReporter = class {
+  onStart(_tasks) {
+  }
+  onTaskStart(_path, _key) {
+  }
+  onTaskComplete(_result) {
+  }
+  onFinish() {
+  }
+  outputLogs(_results, _logsMode) {
+  }
+  outputSummary(result) {
+    const summary = {
+      ok: result.ok,
+      startedAt: result.startedAt,
+      finishedAt: result.finishedAt,
+      durationMs: result.durationMs,
+      tasks: this.serializeTasks(result.tasks)
+    };
+    process.stdout.write(`${JSON.stringify(summary)}
+`);
+  }
+  serializeTasks(tasks) {
+    return tasks.map((t) => ({
+      key: t.key,
+      path: t.path,
+      ok: t.ok,
+      code: t.code,
+      durationMs: t.durationMs,
+      summaryLine: t.summaryLine,
+      ...t.suppressed ? { suppressed: t.suppressed } : {},
+      ...t.suppressedBy ? { suppressedBy: t.suppressedBy } : {},
+      ...t.children ? { children: this.serializeTasks(t.children) } : {}
+    }));
+  }
+};
+var QuietReporter = class extends BaseReporter {
+  onStart(_tasks) {
+  }
+  onTaskStart(_path, _key) {
+  }
+  onTaskComplete(_result) {
+  }
+  onFinish() {
+  }
+  outputLogs(_results, _logsMode) {
+  }
+  outputSummary(result) {
+    const message = result.ok ? this.c(ansi.green, "\u2713 All verifications passed") : this.c(ansi.red, "\u2717 Some verifications failed");
+    process.stdout.write(`${message}
+`);
+  }
+};
+function createReporter(options) {
+  if (options.format === "json") {
+    return new JSONReporter();
+  }
+  if (process.stdout.isTTY && !options.noTty) {
+    return new LiveDashboardReporter(options);
+  }
+  return new SequentialReporter(options);
+}
+
+// src/runner.ts
+import { spawn } from "child_process";
+import treeKill from "tree-kill";
+function normalizeCommand(run) {
+  if (typeof run === "string") {
+    const parts = run.split(/\s+/);
+    return {
+      cmd: parts[0],
+      args: parts.slice(1)
+    };
+  }
+  if (Array.isArray(run)) {
+    return {
+      cmd: run[0],
+      args: run[1]
+    };
+  }
+  return run;
+}
+var ReportingDependencyTracker = class {
+  /** Map of task path/key to their results */
+  results = /* @__PURE__ */ new Map();
+  /** Map of task path/key to waiters (callbacks to resolve when result is available) */
+  waiters = /* @__PURE__ */ new Map();
+  /** Map of task path to its key (for key-based lookups) */
+  pathToKey = /* @__PURE__ */ new Map();
+  /** Map of task key to its path (for key-based lookups) */
+  keyToPath = /* @__PURE__ */ new Map();
+  /** Map of task path to its reportingDependsOn array */
+  dependencies = /* @__PURE__ */ new Map();
+  /** Reverse map: task path → list of tasks that depend on it */
+  reverseDeps = /* @__PURE__ */ new Map();
+  /** Map of task path to its running ChildProcess */
+  processes = /* @__PURE__ */ new Map();
+  /** Set of task paths that have been killed */
+  killedPaths = /* @__PURE__ */ new Set();
+  /**
+   * Initialize the tracker with all tasks from the verification tree.
+   * Also validates for circular dependencies and builds reverse dependency map.
+   */
+  initialize(nodes, parentPath = "") {
+    for (const node of nodes) {
+      const path = parentPath ? `${parentPath}:${node.key}` : node.key;
+      this.pathToKey.set(path, node.key);
+      this.keyToPath.set(node.key, path);
+      if (node.reportingDependsOn && node.reportingDependsOn.length > 0) {
+        this.dependencies.set(path, node.reportingDependsOn);
+      }
+      if (node.children) {
+        this.initialize(node.children, path);
+      }
+    }
+    if (parentPath === "") {
+      this.validateNoCycles();
+      this.buildReverseDeps();
+    }
+  }
+  /**
+   * Build reverse dependency map (task → tasks that depend on it)
+   */
+  buildReverseDeps() {
+    for (const [path, deps] of this.dependencies.entries()) {
+      for (const dep of deps) {
+        const resolvedDep = this.resolveDependency(dep);
+        if (resolvedDep) {
+          const existing = this.reverseDeps.get(resolvedDep) ?? [];
+          existing.push(path);
+          this.reverseDeps.set(resolvedDep, existing);
+        }
+      }
+    }
+  }
+  /**
+   * Validate that there are no circular dependencies using DFS with coloring.
+   * Throws an error with the cycle path if a cycle is detected.
+   */
+  validateNoCycles() {
+    const WHITE = 0;
+    const GRAY = 1;
+    const BLACK = 2;
+    const colors = /* @__PURE__ */ new Map();
+    const parent = /* @__PURE__ */ new Map();
+    for (const path of this.pathToKey.keys()) {
+      colors.set(path, WHITE);
+    }
+    const dfs = (path) => {
+      colors.set(path, GRAY);
+      const deps = this.dependencies.get(path) ?? [];
+      for (const dep of deps) {
+        const depPath = this.resolveDependency(dep);
+        if (!depPath) continue;
+        const color = colors.get(depPath) ?? WHITE;
+        if (color === GRAY) {
+          const cycle = [depPath];
+          let current = path;
+          while (current !== depPath) {
+            cycle.unshift(current);
+            current = parent.get(current) ?? "";
+          }
+          cycle.unshift(depPath);
+          return cycle.join(" \u2192 ");
+        }
+        if (color === WHITE) {
+          parent.set(depPath, path);
+          const cyclePath = dfs(depPath);
+          if (cyclePath) return cyclePath;
+        }
+      }
+      colors.set(path, BLACK);
+      return null;
+    };
+    for (const path of this.pathToKey.keys()) {
+      if (colors.get(path) === WHITE) {
+        const cyclePath = dfs(path);
+        if (cyclePath) {
+          throw new Error(
+            `Circular reporting dependency detected: ${cyclePath}`
+          );
+        }
+      }
+    }
+  }
+  /**
+   * Resolve a dependency identifier to a task path.
+   * Tries exact path match first, then key match.
+   */
+  resolveDependency(dep) {
+    if (this.pathToKey.has(dep)) {
+      return dep;
+    }
+    if (this.keyToPath.has(dep)) {
+      return this.keyToPath.get(dep) ?? null;
+    }
+    return null;
+  }
+  /**
+   * Record a task result and notify any waiters.
+   * If the task failed, kills all dependent processes for early termination.
+   */
+  recordResult(result) {
+    this.results.set(result.path, result);
+    if (!result.ok) {
+      this.killDependents(result.path);
+    }
+    const pathWaiters = this.waiters.get(result.path) ?? [];
+    for (const waiter of pathWaiters) {
+      waiter();
+    }
+    this.waiters.delete(result.path);
+    const key = result.key;
+    if (key !== result.path) {
+      const keyWaiters = this.waiters.get(key) ?? [];
+      for (const waiter of keyWaiters) {
+        waiter();
+      }
+      this.waiters.delete(key);
+    }
+  }
+  /**
+   * Wait for all dependencies of a task to complete.
+   */
+  async waitForDependencies(path) {
+    const deps = this.dependencies.get(path);
+    if (!deps || deps.length === 0) {
+      return;
+    }
+    const waitPromises = deps.map((dep) => this.waitForResult(dep));
+    await Promise.all(waitPromises);
+  }
+  /**
+   * Wait for a specific task result to be available.
+   */
+  waitForResult(pathOrKey) {
+    const resolvedPath = this.resolveDependency(pathOrKey);
+    if (resolvedPath && this.results.has(resolvedPath)) {
+      return Promise.resolve();
+    }
+    if (this.results.has(pathOrKey)) {
+      return Promise.resolve();
+    }
+    return new Promise((resolve3) => {
+      const waiters = this.waiters.get(pathOrKey) ?? [];
+      waiters.push(resolve3);
+      this.waiters.set(pathOrKey, waiters);
+    });
+  }
+  /**
+   * Check if any dependency of a task has failed.
+   * Returns the path of the first failed dependency, or null if all passed.
+   */
+  getFailedDependency(path) {
+    const deps = this.dependencies.get(path);
+    if (!deps || deps.length === 0) {
+      return null;
+    }
+    for (const dep of deps) {
+      const resolvedPath = this.resolveDependency(dep);
+      if (!resolvedPath) continue;
+      const result = this.results.get(resolvedPath);
+      if (result && !result.ok) {
+        return resolvedPath;
+      }
+    }
+    return null;
+  }
+  /**
+   * Check if a task has any reporting dependencies.
+   */
+  hasDependencies(path) {
+    const deps = this.dependencies.get(path);
+    return deps !== void 0 && deps.length > 0;
+  }
+  /**
+   * Register a running process for a task.
+   */
+  registerProcess(path, proc) {
+    this.processes.set(path, proc);
+  }
+  /**
+   * Unregister a process (called when it completes naturally).
+   */
+  unregisterProcess(path) {
+    this.processes.delete(path);
+  }
+  /**
+   * Check if a task was killed.
+   */
+  wasKilled(path) {
+    return this.killedPaths.has(path);
+  }
+  /**
+   * Kill all processes that depend on the failed task.
+   * Called when a task fails to terminate dependent tasks early.
+   */
+  killDependents(failedPath) {
+    const dependents = this.reverseDeps.get(failedPath) ?? [];
+    for (const depPath of dependents) {
+      const proc = this.processes.get(depPath);
+      if (proc?.pid) {
+        this.killedPaths.add(depPath);
+        treeKill(proc.pid, "SIGTERM", (err) => {
+          if (err) {
+          }
+        });
+      }
+    }
+  }
+};
+async function executeCommand(command, cwd, tracker, path) {
+  const start = Date.now();
+  return new Promise((resolve3) => {
+    const proc = spawn(command.cmd, command.args, {
+      shell: process.platform === "win32",
+      cwd: command.cwd ?? cwd,
+      env: { ...process.env, NO_COLOR: "1", ...command.env }
+    });
+    if (tracker && path) {
+      tracker.registerProcess(path, proc);
+    }
+    let output = "";
+    proc.stdout.on("data", (data) => {
+      output += data.toString();
+    });
+    proc.stderr.on("data", (data) => {
+      output += data.toString();
+    });
+    proc.on("close", (code, signal) => {
+      if (tracker && path) {
+        tracker.unregisterProcess(path);
+      }
+      const durationMs = Date.now() - start;
+      const killed = signal === "SIGTERM" || code === 143 || (tracker?.wasKilled(path ?? "") ?? false);
+      resolve3({
+        code: code ?? 1,
+        output,
+        durationMs,
+        killed
+      });
+    });
+    proc.on("error", (err) => {
+      if (tracker && path) {
+        tracker.unregisterProcess(path);
+      }
+      const durationMs = Date.now() - start;
+      resolve3({
+        code: 1,
+        output: `Failed to execute command: ${err.message}`,
+        durationMs,
+        killed: false
+      });
+    });
+  });
+}
+function buildPath(parentPath, key) {
+  return parentPath ? `${parentPath}:${key}` : key;
+}
+function matchesFilter(path, filters) {
+  if (!filters || filters.length === 0) {
+    return true;
+  }
+  return filters.some((filter) => {
+    return path === filter || path.startsWith(`${filter}:`);
+  });
+}
+function hasMatchingDescendant(node, parentPath, filters) {
+  const path = buildPath(parentPath, node.key);
+  if (matchesFilter(path, filters)) {
+    return true;
+  }
+  if (node.children) {
+    return node.children.some(
+      (child) => hasMatchingDescendant(child, path, filters)
+    );
+  }
+  return false;
+}
+var VerificationRunner = class {
+  registry;
+  options;
+  callbacks;
+  dependencyTracker;
+  constructor(options = {}, registry = defaultRegistry, callbacks = {}) {
+    this.options = options;
+    this.registry = registry;
+    this.callbacks = callbacks;
+    this.dependencyTracker = new ReportingDependencyTracker();
+  }
+  /**
+   * Run all verification tasks
+   */
+  async run(tasks) {
+    const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const wallStart = Date.now();
+    this.dependencyTracker.initialize(tasks);
+    const results = await this.runNodes(tasks, "");
+    const finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const durationMs = Date.now() - wallStart;
+    const allOk = results.every((r) => r.ok);
+    return {
+      ok: allOk,
+      startedAt,
+      finishedAt,
+      durationMs,
+      tasks: results
+    };
+  }
+  /**
+   * Run a list of nodes with the appropriate strategy
+   */
+  async runNodes(nodes, parentPath, strategy = "parallel") {
+    const filteredNodes = nodes.filter(
+      (node) => hasMatchingDescendant(node, parentPath, this.options.filter)
+    );
+    if (filteredNodes.length === 0) {
+      return [];
+    }
+    switch (strategy) {
+      case "parallel":
+        return Promise.all(
+          filteredNodes.map((node) => this.runNode(node, parentPath))
+        );
+      case "sequential": {
+        const results = [];
+        for (const node of filteredNodes) {
+          results.push(await this.runNode(node, parentPath));
+        }
+        return results;
+      }
+      case "fail-fast": {
+        const results = [];
+        for (const node of filteredNodes) {
+          const result = await this.runNode(node, parentPath);
+          results.push(result);
+          if (!result.ok) {
+            break;
+          }
+        }
+        return results;
+      }
+    }
+  }
+  /**
+   * Run a single node (leaf or group)
+   */
+  async runNode(node, parentPath) {
+    const path = buildPath(parentPath, node.key);
+    this.callbacks.onTaskStart?.(path, node.key);
+    if (node.children && node.children.length > 0) {
+      const start = Date.now();
+      const childResults = await this.runNodes(
+        node.children,
+        path,
+        node.strategy ?? "parallel"
+      );
+      const durationMs2 = Date.now() - start;
+      const allOk = childResults.every((r) => r.ok || r.suppressed);
+      const allSuppressed = childResults.length > 0 && childResults.every((r) => r.suppressed);
+      const anySuppressed = childResults.some((r) => r.suppressed);
+      const result2 = {
+        key: node.key,
+        path,
+        ok: allOk,
+        code: allOk ? 0 : 1,
+        durationMs: durationMs2,
+        output: "",
+        summaryLine: allOk ? node.successLabel ?? `${node.key}: all passed` : node.failureLabel ?? `${node.key}: some failed`,
+        children: childResults
+      };
+      if (allSuppressed) {
+        result2.suppressed = true;
+        result2.suppressedBy = childResults[0].suppressedBy;
+      } else if (anySuppressed && !allOk) {
+      }
+      this.dependencyTracker.recordResult(result2);
+      this.callbacks.onTaskComplete?.(result2);
+      return result2;
+    }
+    if (!node.run) {
+      const result2 = {
+        key: node.key,
+        path,
+        ok: true,
+        code: 0,
+        durationMs: 0,
+        output: "",
+        summaryLine: `${node.key}: no command specified`
+      };
+      this.dependencyTracker.recordResult(result2);
+      this.callbacks.onTaskComplete?.(result2);
+      return result2;
+    }
+    const command = normalizeCommand(node.run);
+    const cwd = this.options.cwd ?? process.cwd();
+    const { code, output, durationMs, killed } = await executeCommand(
+      command,
+      cwd,
+      this.dependencyTracker,
+      path
+    );
+    const ok = code === 0;
+    if (killed) {
+      await this.dependencyTracker.waitForDependencies(path);
+      const failedDep = this.dependencyTracker.getFailedDependency(path);
+      const result2 = {
+        key: node.key,
+        path,
+        ok: false,
+        code,
+        durationMs,
+        output,
+        summaryLine: `${node.key}: terminated`,
+        suppressed: true,
+        suppressedBy: failedDep ?? "unknown"
+      };
+      this.dependencyTracker.recordResult(result2);
+      this.callbacks.onTaskComplete?.(result2);
+      return result2;
+    }
+    const cmdString = `${command.cmd} ${command.args.join(" ")}`;
+    const parsed = this.registry.parse(
+      output,
+      code,
+      node.parser,
+      cmdString
+    );
+    let summaryLine;
+    if (ok) {
+      summaryLine = node.successLabel ? `${node.key}: ${node.successLabel}` : `${node.key}: ${parsed.summary}`;
+    } else {
+      summaryLine = node.failureLabel ? `${node.key}: ${node.failureLabel}` : `${node.key}: ${parsed.summary}`;
+    }
+    let result = {
+      key: node.key,
+      path,
+      ok,
+      code,
+      durationMs,
+      output,
+      summaryLine,
+      metrics: parsed.metrics
+    };
+    if (this.dependencyTracker.hasDependencies(path)) {
+      await this.dependencyTracker.waitForDependencies(path);
+      if (!ok) {
+        const failedDep = this.dependencyTracker.getFailedDependency(path);
+        if (failedDep) {
+          result = {
+            ...result,
+            suppressed: true,
+            suppressedBy: failedDep
+          };
+        }
+      }
+    }
+    this.dependencyTracker.recordResult(result);
+    this.callbacks.onTaskComplete?.(result);
+    return result;
+  }
+};
+
+// src/index.ts
+async function verify(config, cliOptions) {
+  const options = mergeOptions(config.options, cliOptions);
+  const reporter = createReporter(options);
+  reporter.onStart?.(config.tasks);
+  const runner = new VerificationRunner(options, void 0, {
+    onTaskStart: (path, key) => reporter.onTaskStart(path, key),
+    onTaskComplete: (result2) => reporter.onTaskComplete(result2)
+  });
+  const result = await runner.run(config.tasks);
+  reporter.onFinish?.();
+  reporter.outputLogs(result.tasks, options.logs ?? "failed");
+  reporter.outputSummary(result);
+  return result;
+}
+async function verifyFromConfig(cwd = process.cwd(), cliOptions) {
+  const config = await loadConfigFromCwd(cwd, cliOptions?.cwd);
+  if (!config) {
+    throw new Error(
+      `No verify config found in ${cwd}. Create a verify.config.ts file.`
+    );
+  }
+  return verify(config, { ...cliOptions, cwd });
+}
+export {
+  JSONReporter,
+  LiveDashboardReporter,
+  ParserRegistry,
+  QuietReporter,
+  SequentialReporter,
+  SequentialReporter as TTYReporter,
+  VerificationRunner,
+  biomeParser,
+  createReporter,
+  defaultRegistry,
+  defineConfig,
+  defineTask,
+  detectTasks,
+  discoverPackages,
+  findConfigFile,
+  generateConfigContent,
+  genericParser,
+  gotestParser,
+  hasPackageChanged,
+  loadConfig,
+  loadConfigFromCwd,
+  mergeOptions,
+  runInit,
+  tscParser,
+  verify,
+  verifyFromConfig,
+  vitestParser
+};
+//# sourceMappingURL=index.js.map