@poetic-ai/poetic 1.42.1-bootstrap.0

package/dist/chunk-4BIPZBT7.js

@@ -0,0 +1,791 @@
+// src/core/project/verification-toolchains.ts
+var PYTHON_INTERPRETER_HEAD = /^(?:[\w./-]*[/\\])?(?:python3?|py)(?:\.exe)?(?=\s|$)/;
+function normalizeCommand(command) {
+  return command.trim().replace(/\s+/g, " ");
+}
+function unwrapEnvPythonPathPrefix(normalized) {
+  const parts = normalized.split(" ");
+  if (parts[0] !== "env") return normalized;
+  let index = 1;
+  let sawPythonPath = false;
+  for (; index < parts.length; index += 1) {
+    const token = parts[index] ?? "";
+    if (!token.includes("=")) break;
+    if (!token.startsWith("PYTHONPATH=")) return normalized;
+    sawPythonPath = true;
+  }
+  return sawPythonPath && index < parts.length ? parts.slice(index).join(" ") : normalized;
+}
+function unwrapTrustedEnvPythonPathPrefix(command) {
+  return unwrapEnvPythonPathPrefix(normalizeCommand(command));
+}
+var LOCAL_JS_TOOL_PREFIX = String.raw`(?:(?:npx|pnpx|bunx)\s+(?:--no-install|--offline)\s+)?`;
+function classifyNinjaCommand(normalized) {
+  if (!/^ninja\b/.test(normalized)) return void 0;
+  const targets = [];
+  const tokens = normalized.split(" ");
+  for (let index = 1; index < tokens.length; index += 1) {
+    const token = tokens[index];
+    if (!token) continue;
+    if (token === "-t" || token === "--tool") return void 0;
+    if (["-C", "-f", "-j", "-k", "-l", "-d"].includes(token)) {
+      index += 1;
+      continue;
+    }
+    if (/^-(?:C|f|j|k|l|d).+/.test(token)) continue;
+    if (token === "-v") continue;
+    if (token.startsWith("-")) return void 0;
+    targets.push(token);
+  }
+  if (targets.length === 0) return "build";
+  if (targets.every((target) => /^(?:all|default|build)$/.test(target))) return "build";
+  if (targets.every((target) => /(?:^|:)(?:test|check|tests|checks)$/.test(target))) {
+    return "test";
+  }
+  return void 0;
+}
+var JVM_VALUE_OPTIONS = /* @__PURE__ */ new Set([
+  "-b",
+  "--build-file",
+  "-c",
+  "--settings-file",
+  "-f",
+  "--file",
+  "-gs",
+  "--global-settings",
+  "-I",
+  "--init-script",
+  "-p",
+  "--project-dir",
+  "-pl",
+  "--projects",
+  "-P",
+  "--activate-profiles",
+  "-s",
+  "--settings"
+]);
+function optionTakesSeparateValue(token) {
+  if (JVM_VALUE_OPTIONS.has(token)) return true;
+  if (token.startsWith("--") && token.includes("=")) return false;
+  return false;
+}
+function isAttachedJvmOptionValue(token) {
+  return /^-(?:b|c|f|gs|I|p|pl|P|s).+/.test(token) || /^--(?:build-file|settings-file|file|global-settings|init-script|project-dir|projects|activate-profiles|settings)=/.test(
+    token
+  );
+}
+function extractJvmVerificationGoals(command) {
+  const normalized = normalizeCommand(command);
+  if (!/^(?:\.\/)?(?:gradlew|gradle|mvnw|mvn)\b/.test(normalized)) return [];
+  const tokens = normalized.split(/\s+/).slice(1);
+  const goals = [];
+  for (let index = 0; index < tokens.length; index += 1) {
+    const token = tokens[index];
+    if (!token) continue;
+    if (token === "--") {
+      goals.push(...tokens.slice(index + 1).filter(Boolean));
+      break;
+    }
+    if (optionTakesSeparateValue(token)) {
+      index += 1;
+      continue;
+    }
+    if (isAttachedJvmOptionValue(token)) continue;
+    if (token.startsWith("-")) continue;
+    goals.push(token);
+  }
+  return goals;
+}
+function describeVerificationCommand(command) {
+  const normalized = normalizeCommand(command);
+  const pythonNormalized = unwrapTrustedEnvPythonPathPrefix(normalized);
+  if (new RegExp(`^${LOCAL_JS_TOOL_PREFIX}(?:vitest|jest)\\b`).test(normalized)) {
+    return {
+      command,
+      language: "node",
+      kind: "test",
+      scope: /\s(?:run\s+)?(?:tests?|src|__tests__|[^ ]+\.(?:test|spec)\.)/.test(normalized) ? "targeted" : "full",
+      costClass: /\b(?:--runInBand|--bail|--changed|--findRelatedTests)\b/.test(normalized) ? "medium" : "broad"
+    };
+  }
+  if (/^node\s+scripts\/[^ ]*(?:test|spec|verify|check)[^ ]*\.m?[cj]s\b/.test(normalized)) {
+    return {
+      command,
+      language: "node",
+      kind: "test",
+      scope: "unknown",
+      costClass: "unknown"
+    };
+  }
+  if (/^node\s+scripts\/dynamic-node-options\.mjs\s+(?:\.\/node_modules\/\.bin\/)?(?:vitest|jest)\b/.test(
+    normalized
+  )) {
+    return {
+      command,
+      language: "node",
+      kind: "test",
+      scope: /\s(?:run\s+)?(?:tests?|src|__tests__|[^ ]+\.(?:test|spec)\.)/.test(normalized) ? "targeted" : "full",
+      costClass: "broad"
+    };
+  }
+  if (/^node\s+(?:--[^\s]+\s+)*--test(?=\s|$)/.test(normalized)) {
+    return {
+      command,
+      language: "node",
+      kind: "test",
+      scope: /--test\s+\S/.test(normalized) ? "targeted" : "full",
+      costClass: "broad"
+    };
+  }
+  if (new RegExp(`^${LOCAL_JS_TOOL_PREFIX}(?:mocha|ava)\\b`).test(normalized)) {
+    return {
+      command,
+      language: "node",
+      kind: "test",
+      scope: /\s(?:tests?|src|__tests__|[^ ]+\.(?:test|spec)\.)/.test(normalized) ? "targeted" : "full",
+      costClass: "broad"
+    };
+  }
+  if (new RegExp(`^${LOCAL_JS_TOOL_PREFIX}playwright\\s+test\\b`).test(normalized) || new RegExp(`^${LOCAL_JS_TOOL_PREFIX}cypress\\s+run\\b`).test(normalized)) {
+    return {
+      command,
+      language: "node",
+      kind: "test",
+      scope: "full",
+      costClass: "broad"
+    };
+  }
+  if (new RegExp(`^${LOCAL_JS_TOOL_PREFIX}(?:biome|eslint)\\b`).test(normalized)) {
+    return {
+      command,
+      language: "node",
+      kind: "lint",
+      scope: "full",
+      costClass: "fast"
+    };
+  }
+  if (/^(?:npm|pnpm|yarn|bun)\s+(?:run\s+)?(?:test|test:|lint|typecheck|type-check|build)\b/.test(
+    normalized
+  )) {
+    return {
+      command,
+      language: "node",
+      kind: /\blint\b/.test(normalized) ? "lint" : /\btype-?check\b/.test(normalized) ? "typecheck" : /\bbuild\b/.test(normalized) ? "build" : "test",
+      scope: "unknown",
+      costClass: /\b(?:smoke|unit|fast)\b/.test(normalized) ? "medium" : "broad"
+    };
+  }
+  {
+    const npxRunnerMatch = new RegExp(`^${LOCAL_JS_TOOL_PREFIX}([^\\s]+)`).exec(normalized);
+    const firstToken = npxRunnerMatch?.[1] ?? "";
+    const viaLocalRunner = Boolean(
+      // npx/pnpx/bunx --no-install|--offline tsc ... (the prefix matched and the
+      // runner target basename is tsc).
+      /^(?:npx|pnpx|bunx)\s/.test(normalized) && firstToken.replace(/^.*[/\\]/, "").replace(/\.(?:cmd|exe|ps1)$/i, "") === "tsc"
+    );
+    const firstTokenBasename = firstToken.replace(/^.*[/\\]/, "").replace(/\.(?:cmd|exe|ps1)$/i, "");
+    const isLocalBinPath = /[/\\]node_modules[/\\]\.bin[/\\]tsc(?:\.(?:cmd|exe|ps1))?(?:\s|$)/i.test(firstToken);
+    const isBasenameTsc = firstTokenBasename === "tsc";
+    const hasTsCompilerFlag = /(?:^|\s)(?:--noEmit|-p|--project|-b|--build)(?:\s|=|$)/.test(
+      normalized
+    );
+    const hasTsconfigArg = /(?:^|\s|=)[^\s]*tsconfig[^\s]*\.json(?:\s|$)/i.test(normalized);
+    if (isBasenameTsc && (viaLocalRunner || isLocalBinPath || hasTsCompilerFlag || hasTsconfigArg)) {
+      return {
+        command,
+        language: "node",
+        kind: "typecheck",
+        scope: "full",
+        costClass: "broad"
+      };
+    }
+  }
+  const pythonModuleTest = /^pytest\b/.test(pythonNormalized) || PYTHON_INTERPRETER_HEAD.test(pythonNormalized) && /\s-m\s+(?:pytest|unittest)\b/.test(pythonNormalized);
+  if (pythonModuleTest) {
+    return {
+      command,
+      language: "python",
+      kind: "test",
+      scope: /\s(?:tests?|[^ ]+\.py)\b/.test(pythonNormalized) ? "targeted" : "full",
+      costClass: "broad"
+    };
+  }
+  if (/^(?:ruff|black|mypy)\b/.test(normalized)) {
+    return {
+      command,
+      language: "python",
+      kind: normalized.startsWith("black ") ? "format" : normalized.startsWith("mypy ") ? "typecheck" : "lint",
+      scope: "full",
+      costClass: "fast"
+    };
+  }
+  const ninjaKind = classifyNinjaCommand(normalized);
+  if (/^(?:cmake|ctest|meson)\b/.test(normalized) || ninjaKind) {
+    const kind = ninjaKind ? ninjaKind : /^(?:ctest|meson\s+test)\b/.test(normalized) ? "test" : /^(?:cmake\s+--build|meson\s+compile)\b/.test(normalized) ? "build" : "unknown";
+    return {
+      command,
+      language: "native",
+      kind,
+      scope: "full",
+      costClass: kind === "test" || kind === "build" ? "broad" : "unknown"
+    };
+  }
+  if (/^golangci-lint\s+run\b/.test(normalized)) {
+    return {
+      command,
+      language: "go",
+      kind: "lint",
+      scope: "full",
+      costClass: "fast"
+    };
+  }
+  if (/^go\s+(?:test|vet|build)\b/.test(normalized)) {
+    const kind = normalized.startsWith("go vet") ? "lint" : normalized.startsWith("go build") ? "build" : "test";
+    return {
+      command,
+      language: "go",
+      kind,
+      scope: normalized.includes("./...") ? "full" : "targeted",
+      costClass: kind === "lint" ? "fast" : "broad"
+    };
+  }
+  if (/^cargo\s+(?:fmt|clippy|check|test|build|audit|nextest\s+run)\b/.test(normalized)) {
+    const kind = normalized.startsWith("cargo fmt") ? "format" : normalized.startsWith("cargo clippy") ? "lint" : normalized.startsWith("cargo check") ? "typecheck" : normalized.startsWith("cargo build") ? "build" : normalized.startsWith("cargo audit") ? "unknown" : "test";
+    return {
+      command,
+      language: "rust",
+      kind,
+      scope: "full",
+      costClass: kind === "test" || kind === "build" ? "broad" : "fast"
+    };
+  }
+  if (/^(?:\.\/)?(?:gradlew|gradle|mvnw|mvn)\b/.test(normalized)) {
+    const goals = extractJvmVerificationGoals(normalized);
+    const hasTestGoal = goals.some((goal) => /(?:^|:)(?:test|tests)$/.test(goal));
+    const hasLintGoal = goals.some((goal) => /(?:^|:)(?:check|lint)$/.test(goal));
+    const hasCompileGoal = goals.some(
+      (goal) => /(?:^|:)(?:compile|test-compile|classes|testClasses|compile[A-Z][\w-]*)$/.test(goal)
+    );
+    return {
+      command,
+      language: "jvm",
+      kind: hasTestGoal ? "test" : hasLintGoal ? "lint" : hasCompileGoal ? "typecheck" : "build",
+      scope: normalized.includes(" ./") || goals.some((goal) => /:[^ ]*test$/.test(goal)) ? "targeted" : "full",
+      costClass: hasCompileGoal ? "medium" : "broad"
+    };
+  }
+  if (/^dotnet\s+(?:format|build|test)\b/.test(normalized)) {
+    return {
+      command,
+      language: "dotnet",
+      kind: normalized.startsWith("dotnet format") ? "format" : normalized.startsWith("dotnet build") ? "build" : "test",
+      scope: "full",
+      costClass: normalized.startsWith("dotnet format") ? "fast" : "broad"
+    };
+  }
+  if (/^swift\s+(?:build|test)\b/.test(normalized)) {
+    return {
+      command,
+      language: "swift",
+      kind: normalized.startsWith("swift build") ? "build" : "test",
+      scope: "full",
+      costClass: "broad"
+    };
+  }
+  if (/^(?:flutter|dart)\s+(?:analyze|test)\b/.test(normalized)) {
+    return {
+      command,
+      language: "dart",
+      kind: /\banalyze\b/.test(normalized) ? "lint" : "test",
+      scope: "full",
+      costClass: /\banalyze\b/.test(normalized) ? "medium" : "broad"
+    };
+  }
+  if (/^(?:bundle\s+exec\s+)?(?:rake|rspec|rubocop)\b/.test(normalized)) {
+    return {
+      command,
+      language: "ruby",
+      kind: /\brubocop\b/.test(normalized) ? "lint" : "test",
+      scope: "full",
+      costClass: /\brubocop\b/.test(normalized) ? "fast" : "broad"
+    };
+  }
+  if (/^(?:composer\s+(?:run|exec|test)|phpunit|phpstan|psalm)\b/.test(normalized)) {
+    return {
+      command,
+      language: "php",
+      kind: /\b(?:phpstan|psalm|typecheck|analyse|analyze)\b/.test(normalized) ? "typecheck" : "test",
+      scope: "full",
+      costClass: "broad"
+    };
+  }
+  if (/^shellcheck\b/.test(normalized)) {
+    return {
+      command,
+      language: "shell",
+      kind: "lint",
+      scope: "full",
+      costClass: "fast"
+    };
+  }
+  if (/^R\s+CMD\s+check\b/.test(command.trim())) {
+    return {
+      command,
+      language: "r",
+      kind: "test",
+      scope: "full",
+      costClass: "broad"
+    };
+  }
+  if (/^(?:dbt|sqlfluff)\b/.test(normalized)) {
+    return {
+      command,
+      language: "sql",
+      kind: normalized.startsWith("sqlfluff") ? "lint" : normalized.includes(" compile") ? "build" : "test",
+      scope: "full",
+      costClass: "broad"
+    };
+  }
+  return {
+    command,
+    language: "unknown",
+    kind: "unknown",
+    scope: "unknown",
+    costClass: "unknown"
+  };
+}
+function resolveVerificationExitCode(command, result, options) {
+  const failureExitCode = options?.failureExitCode ?? 1;
+  const unavailableExitCode = options?.unavailableExitCode ?? 127;
+  if (result.timedOut === true) return { exitCode: 124, toolUnavailable: false };
+  if (typeof result.exitCode === "number") {
+    return { exitCode: result.exitCode, toolUnavailable: false };
+  }
+  const all = [
+    result.all ?? `${String(result.stdout ?? "")}
+${String(result.stderr ?? "")}`,
+    result.shortMessage,
+    result.message
+  ].filter((value) => value !== void 0 && value !== null).map(String).join("\n");
+  const toolUnavailable = detectVerificationToolUnavailable(command, all) !== void 0;
+  return {
+    exitCode: toolUnavailable ? unavailableExitCode : failureExitCode,
+    toolUnavailable
+  };
+}
+function detectExitZeroVerifyFailure(command, output) {
+  const normalizedOutput = String(output ?? "");
+  const descriptor = describeVerificationCommand(command);
+  for (const detector of orderedExitZeroFailureDetectors(descriptor)) {
+    const signal = detector(normalizedOutput, descriptor);
+    if (signal) return signal;
+  }
+  return void 0;
+}
+function isPythonStdlibUnittestCommand(command) {
+  const descriptor = describeVerificationCommand(command);
+  if (descriptor.language !== "python" || descriptor.kind !== "test") return false;
+  const normalized = unwrapTrustedEnvPythonPathPrefix(command);
+  if (/\bpytest\b/.test(normalized)) return false;
+  return PYTHON_INTERPRETER_HEAD.test(normalized) && /\s-m\s+unittest\b/.test(normalized);
+}
+function detectZeroCollectedTests(command, output) {
+  const normalizedOutput = String(output ?? "");
+  const descriptor = describeVerificationCommand(command);
+  if (descriptor.kind !== "test" && descriptor.kind !== "unknown") return false;
+  if (/^\s*Ran\s+0\s+tests?\b/im.test(normalizedOutput) || /^\s*NO TESTS RAN\b/im.test(normalizedOutput) || /^\s*=+\s+no tests ran\b.*$/im.test(normalizedOutput) || /^\s*collected\s+0\s+items?\b/im.test(normalizedOutput)) {
+    return true;
+  }
+  if (descriptor.language === "go") {
+    return !/\s-run(?:\s+|=)(?:"\^\$"|'?\^\$'?)/.test(normalizeCommand(command)) && detectsGoZeroCollectedTests(normalizedOutput);
+  }
+  if (descriptor.language === "rust") return detectsRustZeroCollectedTests(normalizedOutput);
+  if (descriptor.language === "jvm") return detectsJvmZeroCollectedTests(normalizedOutput);
+  if (descriptor.language === "node") return detectsNodeZeroCollectedTests(normalizedOutput);
+  if (descriptor.language === "dotnet") return detectsDotnetZeroCollectedTests(normalizedOutput);
+  if (descriptor.language === "ruby") return detectsRubyZeroCollectedTests(normalizedOutput);
+  if (descriptor.language === "dart") return detectsDartZeroCollectedTests(normalizedOutput);
+  if (descriptor.language === "swift") return detectsSwiftZeroCollectedTests(normalizedOutput);
+  if (descriptor.language === "php") return detectsPhpZeroCollectedTests(normalizedOutput);
+  if (descriptor.language === "native") return detectsNativeZeroCollectedTests(normalizedOutput);
+  if (descriptor.language === "r") return detectsRZeroCollectedTests(normalizedOutput);
+  return false;
+}
+function detectsNodeZeroCollectedTests(output) {
+  const csi = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*[A-Za-z]`, "g");
+  const normalized = output.replace(csi, "");
+  if (/^\s*0\s+passing\b/im.test(normalized) && !/^\s*[1-9]\d*\s+(?:passing|failing)\b/im.test(normalized) && !/[1-9]\d*\s+passed\b/i.test(normalized) && !/Tests?\s*[:]?\s*[1-9]/i.test(normalized)) {
+    return true;
+  }
+  if (/^\s*#\s+tests\s+0\s*$/im.test(normalized)) {
+    return true;
+  }
+  return /^\s*(?:\u2139\s+)?tests\s+0\s*$/im.test(normalized) && !/^\s*(?:\u2139\s+)?tests\s+[1-9]\d*\s*$/im.test(normalized);
+}
+function detectsGoZeroCollectedTests(output) {
+  const packageResultLines = output.split(/\r?\n/).map((line) => line.trim()).filter((line) => /^(?:ok|\?)\s+\S+/.test(line));
+  if (packageResultLines.length === 0) return false;
+  return packageResultLines.every(
+    (line) => /\[(?:no test files|no tests to run)\]\s*$/i.test(line)
+  );
+}
+function detectsRustZeroCollectedTests(output) {
+  const runningCounts = Array.from(output.matchAll(/^\s*running\s+(\d+)\s+tests?\b/gim)).map(
+    (match) => Number(match[1] ?? 0)
+  );
+  if (runningCounts.length === 0 || runningCounts.some((count) => count > 0)) return false;
+  return !/^\s*test result:\s+ok\.\s+.*?\b[1-9]\d*\s+passed\b/im.test(output);
+}
+function detectsJvmZeroCollectedTests(output) {
+  const mavenRunCounts = Array.from(
+    output.matchAll(/^\s*(?:\[INFO\]\s*)?Tests run:\s*(\d+)\b/gim),
+    (match) => Number(match[1] ?? 0)
+  );
+  if (mavenRunCounts.length > 0) {
+    return mavenRunCounts.every((count) => count === 0);
+  }
+  if (/^\s*(?:\[INFO\]\s*)?No tests to run\.?\s*$/im.test(output)) {
+    return true;
+  }
+  const gradleTestTaskLines = output.split(/\r?\n/).map((line) => line.trim()).filter(
+    (line) => /^(?:>\s*)?Task\s+:[^\s]*test\b/i.test(line) || /^(?:>\s*)?:[^\s]*test\b/i.test(line)
+  );
+  return gradleTestTaskLines.length > 0 && gradleTestTaskLines.every((line) => /\bNO-SOURCE\b/i.test(line));
+}
+function detectsDotnetZeroCollectedTests(output) {
+  if (/^\s*(?:Passed|Failed)!\s*-\s*Failed:\s*\d+,\s*Passed:\s*\d+,\s*Skipped:\s*\d+,\s*Total:\s*[1-9]/im.test(
+    output
+  )) {
+    return false;
+  }
+  return /^\s*No test is available in\b/im.test(output) || /^\s*No test matches the given testcase filter\b/im.test(output) || /^\s*Passed!\s*-\s*Failed:\s*0,\s*Passed:\s*0,\s*Skipped:\s*\d+,\s*Total:\s*0\b/im.test(output);
+}
+function detectsRubyZeroCollectedTests(output) {
+  if (/^\s*[1-9]\d*\s+examples?,/im.test(output) || /^\s*[1-9]\d*\s+runs?,/im.test(output)) {
+    return false;
+  }
+  return /^\s*0\s+examples,\s+0\s+failures\b/im.test(output) || /^\s*0\s+runs,\s+0\s+assertions\b/im.test(output);
+}
+function detectsDartZeroCollectedTests(output) {
+  return /^\s*(?:\d{2}:\d{2}\s+\+\d+(?:\s+-\d+)?(?:\s+~\d+)?:\s*)?No tests ran\.\s*$/im.test(
+    output
+  );
+}
+function detectsSwiftZeroCollectedTests(output) {
+  if (/^\s*Executed\s+[1-9]\d*\s+tests?\b/im.test(output) || /^[^A-Za-z0-9\r\n]*Test run with\s+[1-9]\d*\s+tests?\b/im.test(output)) {
+    return false;
+  }
+  return /^\s*Executed\s+0\s+tests\b/im.test(output) || /^[^A-Za-z0-9\r\n]*Test run with\s+0\s+tests\b/im.test(output);
+}
+function detectsPhpZeroCollectedTests(output) {
+  return /^\s*No tests executed!\s*$/im.test(output);
+}
+function detectsNativeZeroCollectedTests(output) {
+  return /^\s*No tests were found!!!\s*$/im.test(output) || /^\s*No tests defined\.\s*$/im.test(output);
+}
+function detectsRZeroCollectedTests(output) {
+  if (/^\s*\[\s*FAIL\s+\d+\s*\|\s*WARN\s+\d+\s*\|\s*SKIP\s+\d+\s*\|\s*PASS\s+[1-9]\d*\s*\]/im.test(
+    output
+  )) {
+    return false;
+  }
+  return /^\s*\[\s*FAIL\s+0\s*\|\s*WARN\s+\d+\s*\|\s*SKIP\s+0\s*\|\s*PASS\s+0\s*\]\s*$/im.test(
+    output
+  );
+}
+function selectFallbacksForCommand(primaryCommand, fallbackCommands) {
+  const primary = describeVerificationCommand(primaryCommand);
+  if (primary.kind !== "test" && primary.kind !== "unknown") return [];
+  return fallbackCommands.filter(
+    (fallback) => describeVerificationCommand(fallback).language === primary.language
+  );
+}
+var VERIFICATION_LANGUAGE_PROJECT_LANGUAGES = {
+  node: ["node", "typescript", "javascript"],
+  python: ["python"],
+  native: ["c", "cpp"],
+  go: ["go"],
+  rust: ["rust"],
+  jvm: ["java", "kotlin"],
+  dotnet: ["dotnet"],
+  swift: ["swift"],
+  dart: ["dart"],
+  ruby: ["ruby"],
+  php: ["php"],
+  shell: ["shell", "powershell"],
+  r: ["r"],
+  sql: ["sql"]
+};
+var NODE_PACKAGE_MANAGER_COMMAND_HEAD = /^(?:npm|pnpm|yarn|bun|npx|pnpx|bunx)\b/;
+function verificationCommandMatchesProjectLanguages(command, projectLanguages, options) {
+  if (NODE_PACKAGE_MANAGER_COMMAND_HEAD.test(normalizeCommand(command))) {
+    return options?.hasRootPackageManifest ?? projectLanguages.includes("node");
+  }
+  const descriptor = describeVerificationCommand(command);
+  if (descriptor.language === "unknown") return true;
+  const compatible = VERIFICATION_LANGUAGE_PROJECT_LANGUAGES[descriptor.language];
+  return compatible.some((language) => projectLanguages.includes(language));
+}
+function detectVerificationToolUnavailable(command, output) {
+  const normalizedCommand = normalizeCommand(command).toLowerCase();
+  const normalizedOutput = String(output ?? "").toLowerCase();
+  const descriptor = describeVerificationCommand(command);
+  const interpreterCommand = unwrapTrustedEnvPythonPathPrefix(command).toLowerCase();
+  const moduleRunnerMatch = PYTHON_INTERPRETER_HEAD.test(interpreterCommand) ? interpreterCommand.match(/\s-m\s+([a-z0-9_.-]+)/) : null;
+  const moduleName = moduleRunnerMatch?.[1];
+  if (moduleName && normalizedOutput.includes(`no module named ${moduleName}`)) {
+    return {
+      toolchain: descriptor.language,
+      message: `Verification tool unavailable: module '${moduleName}' is not installed.`
+    };
+  }
+  const executable = normalizedCommand.trim().split(/\s+/)[0]?.replace(/^.*[/\\]/, "");
+  if (!executable) return void 0;
+  const commandParts = normalizedCommand.trim().split(/\s+/);
+  const subcommand = commandParts[1];
+  if (normalizedOutput.includes(`no module named ${executable}`)) {
+    return {
+      toolchain: descriptor.language,
+      message: `Verification tool unavailable: module '${executable}' is not installed.`
+    };
+  }
+  const nestedExecutableMatch = /(?:^|\n)\s*(?:sh:\s*(?:\d+:\s*)?)?([a-z0-9_.-]+):\s*command not found\b/i.exec(
+    normalizedOutput
+  ) ?? /(?:^|\n)\s*(?:sh:\s*)?([a-z0-9_.-]+):\s*not found\b/i.exec(normalizedOutput) ?? /\bnot found:\s*([a-z0-9_.-]+)/i.exec(normalizedOutput) ?? /\bspawn\s+(?:[^\s/\\]+[/\\])*([a-z0-9_.-]+)(?:\s+[^\n]*?)?\s+enoent\b/i.exec(normalizedOutput);
+  const nestedExecutable = nestedExecutableMatch?.[1];
+  if (nestedExecutable) {
+    return {
+      toolchain: descriptor.language,
+      message: `Verification tool unavailable: executable '${nestedExecutable}' was not found.`
+    };
+  }
+  if (subcommand && (normalizedOutput.includes("no such command") || normalizedOutput.includes("no such subcommand"))) {
+    return {
+      toolchain: descriptor.language,
+      message: `Verification tool unavailable: subcommand '${subcommand}' is not installed.`
+    };
+  }
+  if (normalizedOutput.includes("command not found") || normalizedOutput.includes(`${executable}: not found`) || normalizedOutput.includes(`not found: ${executable}`)) {
+    return {
+      toolchain: descriptor.language,
+      message: `Verification tool unavailable: executable '${executable}' was not found.`
+    };
+  }
+  return void 0;
+}
+var EXIT_ZERO_FAILURE_DETECTORS = {
+  node: detectNodeExitZeroFailure,
+  python: detectPythonExitZeroFailure,
+  native: detectNativeExitZeroFailure,
+  go: detectGoExitZeroFailure,
+  rust: detectRustExitZeroFailure,
+  jvm: detectJvmExitZeroFailure,
+  dotnet: detectDotnetExitZeroFailure,
+  swift: detectSwiftExitZeroFailure,
+  dart: detectDartExitZeroFailure,
+  ruby: detectRubyExitZeroFailure,
+  php: detectPhpExitZeroFailure,
+  shell: detectShellExitZeroFailure,
+  r: detectRExitZeroFailure,
+  sql: detectSqlExitZeroFailure
+};
+function orderedExitZeroFailureDetectors(descriptor) {
+  if (descriptor.language === "unknown") return Object.values(EXIT_ZERO_FAILURE_DETECTORS);
+  if (descriptor.language === "node" && descriptor.kind === "test" && /^(?:npm|pnpm|yarn|bun)\s+(?:run\s+)?test\b/.test(normalizeCommand(descriptor.command))) {
+    return Object.values(EXIT_ZERO_FAILURE_DETECTORS);
+  }
+  return [EXIT_ZERO_FAILURE_DETECTORS[descriptor.language]];
+}
+function isPackageTestWrapperDescriptor(descriptor) {
+  return descriptor.language === "node" && descriptor.kind === "test" && /^(?:npm|pnpm|yarn|bun)\s+(?:run\s+)?test\b/.test(normalizeCommand(descriptor.command));
+}
+function detectNodeExitZeroFailure(output) {
+  const vitestTestFiles = output.match(/^\s*Test Files\s+.*?\b([1-9]\d*)\s+failed\b/im);
+  if (vitestTestFiles?.[1]) {
+    return {
+      toolchain: "node",
+      message: `Vitest reported ${vitestTestFiles[1]} failed test file(s) despite exit code 0.`
+    };
+  }
+  const vitestTests = output.match(/^\s*Tests\s+.*?\b([1-9]\d*)\s+failed\b/im);
+  if (vitestTests?.[1]) {
+    return {
+      toolchain: "node",
+      message: `Vitest reported ${vitestTests[1]} failed test(s) despite exit code 0.`
+    };
+  }
+  const jestSuites = output.match(/^\s*Test Suites:\s+.*?\b([1-9]\d*)\s+failed\b/im);
+  if (jestSuites?.[1]) {
+    return {
+      toolchain: "node",
+      message: `Jest reported ${jestSuites[1]} failed test suite(s) despite exit code 0.`
+    };
+  }
+  const jestTests = output.match(/^\s*Tests:\s+.*?\b([1-9]\d*)\s+failed\b/im);
+  if (jestTests?.[1]) {
+    return {
+      toolchain: "node",
+      message: `Jest reported ${jestTests[1]} failed test(s) despite exit code 0.`
+    };
+  }
+  const mochaFailing = output.match(/^\s*([1-9]\d*)\s+failing\b/im);
+  if (mochaFailing?.[1]) {
+    return {
+      toolchain: "node",
+      message: `Mocha reported ${mochaFailing[1]} failing test(s) despite exit code 0.`
+    };
+  }
+  return void 0;
+}
+function detectPythonExitZeroFailure(output) {
+  const pytestSummary = output.match(/^\s*=+\s+.*?\b([1-9]\d*)\s+failed\b.*?=+\s*$/im) ?? output.match(/^\s*([1-9]\d*)\s+failed\b.*\bin\s+\d+(?:\.\d+)?s\s*$/im);
+  if (pytestSummary?.[1]) {
+    return {
+      toolchain: "python",
+      message: `pytest reported ${pytestSummary[1]} failed test(s) despite exit code 0.`
+    };
+  }
+  const mypySummary = output.match(
+    /^\s*Found\s+([1-9]\d*)\s+errors?\s+in\s+\d+\s+files?\s+\(checked\b/im
+  );
+  if (mypySummary?.[1]) {
+    return {
+      toolchain: "python",
+      message: `mypy reported ${mypySummary[1]} error(s) despite exit code 0.`
+    };
+  }
+  return void 0;
+}
+function detectGoExitZeroFailure(output) {
+  if (/^---\s+FAIL:/m.test(output) || /^FAIL(?:\s|\t|$)/m.test(output)) {
+    return {
+      toolchain: "go",
+      message: "go test reported failures despite exit code 0."
+    };
+  }
+  return void 0;
+}
+function detectNativeExitZeroFailure(output) {
+  if (/^\s*Errors while running CTest\b/im.test(output) || /^\s*\d+%\s+tests passed,\s+[1-9]\d*\s+tests failed\b/im.test(output) || /^\s*FAILED:\s/im.test(output) || /\bninja: build stopped\b/i.test(output) || /^\s*Summary of Failures:\s*$/im.test(output) || /^\s*Fail:\s*[1-9]\d*\b/im.test(output) || /^\s*\d+\/\d+\s+.+\s+FAIL(?:\s|$)/im.test(output)) {
+    return {
+      toolchain: "native",
+      message: "Native build/test tooling reported failures despite exit code 0."
+    };
+  }
+  return void 0;
+}
+function detectRustExitZeroFailure(output) {
+  const rustFailure = output.match(/^\s*test result:\s+FAILED\.\s+.*?\b([1-9]\d*)\s+failed\b/im);
+  if (rustFailure?.[1]) {
+    return {
+      toolchain: "rust",
+      message: `cargo reported ${rustFailure[1]} failed test(s) despite exit code 0.`
+    };
+  }
+  return void 0;
+}
+function detectJvmExitZeroFailure(output) {
+  if (/^\s*BUILD FAILED\b/im.test(output) || /^\s*BUILD FAILURE\b/im.test(output) || /\bThere were failing tests\b/i.test(output)) {
+    return {
+      toolchain: "jvm",
+      message: "JVM build tool reported failed verification despite exit code 0."
+    };
+  }
+  return void 0;
+}
+function detectDotnetExitZeroFailure(output) {
+  if (/^\s*Failed!\s+-\s+Failed:\s*[1-9]\d*/im.test(output) || /\bBuild FAILED\b/i.test(output)) {
+    return {
+      toolchain: "dotnet",
+      message: ".NET tooling reported failed verification despite exit code 0."
+    };
+  }
+  return void 0;
+}
+function detectSwiftExitZeroFailure(output, descriptor) {
+  const swiftSpecificFailure = /\*\*\s+TEST FAILED\s+\*\*/i.test(output) || /^\s*Test Suite\b.+\bfailed\b/im.test(output);
+  if (descriptor.language !== "swift" && descriptor.language !== "unknown" && !isPackageTestWrapperDescriptor(descriptor))
+    return void 0;
+  if (descriptor.language === "swift" && /^\s*(?:.+?:\d+:\d+:\s+)?error:\s/im.test(output) || swiftSpecificFailure) {
+    return {
+      toolchain: "swift",
+      message: "Swift tooling reported failed verification despite exit code 0."
+    };
+  }
+  return void 0;
+}
+function detectDartExitZeroFailure(output, descriptor) {
+  if (descriptor.language !== "dart" && descriptor.language !== "unknown" && !isPackageTestWrapperDescriptor(descriptor))
+    return void 0;
+  const dartSpecificFailure = /\bSome tests failed\b/i.test(output);
+  const dartSummaryFailure = descriptor.language === "dart" && /\b[1-9]\d*\s+failed\b/i.test(output);
+  if (dartSpecificFailure || dartSummaryFailure) {
+    return {
+      toolchain: "dart",
+      message: "Dart/Flutter tooling reported failures despite exit code 0."
+    };
+  }
+  return void 0;
+}
+function detectRubyExitZeroFailure(output) {
+  if (/\bFailures?:\s*[1-9]\d*/i.test(output) || /\b[1-9]\d*\s+failures?\b/i.test(output)) {
+    return {
+      toolchain: "ruby",
+      message: "Ruby test tooling reported failures despite exit code 0."
+    };
+  }
+  return void 0;
+}
+function detectPhpExitZeroFailure(output) {
+  if (/\bFAILURES!\b/i.test(output) || /\bTests:\s*\d+,\s*Assertions:\s*\d+,\s*(?:Errors|Failures):\s*[1-9]\d*/i.test(output)) {
+    return {
+      toolchain: "php",
+      message: "PHP test tooling reported failures despite exit code 0."
+    };
+  }
+  return void 0;
+}
+function detectShellExitZeroFailure(output) {
+  if (/\bSC\d{4}:/i.test(output) && /\berror\b/i.test(output)) {
+    return {
+      toolchain: "shell",
+      message: "ShellCheck reported errors despite exit code 0."
+    };
+  }
+  return void 0;
+}
+function detectRExitZeroFailure(output, descriptor) {
+  if (descriptor.language !== "r" && descriptor.language !== "unknown" && !isPackageTestWrapperDescriptor(descriptor))
+    return void 0;
+  if (/^\s*\*\s+checking\b.+\.\.\.\s+ERROR\b/im.test(output) || /^\s*Status:\s+.*\bERROR\b/im.test(output) || descriptor.language === "r" && /\b[1-9]\d*\s+failed\b/i.test(output)) {
+    return {
+      toolchain: "r",
+      message: "R tooling reported failed verification despite exit code 0."
+    };
+  }
+  return void 0;
+}
+function detectSqlExitZeroFailure(output) {
+  if (/\bCompleted with\s+[1-9]\d*\s+error/i.test(output) || /\bFAIL\s+[1-9]\d*/i.test(output) || /\bSQLFluff.*FAIL\b/i.test(output)) {
+    return {
+      toolchain: "sql",
+      message: "SQL/dbt tooling reported failed verification despite exit code 0."
+    };
+  }
+  return void 0;
+}
+
+export {
+  PYTHON_INTERPRETER_HEAD,
+  unwrapTrustedEnvPythonPathPrefix,
+  extractJvmVerificationGoals,
+  describeVerificationCommand,
+  resolveVerificationExitCode,
+  detectExitZeroVerifyFailure,
+  isPythonStdlibUnittestCommand,
+  detectZeroCollectedTests,
+  selectFallbacksForCommand,
+  verificationCommandMatchesProjectLanguages,
+  detectVerificationToolUnavailable
+};
+//# sourceMappingURL=chunk-4BIPZBT7.js.map