@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/backlog-execution-intent-GWUV5TUK.js

@@ -0,0 +1,19 @@
+import {
+  BACKLOG_SPEC_FILE_PREFIX,
+  buildBacklogExecutionIntent,
+  isBacklogExecutionReferenceIntent,
+  resolveBacklogExecutionIntent,
+  shouldExecuteBacklogItemAsAnalysisOnly
+} from "./chunk-HLVTEA6A.js";
+import "./chunk-UAPHFJPN.js";
+import "./chunk-PPHXX4W7.js";
+import "./chunk-R2TIYG7U.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  BACKLOG_SPEC_FILE_PREFIX,
+  buildBacklogExecutionIntent,
+  isBacklogExecutionReferenceIntent,
+  resolveBacklogExecutionIntent,
+  shouldExecuteBacklogItemAsAnalysisOnly
+};
+//# sourceMappingURL=backlog-execution-intent-GWUV5TUK.js.map

package/dist/backup-active-store-XHWLN34M.js

@@ -0,0 +1,16 @@
+import {
+  formatExternalStoreWarnings,
+  inspectActiveStores
+} from "./chunk-YSQPGVFK.js";
+import "./chunk-OI734GRS.js";
+import "./chunk-CHA2HDE5.js";
+import "./chunk-JNMWYMC6.js";
+import "./chunk-7VRJHTGZ.js";
+import "./chunk-XDM65LBX.js";
+import "./chunk-CPSVQR2I.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  formatExternalStoreWarnings,
+  inspectActiveStores
+};
+//# sourceMappingURL=backup-active-store-XHWLN34M.js.map

package/dist/backup-machine-stores-UI4LTJOY.js

@@ -0,0 +1,251 @@
+import {
+  assertSqliteSnapshotIntegrity,
+  backupSqliteDatabase
+} from "./chunk-626AJVMU.js";
+import "./chunk-YSQPGVFK.js";
+import "./chunk-JEDNXGSS.js";
+import "./chunk-OI734GRS.js";
+import "./chunk-JLS65NUQ.js";
+import "./chunk-FRBPKBFE.js";
+import "./chunk-ALDTFNZ3.js";
+import {
+  getDataDir
+} from "./chunk-56WPYDJH.js";
+import "./chunk-RSYTSBOO.js";
+import "./chunk-STW7OFOA.js";
+import "./chunk-CHA2HDE5.js";
+import "./chunk-JNMWYMC6.js";
+import "./chunk-7VRJHTGZ.js";
+import "./chunk-XDM65LBX.js";
+import "./chunk-CPSVQR2I.js";
+import "./chunk-PZ5AY32C.js";
+
+// scripts/backup-machine-stores.ts
+import crypto from "crypto";
+import {
+  copyFileSync,
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  rmSync,
+  statSync,
+  unlinkSync,
+  writeFileSync
+} from "fs";
+import path from "path";
+var MACHINE_MANIFEST_NAME = "machine-manifest.json";
+function resolveMachineBackupBase() {
+  return path.join(getDataDir(), "backups");
+}
+function sha256(filePath) {
+  return crypto.createHash("sha256").update(readFileSync(filePath)).digest("hex");
+}
+function slugify(label) {
+  return label.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") || "store";
+}
+function storeRoot(store) {
+  return store.kind === "file" ? path.dirname(store.location) : store.location;
+}
+function isSqliteFile(store, relativePath) {
+  return store.kind === "file" || relativePath.endsWith(".db");
+}
+function listStoreFiles(store) {
+  if (store.kind === "file") {
+    return existsSync(store.location) ? [path.basename(store.location)] : [];
+  }
+  const files = [];
+  const walk = (dir, relative) => {
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      const rel = relative ? path.join(relative, entry.name) : entry.name;
+      if (entry.isDirectory()) {
+        walk(path.join(dir, entry.name), rel);
+      } else if (entry.isFile()) {
+        if (entry.name.endsWith(".db") && !relative || entry.name.endsWith(".jsonl")) {
+          files.push(rel);
+        }
+      }
+    }
+  };
+  if (existsSync(store.location)) walk(store.location, "");
+  return files.sort();
+}
+async function snapshotMachineStores(stores, timestamp, base = resolveMachineBackupBase()) {
+  const planned = stores.map((store) => ({ store, files: listStoreFiles(store) }));
+  if (planned.every(({ files }) => files.length === 0)) {
+    return { backupDir: null, stores: [] };
+  }
+  const backupDir = path.join(base, timestamp);
+  if (existsSync(backupDir)) {
+    throw new Error(`Machine backup directory already exists: ${backupDir}`);
+  }
+  mkdirSync(backupDir, { recursive: true });
+  try {
+    const used = /* @__PURE__ */ new Set();
+    const captured = [];
+    for (const { store, files } of planned) {
+      let snapshotDir = slugify(store.label);
+      while (used.has(snapshotDir)) snapshotDir = `${snapshotDir}-x`;
+      used.add(snapshotDir);
+      const entries = [];
+      for (const relativePath of files) {
+        const source = path.join(storeRoot(store), relativePath);
+        const destination = path.join(backupDir, snapshotDir, relativePath);
+        mkdirSync(path.dirname(destination), { recursive: true });
+        if (isSqliteFile(store, relativePath)) {
+          await backupSqliteDatabase(source, destination);
+        } else {
+          copyFileSync(source, destination);
+        }
+        entries.push({
+          relativePath,
+          size: statSync(destination).size,
+          checksum: sha256(destination)
+        });
+      }
+      captured.push({ ...store, snapshotDir, files: entries });
+    }
+    const manifest = { timestamp, version: "1.0.0", stores: captured };
+    writeFileSync(path.join(backupDir, MACHINE_MANIFEST_NAME), JSON.stringify(manifest, null, 2));
+    return { backupDir, stores: captured };
+  } catch (error) {
+    rmSync(backupDir, { recursive: true, force: true });
+    throw error;
+  }
+}
+function coverageKey(snapshotDir) {
+  try {
+    const manifest = JSON.parse(
+      readFileSync(path.join(snapshotDir, MACHINE_MANIFEST_NAME), "utf-8")
+    );
+    return manifest.stores.map((store) => path.resolve(store.location)).sort().join("\n");
+  } catch {
+    return "";
+  }
+}
+function pruneMachineBackups(retentionCount, base = resolveMachineBackupBase()) {
+  if (!existsSync(base)) return [];
+  const snapshots = readdirSync(base, { withFileTypes: true }).filter(
+    (entry) => entry.isDirectory() && !entry.name.startsWith(".") && existsSync(path.join(base, entry.name, MACHINE_MANIFEST_NAME))
+  ).map((entry) => entry.name).sort((a, b) => b.localeCompare(a));
+  const kept = /* @__PURE__ */ new Map();
+  const removed = [];
+  for (const name of snapshots) {
+    const key = coverageKey(path.join(base, name));
+    const count = kept.get(key) ?? 0;
+    if (count < retentionCount) {
+      kept.set(key, count + 1);
+    } else {
+      removed.push(name);
+    }
+  }
+  for (const name of removed) {
+    rmSync(path.join(base, name), { recursive: true, force: true });
+  }
+  return removed;
+}
+function resolveTarget(store, relativePath) {
+  const root = path.resolve(storeRoot(store));
+  const target = path.resolve(root, relativePath);
+  const rel = path.relative(root, target);
+  if (rel === "" || rel.startsWith("..") || path.isAbsolute(rel)) {
+    throw new Error(`Machine restore target escapes ${root}: ${relativePath}`);
+  }
+  return target;
+}
+function removeSqliteSidecars(dbPath) {
+  for (const suffix of ["-wal", "-shm"]) {
+    if (existsSync(dbPath + suffix)) unlinkSync(dbPath + suffix);
+  }
+}
+function preflightMachineRestore(backupDir, options = {}) {
+  const manifest = JSON.parse(
+    readFileSync(path.join(backupDir, MACHINE_MANIFEST_NAME), "utf-8")
+  );
+  const plan = [];
+  for (const store of manifest.stores) {
+    for (const file of store.files) {
+      const source = path.join(backupDir, store.snapshotDir, file.relativePath);
+      if (!existsSync(source) || sha256(source) !== file.checksum) {
+        throw new Error(`Machine snapshot file is missing or changed: ${source}`);
+      }
+      plan.push({
+        source,
+        target: resolveTarget(store, file.relativePath),
+        sqlite: isSqliteFile(store, file.relativePath)
+      });
+    }
+  }
+  const existing = plan.filter(({ target }) => existsSync(target));
+  if (options.dryRun) {
+    return { plan, existing };
+  }
+  if (options.offline !== true) {
+    throw new Error(
+      "Restore requires --offline: stop all Build writers on this machine and keep them stopped until restore finishes."
+    );
+  }
+  if (existing.length > 0 && !options.force) {
+    throw new Error(
+      `Existing machine files would be overwritten (use --force): ${existing.map((e) => e.target).join(", ")}`
+    );
+  }
+  return { plan, existing };
+}
+async function restoreMachineSnapshot(backupDir, options = {}) {
+  const { plan, existing } = preflightMachineRestore(backupDir, options);
+  if (options.dryRun) {
+    return { targets: plan.map(({ target }) => target) };
+  }
+  const asideDir = path.join(backupDir, `.pre-restore-${Date.now()}`);
+  const aside = [];
+  const written = [];
+  try {
+    for (const [index, { target, sqlite }] of existing.entries()) {
+      const saved = path.join(asideDir, String(index));
+      mkdirSync(asideDir, { recursive: true });
+      if (sqlite) {
+        await backupSqliteDatabase(target, saved);
+      } else {
+        copyFileSync(target, saved);
+      }
+      aside.push({ target, saved, sqlite });
+    }
+    for (const { source, target, sqlite } of plan) {
+      mkdirSync(path.dirname(target), { recursive: true });
+      if (sqlite) removeSqliteSidecars(target);
+      copyFileSync(source, target);
+      written.push(target);
+      if (sqlite) await assertSqliteSnapshotIntegrity(target);
+    }
+  } catch (error) {
+    try {
+      const savedTargets = new Set(aside.map(({ target }) => target));
+      for (const target of written) {
+        if (!savedTargets.has(target)) rmSync(target, { force: true });
+      }
+      for (const { target, saved, sqlite } of aside) {
+        if (sqlite) removeSqliteSidecars(target);
+        copyFileSync(saved, target);
+      }
+    } catch (rollbackError) {
+      const message = (value) => value instanceof Error ? value.message : String(value);
+      throw new Error(
+        `${message(error)}; rollback failed, originals kept in ${asideDir}: ${message(rollbackError)}`
+      );
+    }
+    rmSync(asideDir, { recursive: true, force: true });
+    throw error;
+  }
+  rmSync(asideDir, { recursive: true, force: true });
+  return { targets: written };
+}
+export {
+  MACHINE_MANIFEST_NAME,
+  preflightMachineRestore,
+  pruneMachineBackups,
+  resolveMachineBackupBase,
+  restoreMachineSnapshot,
+  snapshotMachineStores
+};
+//# sourceMappingURL=backup-machine-stores-UI4LTJOY.js.map

package/dist/backup-telemetry-db-Z4ICYCNW.js

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+import {
+  assertSqliteSnapshotIntegrity,
+  backupResultExitCode,
+  backupSqliteDatabase,
+  backupTelemetryDatabase
+} from "./chunk-626AJVMU.js";
+import "./chunk-YSQPGVFK.js";
+import "./chunk-JEDNXGSS.js";
+import "./chunk-OI734GRS.js";
+import "./chunk-JLS65NUQ.js";
+import "./chunk-FRBPKBFE.js";
+import "./chunk-ALDTFNZ3.js";
+import "./chunk-CHA2HDE5.js";
+import "./chunk-JNMWYMC6.js";
+import "./chunk-7VRJHTGZ.js";
+import "./chunk-XDM65LBX.js";
+import "./chunk-CPSVQR2I.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  assertSqliteSnapshotIntegrity,
+  backupResultExitCode,
+  backupSqliteDatabase,
+  backupTelemetryDatabase
+};
+//# sourceMappingURL=backup-telemetry-db-Z4ICYCNW.js.map

package/dist/branch-archive-manager-FMSQ7YJF.js

@@ -0,0 +1,18 @@
+import {
+  BranchArchiveManager,
+  DEFAULT_BRANCH_HOLD_DAYS,
+  createBranchArchiveManager,
+  heldBranchDeletableAt
+} from "./chunk-TIKTYUJO.js";
+import "./chunk-F55YABKV.js";
+import "./chunk-MHLEZQQI.js";
+import "./chunk-I56TH7VM.js";
+import "./chunk-XDM65LBX.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  BranchArchiveManager,
+  DEFAULT_BRANCH_HOLD_DAYS,
+  createBranchArchiveManager,
+  heldBranchDeletableAt
+};
+//# sourceMappingURL=branch-archive-manager-FMSQ7YJF.js.map

package/dist/branch-cleanup-manager-ST6FJGND.js

@@ -0,0 +1,35 @@
+import {
+  BranchCleanupManager,
+  DEFAULT_BRANCH_CLEANUP_AGE_DAYS,
+  createBranchCleanupManager
+} from "./chunk-ZVVD2XGV.js";
+import "./chunk-6TRD7TEE.js";
+import "./chunk-GZAJHLKO.js";
+import "./chunk-MULMXX4V.js";
+import "./chunk-UTDEOPKV.js";
+import "./chunk-RFDVSI4N.js";
+import "./chunk-P6SSWAKY.js";
+import "./chunk-QYQOVOLR.js";
+import "./chunk-XJ2E7YEJ.js";
+import "./chunk-XGU6PBO5.js";
+import "./chunk-F55YABKV.js";
+import "./chunk-2VLJUXJU.js";
+import "./chunk-AJN5Y5YZ.js";
+import "./chunk-MHLEZQQI.js";
+import "./chunk-35J4NE6S.js";
+import "./chunk-I56TH7VM.js";
+import "./chunk-56WPYDJH.js";
+import "./chunk-RSYTSBOO.js";
+import "./chunk-STW7OFOA.js";
+import "./chunk-CHA2HDE5.js";
+import "./chunk-JNMWYMC6.js";
+import "./chunk-7VRJHTGZ.js";
+import "./chunk-XDM65LBX.js";
+import "./chunk-CPSVQR2I.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  BranchCleanupManager,
+  DEFAULT_BRANCH_CLEANUP_AGE_DAYS,
+  createBranchCleanupManager
+};
+//# sourceMappingURL=branch-cleanup-manager-ST6FJGND.js.map

package/dist/build-gate-7NKWPY62.js

@@ -0,0 +1,68 @@
+import {
+  classifyErrorSeverity,
+  collectBaselineTypecheck,
+  parseTscOutput,
+  resolveTscExecutable,
+  runBuildGate,
+  runTypecheckWithArtifacts
+} from "./chunk-IWBHRSG7.js";
+import "./chunk-6TBEX4R4.js";
+import "./chunk-PXKERBKX.js";
+import "./chunk-S2E632FQ.js";
+import "./chunk-B7YRSULE.js";
+import "./chunk-4U6XK2DG.js";
+import "./chunk-BY6ODHNZ.js";
+import "./chunk-3H4MWYIC.js";
+import "./chunk-DP7FKP6W.js";
+import "./chunk-VIFHYTI5.js";
+import "./chunk-AHU3FKPA.js";
+import "./chunk-TUQMMFEQ.js";
+import "./chunk-EPAMVGI3.js";
+import "./chunk-6CB3KJRY.js";
+import "./chunk-L2S235CU.js";
+import "./chunk-D4VJFCGZ.js";
+import "./chunk-RPIMAMV7.js";
+import "./chunk-ALDTFNZ3.js";
+import "./chunk-QOIASNEJ.js";
+import "./chunk-2VUEDIUM.js";
+import "./chunk-MJ6WNSIX.js";
+import "./chunk-2VLJUXJU.js";
+import "./chunk-H3HGMISG.js";
+import "./chunk-FAZBRHGG.js";
+import "./chunk-FKCG7K6H.js";
+import "./chunk-MHLEZQQI.js";
+import "./chunk-QJ6OEH4K.js";
+import "./chunk-BD3PGW6A.js";
+import "./chunk-43OKHTW4.js";
+import "./chunk-MNOVBYFU.js";
+import "./chunk-QXBKTJT6.js";
+import "./chunk-4BTDUT2S.js";
+import "./chunk-35J4NE6S.js";
+import "./chunk-RIMARPCF.js";
+import "./chunk-V2TVPO3X.js";
+import "./chunk-RRC5BL7B.js";
+import "./chunk-RCP2Y6DQ.js";
+import "./chunk-XSJTIFUY.js";
+import "./chunk-XWIZ6B5S.js";
+import "./chunk-U4DRS6ZW.js";
+import "./chunk-I56TH7VM.js";
+import "./chunk-O26L6F7F.js";
+import "./chunk-RJ6RSNT6.js";
+import "./chunk-56WPYDJH.js";
+import "./chunk-RSYTSBOO.js";
+import "./chunk-STW7OFOA.js";
+import "./chunk-CHA2HDE5.js";
+import "./chunk-JNMWYMC6.js";
+import "./chunk-7VRJHTGZ.js";
+import "./chunk-XDM65LBX.js";
+import "./chunk-CPSVQR2I.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  classifyErrorSeverity,
+  collectBaselineTypecheck,
+  parseTscOutput,
+  resolveTscExecutable,
+  runBuildGate,
+  runTypecheckWithArtifacts
+};
+//# sourceMappingURL=build-gate-7NKWPY62.js.map

package/dist/build-root-S7DINODY.js

@@ -0,0 +1,18 @@
+import {
+  findRootByMarkers,
+  getBuildProjectRoot,
+  resetResolveBuildRootCache,
+  resolveBuildRoot
+} from "./chunk-CHA2HDE5.js";
+import "./chunk-JNMWYMC6.js";
+import "./chunk-7VRJHTGZ.js";
+import "./chunk-XDM65LBX.js";
+import "./chunk-CPSVQR2I.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  findRootByMarkers,
+  getBuildProjectRoot,
+  resetResolveBuildRootCache,
+  resolveBuildRoot
+};
+//# sourceMappingURL=build-root-S7DINODY.js.map

package/dist/change-summary-R6CB6VXJ.js

@@ -0,0 +1,50 @@
+import {
+  DIFF_EXCLUDE_PATTERNS,
+  assembleDiffText,
+  buildExcludeArgs,
+  collectWorktreeSnapshot,
+  deriveChangeSummaryFromSnapshot,
+  deriveDiffTextFromSnapshot,
+  deriveEffectiveDiffMetrics,
+  getGitChangeSummary,
+  parseNumstat,
+  readUntrackedFileDiffEntry,
+  renderUntrackedFileDiff,
+  shouldExcludePath,
+  shouldExcludeUntrackedPath,
+  splitTextLines,
+  synthesizeUntrackedDiffs,
+  untrackedOmittedMarker
+} from "./chunk-5UBIFVRD.js";
+import "./chunk-5FKHIKTS.js";
+import "./chunk-5EQN56OZ.js";
+import "./chunk-RBBTBCHX.js";
+import "./chunk-4DJL2VXA.js";
+import "./chunk-QOIASNEJ.js";
+import "./chunk-5KQETTNS.js";
+import "./chunk-J2ICMYDA.js";
+import "./chunk-MHLEZQQI.js";
+import "./chunk-I56TH7VM.js";
+import "./chunk-7VRJHTGZ.js";
+import "./chunk-XDM65LBX.js";
+import "./chunk-CPSVQR2I.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  DIFF_EXCLUDE_PATTERNS,
+  assembleDiffText,
+  buildExcludeArgs,
+  collectWorktreeSnapshot,
+  deriveChangeSummaryFromSnapshot,
+  deriveDiffTextFromSnapshot,
+  deriveEffectiveDiffMetrics,
+  getGitChangeSummary,
+  parseNumstat,
+  readUntrackedFileDiffEntry,
+  renderUntrackedFileDiff,
+  shouldExcludePath,
+  shouldExcludeUntrackedPath,
+  splitTextLines,
+  synthesizeUntrackedDiffs,
+  untrackedOmittedMarker
+};
+//# sourceMappingURL=change-summary-R6CB6VXJ.js.map

package/dist/chunk-24MNKKOM.js

@@ -0,0 +1,173 @@
+import {
+  FILE_EXTENSION_PATTERN
+} from "./chunk-DJG5RIOR.js";
+import {
+  extractFileTargets,
+  extractScopedEditOnlyPaths,
+  normalizePath,
+  stripBuildContextBlocks,
+  stripNegatedFileClauses
+} from "./chunk-KUEWV2JH.js";
+
+// src/orchestrator/utils/file-specification.ts
+var BARE_PATH_PATTERN = String.raw`(?<!\/\/\S*)((?:\.?[\w-]+\/)+[\w.-]+\.${FILE_EXTENSION_PATTERN})(?![A-Za-z0-9_])`;
+var FILE_EXTENSION_SUFFIX = new RegExp(String.raw`\.${FILE_EXTENSION_PATTERN}$`);
+function parseFileSpecifications(prompt) {
+  const explicitTargets = extractFileTargets(prompt);
+  const scopedEditTargets = extractScopedEditOnlyPaths(prompt);
+  if (scopedEditTargets.length > 0) {
+    return {
+      cleanedPrompt: prompt.trim(),
+      targetFiles: Array.from(/* @__PURE__ */ new Set([...explicitTargets, ...scopedEditTargets]))
+    };
+  }
+  const targetFiles = Array.from(
+    /* @__PURE__ */ new Set([
+      ...explicitTargets,
+      ...extractNaturalLanguageTargets(prompt),
+      ...extractCriticalFilesTargets(prompt),
+      ...extractSectionBulletTargets(prompt)
+    ])
+  );
+  const cleanedPrompt = prompt.trim();
+  return { cleanedPrompt, targetFiles };
+}
+function normalizeExtractedTarget(raw) {
+  return normalizePath(
+    raw.replace(/#L?\d+-L?\d+$/i, "").replace(/[:#]L?\d+(?::\d+)?$/i, "").trim()
+  );
+}
+var LIST_SEPARATOR = String.raw`\s*(?:,\s*(?:and\s+)?|\s+and\s+|\s*&\s*)`;
+var QUOTED_CONTINUATION = new RegExp(
+  String.raw`${LIST_SEPARATOR}[\u0060'"]([^\u0060'"\n]+)[\u0060'"]`,
+  "y"
+);
+var BARE_CONTINUATION = new RegExp(`${LIST_SEPARATOR}${BARE_PATH_PATTERN}`, "iy");
+function listContinuation(text, match, kind) {
+  const pattern = kind === "quoted" ? QUOTED_CONTINUATION : BARE_CONTINUATION;
+  const found = [];
+  let at = (match.index ?? 0) + match[0].length;
+  for (; ; ) {
+    pattern.lastIndex = at;
+    const next = pattern.exec(text);
+    if (!next?.[1]) return found;
+    found.push(next[1]);
+    at = pattern.lastIndex;
+  }
+}
+function extractNaturalLanguageTargets(prompt) {
+  const targets = /* @__PURE__ */ new Set();
+  const cleanPrompt = stripNegatedFileClauses(stripBuildContextBlocks(prompt));
+  const addCandidate = (raw) => {
+    if (!raw) return;
+    const candidate = normalizeExtractedTarget(raw);
+    if (!isLikelyTargetPath(candidate)) {
+      return;
+    }
+    targets.add(candidate);
+  };
+  const backtickedActionPatterns = [
+    /\b(?:create|write|add|update|edit|modify|rename|move)\b(?:\s+(?:a|an|the))?(?:\s+new)?(?:\s+file)?\s+`([^`\n]+)`/gi,
+    /\b(?:create|write|add|update|edit|modify|rename|move)\b(?:\s+(?:a|an|the))?(?:\s+new)?(?:\s+file)?\s+'([^'\n]+)'/gi,
+    /\b(?:create|write|add|update|edit|modify|rename|move)\b(?:\s+(?:a|an|the))?(?:\s+new)?(?:\s+file)?\s+"([^"\n]+)"/gi,
+    /\bin\s+path\s+`([^`\n]+)`/gi,
+    /\bin\s+path\s+'([^'\n]+)'/gi,
+    /\bin\s+path\s+"([^"\n]+)"/gi,
+    /\*\*file\s+\d+\s*:\s*`([^`\n]+)`/gi
+  ];
+  const barePathPatterns = [
+    new RegExp(
+      String.raw`\b(?:create|write|add|update|edit|modify|rename|move)\b(?:\s+(?:a|an|the))?(?:\s+new)?(?:\s+file)?\s+${BARE_PATH_PATTERN}`,
+      "gi"
+    ),
+    new RegExp(String.raw`\bin\s+path\s+${BARE_PATH_PATTERN}`, "gi")
+  ];
+  for (const pattern of backtickedActionPatterns) {
+    for (const match of cleanPrompt.matchAll(pattern)) {
+      addCandidate(match[1]);
+      for (const more of listContinuation(cleanPrompt, match, "quoted")) addCandidate(more);
+    }
+  }
+  for (const pattern of barePathPatterns) {
+    for (const match of cleanPrompt.matchAll(pattern)) {
+      addCandidate(match[1]);
+      for (const more of listContinuation(cleanPrompt, match, "bare")) addCandidate(more);
+    }
+  }
+  return Array.from(targets);
+}
+function pathsOnDeclaredLine(line) {
+  const backticked = Array.from(line.matchAll(/`([^`\n]+)`/g), (m) => m[1] ?? "");
+  if (backticked.length > 0) return backticked;
+  return Array.from(line.matchAll(new RegExp(BARE_PATH_PATTERN, "gi")), (m) => m[1] ?? "");
+}
+function extractCriticalFilesTargets(prompt) {
+  const targets = /* @__PURE__ */ new Set();
+  const cleanPrompt = stripBuildContextBlocks(prompt);
+  const criticalFilesMatch = cleanPrompt.match(
+    /(?:^|\n)##\s+Critical Files\s*\n+((?:\s*-\s+[^\n]+\n?)+)/i
+  );
+  if (!criticalFilesMatch?.[1]) {
+    return [];
+  }
+  const fileLines = criticalFilesMatch[1].match(/^\s*-\s+[^\n]+/gm);
+  if (!fileLines) {
+    return [];
+  }
+  const addCandidate = (raw) => {
+    if (!raw) return;
+    const candidate = normalizeExtractedTarget(raw);
+    if (!isLikelyTargetPath(candidate)) {
+      return;
+    }
+    targets.add(candidate);
+  };
+  for (const line of fileLines) {
+    for (const raw of pathsOnDeclaredLine(line)) addCandidate(raw);
+  }
+  return Array.from(targets);
+}
+function extractSectionBulletTargets(prompt) {
+  const targets = /* @__PURE__ */ new Set();
+  const cleanPrompt = stripBuildContextBlocks(prompt);
+  const sectionMatch = cleanPrompt.match(
+    /(?:^|\n)##\s+(?:Scope\s*\/\s*Surfaces Affected(?:\s*\(Optional\))?|Files to Modify)\s*\n+((?:\s*-\s+[^\n]+\n?)+)/i
+  );
+  if (!sectionMatch?.[1]) {
+    return [];
+  }
+  const fileLines = sectionMatch[1].match(/^\s*-\s+[^\n]+/gm);
+  if (!fileLines) {
+    return [];
+  }
+  const addCandidate = (raw) => {
+    if (!raw) return;
+    const candidate = normalizeExtractedTarget(raw);
+    if (isLikelyTargetPath(candidate)) {
+      targets.add(candidate);
+    }
+  };
+  for (const line of fileLines) {
+    for (const raw of pathsOnDeclaredLine(line)) addCandidate(raw);
+  }
+  return Array.from(targets);
+}
+function isBuildEvidencePath(candidate) {
+  return /^\.build-project\/(?:plans|planning|state|telemetry|artifacts|tmp|logs|runs|labs)\//.test(
+    candidate
+  );
+}
+function isLikelyTargetPath(candidate) {
+  if (!candidate) return false;
+  if (candidate.startsWith("/")) return false;
+  if (/^(?:https?:)?\/\//i.test(candidate)) return false;
+  if (candidate.includes(" ")) return false;
+  if (/^[A-Za-z]:$/.test(candidate)) return false;
+  if (isBuildEvidencePath(candidate)) return false;
+  return candidate.includes("/") && FILE_EXTENSION_SUFFIX.test(candidate);
+}
+
+export {
+  parseFileSpecifications
+};
+//# sourceMappingURL=chunk-24MNKKOM.js.map