@ulpi/cli 0.1.0

package/dist/chunk-3SBPZRB5.js

@@ -0,0 +1,772 @@
+import {
+  external_exports
+} from "./chunk-KIKPIH6N.js";
+import {
+  REVIEWS_DIR
+} from "./chunk-7LXY5UVC.js";
+import {
+  __require
+} from "./chunk-4VNS5WPM.js";
+
+// ../../packages/review-engine/dist/index.js
+import { promises as fs } from "fs";
+import { join } from "path";
+var __require2 = /* @__PURE__ */ ((x) => typeof __require !== "undefined" ? __require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof __require !== "undefined" ? __require : a)[b]
+}) : x)(function(x) {
+  if (typeof __require !== "undefined") return __require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+function parseMarkdownToBlocks(markdown) {
+  if (!markdown) return [];
+  try {
+    return parseMarkdownToBlocksInternal(markdown);
+  } catch {
+    return [{
+      id: "block-0",
+      type: "paragraph",
+      content: markdown,
+      order: 0,
+      startLine: 1
+    }];
+  }
+}
+function parseMarkdownToBlocksInternal(markdown) {
+  const lines = markdown.split("\n");
+  const blocks = [];
+  let blockIndex = 0;
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    if (line.trim() === "") {
+      i++;
+      continue;
+    }
+    if (/^(-{3,}|_{3,}|\*{3,})$/.test(line.trim())) {
+      blocks.push({
+        id: `block-${blockIndex}`,
+        type: "hr",
+        content: line,
+        order: blockIndex,
+        startLine: i + 1
+      });
+      blockIndex++;
+      i++;
+      continue;
+    }
+    const headingMatch = line.match(/^(#{1,6})\s+(.+)$/);
+    if (headingMatch) {
+      blocks.push({
+        id: `block-${blockIndex}`,
+        type: "heading",
+        content: headingMatch[2].trim(),
+        level: headingMatch[1].length,
+        order: blockIndex,
+        startLine: i + 1
+      });
+      blockIndex++;
+      i++;
+      continue;
+    }
+    const codeMatch = line.match(/^(`{3,}|~{3,})(\w*)/);
+    if (codeMatch) {
+      const fence = codeMatch[1];
+      const language = codeMatch[2] || void 0;
+      const codeLines = [];
+      const startLine = i + 1;
+      i++;
+      while (i < lines.length) {
+        if (lines[i].startsWith(fence.charAt(0).repeat(fence.length))) {
+          i++;
+          break;
+        }
+        codeLines.push(lines[i]);
+        i++;
+      }
+      blocks.push({
+        id: `block-${blockIndex}`,
+        type: "code",
+        content: codeLines.join("\n"),
+        language,
+        order: blockIndex,
+        startLine
+      });
+      blockIndex++;
+      continue;
+    }
+    if (line.startsWith(">")) {
+      const quoteLines = [];
+      const startLine = i + 1;
+      while (i < lines.length && lines[i].startsWith(">")) {
+        quoteLines.push(lines[i].replace(/^>\s?/, ""));
+        i++;
+      }
+      blocks.push({
+        id: `block-${blockIndex}`,
+        type: "blockquote",
+        content: quoteLines.join("\n"),
+        order: blockIndex,
+        startLine
+      });
+      blockIndex++;
+      continue;
+    }
+    if (line.startsWith("|") || line.includes("|") && i + 1 < lines.length && /^\|?\s*[-:]+/.test(lines[i + 1])) {
+      const tableLines = [];
+      const startLine = i + 1;
+      while (i < lines.length && lines[i].includes("|") && lines[i].trim() !== "") {
+        tableLines.push(lines[i]);
+        i++;
+      }
+      blocks.push({
+        id: `block-${blockIndex}`,
+        type: "table",
+        content: tableLines.join("\n"),
+        order: blockIndex,
+        startLine
+      });
+      blockIndex++;
+      continue;
+    }
+    const listMatch = line.match(/^(\s*)([-*+]|\d+\.)\s+(.*)$/);
+    if (listMatch) {
+      const startLine = i + 1;
+      const checkboxMatch = listMatch[3].match(/^\[([ xX])\]\s*(.*)/);
+      const checked = checkboxMatch ? checkboxMatch[1].toLowerCase() === "x" : void 0;
+      const content = checkboxMatch ? checkboxMatch[2] : listMatch[3];
+      const allContent = [content];
+      i++;
+      while (i < lines.length) {
+        const nextLine = lines[i];
+        if (nextLine.match(/^\s{2,}/) && !nextLine.match(/^\s*([-*+]|\d+\.)\s/)) {
+          allContent.push(nextLine.trim());
+          i++;
+        } else {
+          break;
+        }
+      }
+      blocks.push({
+        id: `block-${blockIndex}`,
+        type: "list-item",
+        content: allContent.join("\n"),
+        checked,
+        order: blockIndex,
+        startLine
+      });
+      blockIndex++;
+      continue;
+    }
+    {
+      const paraLines = [];
+      const startLine = i + 1;
+      while (i < lines.length) {
+        const l = lines[i];
+        if (l.trim() === "") break;
+        if (l.match(/^#{1,6}\s/)) break;
+        if (l.match(/^(`{3,}|~{3,})/)) break;
+        if (l.startsWith(">")) break;
+        if (l.match(/^(-{3,}|_{3,}|\*{3,})$/)) break;
+        if (l.match(/^\s*([-*+]|\d+\.)\s/)) break;
+        if (l.startsWith("|") && i + 1 < lines.length && /^\|?\s*[-:]/.test(lines[i + 1] || ""))
+          break;
+        paraLines.push(l);
+        i++;
+      }
+      if (paraLines.length > 0) {
+        blocks.push({
+          id: `block-${blockIndex}`,
+          type: "paragraph",
+          content: paraLines.join("\n"),
+          order: blockIndex,
+          startLine
+        });
+        blockIndex++;
+      }
+    }
+  }
+  return blocks;
+}
+function extractTitle(blocks) {
+  const heading = blocks.find((b) => b.type === "heading");
+  return heading?.content ?? "Untitled Plan";
+}
+function generateSlug(title, date) {
+  const d = date ?? /* @__PURE__ */ new Date();
+  const dateStr = d.toISOString().split("T")[0];
+  const titleSlug = title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 50);
+  return `${dateStr}-${titleSlug || "untitled-plan"}`;
+}
+function extractSections(blocks) {
+  const sections = [];
+  let currentSection = null;
+  let sectionOrder = 0;
+  const headingStack = [];
+  const usedSlugs = /* @__PURE__ */ new Set();
+  function sectionSlug(title) {
+    const base = title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") || "section";
+    let slug = base;
+    let n = 2;
+    while (usedSlugs.has(slug)) {
+      slug = `${base}-${n++}`;
+    }
+    usedSlugs.add(slug);
+    return slug;
+  }
+  for (const block of blocks) {
+    if (block.type === "heading" && block.level != null) {
+      while (headingStack.length > 0 && headingStack[headingStack.length - 1].level >= block.level) {
+        headingStack.pop();
+      }
+      headingStack.push({ level: block.level, title: block.content });
+      const path = headingStack.map((h) => h.title).join(" > ");
+      if (currentSection) {
+        sections.push(currentSection);
+      }
+      currentSection = {
+        id: sectionSlug(block.content),
+        blockIds: [block.id],
+        title: block.content,
+        level: block.level,
+        path,
+        status: "pending",
+        order: sectionOrder++
+      };
+    } else {
+      if (!currentSection) {
+        currentSection = {
+          id: sectionSlug("Overview"),
+          blockIds: [],
+          title: "Overview",
+          level: 0,
+          path: "Overview",
+          status: "pending",
+          order: sectionOrder++
+        };
+      }
+      currentSection.blockIds.push(block.id);
+    }
+  }
+  if (currentSection) {
+    sections.push(currentSection);
+  }
+  return sections;
+}
+function getSectionFullText(section, blocks) {
+  return section.blockIds.map((id) => blocks.find((b) => b.id === id)).filter((b) => b != null).map((b) => b.content).join("\n\n");
+}
+var FILE_PATH_PATTERN = /(?:src\/|\.\/|\/)[a-zA-Z0-9_\-/.]+\.[a-zA-Z]{1,5}/g;
+var DIMENSION_CHECKERS = [
+  {
+    name: "Test Plan",
+    check(ctx) {
+      const testKeywords = /\b(test plan|testing|test cases?|unit tests?|integration tests?|e2e tests?|test coverage)\b/i;
+      const hasTestHeading = ctx.sections.some(
+        (s) => testKeywords.test(s.title)
+      );
+      const hasTestContent = testKeywords.test(ctx.fullText);
+      const found = hasTestHeading || hasTestContent;
+      return {
+        found,
+        score: hasTestHeading ? 100 : hasTestContent ? 60 : 0,
+        details: hasTestHeading ? "Dedicated test section found" : hasTestContent ? "Testing mentioned but no dedicated section" : "No test plan found"
+      };
+    }
+  },
+  {
+    name: "Error Handling",
+    check(ctx) {
+      const keywords = /\b(error handling|edge cases?|fallback|graceful degradation|try.?catch|error boundary|validation)\b/i;
+      const found = keywords.test(ctx.fullText);
+      const mentionCount = (ctx.fullText.match(keywords) || []).length;
+      return {
+        found,
+        score: found ? Math.min(mentionCount * 25, 100) : 0,
+        details: found ? `${mentionCount} error handling reference(s)` : "No error handling mentioned"
+      };
+    }
+  },
+  {
+    name: "Rollback Strategy",
+    check(ctx) {
+      const keywords = /\b(rollback|revert|migration down|undo|backward.?compat|breaking change)\b/i;
+      const found = keywords.test(ctx.fullText);
+      return {
+        found,
+        score: found ? 100 : 0,
+        details: found ? "Rollback/revert strategy mentioned" : "No rollback strategy found"
+      };
+    }
+  },
+  {
+    name: "File Specificity",
+    check(ctx) {
+      const paths = ctx.fullText.match(FILE_PATH_PATTERN) || [];
+      const uniquePaths = new Set(paths).size;
+      const found = uniquePaths > 0;
+      return {
+        found,
+        score: found ? Math.min(uniquePaths * 15, 100) : 0,
+        details: found ? `${uniquePaths} specific file path(s) referenced` : "No concrete file paths \u2014 plan may be too vague"
+      };
+    }
+  },
+  {
+    name: "Scope Clarity",
+    check(ctx) {
+      const headingCount = ctx.sections.length;
+      const hasMultipleLevels = new Set(ctx.sections.map((s) => s.level)).size > 1;
+      const found = headingCount >= 3 && hasMultipleLevels;
+      return {
+        found,
+        score: found ? 100 : headingCount >= 2 ? 60 : 30,
+        details: `${headingCount} section(s), ${hasMultipleLevels ? "multiple heading levels" : "single heading level"}`
+      };
+    }
+  },
+  {
+    name: "Verification Steps",
+    check(ctx) {
+      const keywords = /\b(verification|how to test|verify|acceptance criteria|smoke test|manual test|check that|should see|expected result)\b/i;
+      const hasVerifyHeading = ctx.sections.some(
+        (s) => /\b(verification|testing|test)\b/i.test(s.title)
+      );
+      const found = keywords.test(ctx.fullText) || hasVerifyHeading;
+      return {
+        found,
+        score: hasVerifyHeading ? 100 : found ? 50 : 0,
+        details: hasVerifyHeading ? "Dedicated verification section" : found ? "Verification mentioned but no dedicated section" : "No verification steps found"
+      };
+    }
+  },
+  {
+    name: "Security Considerations",
+    check(ctx) {
+      const keywords = /\b(security|authentication|authorization|auth|CSRF|XSS|SQL injection|sanitiz|validat|CORS|rate.?limit|encrypt)\b/i;
+      const found = keywords.test(ctx.fullText);
+      const isRelevant = /\b(API|endpoint|route|database|user|login|form|input|request)\b/i.test(
+        ctx.fullText
+      );
+      return {
+        found: found || !isRelevant,
+        score: found ? 100 : isRelevant ? 0 : 100,
+        details: found ? "Security considerations mentioned" : isRelevant ? "Plan involves user-facing features but no security considerations" : "Not applicable (no user-facing features detected)"
+      };
+    }
+  },
+  {
+    name: "Dependencies Identified",
+    check(ctx) {
+      const keywords = /\b(dependenc|npm|package|library|import|install|require|third.?party|external|API key|service)\b/i;
+      const found = keywords.test(ctx.fullText);
+      return {
+        found,
+        score: found ? 100 : 0,
+        details: found ? "External dependencies or services identified" : "No dependencies mentioned \u2014 may be self-contained or incomplete"
+      };
+    }
+  }
+];
+var MAX_SCORING_INPUT_LENGTH = 5e5;
+function scorePlanQuality(blocks, sections) {
+  const fullText = blocks.map((b) => b.content).join("\n\n");
+  if (fullText.length > MAX_SCORING_INPUT_LENGTH) {
+    return {
+      overall: 0,
+      breakdown: DIMENSION_CHECKERS.map((c) => ({
+        name: c.name,
+        score: 0,
+        found: false,
+        details: "Input too large to score"
+      })),
+      suggestions: ["Plan text exceeds maximum scoring size"],
+      scoredAt: Date.now()
+    };
+  }
+  const ctx = { blocks, sections, fullText };
+  const breakdown = DIMENSION_CHECKERS.map((checker) => {
+    const result = checker.check(ctx);
+    return {
+      name: checker.name,
+      score: result.score,
+      found: result.found,
+      details: result.details
+    };
+  });
+  const overall = Math.round(
+    breakdown.reduce((sum, d) => sum + d.score, 0) / breakdown.length
+  );
+  const suggestions = breakdown.filter((d) => !d.found).map((d) => `Consider adding: ${d.name.toLowerCase()} \u2014 ${d.details}`);
+  return {
+    overall,
+    breakdown,
+    suggestions,
+    scoredAt: Date.now()
+  };
+}
+function buildAiScoringPrompt(markdown) {
+  return `You are a senior engineering reviewer. Score this implementation plan on 8 quality dimensions.
+
+For each dimension, provide:
+- name: dimension name (exactly as listed)
+- score: 0-100
+- found: whether the dimension is adequately addressed
+- details: brief explanation
+
+Dimensions to score:
+1. Test Plan \u2014 testing strategy, coverage requirements
+2. Error Handling \u2014 edge cases, fallbacks, graceful degradation
+3. Rollback Strategy \u2014 revert plan, backward compatibility
+4. File Specificity \u2014 concrete file paths and locations
+5. Scope Clarity \u2014 well-structured sections, clear boundaries
+6. Verification Steps \u2014 how to verify the implementation works
+7. Security Considerations \u2014 auth, validation, XSS, injection risks
+8. Dependencies Identified \u2014 external libraries, services, APIs
+
+Also provide:
+- overall: weighted average score (0-100)
+- suggestions: array of improvement suggestions (strings)
+
+Return ONLY valid JSON matching this schema:
+{
+  "overall": number,
+  "breakdown": [{ "name": string, "score": number, "found": boolean, "details": string }],
+  "suggestions": [string]
+}
+
+Plan to review:
+
+${markdown}`;
+}
+function validateSlug(slug) {
+  if (!slug || slug.includes("..") || slug.includes("/") || slug.includes("\\") || slug.length > 200) {
+    throw new Error("Invalid plan slug");
+  }
+  if (!/^[a-zA-Z0-9_-]+$/.test(slug)) {
+    throw new Error("Invalid plan slug characters");
+  }
+}
+function toProjectSlug(projectPath) {
+  return projectPath.toLowerCase().replace(/^\//, "").replace(/[/\\]+/g, "-").replace(/[^a-z0-9-]/g, "").replace(/-+/g, "-").replace(/^-+|-+$/g, "").slice(0, 200);
+}
+async function ensurePlanDir(slug, projectPath) {
+  validateSlug(slug);
+  let dir;
+  if (projectPath) {
+    const projectSlug = toProjectSlug(projectPath);
+    validateSlug(projectSlug);
+    dir = join(REVIEWS_DIR, projectSlug, slug);
+  } else {
+    dir = join(REVIEWS_DIR, slug);
+  }
+  await fs.mkdir(dir, { recursive: true });
+  return dir;
+}
+function extractTitleFromMarkdown(plan) {
+  const match = plan.match(/^#\s+(.+)$/m);
+  if (match) return match[1].trim();
+  const firstLine = plan.split("\n").find((line) => line.trim());
+  return firstLine?.trim().slice(0, 50) || "Untitled Plan";
+}
+async function savePlan(plan, version, slug, projectPath) {
+  const title = extractTitleFromMarkdown(plan);
+  const resolvedSlug = slug || title.toLowerCase().replace(/[^\w\s-]/g, "").replace(/[\s_-]+/g, "-").replace(/^-+|-+$/g, "");
+  const dir = await ensurePlanDir(resolvedSlug, projectPath);
+  const planFile = join(dir, "plan.json");
+  await fs.writeFile(
+    planFile,
+    JSON.stringify(
+      { title, slug: resolvedSlug, plan, version, projectPath },
+      null,
+      2
+    ),
+    "utf-8"
+  );
+  const versionFile = join(dir, `v${version.versionNumber}.json`);
+  await fs.writeFile(
+    versionFile,
+    JSON.stringify({ plan, version, projectPath }, null, 2),
+    "utf-8"
+  );
+}
+async function loadPlan(slug, projectPath) {
+  try {
+    validateSlug(slug);
+    const candidates = [];
+    if (projectPath) {
+      const projectSlug = toProjectSlug(projectPath);
+      candidates.push(join(REVIEWS_DIR, projectSlug, slug));
+    }
+    candidates.push(join(REVIEWS_DIR, slug));
+    for (const dir of candidates) {
+      const result = await tryLoadPlanFromDir(dir);
+      if (result) return result;
+    }
+    try {
+      const topEntries = await fs.readdir(REVIEWS_DIR, { withFileTypes: true });
+      for (const entry of topEntries) {
+        if (!entry.isDirectory()) continue;
+        const dir = join(REVIEWS_DIR, entry.name, slug);
+        const result = await tryLoadPlanFromDir(dir);
+        if (result) return result;
+      }
+    } catch {
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function tryLoadPlanFromDir(dir) {
+  try {
+    const planFile = join(dir, "plan.json");
+    const content = await fs.readFile(planFile, "utf-8");
+    const data = JSON.parse(content);
+    const files = await fs.readdir(dir);
+    const versionFiles = files.filter((f) => f.match(/^v\d+\.json$/));
+    const versions = [];
+    for (const file of versionFiles) {
+      const versionContent = await fs.readFile(join(dir, file), "utf-8");
+      const versionData = JSON.parse(versionContent);
+      versions.push(versionData.version);
+    }
+    versions.sort((a, b) => a.versionNumber - b.versionNumber);
+    return {
+      title: data.title,
+      slug: data.slug,
+      plan: data.plan,
+      version: data.version,
+      versions,
+      projectPath: data.projectPath
+    };
+  } catch {
+    return null;
+  }
+}
+async function getNextVersionNumber(slug, projectPath) {
+  try {
+    validateSlug(slug);
+    let dir;
+    if (projectPath) {
+      const projectSlug = toProjectSlug(projectPath);
+      dir = join(REVIEWS_DIR, projectSlug, slug);
+    } else {
+      dir = join(REVIEWS_DIR, slug);
+    }
+    const files = await fs.readdir(dir);
+    const versionFiles = files.filter((f) => f.match(/^v\d+\.json$/));
+    if (versionFiles.length === 0) return 1;
+    const versions = versionFiles.map((f) => {
+      const match = f.match(/^v(\d+)\.json$/);
+      return match ? parseInt(match[1], 10) : 0;
+    });
+    return Math.max(...versions) + 1;
+  } catch {
+    return 1;
+  }
+}
+async function listPlansWithMeta(projectPath) {
+  try {
+    const summaries = [];
+    if (projectPath) {
+      const projectSlug = toProjectSlug(projectPath);
+      const baseDir = join(REVIEWS_DIR, projectSlug);
+      await collectPlansFromDir(baseDir, summaries);
+    } else {
+      await fs.mkdir(REVIEWS_DIR, { recursive: true });
+      const topEntries = await fs.readdir(REVIEWS_DIR, { withFileTypes: true });
+      for (const entry of topEntries) {
+        if (!entry.isDirectory()) continue;
+        const projectDir = join(REVIEWS_DIR, entry.name);
+        await collectPlansFromDir(projectDir, summaries);
+      }
+    }
+    summaries.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+    return summaries;
+  } catch {
+    return [];
+  }
+}
+async function collectPlansFromDir(baseDir, summaries) {
+  try {
+    const entries = await fs.readdir(baseDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      try {
+        const dir = join(baseDir, entry.name);
+        const planFile = join(dir, "plan.json");
+        const content = await fs.readFile(planFile, "utf-8");
+        const data = JSON.parse(content);
+        const files = await fs.readdir(dir);
+        const versionFiles = files.filter((f) => f.match(/^v\d+\.json$/));
+        let status = "pending";
+        if (data.version?.decision) {
+          status = data.version.decision.behavior === "allow" ? "approved" : "denied";
+        }
+        const stat = await fs.stat(planFile);
+        summaries.push({
+          slug: entry.name,
+          title: data.title || entry.name,
+          versionCount: versionFiles.length,
+          updatedAt: new Date(stat.mtimeMs).toISOString(),
+          status,
+          projectPath: data.projectPath
+        });
+      } catch {
+      }
+    }
+  } catch {
+  }
+}
+function isGitCommitCommand(command) {
+  if (!command) return false;
+  const subcommands = command.split(/\s*(?:&&|\|\||[;|])\s*/);
+  return subcommands.some((sub) => /(?:^|\b)(?:\w+=\S*\s+)*git(?:\s+-c\s+\S+)*\s+commit\b/.test(sub));
+}
+function gitOutputSync(args, cwd) {
+  const { execFileSync } = __require2("child_process");
+  try {
+    return execFileSync(args[0], args.slice(1), {
+      cwd,
+      encoding: "utf-8",
+      timeout: 1e4,
+      maxBuffer: 10 * 1024 * 1024
+    });
+  } catch {
+    return "";
+  }
+}
+function captureUntrackedDiff(files, cwd) {
+  const { existsSync, readFileSync } = __require2("fs");
+  const { join: join2 } = __require2("path");
+  const parts = [];
+  for (const file of files) {
+    const fullPath = join2(cwd, file);
+    if (!existsSync(fullPath)) continue;
+    const noIndexDiff = gitOutputSync(["git", "diff", "--no-index", "--", "/dev/null", file], cwd);
+    if (noIndexDiff.trim()) {
+      parts.push(noIndexDiff);
+    } else {
+      try {
+        const content = readFileSync(fullPath, "utf-8");
+        const lines = content.split("\n");
+        const header = `diff --git a/${file} b/${file}
+new file mode 100644
+--- /dev/null
++++ b/${file}
+@@ -0,0 +1,${lines.length} @@`;
+        const body = lines.map((l) => `+${l}`).join("\n");
+        parts.push(`${header}
+${body}`);
+      } catch {
+      }
+    }
+  }
+  return parts.join("\n");
+}
+function captureCommitDiff(opts) {
+  const { command, cwd } = opts;
+  let commitMessage = "";
+  const heredocMatch = command.match(/<<'?EOF'?\s*\n([\s\S]*?)\n\s*EOF/);
+  if (heredocMatch) {
+    commitMessage = heredocMatch[1].trim();
+  } else {
+    const mMatch = command.match(/-m\s+(?:"([^"]*(?:\\.[^"]*)*)"|'([^']*)'|(\S+))/);
+    if (mMatch) {
+      commitMessage = mMatch[1] ?? mMatch[2] ?? mMatch[3] ?? "";
+    }
+  }
+  const hasAllFlag = /\bcommit\b[^|&;]*(?:-[a-z]*a[a-z]*\b|--all\b)/.test(command);
+  const isAmend = /\bcommit\b[^|&;\n]*--amend\b/.test(command);
+  const allowEmpty = /\bcommit\b[^|&;\n]*--allow-empty\b/.test(command);
+  const scopedFiles = [];
+  let hasChainedAdd = false;
+  let isBroadAdd = false;
+  const chainedAddMatch = command.match(/\bgit\s+add\s+([\s\S]*?)(?:&&|;|\n)\s*git\b.*\bcommit\b/);
+  if (chainedAddMatch) {
+    hasChainedAdd = true;
+    const addArgs = chainedAddMatch[1].trim();
+    isBroadAdd = addArgs === "." || /(?:^|\s)(?:-A|--all|-u|--update)(?:\s|$)/.test(addArgs);
+    const files = addArgs.split(/\s+/).filter((arg) => !arg.startsWith("-") && arg !== ".");
+    scopedFiles.push(...files);
+  }
+  const commitPart = command.match(/\bgit\b.*\bcommit\b(.*)/s);
+  if (commitPart) {
+    let rest = commitPart[1];
+    rest = rest.replace(/-m\s+(?:"[^"]*(?:\\.[^"]*)*"|'[^']*'|\S+)/, "");
+    rest = rest.replace(/<<'?EOF'?\s*\n[\s\S]*?\n\s*EOF/, "");
+    rest = rest.replace(/-m\s*"?\$\(cat\s*<<'?EOF'?[\s\S]*?EOF\s*\)"?/, "");
+    rest = rest.replace(/\s--(?:amend|no-edit|no-verify|allow-empty|signoff|gpg-sign|no-gpg-sign|fixup|squash|reset-author|short|branch|long|porcelain|dry-run|verbose|quiet|all)\b/g, "");
+    rest = rest.replace(/\s-[aSsnvq]\b/g, "");
+    rest = rest.replace(/\s--\s/, " ");
+    const commitFiles = rest.trim().split(/\s+/).filter((f) => f && !f.startsWith("-"));
+    if (commitFiles.length > 0) {
+      scopedFiles.push(...commitFiles);
+    }
+  }
+  let diff = "";
+  if (isAmend) {
+    const baseArgs = scopedFiles.length > 0 ? ["git", "diff", "HEAD~1", "--", ...scopedFiles] : ["git", "diff", "HEAD~1"];
+    diff = gitOutputSync(baseArgs, cwd);
+    if (!diff.trim()) {
+      const fallbackArgs = scopedFiles.length > 0 ? ["git", "diff", "HEAD", "--", ...scopedFiles] : ["git", "diff", "HEAD"];
+      diff = gitOutputSync(fallbackArgs, cwd);
+    }
+  } else if (hasChainedAdd && !isBroadAdd && scopedFiles.length > 0) {
+    const stagedDiff = gitOutputSync(["git", "diff", "--cached", "--", ...scopedFiles], cwd);
+    const unstagedDiff = gitOutputSync(["git", "diff", "--", ...scopedFiles], cwd);
+    diff = [stagedDiff, unstagedDiff].filter((d) => d.trim()).join("\n");
+    if (!diff.trim()) {
+      diff = captureUntrackedDiff(scopedFiles, cwd);
+    }
+  } else if (hasChainedAdd && isBroadAdd) {
+    const stagedDiff = gitOutputSync(["git", "diff", "--cached"], cwd);
+    const unstagedDiff = gitOutputSync(["git", "diff"], cwd);
+    diff = [stagedDiff, unstagedDiff].filter((d) => d.trim()).join("\n");
+    if (!diff.trim()) {
+      const untrackedFiles = gitOutputSync(["git", "ls-files", "--others", "--exclude-standard"], cwd).split("\n").filter((f) => f.trim());
+      if (untrackedFiles.length > 0) {
+        diff = captureUntrackedDiff(untrackedFiles, cwd);
+      }
+    }
+  } else {
+    const baseArgs = hasAllFlag ? ["git", "diff", "HEAD"] : ["git", "diff", "--cached"];
+    const diffArgs = scopedFiles.length > 0 ? [...baseArgs, "--", ...scopedFiles] : baseArgs;
+    diff = gitOutputSync(diffArgs, cwd);
+    if (!diff.trim() && hasAllFlag) {
+      const fallbackArgs = scopedFiles.length > 0 ? ["git", "diff", "--cached", "--", ...scopedFiles] : ["git", "diff", "--cached"];
+      diff = gitOutputSync(fallbackArgs, cwd);
+    }
+    if (!diff.trim() && scopedFiles.length > 0) {
+      diff = captureUntrackedDiff(scopedFiles, cwd);
+    }
+  }
+  return { diff, commitMessage, allowEmpty, isAmend };
+}
+var ReviewConfigSchema = external_exports.object({
+  enabled: external_exports.boolean().default(true),
+  plan_review: external_exports.boolean().default(true),
+  code_review: external_exports.boolean().default(true),
+  auto_open_browser: external_exports.boolean().default(true),
+  require_server: external_exports.boolean().default(false),
+  review_timeout_seconds: external_exports.number().int().min(0).max(600).default(0),
+  timeout_behavior: external_exports.enum(["allow", "deny"]).default("allow"),
+  default_export_format: external_exports.enum(["markdown", "github", "jira", "json"]).default("markdown"),
+  webhook_url: external_exports.string().default("")
+});
+
+export {
+  parseMarkdownToBlocks,
+  extractTitle,
+  generateSlug,
+  extractSections,
+  getSectionFullText,
+  scorePlanQuality,
+  buildAiScoringPrompt,
+  savePlan,
+  loadPlan,
+  getNextVersionNumber,
+  listPlansWithMeta,
+  isGitCommitCommand,
+  captureCommitDiff,
+  ReviewConfigSchema
+};