@poetic-ai/poetic 1.42.0

package/dist/chunk-7T7RUJI7.js

@@ -0,0 +1,949 @@
+import {
+  detectExplicitNoEditDirective
+} from "./chunk-JOSYEJKY.js";
+import {
+  JUDGE_FEATURE_FLAGS
+} from "./chunk-BSE4R6XD.js";
+import {
+  stripPoeticContextBlocks
+} from "./chunk-VX3UMWB7.js";
+import {
+  isProjectTestPath
+} from "./chunk-UDMS5AD3.js";
+
+// src/core/judge/verification-intent.ts
+var OVERRIDE_PATTERN = /verification\s+intent\s*:\s*(add|pass|both|neither)/i;
+var ADD_PATTERNS = [
+  {
+    id: "add_tests",
+    re: /\b(add|write|create|implement)\s+(?:new\s+)?tests?\b/i,
+    label: "add tests"
+  },
+  {
+    id: "add_regression",
+    re: /\b(regression|unit|integration)\s+tests?\b/i,
+    label: "regression tests"
+  },
+  {
+    id: "add_coverage",
+    re: /\b(improve|increase|boost)\s+test\s+coverage\b/i,
+    label: "coverage target"
+  }
+];
+var PASS_PATTERNS = [
+  {
+    id: "tests_must_pass",
+    re: /\btests?\s+(?:must|should|need|needs|has\s+to)\s+pass\b/i,
+    label: "tests must pass"
+  },
+  {
+    id: "ensure_tests_pass",
+    re: /\bensure\s+(?:the\s+)?tests?\s+pass\b/i,
+    label: "ensure tests pass"
+  },
+  {
+    id: "run_tests",
+    re: /\b(run(?:ning)?|execute|validate)\s+(?:the\s+)?tests?\b/i,
+    label: "run tests"
+  },
+  {
+    id: "test_suite_pass",
+    re: /\btest\s+suite\s+(?:must|should|needs)\s+pass\b/i,
+    label: "test suite passes"
+  }
+];
+var NEITHER_PATTERNS = [
+  { id: "tests_optional", re: /\btests?\s+(?:are\s+)?optional\b/i, label: "tests optional" },
+  { id: "no_tests_required", re: /\bno\s+tests?\s+required\b/i, label: "no tests required" },
+  { id: "skip_tests", re: /\bskip\s+(?:running\s+)?tests?\b/i, label: "skip tests" },
+  {
+    id: "docs_no_tests",
+    re: /\bdocs?|documentation\b[\s\S]{0,60}\btests?\b(?:\s+not\s+required|\s+optional)?\b/i,
+    label: "docs without tests"
+  }
+];
+function collectMatches(text, patterns) {
+  const matches = [];
+  for (const pattern of patterns) {
+    const regex = new RegExp(pattern.re.source, pattern.re.flags);
+    if (regex.test(text)) {
+      matches.push(pattern);
+    }
+  }
+  return matches;
+}
+function extractOverride(requirements) {
+  for (const requirement of requirements) {
+    const match = requirement.description.match(OVERRIDE_PATTERN);
+    if (match?.[1]) {
+      const candidate = match[1].toLowerCase();
+      if (candidate === "add" || candidate === "pass" || candidate === "both" || candidate === "neither") {
+        return {
+          type: candidate,
+          description: requirement.description.trim()
+        };
+      }
+    }
+  }
+  return void 0;
+}
+function formatEvidence(evidence) {
+  return evidence.map((raw) => raw.replace(/\s+/g, " ").trim());
+}
+function deriveVerificationIntent(context) {
+  const override = extractOverride(context.requirements);
+  const evidence = [];
+  const seen = /* @__PURE__ */ new Set();
+  const addMatchCount = collectMatches(context.prompt, ADD_PATTERNS);
+  const passMatchCount = collectMatches(context.prompt, PASS_PATTERNS);
+  const neitherMatchCount = collectMatches(context.prompt, NEITHER_PATTERNS);
+  const requirementMentionedTests = context.requirements.some((req) => req.type === "tests");
+  const addEvidence = (message) => {
+    if (!seen.has(message)) {
+      seen.add(message);
+      evidence.push(message);
+    }
+  };
+  if (override) {
+    addEvidence(`override: ${override.description}`);
+    return {
+      type: override.type,
+      confidence: 0.95,
+      evidence: formatEvidence(evidence),
+      overrideSource: override.description
+    };
+  }
+  for (const match of addMatchCount) {
+    addEvidence(`add:${match.label}`);
+  }
+  for (const match of passMatchCount) {
+    addEvidence(`pass:${match.label}`);
+  }
+  for (const match of neitherMatchCount) {
+    addEvidence(`neither:${match.label}`);
+  }
+  if (context.testsRequested) addEvidence("testsRequested flag");
+  if (context.isTestIntent) addEvidence("test intent detected");
+  if (context.testExecutionRequested) addEvidence("testExecutionRequested flag");
+  if (context.testExecutionEvidence?.length) {
+    addEvidence(`testExecutionEvidence: ${context.testExecutionEvidence.join(", ")}`);
+  }
+  if (requirementMentionedTests) addEvidence("requirements mention tests");
+  if (context.isAnalysisIntent) addEvidence("analysis intent detected");
+  if (context.intent === "docs") addEvidence("documentation task");
+  let selectedType = "neither";
+  let strength = 0.35;
+  const addScore = Math.min(
+    1,
+    addMatchCount.length * 0.15 + (context.testsRequested ? 0.6 : 0) + (context.isTestIntent ? 0.3 : 0) + (requirementMentionedTests ? 0.3 : 0)
+  );
+  const passScore = Math.min(
+    1,
+    passMatchCount.length * 0.2 + (context.testExecutionRequested ? 0.6 : 0)
+  );
+  const neitherScore = Math.min(
+    1,
+    neitherMatchCount.length * 0.2 + (context.isAnalysisIntent ? 0.5 : 0) + (context.intent === "docs" ? 0.3 : 0)
+  );
+  if (addScore >= 0.6 && passScore >= 0.6) {
+    selectedType = "both";
+    strength = Math.min(1, (addScore + passScore) / 2);
+  } else if (addScore >= 0.6) {
+    selectedType = "add";
+    strength = addScore;
+  } else if (passScore >= 0.6) {
+    selectedType = "pass";
+    strength = passScore;
+  } else if (neitherScore >= 0.35) {
+    selectedType = "neither";
+    strength = Math.max(neitherScore, 0.35);
+  } else {
+    selectedType = "neither";
+    strength = 0.35;
+    addEvidence("no explicit verification directives found (default to neither)");
+  }
+  const confidence = Math.min(0.95, 0.25 + strength * 0.5 + Math.min(0.2, evidence.length * 0.04));
+  return {
+    type: selectedType,
+    confidence,
+    evidence: formatEvidence(evidence)
+  };
+}
+
+// src/core/judge/prompt-spec-parser.ts
+var PROMPT_DESCRIPTION_MAX_LENGTH = 1e4;
+var CODE_FENCE_PATTERN = /```[\s\S]*?```/g;
+var INLINE_CODE_PATTERN = /`[^`]*`/g;
+function buildTaskDescription(prompt) {
+  if (!prompt) {
+    return "";
+  }
+  const lines = prompt.split(/\r?\n/);
+  const keptLines = [];
+  let skippingFileBlock = false;
+  for (const line of lines) {
+    const isMarkerLine = /^\s*(FILES_ONLY|FILES?):/i.test(line);
+    if (isMarkerLine) {
+      skippingFileBlock = true;
+      continue;
+    }
+    if (skippingFileBlock) {
+      if (!line.trim()) {
+        skippingFileBlock = false;
+        continue;
+      }
+      if (/^\s*[-*]\s+\S+/.test(line)) {
+        continue;
+      }
+      const trimmed = line.trim();
+      if (!trimmed.includes(" ") && /[/*.]/.test(trimmed)) {
+        continue;
+      }
+      skippingFileBlock = false;
+    }
+    keptLines.push(line);
+  }
+  const cleaned = keptLines.join("\n").replace(CODE_FENCE_PATTERN, " ").replace(INLINE_CODE_PATTERN, " ").replace(/\s+/g, " ").trim();
+  return cleaned.slice(0, PROMPT_DESCRIPTION_MAX_LENGTH);
+}
+function stripFileAnnotations(path) {
+  let cleaned = path.trim();
+  cleaned = cleaned.replace(/^\s*[-*]\s+/, "").trim();
+  cleaned = cleaned.replace(/\s*\([^)]*\)\s*$/, "").trim();
+  if (/\s/.test(cleaned)) {
+    cleaned = cleaned.split(/\s+/)[0] ?? cleaned;
+  }
+  cleaned = cleaned.replace(/[;,]$/, "").trim();
+  cleaned = cleaned.replace(
+    /\s*\((create|new|modify|update|delete|integrate|optional|required)\)\s*$/i,
+    ""
+  );
+  cleaned = cleaned.trim();
+  if (cleaned === "-" || cleaned === "*") return "";
+  return cleaned;
+}
+function normalizePath(path) {
+  return path.replace(/^\.\//, "").replace(/\/+/g, "/").toLowerCase().trim();
+}
+function extractFilePaths(text) {
+  const paths = /* @__PURE__ */ new Set();
+  const shouldAcceptPathToken = (candidate) => {
+    const trimmed = candidate.trim();
+    if (!trimmed) return false;
+    const looksLikePath = trimmed.startsWith(".") || trimmed.includes("/") || trimmed.includes("\\") || trimmed.includes(".") || /[*?]/.test(trimmed) || trimmed.endsWith("/");
+    const knownRootFiles = /* @__PURE__ */ new Set(["makefile", "dockerfile", "license", "readme"]);
+    if (!looksLikePath && !knownRootFiles.has(trimmed.toLowerCase())) return false;
+    if (/^files?_only:$/i.test(trimmed) || /^files?:$/i.test(trimmed) || /^file:$/i.test(trimmed))
+      return false;
+    if (trimmed.includes(" ") && !trimmed.endsWith("/")) return false;
+    if (trimmed.endsWith(":")) return false;
+    return true;
+  };
+  const backtickPattern = /`([^`]+)`/g;
+  for (; ; ) {
+    const match = backtickPattern.exec(text);
+    if (!match) break;
+    const captured = match[1];
+    if (!captured) continue;
+    const path = stripFileAnnotations(captured.trim());
+    if (path && shouldAcceptPathToken(path)) {
+      paths.add(normalizePath(path));
+    }
+  }
+  const withoutBackticks = text.replace(/`[^`]+`/g, "");
+  const bulletPattern = /^[\s]*[-*]\s+(.+)$/gm;
+  for (; ; ) {
+    const match = bulletPattern.exec(withoutBackticks);
+    if (!match) break;
+    const captured = match[1];
+    if (!captured) continue;
+    const path = stripFileAnnotations(captured.trim());
+    if (path && shouldAcceptPathToken(path)) {
+      paths.add(normalizePath(path));
+    }
+  }
+  const commaSeparated = withoutBackticks.split(/[,\n]/).map((p) => stripFileAnnotations(p.trim())).filter(Boolean);
+  for (const path of commaSeparated) {
+    if (!shouldAcceptPathToken(path)) {
+      continue;
+    }
+    paths.add(normalizePath(path));
+  }
+  return Array.from(paths).filter((p) => p.length > 0);
+}
+function parseFileConstraint(prompt) {
+  const lines = (prompt ?? "").split(/\r?\n/);
+  const hardTargets = [];
+  const softTargets = [];
+  let sawHardMarker = false;
+  let sawSoftMarker = false;
+  let hasNewFileTargets = false;
+  const isBlockBoundary = (line) => {
+    const trimmed = line.trim();
+    if (!trimmed) return true;
+    if (/^#{1,6}\s+/.test(trimmed)) return true;
+    if (/^[A-Za-z0-9_-]+:\s*$/.test(trimmed)) return true;
+    if (/^[A-Z][A-Z0-9 _-]{2,}$/.test(trimmed)) return true;
+    return false;
+  };
+  const collectFollowingBlock = (startIndex, firstLineRemainder) => {
+    const collected = [];
+    if (firstLineRemainder.trim()) collected.push(firstLineRemainder);
+    for (let j = startIndex + 1; j < lines.length; j++) {
+      const line = lines[j] ?? "";
+      if (isBlockBoundary(line)) break;
+      collected.push(line);
+    }
+    return collected.join("\n");
+  };
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i] ?? "";
+    const hardMatch = /^\s*FILES_ONLY:\s*(.*)\s*$/i.exec(line);
+    if (hardMatch) {
+      sawHardMarker = true;
+      const block = collectFollowingBlock(i, hardMatch[1] ?? "");
+      if (/\((?:new|create)\)/i.test(block)) hasNewFileTargets = true;
+      hardTargets.push(...extractFilePaths(block));
+      continue;
+    }
+    const filesMatch = /^\s*FILES:\s*(.*)\s*$/i.exec(line);
+    if (filesMatch) {
+      sawSoftMarker = true;
+      const block = collectFollowingBlock(i, filesMatch[1] ?? "");
+      if (/\((?:new|create)\)/i.test(block)) hasNewFileTargets = true;
+      softTargets.push(...extractFilePaths(block));
+      continue;
+    }
+    const filesWithParenMatch = /^\s*FILES\s*\([^)]*\)\s*:\s*(.*)\s*$/i.exec(line);
+    if (filesWithParenMatch) {
+      sawSoftMarker = true;
+      const block = collectFollowingBlock(i, filesWithParenMatch[1] ?? "");
+      if (/\((?:new|create)\)/i.test(block)) hasNewFileTargets = true;
+      softTargets.push(...extractFilePaths(block));
+      continue;
+    }
+    const fileMatch = /^\s*FILE:\s*(.*)\s*$/i.exec(line);
+    if (fileMatch) {
+      sawSoftMarker = true;
+      const block = collectFollowingBlock(i, fileMatch[1] ?? "");
+      if (/\((?:new|create)\)/i.test(block)) hasNewFileTargets = true;
+      softTargets.push(...extractFilePaths(block));
+      continue;
+    }
+    const inlineFileMatch = /(?:^|[^\w`])FILE:\s*([^\n]+)/i.exec(line);
+    if (inlineFileMatch) {
+      const block = inlineFileMatch[1] ?? "";
+      if (/\((?:new|create)\)/i.test(block)) hasNewFileTargets = true;
+      const extracted = extractFilePaths(block);
+      if (extracted.length > 0) {
+        sawSoftMarker = true;
+        softTargets.push(...extracted);
+      }
+    }
+  }
+  if (hardTargets.length > 0) {
+    return { mode: "hard", targets: Array.from(new Set(hardTargets)), hasNewFileTargets };
+  }
+  if (sawHardMarker) {
+    return { mode: "hard", targets: [], hasNewFileTargets };
+  }
+  if (softTargets.length > 0) {
+    return { mode: "soft", targets: Array.from(new Set(softTargets)), hasNewFileTargets };
+  }
+  if (sawSoftMarker) {
+    return { mode: "soft", targets: [], hasNewFileTargets };
+  }
+  return { mode: "none", targets: [], hasNewFileTargets };
+}
+function parseDeliverableConstraint(prompt) {
+  const lines = (prompt ?? "").split(/\r?\n/);
+  const targets = [];
+  let sawMarker = false;
+  let possibleCollision = false;
+  const isBlockBoundary = (line) => {
+    const trimmed = line.trim();
+    if (!trimmed) return true;
+    if (/^#{1,6}\s+/.test(trimmed)) return true;
+    if (/^[A-Za-z0-9_-]+:\s*$/.test(trimmed)) return true;
+    if (/^[A-Z][A-Z0-9 _-]{2,}$/.test(trimmed)) return true;
+    return false;
+  };
+  const collectFollowingBlock = (startIndex, firstLineRemainder) => {
+    const collected = [];
+    if (firstLineRemainder.trim()) collected.push(firstLineRemainder);
+    for (let j = startIndex + 1; j < lines.length; j++) {
+      const line = lines[j] ?? "";
+      if (isBlockBoundary(line)) break;
+      collected.push(line);
+    }
+    return collected.join("\n");
+  };
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i] ?? "";
+    const deliverableMatch = /^\s*(DELIVERABLES?):\s*(.*)\s*$/i.exec(line);
+    if (deliverableMatch) {
+      sawMarker = true;
+      const rawMarker = deliverableMatch[1] ?? "";
+      if (rawMarker !== rawMarker.toUpperCase()) {
+        possibleCollision = true;
+      }
+      const block = collectFollowingBlock(i, deliverableMatch[2] ?? "");
+      targets.push(...extractFilePaths(block));
+    }
+  }
+  return {
+    specified: sawMarker,
+    targets: Array.from(new Set(targets)),
+    possibleCollision
+  };
+}
+var INTENT_KEYWORDS = {
+  bugfix: /\b(fix|bug|issue|broken|crash|regression|incorrect)\b/i,
+  refactor: /\b(refactor|cleanup|simplify|restructure|rename|improve\s+maintainability)\b/i,
+  feature: /\b(add|implement|introduce|support|new|feature)\b/i,
+  // Note: docs intent is handled by a dedicated heuristic below to avoid
+  // misclassifying code tasks that mention "documentation" (e.g. "Add JSDoc documentation").
+  docs: /\b(docs|readme|changelog|typo|spelling|grammar)\b/i
+};
+function classifyIntent(prompt, fileConstraint) {
+  const lower = prompt.toLowerCase();
+  const hasDocTarget = (fileConstraint?.targets ?? []).some(
+    (t) => t.endsWith(".md") || t.startsWith("docs/")
+  );
+  const hasCodeTarget = (fileConstraint?.targets ?? []).some(
+    (t) => /\.(ts|tsx|js|jsx|py|go|rs|java|c|cpp|cs|rb|php)$/.test(t)
+  );
+  const docsArtifacts = /\b(readme|changelog)\b/i.test(lower) || /(^|\s)docs\//i.test(prompt) || /\.md\b/i.test(lower);
+  const jsDocSignals = /\b(jsdoc|tsdoc)\b/i.test(lower);
+  if (hasDocTarget && !hasCodeTarget && !jsDocSignals) {
+    return "docs";
+  }
+  const strongCodeSignals = hasCodeTarget || /\b(implement|refactor|feature|export|function|class|interface|type|tests?)\b/i.test(lower);
+  if ((hasDocTarget || docsArtifacts) && !strongCodeSignals && !jsDocSignals) {
+    return "docs";
+  }
+  if (jsDocSignals || /\b(code\s+comments?)\b/i.test(lower)) {
+    return "refactor";
+  }
+  if (INTENT_KEYWORDS.bugfix.test(lower)) return "bugfix";
+  if (INTENT_KEYWORDS.refactor.test(lower)) return "refactor";
+  if (INTENT_KEYWORDS.feature.test(lower)) return "feature";
+  if ((hasDocTarget || docsArtifacts) && INTENT_KEYWORDS.docs.test(lower) && !jsDocSignals) {
+    return "docs";
+  }
+  return "bugfix";
+}
+function detectMinimalChangePreference(prompt) {
+  const lower = prompt.toLowerCase();
+  return /\b(minimal|surgical|small\s+change|avoid\s+refactor(ing)?|do\s+not\s+rewrite)\b/.test(
+    lower
+  );
+}
+function detectHardFileConstraintPreference(prompt) {
+  const lower = prompt.toLowerCase();
+  return /\bonly\s+(?:modify|edit|change|touch)\b[^.\n]*\bfiles?\b/.test(lower) || /\bdo\s+not\s+(?:touch|modify|edit|change)\s+any\s+other\s+files?\b/.test(lower) || /\bno\s+other\s+files?\b/.test(lower);
+}
+var EDIT_VERBS = /\b(change|update|remove|replace|add|fix)\b/i;
+function determineEditsRequired(prompt, intent, hasFileMarkers, isReviewOnly) {
+  const intentRequiresEdits = ["bugfix", "refactor", "feature", "docs"].includes(intent);
+  if (hasFileMarkers && !isReviewOnly) {
+    return true;
+  }
+  if (EDIT_VERBS.test(prompt)) {
+    return true;
+  }
+  return intentRequiresEdits;
+}
+function detectExplicitNoEdits(prompt) {
+  return detectExplicitNoEditDirective(prompt);
+}
+function detectAnalysisIntent(prompt) {
+  const lower = prompt.toLowerCase();
+  const analysisPatterns = [
+    /\b(analyze|analyse|review|investigate|audit|evaluate|assess|inspect|examine)\s+(the|this|our|my|a)?\s*\w/,
+    /\b(return|provide|produce)\s+(?:a\s+)?(?:concise\s+)?(?:assessment|analysis|findings?|summary|report)\b/,
+    /\b(find|identify|locate)\s+(where|what|which|the|all|any)/,
+    /\b(explain|describe|document)\s+(how|what|the|this)/,
+    /\bwhat\s+(is|are|causes?|could)\b/,
+    /\bhow\s+(does|do|is|are|can)\b/,
+    /\bwhy\s+(does|do|is|are)\b/
+  ];
+  const codeChangePatterns = [
+    /\b(fix|implement|add|remove|update|change|refactor|modify|create|write)\b/,
+    /\b(then|and)\s+(fix|implement|add|change|update)/
+  ];
+  const hasAnalysisSignal = analysisPatterns.some((p) => p.test(lower));
+  const hasCodeChangeSignal = codeChangePatterns.some((p) => p.test(lower));
+  return hasAnalysisSignal && !hasCodeChangeSignal;
+}
+function detectReviewOnlyIntent(prompt) {
+  const lower = prompt.toLowerCase();
+  const reviewPatterns = [
+    /\b(review|evaluate|assess|analyze|analyse|audit)\s+(the\s+)?(code|implementation|design|architecture|structure|approach|performance|security|quality|logic|flow|api|interface)\b/,
+    /\b(code|implementation|design|architecture|structure|approach|performance|security|quality|logic|flow|api|interface)\s+review\b/
+  ];
+  const reviewAndFixPatterns = [
+    /\b(review|evaluate|assess|analyze|analyse)\s+(?:and|then)\s+(fix|update|change|modify|improve)\b/,
+    /\b(fix|update|change|modify|improve)\s+(?:and|then)\s+(review|evaluate|assess|analyze|analyse)\b/
+  ];
+  const hasReviewPattern = reviewPatterns.some((p) => p.test(lower));
+  const hasReviewAndFix = reviewAndFixPatterns.some((p) => p.test(lower));
+  return hasReviewPattern && !hasReviewAndFix;
+}
+function detectExplicitReviewTask(prompt) {
+  const lower = prompt.toLowerCase();
+  const noEditPatterns = [
+    { re: /\bdo\s+not\s+(write|edit|modify|change)\s+(any\s+)?code\b/, signal: "explicit no-edit" },
+    { re: /\bdon't\s+(write|edit|modify|change)\s+(any\s+)?code\b/, signal: "explicit no-edit" },
+    { re: /\bwithout\s+(writing|editing|modifying|changing)\s+code\b/, signal: "without editing" }
+  ];
+  for (const { re, signal } of noEditPatterns) {
+    if (re.test(lower)) {
+      return { isExplicitReview: true, signal };
+    }
+  }
+  const mixedReviewEditPatterns = [
+    /\b(review|evaluate|assess|analyze|analyse|audit)\b[\s\S]{0,80}\b(and|then)\b[\s\S]{0,40}\b(fix|update|modify|change|implement|add|remove|refactor|write)\b/,
+    /\b(fix|update|modify|change|implement|add|remove|refactor|write)\b[\s\S]{0,80}\b(and|then)\b[\s\S]{0,40}\b(review|evaluate|assess|analyze|analyse|audit)\b/,
+    /\b(review|evaluate|assess|analyze|analyse|audit)\b[\s\S]{0,120}\b(fix|update|modify|change|implement|add|remove|refactor|write)\b[\s\S]{0,40}\b(issue|issues|bug|bugs|problem|problems|regression|regressions|failure|failures)\b/,
+    /\baddress\s+(any\s+)?(issues?|bugs?|problems?|regressions?)\b/,
+    /\bapply\s+(the\s+)?(fix|fixes|changes?)\b/,
+    /\bmake\s+(the\s+)?(fix|fixes|changes?)\b/
+  ];
+  if (mixedReviewEditPatterns.some((re) => re.test(lower))) {
+    return { isExplicitReview: false, signal: "" };
+  }
+  const reviewTargetPatterns = [
+    { re: /\b(review|evaluate|assess)\s+(the\s+)?design\b/, signal: "review design" },
+    { re: /\b(review|evaluate|assess)\s+(the\s+)?code\b/, signal: "review code" },
+    {
+      re: /\b(review|evaluate|assess)\s+(the\s+)?architecture\b/,
+      signal: "review architecture"
+    },
+    {
+      re: /\b(review|evaluate|assess)\s+(the\s+)?implementation\b/,
+      signal: "review implementation"
+    },
+    { re: /\bdesign\s+review\b/, signal: "design review" },
+    { re: /\bcode\s+review\b/, signal: "code review" },
+    { re: /\barchitecture\s+review\b/, signal: "architecture review" }
+  ];
+  for (const { re, signal } of reviewTargetPatterns) {
+    if (re.test(lower)) {
+      return { isExplicitReview: true, signal };
+    }
+  }
+  const analyzePatterns = [
+    { re: /\b(analyze|analyse)\s+(the\s+)?code\b/, signal: "analyze code" },
+    { re: /\b(analyze|analyse)\s+(the\s+)?design\b/, signal: "analyze design" },
+    { re: /\b(analyze|analyse)\s+(the\s+)?implementation\b/, signal: "analyze implementation" },
+    { re: /\b(analyze|analyse)\s+(the\s+)?architecture\b/, signal: "analyze architecture" }
+  ];
+  for (const { re, signal } of analyzePatterns) {
+    if (re.test(lower)) {
+      return { isExplicitReview: true, signal };
+    }
+  }
+  const auditPatterns = [
+    { re: /\baudit\s+(the\s+)?code\b/, signal: "audit code" },
+    { re: /\baudit\s+(the\s+)?architecture\b/, signal: "audit architecture" },
+    { re: /\bcode\s+audit\b/, signal: "code audit" }
+  ];
+  for (const { re, signal } of auditPatterns) {
+    if (re.test(lower)) {
+      return { isExplicitReview: true, signal };
+    }
+  }
+  return { isExplicitReview: false, signal: "" };
+}
+function detectTestsRequested(prompt) {
+  const lower = prompt.toLowerCase();
+  const explicitTestPatterns = [
+    /\badd\s+(corresponding\s+)?tests?\b/,
+    /\bwrite\s+tests?\b/,
+    /\binclude\s+tests?\b/,
+    /\bcreate\s+tests?\b/,
+    /\bimplement\s+tests?\b/,
+    /\bupdate\s+tests?\b/,
+    /\bextend\s+tests?\b/,
+    /\bmodify\s+tests?\b/,
+    /\btests?\s+required\b/,
+    /\bmust\s+(have|include)\s+tests?\b/,
+    /\bunit\s+tests?\b/,
+    /\btest\s+coverage\b/
+  ];
+  const testFilePatterns = [
+    /\.test\.[jt]sx?/,
+    /\.spec\.[jt]sx?/,
+    /__tests__/,
+    /tests?\/unit\//,
+    /tests?\/integration\//
+  ];
+  for (const pattern of explicitTestPatterns) {
+    if (pattern.test(lower)) {
+      return true;
+    }
+  }
+  for (const pattern of testFilePatterns) {
+    if (pattern.test(lower)) {
+      return true;
+    }
+  }
+  return false;
+}
+function detectTestExecutionRequested(prompt) {
+  const lower = prompt.toLowerCase();
+  const lines = lower.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  const evidence = [];
+  const strongPatterns = [
+    { id: "run_tests", re: /\brun(?:ning)?\s+(?:the\s+)?tests?\b/ },
+    { id: "run_test_suite", re: /\brun(?:ning)?\s+(?:the\s+)?test\s+suite\b/ },
+    { id: "execute_tests", re: /\bexecute(?:\s+the)?\s+tests?\b/ },
+    // "Fix failing tests" strongly implies running/verifying the suite.
+    { id: "fix_failing_tests", re: /\bfix\s+(?:the\s+)?(?:failing|broken)\s+tests?\b/ },
+    { id: "fix_test_failures", re: /\bfix\s+test\s+failures\b/ },
+    { id: "tests_must_pass", re: /\btests?\s+(?:must|should)\s+pass\b/ },
+    { id: "test_suite_must_pass", re: /\btest\s+suite\s+(?:must|should)\s+pass\b/ },
+    { id: "ensure_tests_pass", re: /\bensure\s+(?:the\s+)?tests?\s+pass\b/ },
+    { id: "ensure_test_suite_passes", re: /\bensure\s+(?:the\s+)?test\s+suite\s+passes\b/ },
+    { id: "make_tests_pass", re: /\bmake\s+(?:the\s+)?tests?\s+pass\b/ },
+    { id: "verify_tests", re: /\bverify\s+(?:the\s+)?tests?\b/ },
+    { id: "validate_tests", re: /\bvalidate\s+(?:the\s+)?tests?\b/ }
+  ];
+  const negatedTestRun = /\b(do\s+not|don't|dont|never|no\s+need\s+to)\b[\s\S]*\b(run|running|execute|executing|verify|verifying|validate|validating)\b[\s\S]*\b(test(?:s| suite)?)\b/;
+  const runVerb = /\b(run|running|execute|executing|verify|verifying|validate|validating|ensure|make)\b/;
+  const commandSignals = [
+    { id: "command_npm_test", re: /\bnpm\s+test\b/ },
+    { id: "command_pnpm_test", re: /\bpnpm\s+test\b/ },
+    { id: "command_yarn_test", re: /\byarn\s+test\b/ },
+    { id: "command_bun_test", re: /\bbun\s+test\b/ },
+    { id: "command_vitest", re: /\bvitest\b/ },
+    { id: "command_jest", re: /\bjest\b/ },
+    { id: "command_pytest", re: /\bpytest\b|\bpython3?\s+-m\s+pytest\b/ },
+    { id: "command_go_test", re: /\bgo\s+test\b/ },
+    { id: "command_cargo_test", re: /\bcargo\s+test\b/ },
+    { id: "command_jvm_test", re: /\b(?:mvn|mvnw|gradle|gradlew)\b.*\btest\b/ }
+  ];
+  for (const line of lines) {
+    if (negatedTestRun.test(line)) {
+      continue;
+    }
+    for (const { id, re } of strongPatterns) {
+      if (re.test(line)) {
+        evidence.push(id);
+      }
+    }
+    if (!runVerb.test(line)) continue;
+    for (const { id, re } of commandSignals) {
+      if (re.test(line)) {
+        evidence.push(id);
+      }
+    }
+  }
+  return {
+    requested: evidence.length > 0,
+    evidence
+  };
+}
+function detectTestIntent(prompt, fileConstraint) {
+  const lower = prompt.toLowerCase();
+  const allTargetsAreTests = fileConstraint.targets.length > 0 && fileConstraint.targets.every((t) => isProjectTestPath(t));
+  if (allTargetsAreTests) {
+    return true;
+  }
+  const lines = lower.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  const candidates = [];
+  if (lines[0]) {
+    candidates.push(lines[0]);
+  }
+  const taskLineIndex = lines.findIndex((line) => line.startsWith("task:"));
+  if (taskLineIndex !== -1) {
+    const taskLine = lines[taskLineIndex];
+    if (taskLine) {
+      const taskBody = taskLine.replace(/^task:\s*/, "").trim();
+      if (taskBody) {
+        candidates.push(taskBody);
+      } else if (lines[taskLineIndex + 1]) {
+        const nextLine = lines[taskLineIndex + 1];
+        if (nextLine) {
+          candidates.push(nextLine);
+        }
+      }
+    }
+  }
+  const testIntentPatterns = [
+    /^(write|create|add|implement)\s+(unit\s+)?tests?\s+for\b/,
+    /^(run|rerun|execute)\s+(?:the\s+)?tests?\b/,
+    /^(run|rerun|execute)\s+(?:the\s+)?test\s+suite\b/,
+    /^(make|ensure)\s+(?:the\s+)?tests?\s+pass\b/,
+    /^(fix|repair)\s+(?:the\s+)?(?:failing|broken)\s+tests?\b/,
+    /^\s*fix\s+test\s+failures\b/,
+    /\btest\s+suite\s+for\b/,
+    /\bincrease\s+test\s+coverage\b/,
+    /\badd\s+missing\s+tests?\b/,
+    /\btest\s+the\s+\w+\s+(function|class|method|component)\b/,
+    /target:\s*>\d+%\s*coverage/i
+    // Coverage target specification
+  ];
+  for (const candidate of candidates) {
+    for (const pattern of testIntentPatterns) {
+      if (pattern.test(candidate)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function extractCliFlagName(text) {
+  const flagPattern = /--([a-z][a-z0-9-]*)/i;
+  const match = flagPattern.exec(text);
+  return match?.[1] ?? null;
+}
+function isNegativeTestRequirement(text) {
+  const normalized = text.toLowerCase();
+  const negativePatterns = [
+    /\bno\s+(?:new\s+)?tests?\s+required\b/i,
+    /\btests?\s+are\s+not\s+required\b/i,
+    /\btests?\s+not\s+required\b/i,
+    /\bdo\s+not\s+(?:add|write|create|run|execute)\s+(?:any\s+)?tests?\b/i,
+    /\bdon['’]t\s+(?:add|write|create|run|execute)\s+(?:any\s+)?tests?\b/i,
+    /\bwithout\s+(?:adding\s+|running\s+)?tests?\b/i
+  ];
+  return negativePatterns.some((pattern) => pattern.test(normalized));
+}
+function classifyTestRequirementMode(text) {
+  const normalized = text.toLowerCase();
+  const passPatterns = [
+    /\btests?\s+(?:must|should|need(?:s)?|has\s+to|required\s+to)\s+pass\b/i,
+    /\bensure\s+(?:the\s+)?tests?\s+pass\b/i,
+    /\ball\s+tests?\s+pass(?:ing)?\b/i,
+    /\btest\s+suite\s+(?:must|should|need(?:s)?|has\s+to|required\s+to)\s+pass\b/i
+  ];
+  if (passPatterns.some((pattern) => pattern.test(normalized))) {
+    return "pass";
+  }
+  const runPatterns = [
+    /\b(run|execute|verify|validate)\s+(?:the\s+)?tests?\b/i,
+    /\btests?\s+(?:must|should|need(?:s)?|has\s+to|required\s+to)\s+run\b/i,
+    /\btest\s+suite\s+(?:must|should|need(?:s)?|has\s+to|required\s+to)\s+run\b/i
+  ];
+  if (runPatterns.some((pattern) => pattern.test(normalized))) {
+    return "run";
+  }
+  return "presence";
+}
+function parseRequirements(prompt, fileConstraint) {
+  const requirements = [];
+  const checkboxRequirementsByDescription = /* @__PURE__ */ new Map();
+  const requirementBlockPattern = /(?:^|\n)\s*(?:requirements?|must|should):\s*\n((?:\s*(?:[-*]|\d+[.)])(?:[ \t]+.*)?(?:\n|$))+)/gim;
+  for (; ; ) {
+    const match = requirementBlockPattern.exec(prompt);
+    if (!match) break;
+    const blockText = match[1] ?? "";
+    const itemPattern = /^\s*([-*]|\d+[.)])(?:[ \t]+(.*))?$/gm;
+    for (; ; ) {
+      const itemMatch = itemPattern.exec(blockText);
+      if (!itemMatch) break;
+      const rawRequirement = itemMatch[2] || "";
+      let requirement = rawRequirement.trim();
+      let checkboxMeta = null;
+      const checkboxMatch = requirement.match(/^\[([ xX])\]\s*(.*)$/);
+      if (checkboxMatch) {
+        checkboxMeta = { checked: checkboxMatch[1]?.toLowerCase() === "x" };
+        requirement = (checkboxMatch[2] ?? "").trim();
+      }
+      if (requirement.length === 0) {
+        continue;
+      }
+      if (/\btests?\b/i.test(requirement) && !isNegativeTestRequirement(requirement)) {
+        const testRequirementMode = classifyTestRequirementMode(requirement);
+        requirements.push({
+          description: requirement,
+          type: "tests",
+          metadata: checkboxMeta ? {
+            source: "checkbox",
+            checked: checkboxMeta.checked,
+            testRequirementMode
+          } : { testRequirementMode }
+        });
+        continue;
+      }
+      const flagName = extractCliFlagName(requirement);
+      if (flagName) {
+        requirements.push({
+          description: requirement,
+          type: "cli-flag",
+          metadata: checkboxMeta ? { flagName, source: "checkbox", checked: checkboxMeta.checked } : { flagName }
+        });
+      } else {
+        requirements.push({
+          description: requirement,
+          type: "explicit",
+          metadata: checkboxMeta ? { source: "checkbox", checked: checkboxMeta.checked } : void 0
+        });
+      }
+    }
+  }
+  const promptSansCode = (prompt ?? "").replace(CODE_FENCE_PATTERN, "");
+  const checkboxPattern = /^\s*[-*]\s*\[([ xX])\]\s*(.+)$/gm;
+  for (; ; ) {
+    const match = checkboxPattern.exec(promptSansCode);
+    if (!match) break;
+    const checked = (match[1] ?? "").toLowerCase() === "x";
+    const text = String(match[2] ?? "").trim();
+    if (!text) continue;
+    const key = text.toLowerCase();
+    if (checkboxRequirementsByDescription.has(key)) continue;
+    const positiveTestRequirement = /\btests?\b/i.test(text) && !isNegativeTestRequirement(text);
+    const spec = {
+      description: text,
+      type: positiveTestRequirement ? "tests" : "explicit",
+      metadata: positiveTestRequirement ? {
+        source: "checkbox",
+        checked,
+        testRequirementMode: classifyTestRequirementMode(text)
+      } : { source: "checkbox", checked }
+    };
+    checkboxRequirementsByDescription.set(key, spec);
+  }
+  for (const checkboxReq of checkboxRequirementsByDescription.values()) {
+    const alreadyPresent = requirements.some(
+      (r) => r.metadata?.source === "checkbox" && r.description.trim().toLowerCase() === checkboxReq.description.trim().toLowerCase()
+    );
+    if (!alreadyPresent) {
+      requirements.push(checkboxReq);
+    }
+  }
+  const cliFlagContextPattern = /\b(add|implement|support|introduce|create)\s+(a\s+)?(--[a-z][a-z0-9-]*)\s+(flag|option|parameter|argument)/gi;
+  for (; ; ) {
+    const match = cliFlagContextPattern.exec(prompt);
+    if (!match) break;
+    const flagWithDashes = match[3];
+    if (!flagWithDashes) {
+      continue;
+    }
+    const flagName = flagWithDashes.substring(2);
+    const alreadyHasFlag = requirements.some(
+      (r) => r.type === "cli-flag" && r.metadata?.flagName === flagName
+    );
+    if (!alreadyHasFlag) {
+      const kind = match[4] ?? "flag";
+      requirements.push({
+        description: `Implement ${flagWithDashes} ${kind}`,
+        type: "cli-flag",
+        metadata: { flagName }
+      });
+    }
+  }
+  if (fileConstraint.mode !== "none" && fileConstraint.targets.length > 0) {
+    for (const target of fileConstraint.targets) {
+      requirements.push({
+        description: `Modify required file: ${target}`,
+        type: "file-constraint",
+        metadata: { files: [target], mode: "soft" }
+      });
+    }
+    if (fileConstraint.mode === "hard") {
+      const description = `Respect file targets (hard): ${fileConstraint.targets.join(", ")}`;
+      requirements.push({
+        description,
+        type: "file-constraint",
+        metadata: { files: fileConstraint.targets, mode: "hard" }
+      });
+    }
+  }
+  return requirements;
+}
+function parsePromptSpec(prompt, options = {}) {
+  const withoutContext = stripPoeticContextBlocks(prompt ?? "");
+  const normalizedPrompt = withoutContext;
+  const fileConstraintResult = parseFileConstraint(normalizedPrompt);
+  const { hasNewFileTargets, ...fileConstraint } = fileConstraintResult;
+  const deliverableConstraint = parseDeliverableConstraint(normalizedPrompt);
+  if (fileConstraint.mode === "soft" && fileConstraint.targets.length > 0 && detectHardFileConstraintPreference(normalizedPrompt)) {
+    fileConstraint.mode = "hard";
+  }
+  const intent = classifyIntent(normalizedPrompt, fileConstraint);
+  const prefersMinimalChange = detectMinimalChangePreference(normalizedPrompt);
+  const hasFileMarkers = fileConstraint.mode !== "none";
+  const taskDescription = buildTaskDescription(normalizedPrompt);
+  const originalPrompt = normalizedPrompt;
+  const testsRequested = detectTestsRequested(normalizedPrompt);
+  const testExecution = detectTestExecutionRequested(normalizedPrompt);
+  const isTestIntent = detectTestIntent(normalizedPrompt, fileConstraint);
+  const hasExplicitNoEdits = detectExplicitNoEdits(normalizedPrompt);
+  const detectedAnalysisIntent = detectAnalysisIntent(normalizedPrompt);
+  const reviewOnlyIntent = detectReviewOnlyIntent(normalizedPrompt);
+  const explicitReviewDetection = detectExplicitReviewTask(normalizedPrompt);
+  const analysisReviewFlag = JUDGE_FEATURE_FLAGS.ANALYSIS_REVIEW_DETECTION;
+  let isAnalysisIntent = hasExplicitNoEdits || detectedAnalysisIntent && (!hasFileMarkers || hasExplicitNoEdits || reviewOnlyIntent);
+  if (analysisReviewFlag === "on" && explicitReviewDetection.isExplicitReview && hasFileMarkers && !hasExplicitNoEdits && !reviewOnlyIntent) {
+    isAnalysisIntent = true;
+  }
+  if (analysisReviewFlag === "shadow" && explicitReviewDetection.isExplicitReview && hasFileMarkers && !hasExplicitNoEdits && !reviewOnlyIntent && !isAnalysisIntent) {
+  }
+  if (options.analysisMode) {
+    isAnalysisIntent = true;
+  }
+  const editsRequired = isAnalysisIntent ? false : determineEditsRequired(normalizedPrompt, intent, hasFileMarkers, reviewOnlyIntent);
+  const requirements = parseRequirements(normalizedPrompt, fileConstraint);
+  const testRequirements = requirements.filter((r) => r.type === "tests");
+  const testExplicitlyRequired = testRequirements.length > 0;
+  const modeRank = { presence: 1, run: 2, pass: 3 };
+  const strongestTestRequirementMode = testRequirements.reduce(
+    (currentStrongest, requirement) => {
+      const candidate = requirement.metadata?.testRequirementMode ?? "presence";
+      if (!currentStrongest) return candidate;
+      return modeRank[candidate] > modeRank[currentStrongest] ? candidate : currentStrongest;
+    },
+    null
+  );
+  const testRequirementMode = testRequirements.length > 0 ? strongestTestRequirementMode : null;
+  const checkboxPattern = /^\s*[-*]\s*\[([ xX])\]\s*(.+)$/gm;
+  const checkboxMatches = (normalizedPrompt ?? "").replace(CODE_FENCE_PATTERN, "").match(checkboxPattern);
+  const totalCheckboxes = checkboxMatches ? checkboxMatches.length : 0;
+  const parsedCheckboxes = requirements.filter((r) => r.metadata?.source === "checkbox").length;
+  const checklistCoverage = totalCheckboxes > 0 ? Math.min(1, parsedCheckboxes / totalCheckboxes) : 1;
+  const verificationIntent = deriveVerificationIntent({
+    prompt: normalizedPrompt,
+    intent,
+    testsRequested,
+    testExecutionRequested: testExecution.requested,
+    testExecutionEvidence: testExecution.evidence,
+    isTestIntent,
+    isAnalysisIntent,
+    requirements
+  });
+  return {
+    fileConstraint,
+    deliverableConstraint,
+    intent,
+    editsRequired,
+    prefersMinimalChange,
+    taskDescription,
+    originalPrompt,
+    testsRequested,
+    testExecutionRequested: testExecution.requested,
+    testExecutionEvidence: testExecution.evidence,
+    isTestIntent,
+    isAnalysisIntent,
+    requirements,
+    requirementsChecklist: {
+      total: totalCheckboxes,
+      parsed: parsedCheckboxes,
+      coverage: checklistCoverage
+    },
+    verificationIntent,
+    analysisMode: options.analysisMode,
+    testExplicitlyRequired,
+    testRequirementMode,
+    hasNewFileTargets,
+    explicitReviewDetection: explicitReviewDetection.isExplicitReview || analysisReviewFlag === "shadow" ? explicitReviewDetection : void 0
+  };
+}
+
+export {
+  detectExplicitReviewTask,
+  parsePromptSpec
+};
+//# sourceMappingURL=chunk-7T7RUJI7.js.map