@ulpi/cli 0.1.5 → 0.1.6

package/dist/dist-3EIQTZHT.js

@@ -0,0 +1,1380 @@
+import "./chunk-4VNS5WPM.js";
+
+// ../../packages/prd-engine/dist/index.js
+var TITLE_PATTERN = /^#\s+(?:PRD:\s*)?(.+)$/;
+var TASK_HEADING_PATTERN = /^#{2,4}\s+(?:Task:\s*|(?:TASK|US|STORY|EPIC)-\d{1,4}:\s*)(.+)$/i;
+var ID_HEADING_PATTERN = /^#{2,4}\s+((?:TASK|US|STORY|EPIC)-\d{1,4}):\s*(.+)$/i;
+var CHECKLIST_PATTERN = /^[-*]\s+\[[\sx]\]\s+(.+)$/;
+var AC_SECTION_PATTERN = /^#{2,5}\s+Acceptance\s+Criteria|^\*\*Acceptance\s+Criteria[:\*]*\*\*/i;
+var DEPENDS_PATTERN = /\*{0,2}(?:depends?\s+on|depends|prerequisites?|requires):?\*{0,2}\s*(.+)/i;
+var PAREN_DEPENDS_PATTERN = /\(depends?\s+on\s+([^)]+)\)/i;
+var HTML_DEPENDS_PATTERN = /<!--\s*depends?:\s*(.+?)\s*-->/i;
+var LABEL_PATTERN = /\[([a-zA-Z0-9_-]+)\]/g;
+var PRIORITY_PATTERN = /(?:\*\*Priority:\*\*\s*P?|priority:\s*P?)(\d)/i;
+var GWT_PATTERN = /^(?:Given|When|Then|And|But)\s+/i;
+function extractTitle(markdown) {
+  const lines = markdown.split("\n");
+  for (const line of lines) {
+    const match = line.match(TITLE_PATTERN);
+    if (match) {
+      return match[1]?.trim() ?? "Untitled PRD";
+    }
+  }
+  return "Untitled PRD";
+}
+function extractDescription(markdown) {
+  const overviewMatch = markdown.match(
+    /^##\s+Overview\s*\n+([\s\S]*?)(?=\n##|\n---|\n$)/m
+  );
+  if (overviewMatch?.[1]) {
+    return overviewMatch[1].trim();
+  }
+  const lines = markdown.split("\n");
+  let foundTitle = false;
+  const descLines = [];
+  for (const line of lines) {
+    if (line.match(TITLE_PATTERN)) {
+      foundTitle = true;
+      continue;
+    }
+    if (foundTitle && !line.startsWith("#") && !line.startsWith(">")) {
+      if (line.trim()) {
+        descLines.push(line.trim());
+      } else if (descLines.length > 0) {
+        break;
+      }
+    }
+  }
+  return descLines.join(" ").trim() || "No description";
+}
+function extractSections(markdown) {
+  const lines = markdown.split("\n");
+  const sections = [];
+  let currentSection = null;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i] ?? "";
+    const headingMatch = line.match(/^(#{1,6})\s+(.+)$/);
+    if (headingMatch) {
+      if (currentSection) {
+        const content = lines.slice(currentSection.startLine + 1, i).join("\n").trim();
+        sections.push({
+          heading: currentSection.heading,
+          level: currentSection.level,
+          content,
+          tasks: []
+        });
+      }
+      currentSection = {
+        heading: headingMatch[2]?.trim() ?? "",
+        level: headingMatch[1]?.length ?? 1,
+        startLine: i
+      };
+    }
+  }
+  if (currentSection) {
+    const content = lines.slice(currentSection.startLine + 1).join("\n").trim();
+    sections.push({
+      heading: currentSection.heading,
+      level: currentSection.level,
+      content,
+      tasks: []
+    });
+  }
+  return sections;
+}
+function generateTaskId(prefix, index) {
+  return `${prefix}${String(index).padStart(3, "0")}`;
+}
+function extractCriteria(text) {
+  const criteria = [];
+  const lines = text.split("\n");
+  let inAcSection = false;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (AC_SECTION_PATTERN.test(trimmed)) {
+      inAcSection = true;
+      continue;
+    }
+    if (inAcSection && /^#{2,5}\s+/.test(trimmed) && !AC_SECTION_PATTERN.test(trimmed)) {
+      break;
+    }
+    if (inAcSection && /^\*\*(?!Acceptance)/.test(trimmed)) {
+      break;
+    }
+    if (inAcSection) {
+      const checkMatch = trimmed.match(CHECKLIST_PATTERN);
+      if (checkMatch?.[1]) {
+        criteria.push(checkMatch[1].trim());
+        continue;
+      }
+      const bulletMatch = trimmed.match(/^[-*]\s+(.+)$/);
+      if (bulletMatch?.[1] && !bulletMatch[1].startsWith("[")) {
+        criteria.push(bulletMatch[1].trim());
+        continue;
+      }
+      const numberedMatch = trimmed.match(/^\d+\.\s+(.+)$/);
+      if (numberedMatch?.[1]) {
+        criteria.push(numberedMatch[1].trim());
+        continue;
+      }
+      if (GWT_PATTERN.test(trimmed)) {
+        criteria.push(trimmed);
+        continue;
+      }
+    }
+  }
+  if (criteria.length === 0) {
+    for (const line of lines) {
+      const acMatch = line.trim().match(/^[-*]\s+\[AC\]\s+(.+)$/i);
+      if (acMatch?.[1]) {
+        criteria.push(acMatch[1].trim());
+      }
+    }
+  }
+  return criteria;
+}
+function extractLabels(text) {
+  const labels = [];
+  let match;
+  LABEL_PATTERN.lastIndex = 0;
+  while ((match = LABEL_PATTERN.exec(text)) !== null) {
+    const label = match[1];
+    if (label && !["x", " ", "AC"].includes(label)) {
+      labels.push(label);
+    }
+  }
+  return [...new Set(labels)];
+}
+var TASK_ID_PATTERN = /^(?:TASK|US|STORY|EPIC)-\d{1,4}$/i;
+function cleanDepRef(raw) {
+  const cleaned = raw.replace(/\*{1,2}/g, "").replace(/`/g, "").trim();
+  if (!cleaned || /^[\s(]*none|^[\s(]*n\/?a|^[\s(]*\(/i.test(cleaned)) {
+    return null;
+  }
+  if (!TASK_ID_PATTERN.test(cleaned)) {
+    return null;
+  }
+  return cleaned.toUpperCase();
+}
+function extractDependencies(text) {
+  const deps = [];
+  const lines = text.split("\n");
+  for (const line of lines) {
+    const inlineMatch = line.match(DEPENDS_PATTERN);
+    if (inlineMatch?.[1]) {
+      const parsed = inlineMatch[1].split(/[,;]\s*/).map(cleanDepRef).filter((d) => d !== null);
+      deps.push(...parsed);
+    }
+    const parenMatch = line.match(PAREN_DEPENDS_PATTERN);
+    if (parenMatch?.[1]) {
+      const parsed = parenMatch[1].split(/[,;]\s*/).map(cleanDepRef).filter((d) => d !== null);
+      deps.push(...parsed);
+    }
+    const htmlMatch = line.match(HTML_DEPENDS_PATTERN);
+    if (htmlMatch?.[1]) {
+      const parsed = htmlMatch[1].split(/[,;]\s*/).map(cleanDepRef).filter((d) => d !== null);
+      deps.push(...parsed);
+    }
+  }
+  return [...new Set(deps)];
+}
+function extractPriority(text) {
+  const match = text.match(PRIORITY_PATTERN);
+  if (match?.[1]) {
+    const p = parseInt(match[1], 10);
+    if (!isNaN(p) && p >= 1 && p <= 4) {
+      return p;
+    }
+  }
+  return 2;
+}
+function extractDependencyMap(markdown) {
+  const sectionMatch = markdown.match(
+    /##\s+Task\s+Dependencies\s*\n+```json\s*\n([\s\S]*?)\n```/i
+  );
+  if (!sectionMatch?.[1]) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(sectionMatch[1]);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      return null;
+    }
+    const depMap = /* @__PURE__ */ new Map();
+    for (const [taskId, deps] of Object.entries(parsed)) {
+      if (Array.isArray(deps)) {
+        depMap.set(
+          taskId.toUpperCase(),
+          deps.filter((d) => typeof d === "string" && d.length > 0).map((d) => d.toUpperCase())
+        );
+      }
+    }
+    return depMap.size > 0 ? depMap : null;
+  } catch {
+    return null;
+  }
+}
+function extractTasks(markdown, sections, prefix) {
+  const tasks = [];
+  let taskCounter = 0;
+  const lines = markdown.split("\n");
+  let currentTask = null;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i] ?? "";
+    const idMatch = line.match(ID_HEADING_PATTERN);
+    if (idMatch) {
+      if (currentTask) {
+        const sectionText = lines.slice(currentTask.startLine + 1, i).join("\n");
+        tasks.push(buildTask(currentTask.id, currentTask.title, sectionText));
+      }
+      currentTask = {
+        id: idMatch[1]?.toUpperCase() ?? "",
+        title: idMatch[2]?.trim() ?? "",
+        startLine: i
+      };
+      continue;
+    }
+    const taskMatch = line.match(TASK_HEADING_PATTERN);
+    if (taskMatch && !idMatch) {
+      if (currentTask) {
+        const sectionText = lines.slice(currentTask.startLine + 1, i).join("\n");
+        tasks.push(buildTask(currentTask.id, currentTask.title, sectionText));
+      }
+      taskCounter++;
+      currentTask = {
+        id: generateTaskId(prefix, taskCounter),
+        title: taskMatch[1]?.trim() ?? "",
+        startLine: i
+      };
+    }
+  }
+  if (currentTask) {
+    const sectionText = lines.slice(currentTask.startLine + 1).join("\n");
+    tasks.push(buildTask(currentTask.id, currentTask.title, sectionText));
+  }
+  if (tasks.length === 0) {
+    const tasksSections = sections.filter(
+      (s) => /^tasks?$/i.test(s.heading.trim())
+    );
+    for (const section of tasksSections) {
+      const sectionLines = section.content.split("\n");
+      for (const sectionLine of sectionLines) {
+        const checkMatch = sectionLine.match(CHECKLIST_PATTERN);
+        if (checkMatch?.[1]) {
+          taskCounter++;
+          tasks.push({
+            id: generateTaskId(prefix, taskCounter),
+            title: checkMatch[1].trim(),
+            description: checkMatch[1].trim(),
+            acceptanceCriteria: [],
+            dependsOn: extractDependencies(checkMatch[1]),
+            priority: taskCounter,
+            labels: extractLabels(checkMatch[1])
+          });
+        }
+      }
+    }
+  }
+  if (tasks.length === 0) {
+    const tasksSections = sections.filter(
+      (s) => /^tasks?$/i.test(s.heading.trim())
+    );
+    for (const section of tasksSections) {
+      const sectionLines = section.content.split("\n");
+      for (const sectionLine of sectionLines) {
+        const numberedMatch = sectionLine.match(/^\d+\.\s+(.+)$/);
+        if (numberedMatch?.[1]) {
+          taskCounter++;
+          tasks.push({
+            id: generateTaskId(prefix, taskCounter),
+            title: numberedMatch[1].trim(),
+            description: numberedMatch[1].trim(),
+            acceptanceCriteria: [],
+            dependsOn: extractDependencies(numberedMatch[1]),
+            priority: taskCounter,
+            labels: extractLabels(numberedMatch[1])
+          });
+        }
+      }
+    }
+  }
+  return tasks;
+}
+function buildTask(id, title, sectionText) {
+  const descLines = [];
+  const textLines = sectionText.split("\n");
+  for (const line of textLines) {
+    const trimmed = line.trim();
+    if (!trimmed && descLines.length > 0) break;
+    if (AC_SECTION_PATTERN.test(trimmed)) break;
+    if (/^\*\*(?:Acceptance|Priority|Depends|Labels|Notes):/.test(trimmed)) break;
+    if (/^#{2,5}\s+/.test(trimmed)) break;
+    if (trimmed) {
+      descLines.push(trimmed.replace(/^\*\*Description:\*\*\s*/, ""));
+    }
+  }
+  const description = descLines.join(" ").replace(/\*\*([^*]+)\*\*/g, "$1").trim() || title;
+  return {
+    id,
+    title,
+    description,
+    acceptanceCriteria: extractCriteria(sectionText),
+    dependsOn: extractDependencies(sectionText),
+    priority: extractPriority(sectionText),
+    labels: extractLabels(sectionText)
+  };
+}
+function parsePrdMarkdown(markdown, options = {}) {
+  const warnings = [];
+  const prefix = options.taskPrefix ?? "TASK-";
+  const title = extractTitle(markdown);
+  const description = extractDescription(markdown);
+  const sections = extractSections(markdown);
+  const tasks = extractTasks(markdown, sections, prefix);
+  if (tasks.length === 0) {
+    warnings.push(`No tasks found in PRD. Expected headings like "## Task: Title" or checklist items under a "Tasks" section.`);
+  }
+  const depMap = extractDependencyMap(markdown);
+  if (depMap) {
+    for (const task of tasks) {
+      const deps = depMap.get(task.id.toUpperCase());
+      if (deps !== void 0) {
+        task.dependsOn = deps;
+      }
+    }
+  }
+  for (const task of tasks) {
+    if (task.acceptanceCriteria.length === 0) {
+      warnings.push(`Task ${task.id} (${task.title}) has no acceptance criteria.`);
+    }
+  }
+  const sectionsWithTasks = sections.map((section) => ({
+    ...section,
+    tasks: tasks.filter(
+      (t) => section.content.includes(t.title) || section.content.includes(t.id)
+    )
+  }));
+  const metadata = {};
+  const branchMatch = markdown.match(/^>\s*Branch:\s*`?([^`\n]+)`?/m);
+  if (branchMatch?.[1]) {
+    metadata.branchName = branchMatch[1].trim();
+  }
+  const dateMatch = markdown.match(/^>\s*Generated:\s*(.+)$/m);
+  if (dateMatch?.[1]) {
+    metadata.createdAt = dateMatch[1].trim();
+  }
+  const document = {
+    title,
+    description,
+    sections: sectionsWithTasks,
+    tasks,
+    metadata
+  };
+  return { document, warnings };
+}
+var PRD_CHAT_PROMPT = `You are an expert product engineer helping create a Product Requirements Document (PRD) through conversation.
+
+## Conversation Strategy
+
+1. **Progressive refinement** \u2014 ask 3-5 adaptive clarifying questions, one set at a time. Do NOT ask all questions upfront.
+2. **Adapt to answers** \u2014 each follow-up question set should build on previous responses. Dig deeper into areas of ambiguity or risk.
+3. **Infer context** \u2014 if the user provides a brief description, infer reasonable defaults and confirm them rather than asking from scratch.
+4. **Know when to stop** \u2014 after 2-3 rounds of questions, generate the PRD. Do not over-question.
+
+## Question Categories (pick 3-5 per round)
+
+- **Scope:** What exactly should this feature do? What is explicitly out of scope?
+- **Users:** Who uses this? What is their current workflow?
+- **Technical:** Are there existing systems this integrates with? What constraints exist?
+- **Dependencies:** What must be built first? Are there external dependencies?
+- **Risks:** What could go wrong? What are the edge cases?
+
+## PRD Output Format
+
+When you have enough context, generate the complete PRD wrapped in [PRD]...[/PRD] markers.
+
+The PRD must include:
+- Title: \`# PRD: Feature Name\`
+- \`## Overview\` section with description and target users
+- \`## Tasks\` section with structured task headings
+
+Each task must follow this format:
+
+\`\`\`
+### TASK-NNN: Title
+
+Description of what this task involves, scoped to specific files or areas.
+
+**Acceptance Criteria:**
+- [ ] Criterion 1
+- [ ] Criterion 2
+
+**Priority:** P1
+\`\`\`
+
+After ALL tasks, add a \`## Task Dependencies\` section with a JSON block declaring ALL dependencies:
+
+\`\`\`
+## Task Dependencies
+
+\\\`\\\`\\\`json
+{
+  "TASK-001": [],
+  "TASK-002": ["TASK-001"],
+  "TASK-003": ["TASK-001", "TASK-002"],
+  "TASK-004": [],
+  "TASK-005": ["TASK-004"]
+}
+\\\`\\\`\\\`
+\`\`\`
+
+CRITICAL: The \`## Task Dependencies\` JSON block is REQUIRED. It is machine-parsed to schedule parallel execution. Every task ID must appear as a key. Tasks with no dependencies use an empty array \`[]\`. Dependencies list task IDs that MUST complete before that task can start.
+
+## Task Design Principles
+
+- **Decompose into discrete tasks** \u2014 each task should be completable independently (given its dependencies).
+- **Assign priorities P1-P4:** P1 = critical path, P2 = important, P3 = nice-to-have, P4 = future.
+- **Group for parallel execution** \u2014 independent tasks with no mutual dependencies can run in parallel.
+- **Map dependencies explicitly** \u2014 in the Task Dependencies JSON block. Over-constraining reduces parallelism.
+- **Scope to specific areas** \u2014 reference file paths, modules, or components in task descriptions.
+
+The user can respond with shorthand for quick iteration.
+`;
+var PRD_GENERATION_PROMPT = `You are an autonomous product engineer generating a Product Requirements Document (PRD).
+
+## Your Mission
+
+You will receive a feature description. Your job is to:
+
+1. **Explore the codebase first** \u2014 read package.json, key config files, directory structure, and relevant source files to understand the project architecture.
+2. **Understand the existing patterns** \u2014 identify frameworks, conventions, file organization, and testing patterns in use.
+3. **Decompose the feature** into well-scoped tasks that reference specific files and areas found in the codebase.
+4. **Map dependencies** using actual file and module relationships you discover.
+5. **Write the PRD file** to the specified output path using the Write tool.
+
+## Important Rules
+
+- Work **autonomously** \u2014 do NOT ask questions or wait for interaction.
+- Base your task decomposition on **actual codebase analysis**, not assumptions.
+- Each task should reference **specific files, directories, or modules** you found during exploration.
+- Ensure the output is **parseable** by the PRD parser (follow the exact format below).
+
+## PRD Output Format
+
+Write a markdown file with this exact structure:
+
+\`\`\`markdown
+# PRD: Feature Name
+
+## Overview
+
+High-level description of the feature, its purpose, and target users.
+
+## Tasks
+
+### TASK-001: Title
+
+Description scoped to specific files/areas found in the codebase.
+
+**Acceptance Criteria:**
+- [ ] Criterion 1
+- [ ] Criterion 2
+
+**Priority:** P1
+
+---
+
+### TASK-002: Title
+
+Description...
+
+**Acceptance Criteria:**
+- [ ] Criterion 1
+
+**Priority:** P1
+
+---
+
+## Task Dependencies
+
+\\\`\\\`\\\`json
+{
+  "TASK-001": [],
+  "TASK-002": ["TASK-001"]
+}
+\\\`\\\`\\\`
+\`\`\`
+
+CRITICAL: The \`## Task Dependencies\` section with the JSON block is REQUIRED at the end of the PRD. It is machine-parsed to schedule parallel execution. Every task ID must appear as a key. Tasks with no dependencies use an empty array \`[]\`. Dependencies list task IDs that MUST complete before that task can start.
+
+## Task Design Principles
+
+- **Atomic tasks** \u2014 each task should be completable in a single focused session. If a task has >3 acceptance criteria, consider splitting it.
+- **File-scoped** \u2014 reference specific files or directories in the description (e.g., "Update \`src/api/routes.ts\` to add...").
+- **Priority P1-P4:** P1 = must-have for MVP, P2 = important, P3 = enhancement, P4 = future/optional.
+- **Parallel-friendly** \u2014 tasks with no mutual dependencies can run in parallel.
+- **Dependency accuracy** \u2014 only declare dependencies that are truly blocking. Over-constraining reduces parallelism.
+`;
+function getPrdSystemPrompt() {
+  return PRD_CHAT_PROMPT;
+}
+function getPrdGenerationPrompt() {
+  return PRD_GENERATION_PROMPT;
+}
+function buildPrdGenerationPrompt(featureDescription, options) {
+  const parts = [];
+  parts.push("## Instructions\n");
+  parts.push(PRD_GENERATION_PROMPT);
+  parts.push("");
+  parts.push("## Feature Request\n");
+  parts.push(featureDescription);
+  parts.push("");
+  const outputDir = options?.outputDir ?? ".ulpi/prds";
+  const slug = options?.slug ?? "generated-prd";
+  const outputPath = `${outputDir}/prd-${slug}.md`;
+  parts.push("## Output\n");
+  parts.push(`Write the PRD to: \`${outputPath}\``);
+  parts.push("Use the Write tool to create the file at this path.");
+  return parts.join("\n");
+}
+function detectPrd(response) {
+  const markerMatch = response.match(/\[PRD\]([\s\S]+?)\[\/PRD\]/);
+  if (markerMatch?.[1]) {
+    const content = markerMatch[1].trim();
+    const nameMatch = content.match(/^#\s+(?:PRD:\s*)?(.+?)[\n\r]/m);
+    return {
+      found: true,
+      content,
+      featureName: nameMatch?.[1]?.trim() ?? "Untitled Feature"
+    };
+  }
+  const prdMatch = response.match(/# PRD:\s*(.+?)[\n\r]([\s\S]+)$/);
+  if (prdMatch?.[1] && prdMatch[2]) {
+    return {
+      found: true,
+      content: `# PRD: ${prdMatch[1]}
+${prdMatch[2]}`.trim(),
+      featureName: prdMatch[1].trim()
+    };
+  }
+  return { found: false };
+}
+function buildConversationPrompt(history, userMessage, maxHistory = 50) {
+  const parts = [];
+  parts.push("## Instructions\n");
+  parts.push(PRD_CHAT_PROMPT);
+  parts.push("");
+  const historySlice = history.slice(-maxHistory);
+  if (historySlice.length > 0) {
+    parts.push("## Conversation History\n");
+    for (const msg of historySlice) {
+      if (msg.role === "user") {
+        parts.push(`User: ${msg.content}`);
+      } else if (msg.role === "assistant") {
+        parts.push(`Assistant: ${msg.content}`);
+      }
+    }
+    parts.push("");
+  }
+  parts.push("## Current Request\n");
+  parts.push(userMessage);
+  return parts.join("\n");
+}
+function slugify(text) {
+  return text.toLowerCase().trim().replace(/[^\w\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+}
+function renderPrdMarkdown(doc) {
+  const lines = [];
+  lines.push(`# PRD: ${doc.title}`);
+  lines.push("");
+  if (doc.metadata.createdAt) {
+    lines.push(`> Generated: ${doc.metadata.createdAt}`);
+  }
+  if (doc.metadata.branchName) {
+    lines.push(`> Branch: \`${doc.metadata.branchName}\``);
+  }
+  if (doc.metadata.createdAt || doc.metadata.branchName) {
+    lines.push("");
+  }
+  lines.push("## Overview");
+  lines.push("");
+  lines.push(doc.description);
+  lines.push("");
+  if (doc.tasks.length > 0) {
+    lines.push("## Tasks");
+    lines.push("");
+    for (const task of doc.tasks) {
+      lines.push(`### ${task.id}: ${task.title}`);
+      lines.push("");
+      lines.push(task.description);
+      lines.push("");
+      if (task.acceptanceCriteria.length > 0) {
+        lines.push("**Acceptance Criteria:**");
+        for (const criterion of task.acceptanceCriteria) {
+          lines.push(`- [ ] ${criterion}`);
+        }
+        lines.push("");
+      }
+      if (task.labels.length > 0) {
+        lines.push(`**Labels:** ${task.labels.map((l) => `[${l}]`).join(" ")}`);
+        lines.push("");
+      }
+      lines.push(`**Priority:** P${task.priority}`);
+      lines.push("");
+      lines.push("---");
+      lines.push("");
+    }
+    const depObj = {};
+    for (const task of doc.tasks) {
+      depObj[task.id] = [...task.dependsOn];
+    }
+    lines.push("## Task Dependencies");
+    lines.push("");
+    lines.push("```json");
+    lines.push(JSON.stringify(depObj, null, 2));
+    lines.push("```");
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function processPrdResponse(response) {
+  const detection = detectPrd(response);
+  if (!detection.found || !detection.content) {
+    return null;
+  }
+  const parsed = parsePrdMarkdown(detection.content);
+  return parsed.document;
+}
+function extractFilePaths(text) {
+  const patterns = [
+    /`([^`]+\.[a-zA-Z]{1,5})`/g,
+    // `path/to/file.ext`
+    /(?:^|\s)([\w./\\-]+\.[a-zA-Z]{2,5})/gm,
+    // bare file.ext references
+    /(?:src|lib|app|packages?|modules?)\/[\w./-]+/g
+    // src/... style paths
+  ];
+  const paths = /* @__PURE__ */ new Set();
+  for (const pattern of patterns) {
+    let match;
+    pattern.lastIndex = 0;
+    while ((match = pattern.exec(text)) !== null) {
+      const candidate = match[1] ?? match[0];
+      if (candidate && candidate.length > 2 && !candidate.startsWith("http")) {
+        paths.add(candidate.trim());
+      }
+    }
+  }
+  return Array.from(paths);
+}
+function hasCyclicDeps(tasks) {
+  const taskIds = new Set(tasks.map((t) => t.id));
+  const visited = /* @__PURE__ */ new Set();
+  const inStack = /* @__PURE__ */ new Set();
+  function dfs(id) {
+    if (inStack.has(id)) return true;
+    if (visited.has(id)) return false;
+    visited.add(id);
+    inStack.add(id);
+    const task = tasks.find((t) => t.id === id);
+    if (task) {
+      for (const dep of task.dependsOn) {
+        if (taskIds.has(dep) && dfs(dep)) return true;
+      }
+    }
+    inStack.delete(id);
+    return false;
+  }
+  for (const task of tasks) {
+    if (dfs(task.id)) return true;
+  }
+  return false;
+}
+function computeParallelism(tasks) {
+  if (tasks.length === 0) return 0;
+  const taskIds = new Set(tasks.map((t) => t.id));
+  const independent = tasks.filter(
+    (t) => t.dependsOn.length === 0 || t.dependsOn.every((d) => !taskIds.has(d))
+  );
+  return independent.length / tasks.length;
+}
+function scoreTaskAtomicity(tasks) {
+  if (tasks.length === 0) {
+    return { name: "Task Atomicity", score: 0, found: false, details: "No tasks found" };
+  }
+  let totalPenalty = 0;
+  const issues = [];
+  for (const task of tasks) {
+    let penalty = 0;
+    if (task.acceptanceCriteria.length > 3) {
+      penalty += Math.min(30, (task.acceptanceCriteria.length - 3) * 10);
+      issues.push(`${task.id} has ${task.acceptanceCriteria.length} criteria (consider splitting)`);
+    }
+    if (task.description.length > 500) {
+      penalty += Math.min(20, Math.floor((task.description.length - 500) / 100) * 5);
+    }
+    const vaguePatterns = /^(implement|build|create|add|update|fix)\s+(the\s+)?feature$/i;
+    if (vaguePatterns.test(task.title)) {
+      penalty += 20;
+      issues.push(`${task.id} has a vague title`);
+    }
+    totalPenalty += penalty;
+  }
+  const avgPenalty = totalPenalty / tasks.length;
+  const score = Math.max(0, Math.round(100 - avgPenalty));
+  return {
+    name: "Task Atomicity",
+    score,
+    found: true,
+    details: issues.length > 0 ? issues.slice(0, 3).join("; ") : "Tasks are well-scoped"
+  };
+}
+function scoreTaskDecoupling(tasks) {
+  if (tasks.length <= 1) {
+    return { name: "Task Decoupling", score: 100, found: true, details: "Single task or empty" };
+  }
+  const taskFiles = /* @__PURE__ */ new Map();
+  for (const task of tasks) {
+    const fullText = `${task.title} ${task.description} ${task.acceptanceCriteria.join(" ")}`;
+    const files = extractFilePaths(fullText);
+    taskFiles.set(task.id, new Set(files));
+  }
+  let overlapCount = 0;
+  let pairCount = 0;
+  const taskList = Array.from(taskFiles.entries());
+  for (let i = 0; i < taskList.length; i++) {
+    for (let j = i + 1; j < taskList.length; j++) {
+      pairCount++;
+      const filesA = taskList[i][1];
+      const filesB = taskList[j][1];
+      for (const file of filesA) {
+        if (filesB.has(file)) {
+          overlapCount++;
+          break;
+        }
+      }
+    }
+  }
+  if (pairCount === 0) {
+    return { name: "Task Decoupling", score: 100, found: true };
+  }
+  const overlapRatio = overlapCount / pairCount;
+  const score = Math.max(0, Math.round(100 - overlapRatio * 100));
+  return {
+    name: "Task Decoupling",
+    score,
+    found: true,
+    details: overlapCount > 0 ? `${overlapCount} task pair(s) reference the same files` : "No file overlap between tasks"
+  };
+}
+function scoreDependencyClarity(tasks) {
+  if (tasks.length === 0) {
+    return { name: "Dependency Clarity", score: 0, found: false, details: "No tasks found" };
+  }
+  const taskIds = new Set(tasks.map((t) => t.id));
+  const issues = [];
+  let danglingCount = 0;
+  for (const task of tasks) {
+    for (const dep of task.dependsOn) {
+      if (!taskIds.has(dep)) {
+        danglingCount++;
+        issues.push(`${task.id} depends on non-existent ${dep}`);
+      }
+    }
+  }
+  const hasCycles = hasCyclicDeps(tasks);
+  if (hasCycles) {
+    issues.push("Circular dependency detected");
+  }
+  let score = 100;
+  score -= danglingCount * 15;
+  if (hasCycles) score -= 30;
+  score = Math.max(0, Math.round(score));
+  return {
+    name: "Dependency Clarity",
+    score,
+    found: true,
+    details: issues.length > 0 ? issues.slice(0, 3).join("; ") : "All dependencies are valid"
+  };
+}
+function scoreTaskScope(tasks) {
+  if (tasks.length === 0) {
+    return { name: "Task Scope", score: 0, found: false, details: "No tasks found" };
+  }
+  let scopedCount = 0;
+  for (const task of tasks) {
+    const fullText = `${task.title} ${task.description}`;
+    const files = extractFilePaths(fullText);
+    const hasSpecificRef = files.length > 0 || /(?:module|component|package|service|handler|controller|route|model|schema|hook|util)/i.test(fullText);
+    if (hasSpecificRef) {
+      scopedCount++;
+    }
+  }
+  const ratio = scopedCount / tasks.length;
+  const score = Math.round(ratio * 100);
+  return {
+    name: "Task Scope",
+    score,
+    found: true,
+    details: `${scopedCount}/${tasks.length} tasks reference specific files or areas`
+  };
+}
+function scoreParallelPotential(tasks) {
+  if (tasks.length <= 1) {
+    return { name: "Parallel Potential", score: 100, found: true, details: "Single task" };
+  }
+  const parallelism = computeParallelism(tasks);
+  const score = Math.round(parallelism * 100);
+  const taskIds = new Set(tasks.map((t) => t.id));
+  const independent = tasks.filter(
+    (t) => t.dependsOn.length === 0 || t.dependsOn.every((d) => !taskIds.has(d))
+  );
+  return {
+    name: "Parallel Potential",
+    score,
+    found: true,
+    details: `${independent.length}/${tasks.length} tasks can run independently`
+  };
+}
+function scoreAcceptanceCriteria(tasks) {
+  if (tasks.length === 0) {
+    return { name: "Acceptance Criteria", score: 0, found: false, details: "No tasks found" };
+  }
+  let totalScore = 0;
+  const issues = [];
+  for (const task of tasks) {
+    if (task.acceptanceCriteria.length === 0) {
+      issues.push(`${task.id} has no acceptance criteria`);
+    } else if (task.acceptanceCriteria.length === 1) {
+      totalScore += 50;
+    } else {
+      totalScore += 100;
+    }
+  }
+  const score = Math.round(totalScore / tasks.length);
+  return {
+    name: "Acceptance Criteria",
+    score,
+    found: true,
+    details: issues.length > 0 ? issues.slice(0, 3).join("; ") : "All tasks have acceptance criteria"
+  };
+}
+function scorePriorityDistribution(tasks) {
+  if (tasks.length === 0) {
+    return { name: "Priority Distribution", score: 0, found: false, details: "No tasks found" };
+  }
+  const priorities = tasks.map((t) => t.priority);
+  const uniquePriorities = new Set(priorities);
+  const issues = [];
+  let penalty = 0;
+  if (uniquePriorities.size === 1 && tasks.length > 2) {
+    penalty += 30;
+    issues.push(`All ${tasks.length} tasks have the same priority P${priorities[0]}`);
+  }
+  for (const task of tasks) {
+    if (task.priority === 1) {
+      for (const depId of task.dependsOn) {
+        const depTask = tasks.find((t) => t.id === depId);
+        if (depTask && depTask.priority > 2) {
+          penalty += 15;
+          issues.push(`P1 ${task.id} depends on P${depTask.priority} ${depId}`);
+        }
+      }
+    }
+  }
+  if (uniquePriorities.size >= 3 && tasks.length >= 4) {
+    penalty = Math.max(0, penalty - 10);
+  }
+  const score = Math.max(0, Math.round(100 - penalty));
+  return {
+    name: "Priority Distribution",
+    score,
+    found: true,
+    details: issues.length > 0 ? issues.slice(0, 3).join("; ") : `${uniquePriorities.size} priority levels across ${tasks.length} tasks`
+  };
+}
+function scoreCompleteness(doc) {
+  let score = 0;
+  const issues = [];
+  if (doc.description && doc.description !== "No description") {
+    score += 25;
+  } else {
+    issues.push("Missing overview/description");
+  }
+  if (doc.tasks.length >= 2) {
+    score += 25;
+  } else if (doc.tasks.length === 1) {
+    score += 15;
+    issues.push("Only 1 task found (consider splitting)");
+  } else {
+    issues.push("No tasks found");
+  }
+  const withDesc = doc.tasks.filter((t) => t.description && t.description !== t.title);
+  if (doc.tasks.length > 0 && withDesc.length === doc.tasks.length) {
+    score += 25;
+  } else if (withDesc.length > 0) {
+    score += Math.round(25 * (withDesc.length / Math.max(1, doc.tasks.length)));
+    issues.push(`${doc.tasks.length - withDesc.length} task(s) lack descriptions`);
+  }
+  if (doc.title && doc.title !== "Untitled PRD") {
+    score += 25;
+  } else {
+    issues.push("Missing or generic title");
+  }
+  return {
+    name: "Completeness",
+    score: Math.round(score),
+    found: true,
+    details: issues.length > 0 ? issues.join("; ") : "PRD has all required sections"
+  };
+}
+function scorePrdQuality(document) {
+  const dimensions = [
+    scoreTaskAtomicity(document.tasks),
+    scoreTaskDecoupling(document.tasks),
+    scoreDependencyClarity(document.tasks),
+    scoreTaskScope(document.tasks),
+    scoreParallelPotential(document.tasks),
+    scoreAcceptanceCriteria(document.tasks),
+    scorePriorityDistribution(document.tasks),
+    scoreCompleteness(document)
+  ];
+  const totalScore = dimensions.reduce((sum, d) => sum + d.score, 0);
+  const overall = Math.round(totalScore / dimensions.length);
+  const suggestions = [];
+  for (const dim of dimensions) {
+    if (dim.score < 50) {
+      switch (dim.name) {
+        case "Task Atomicity":
+          suggestions.push("Split tasks with more than 3 acceptance criteria into smaller, focused tasks.");
+          break;
+        case "Task Decoupling":
+          suggestions.push("Reduce file overlap between tasks by scoping each task to distinct areas of the codebase.");
+          break;
+        case "Dependency Clarity":
+          suggestions.push("Fix dangling dependency references and remove any circular dependencies.");
+          break;
+        case "Task Scope":
+          suggestions.push("Reference specific files, modules, or components in each task description.");
+          break;
+        case "Parallel Potential":
+          suggestions.push("Reduce unnecessary dependencies to enable more parallel execution.");
+          break;
+        case "Acceptance Criteria":
+          suggestions.push("Add 2+ acceptance criteria to every task for clear definition of done.");
+          break;
+        case "Priority Distribution":
+          suggestions.push("Use a range of priorities (P1-P4) and ensure P1 tasks do not depend on P3/P4 tasks.");
+          break;
+        case "Completeness":
+          suggestions.push("Add an overview section, meaningful title, and descriptions for all tasks.");
+          break;
+      }
+    }
+  }
+  return {
+    overall,
+    breakdown: dimensions,
+    suggestions,
+    scoredAt: Date.now(),
+    isAiScore: false
+  };
+}
+function buildAiPrdScoringPrompt(markdown) {
+  return `You are evaluating a Product Requirements Document (PRD) for quality.
+
+## PRD Content
+
+${markdown}
+
+## Evaluation Criteria
+
+Score each dimension from 0-100:
+
+1. **Task Atomicity** - Are tasks small enough to complete in a single session? Do any have too many acceptance criteria?
+2. **Task Decoupling** - Can tasks be worked on independently? Do they reference overlapping files?
+3. **Dependency Clarity** - Are dependencies valid and acyclic? Do they accurately reflect build order?
+4. **Task Scope** - Do tasks reference specific files, modules, or components from the actual codebase?
+5. **Parallel Potential** - What percentage of tasks can run in parallel based on the dependency graph?
+6. **Acceptance Criteria** - Do all tasks have clear, testable acceptance criteria?
+7. **Priority Distribution** - Is there a reasonable spread of priorities? Are high-priority tasks blocking lower-priority work?
+8. **Completeness** - Does the PRD have an overview, title, descriptions for all tasks?
+
+## Codebase Analysis
+
+Before scoring, explore the codebase to verify:
+- Referenced files actually exist
+- Dependencies match actual module relationships
+- Task scope aligns with codebase architecture
+
+## Output Format
+
+Respond with a JSON object (no markdown fencing):
+
+{
+  "overall": <number 0-100>,
+  "breakdown": [
+    { "name": "<dimension name>", "score": <number 0-100>, "found": true, "details": "<explanation>" },
+    ...
+  ],
+  "suggestions": ["<actionable improvement tip>", ...]
+}`;
+}
+function buildPrdEnhancementPrompt(existingMarkdown, feedback, options) {
+  const parts = [];
+  parts.push("## Instructions\n");
+  parts.push(ENHANCEMENT_PROMPT);
+  parts.push("");
+  parts.push("## Existing PRD\n");
+  parts.push("```markdown");
+  parts.push(existingMarkdown);
+  parts.push("```");
+  parts.push("");
+  if (feedback.annotations.length > 0) {
+    parts.push("## User Annotations\n");
+    const concerns = feedback.annotations.filter(
+      (a) => a.type === "concern"
+    );
+    const suggestions = feedback.annotations.filter(
+      (a) => a.type === "suggestion"
+    );
+    const questions = feedback.annotations.filter(
+      (a) => a.type === "question"
+    );
+    const comments = feedback.annotations.filter(
+      (a) => a.type === "comment" || a.type === "global_comment" || a.type === "approval"
+    );
+    const instructionAnns = feedback.annotations.filter(
+      (a) => a.type === "instruction"
+    );
+    if (concerns.length > 0) {
+      parts.push("### Concerns (address these first)\n");
+      for (const a of concerns) {
+        const loc = a.sectionTitle ? ` [Section: ${a.sectionTitle}]` : "";
+        parts.push(`- **CONCERN**${loc}: ${a.text}`);
+      }
+      parts.push("");
+    }
+    if (suggestions.length > 0) {
+      parts.push("### Suggestions\n");
+      for (const a of suggestions) {
+        const loc = a.sectionTitle ? ` [Section: ${a.sectionTitle}]` : "";
+        parts.push(`- **SUGGESTION**${loc}: ${a.text}`);
+      }
+      parts.push("");
+    }
+    if (questions.length > 0) {
+      parts.push("### Questions (answer these in the PRD)\n");
+      for (const a of questions) {
+        const loc = a.sectionTitle ? ` [Section: ${a.sectionTitle}]` : "";
+        parts.push(`- **QUESTION**${loc}: ${a.text}`);
+      }
+      parts.push("");
+    }
+    if (instructionAnns.length > 0) {
+      parts.push("### Annotation Instructions\n");
+      for (const a of instructionAnns) {
+        const loc = a.sectionTitle ? ` [Section: ${a.sectionTitle}]` : "";
+        parts.push(`- **INSTRUCTION**${loc}: ${a.text}`);
+      }
+      parts.push("");
+    }
+    if (comments.length > 0) {
+      parts.push("### Comments\n");
+      for (const a of comments) {
+        const loc = a.sectionTitle ? ` [Section: ${a.sectionTitle}]` : "";
+        parts.push(`- ${a.type.toUpperCase()}${loc}: ${a.text}`);
+      }
+      parts.push("");
+    }
+  }
+  if (feedback.edits.length > 0) {
+    parts.push("## Inline Edits (apply these changes)\n");
+    for (const edit of feedback.edits) {
+      parts.push(`### Section: ${edit.sectionTitle}
+`);
+      parts.push("**Original:**");
+      parts.push("```");
+      parts.push(edit.original.slice(0, 2e3));
+      parts.push("```");
+      parts.push("**Edited (use this version):**");
+      parts.push("```");
+      parts.push(edit.edited.slice(0, 2e3));
+      parts.push("```");
+      parts.push("");
+    }
+  }
+  if (feedback.priorities.length > 0) {
+    parts.push("## Priority Assignments\n");
+    parts.push(
+      "Apply these priority levels. Sections marked must-have should be expanded with more detail. Sections marked out-of-scope should be removed or moved to a 'Future Considerations' section.\n"
+    );
+    for (const p of feedback.priorities) {
+      const note = p.note ? ` \u2014 ${p.note}` : "";
+      parts.push(`- **${p.sectionTitle}**: ${p.level}${note}`);
+    }
+    parts.push("");
+  }
+  if (feedback.risks.length > 0) {
+    parts.push("## Risk Flags\n");
+    parts.push(
+      "High-risk sections need mitigation steps added. Medium-risk sections should note the risk. Low-risk items are informational.\n"
+    );
+    for (const r of feedback.risks) {
+      const desc = r.description ? ` \u2014 ${r.description}` : "";
+      parts.push(`- **${r.sectionTitle}**: ${r.level} risk${desc}`);
+    }
+    parts.push("");
+  }
+  if (feedback.instructions.length > 0) {
+    parts.push("## Explicit Instructions\n");
+    parts.push("Follow these directives exactly:\n");
+    for (const i of feedback.instructions) {
+      const pri = i.priority ? ` [${i.priority}]` : "";
+      parts.push(`- **${i.sectionTitle}**${pri}: ${i.instruction}`);
+    }
+    parts.push("");
+  }
+  const outputDir = options?.outputDir ?? ".ulpi/prds";
+  const slug = options?.slug ?? "enhanced-prd";
+  const outputPath = `${outputDir}/prd-${slug}.md`;
+  parts.push("## Output\n");
+  parts.push(`Write the enhanced PRD to: \`${outputPath}\``);
+  parts.push("Use the Write tool to create the file at this path.");
+  parts.push(
+    "The enhanced PRD should address ALL the feedback above while maintaining the same overall structure."
+  );
+  return parts.join("\n");
+}
+var ENHANCEMENT_PROMPT = `You are an expert product engineer enhancing a Product Requirements Document (PRD).
+
+## Your Mission
+
+You will receive:
+1. An existing PRD markdown document
+2. User feedback: annotations, inline edits, priority assignments, risk flags, and explicit instructions
+
+Your job is to produce an **enhanced version** of the PRD that addresses ALL feedback while:
+- Maintaining the overall document structure and format
+- Preserving content that was NOT flagged for changes
+- Applying inline edits exactly as specified
+- Expanding sections marked as must-have priorities
+- Adding mitigation steps for high-risk sections
+- Answering questions raised in annotations directly in the PRD text
+- Addressing concerns by improving the relevant sections
+- Incorporating suggestions where they improve the document
+
+## Important Rules
+
+- Work **autonomously** \u2014 do NOT ask questions or wait for interaction.
+- **Explore the codebase** if needed to provide more specific file references or technical details.
+- Keep the PRD format parseable: use \`# PRD: Title\`, \`## Section\`, \`### TASK-NNN: Title\` format.
+- Do NOT remove tasks unless explicitly marked as out-of-scope.
+- If a section has both edits and annotations, apply the edit first, then address annotations.
+- Write the complete enhanced PRD to the output path using the Write tool.`;
+function clampPriority(p) {
+  return Math.max(0, Math.min(4, Math.round(p)));
+}
+function convertTask(task) {
+  return {
+    id: task.id,
+    title: task.title,
+    description: task.description,
+    status: "open",
+    priority: clampPriority(task.priority),
+    labels: [...task.labels],
+    dependsOn: [...task.dependsOn],
+    metadata: {
+      acceptanceCriteria: [...task.acceptanceCriteria],
+      source: "prd"
+    }
+  };
+}
+function computeDependencyDepths(tasks) {
+  const depths = /* @__PURE__ */ new Map();
+  const taskIds = new Set(tasks.map((t) => t.id));
+  function getDepth(taskId, visited) {
+    if (depths.has(taskId)) {
+      return depths.get(taskId);
+    }
+    if (visited.has(taskId)) {
+      return 0;
+    }
+    visited.add(taskId);
+    const task = tasks.find((t) => t.id === taskId);
+    if (!task || task.dependsOn.length === 0) {
+      depths.set(taskId, 0);
+      return 0;
+    }
+    let maxDepth = 0;
+    for (const depId of task.dependsOn) {
+      if (taskIds.has(depId)) {
+        const depDepth = getDepth(depId, visited);
+        maxDepth = Math.max(maxDepth, depDepth + 1);
+      }
+    }
+    depths.set(taskId, maxDepth);
+    return maxDepth;
+  }
+  for (const task of tasks) {
+    getDepth(task.id, /* @__PURE__ */ new Set());
+  }
+  return depths;
+}
+function convertPrdToTasks(prd, useDependencyPriority = false) {
+  const trackerTasks = prd.tasks.map(convertTask);
+  if (useDependencyPriority) {
+    const depths = computeDependencyDepths(prd.tasks);
+    for (const task of trackerTasks) {
+      const depth = depths.get(task.id) ?? 0;
+      task.priority = clampPriority(depth + 1);
+    }
+  }
+  const validIds = new Set(trackerTasks.map((t) => t.id));
+  for (const task of trackerTasks) {
+    task.dependsOn = (task.dependsOn ?? []).filter((depId) => validIds.has(depId));
+  }
+  return trackerTasks;
+}
+function convertPrdToJson(prd) {
+  return {
+    name: prd.title,
+    description: prd.description,
+    tasks: prd.tasks.map((task) => ({
+      id: task.id,
+      title: task.title,
+      description: task.description,
+      acceptanceCriteria: task.acceptanceCriteria,
+      priority: task.priority,
+      labels: task.labels,
+      dependsOn: task.dependsOn,
+      status: "pending"
+    })),
+    metadata: {
+      ...prd.metadata,
+      convertedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      version: "1.0.0"
+    }
+  };
+}
+function buildPrdValidationPrompt(prdMarkdown, _taskSummaries) {
+  const parts = [];
+  parts.push("## Your Role");
+  parts.push("");
+  parts.push("You are a senior engineer performing a **post-implementation validation**.");
+  parts.push("Multiple agents worked on different tasks in parallel. Their work has been merged into this branch.");
+  parts.push("You do NOT care about what the agents did or didn't do. You only care about the current state of the code on this branch.");
+  parts.push("");
+  parts.push("## Instructions");
+  parts.push("");
+  parts.push("### Step 1: Run the build");
+  parts.push("");
+  parts.push("Run the project's build command first to see the current state.");
+  parts.push("Note any build errors \u2014 you will fix them.");
+  parts.push("");
+  parts.push("### Step 2: Validate task by task");
+  parts.push("");
+  parts.push("Go through each task in the PRD below, one by one, in order.");
+  parts.push("For each task:");
+  parts.push("");
+  parts.push("1. Read the task description and acceptance criteria in the PRD");
+  parts.push("2. Check if the code for that task exists on the branch (read the relevant files)");
+  parts.push("3. If the code is there and correct \u2014 move on to the next task");
+  parts.push("4. If the code is missing, incomplete, or broken \u2014 **implement or fix it**");
+  parts.push("");
+  parts.push("Do not skip tasks. Do not assume anything. Read the actual files.");
+  parts.push("");
+  parts.push("### Step 3: Fix build errors");
+  parts.push("");
+  parts.push("After going through all tasks, run the build again.");
+  parts.push("Fix any build errors, type errors, broken imports, or missing exports.");
+  parts.push("Keep running the build until it passes cleanly.");
+  parts.push("");
+  parts.push("## PRD");
+  parts.push("");
+  parts.push(prdMarkdown);
+  return parts.join("\n");
+}
+function extractAcceptanceCriteria(markdown) {
+  const criteria = [];
+  const lines = markdown.split("\n");
+  let inAcSection = false;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (/^#{2,5}\s+Acceptance\s+Criteria/i.test(trimmed) || /^\*\*Acceptance\s+Criteria[:\*]*\*\*/i.test(trimmed) || /^Acceptance\s+Criteria:$/i.test(trimmed)) {
+      inAcSection = true;
+      continue;
+    }
+    if (inAcSection) {
+      if (/^#{2,5}\s+/.test(trimmed) && !/Acceptance\s+Criteria/i.test(trimmed)) {
+        inAcSection = false;
+        continue;
+      }
+      if (/^\*\*(?!Acceptance)/.test(trimmed)) {
+        inAcSection = false;
+        continue;
+      }
+      if (trimmed === "---") {
+        inAcSection = false;
+        continue;
+      }
+    }
+    if (inAcSection) {
+      const checkMatch = trimmed.match(/^[-*]\s+\[[\sx]\]\s+(.+)$/);
+      if (checkMatch?.[1]) {
+        criteria.push(checkMatch[1].trim());
+        continue;
+      }
+      const bulletMatch = trimmed.match(/^[-*]\s+(.+)$/);
+      if (bulletMatch?.[1] && !bulletMatch[1].startsWith("[")) {
+        criteria.push(bulletMatch[1].trim());
+        continue;
+      }
+      const numberedMatch = trimmed.match(/^\d+\.\s+(.+)$/);
+      if (numberedMatch?.[1]) {
+        criteria.push(numberedMatch[1].trim());
+        continue;
+      }
+      if (/^(?:Given|When|Then|And|But)\s+/i.test(trimmed)) {
+        criteria.push(trimmed);
+        continue;
+      }
+    }
+  }
+  if (criteria.length === 0) {
+    for (const line of lines) {
+      const acMatch = line.trim().match(/^[-*]\s+\[AC\]\s+(.+)$/i);
+      if (acMatch?.[1]) {
+        criteria.push(acMatch[1].trim());
+      }
+    }
+  }
+  return criteria;
+}
+function formatCriteriaAsChecklist(criteria) {
+  return criteria.map((c) => `- [ ] ${c}`).join("\n");
+}
+function hasAcceptanceCriteria(text) {
+  return extractAcceptanceCriteria(text).length > 0;
+}
+export {
+  buildAiPrdScoringPrompt,
+  buildConversationPrompt,
+  buildPrdEnhancementPrompt,
+  buildPrdGenerationPrompt,
+  buildPrdValidationPrompt,
+  convertPrdToJson,
+  convertPrdToTasks,
+  detectPrd,
+  extractAcceptanceCriteria,
+  extractCriteria,
+  formatCriteriaAsChecklist,
+  getPrdGenerationPrompt,
+  getPrdSystemPrompt,
+  hasAcceptanceCriteria,
+  parsePrdMarkdown,
+  processPrdResponse,
+  renderPrdMarkdown,
+  scorePrdQuality,
+  slugify
+};