@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-MULMXX4V.js

@@ -0,0 +1,150 @@
+import {
+  atomicWriteText
+} from "./chunk-RFDVSI4N.js";
+import {
+  acquireFencedFileLock
+} from "./chunk-QYQOVOLR.js";
+import {
+  isProtectedPipelineBranch
+} from "./chunk-XGU6PBO5.js";
+import {
+  isValidationBranch
+} from "./chunk-F55YABKV.js";
+
+// src/core/cleanup/branch-cleanup-queue.ts
+import { readFile, rm } from "fs/promises";
+import { resolve } from "path";
+
+// src/core/cleanup/file-mutation-lock.ts
+import { mkdir } from "fs/promises";
+import path from "path";
+var DEFAULT_TIMEOUT_MS = 1e4;
+var DEFAULT_RETRY_DELAY_MS = 50;
+var DEFAULT_STALE_LOCK_AGE_MS = 6e4;
+async function withFileMutationLock(targetPath, mutate, options = {}) {
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const retryDelayMs = options.retryDelayMs ?? DEFAULT_RETRY_DELAY_MS;
+  const startedAt = Date.now();
+  await mkdir(path.dirname(targetPath), { recursive: true });
+  let lock;
+  for (; ; ) {
+    try {
+      lock = await acquireFencedFileLock(targetPath, {
+        // The shared primitive heartbeats live owners and has a 2-second stale floor.
+        stale: options.staleLockAgeMs ?? DEFAULT_STALE_LOCK_AGE_MS,
+        realpath: false,
+        retries: 0,
+        description: "Cleanup queue lock"
+      });
+      break;
+    } catch (error) {
+      if (error.code !== "ELOCKED") throw error;
+      if (Date.now() - startedAt >= timeoutMs) {
+        throw new Error(`Timed out waiting for file mutation lock: ${targetPath}.lock`);
+      }
+      await new Promise((resolve2) => setTimeout(resolve2, retryDelayMs));
+    }
+  }
+  try {
+    await lock.assertOwned();
+    const result = await mutate();
+    await lock.assertOwned();
+    return result;
+  } finally {
+    await lock();
+    if (!lock.isOwned()) await lock.assertOwned();
+  }
+}
+
+// src/core/cleanup/branch-cleanup-queue.ts
+var DEFAULT_QUEUE_RELATIVE_PATH = ".build-project/tmp/branch-cleanup-queue.jsonl";
+function getBranchCleanupQueuePath(cwd = process.cwd()) {
+  return resolve(cwd, DEFAULT_QUEUE_RELATIVE_PATH);
+}
+function isValidLocalBranchCleanupEntry(branch, cwd) {
+  if (!branch || branch === "HEAD") {
+    return false;
+  }
+  if (isProtectedPipelineBranch(branch, void 0, cwd) || isValidationBranch(branch)) {
+    return false;
+  }
+  return true;
+}
+async function enqueueBranchCleanup(branch, options = {}) {
+  if (!isValidLocalBranchCleanupEntry(branch, options.cwd)) {
+    throw new Error(`Refusing to enqueue protected or invalid branch for cleanup: ${branch}`);
+  }
+  const queuePath = options.queuePath ?? getBranchCleanupQueuePath();
+  const entry = {
+    branch,
+    reason: options.reason,
+    queuedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    expectedHeadSha: options.expectedHeadSha
+  };
+  await withFileMutationLock(queuePath, async () => {
+    const entries = await readBranchCleanupQueue(queuePath);
+    const existingIndex = entries.findIndex((existing) => existing.branch === branch);
+    if (existingIndex >= 0) {
+      const existing = entries[existingIndex];
+      if (!options.expectedHeadSha || existing.expectedHeadSha && existing.expectedHeadSha === options.expectedHeadSha) {
+        return;
+      }
+      entries[existingIndex] = {
+        ...existing,
+        expectedHeadSha: options.expectedHeadSha,
+        queuedAt: entry.queuedAt,
+        reason: options.reason ?? existing.reason
+      };
+      const serialized2 = `${entries.map((item) => JSON.stringify(item)).join("\n")}
+`;
+      await atomicWriteText(queuePath, serialized2);
+      return;
+    }
+    const serialized = `${[...entries, entry].map((item) => JSON.stringify(item)).join("\n")}
+`;
+    await atomicWriteText(queuePath, serialized);
+  });
+}
+async function readBranchCleanupQueue(queuePath = getBranchCleanupQueuePath()) {
+  try {
+    const raw = await readFile(queuePath, "utf8");
+    const lines = raw.split("\n").filter(Boolean);
+    const entries = [];
+    for (const line of lines) {
+      try {
+        const parsed = JSON.parse(line);
+        if (!parsed.branch || !parsed.queuedAt) continue;
+        entries.push(parsed);
+      } catch {
+      }
+    }
+    return entries;
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return [];
+    }
+    throw error;
+  }
+}
+async function removeBranchCleanupEntries(branches, queuePath = getBranchCleanupQueuePath()) {
+  await withFileMutationLock(queuePath, async () => {
+    const entries = await readBranchCleanupQueue(queuePath);
+    const remaining = entries.filter((entry) => !branches.includes(entry.branch));
+    if (remaining.length === 0) {
+      await rm(queuePath, { force: true });
+      return;
+    }
+    const serialized = `${remaining.map((entry) => JSON.stringify(entry)).join("\n")}
+`;
+    await atomicWriteText(queuePath, serialized);
+  });
+}
+
+export {
+  withFileMutationLock,
+  getBranchCleanupQueuePath,
+  enqueueBranchCleanup,
+  readBranchCleanupQueue,
+  removeBranchCleanupEntries
+};
+//# sourceMappingURL=chunk-MULMXX4V.js.map

package/dist/chunk-MW2DWWVA.js

@@ -0,0 +1,147 @@
+import {
+  isCostBreakdownUnavailable,
+  resolveAvailableTotalCostUsd
+} from "./chunk-ONYPLIVE.js";
+import {
+  sumTokenUsage
+} from "./chunk-H6MJGKAW.js";
+
+// src/core/providers/shared/provider-run-diagnostics.ts
+var STDERR_SEVERITIES = /* @__PURE__ */ new Set(["none", "info", "warning", "error", "fatal"]);
+function asRecord(value) {
+  return value && typeof value === "object" ? value : void 0;
+}
+function normalizeStringArray(value) {
+  if (!Array.isArray(value)) return void 0;
+  const entries = value.filter(
+    (entry) => typeof entry === "string" && entry.length > 0
+  );
+  return entries.length > 0 ? entries : void 0;
+}
+function normalizeProviderRunDiagnostics(value) {
+  const record = asRecord(value);
+  if (!record) return void 0;
+  const normalized = {};
+  if (typeof record.finalAnswerPresent === "boolean") {
+    normalized.finalAnswerPresent = record.finalAnswerPresent;
+  }
+  if (typeof record.terminalResultPresent === "boolean") {
+    normalized.terminalResultPresent = record.terminalResultPresent;
+  }
+  const toolErrors = normalizeStringArray(record.toolErrors);
+  if (toolErrors) normalized.toolErrors = toolErrors;
+  const authErrors = normalizeStringArray(record.authErrors);
+  if (authErrors) normalized.authErrors = authErrors;
+  const transportErrors = normalizeStringArray(record.transportErrors);
+  if (transportErrors) normalized.transportErrors = transportErrors;
+  const retryErrors = normalizeStringArray(record.retryErrors);
+  if (retryErrors) normalized.retryErrors = retryErrors;
+  if (typeof record.stderrSeverity === "string" && STDERR_SEVERITIES.has(record.stderrSeverity)) {
+    normalized.stderrSeverity = record.stderrSeverity;
+  }
+  return Object.keys(normalized).length > 0 ? normalized : void 0;
+}
+function providerDiagnosticsReportFatalRuntimeIssue(diagnostics) {
+  if (!diagnostics) return false;
+  return Boolean(
+    (diagnostics.toolErrors?.length ?? 0) > 0 || (diagnostics.authErrors?.length ?? 0) > 0 || (diagnostics.transportErrors?.length ?? 0) > 0 || diagnostics.stderrSeverity === "error" || diagnostics.stderrSeverity === "fatal"
+  );
+}
+
+// src/orchestrator/cost-metrics-utils.ts
+var APPROX_USD_PER_TOKEN = 1e-6;
+function costBreakdownMetadata(costBreakdown) {
+  const pricingUnavailable = isCostBreakdownUnavailable(costBreakdown);
+  return {
+    pricingStatus: pricingUnavailable ? "unavailable" : costBreakdown.pricingStatus ?? "ok",
+    ...costBreakdown.pricingSource ? { pricingSource: costBreakdown.pricingSource } : {},
+    ...costBreakdown.pricingConfidence ? { pricingConfidence: costBreakdown.pricingConfidence } : {},
+    ...costBreakdown.pricingError ? { pricingError: costBreakdown.pricingError } : costBreakdown.totalCostAmount.status !== "available" && costBreakdown.totalCostAmount.detail ? { pricingError: costBreakdown.totalCostAmount.detail } : {},
+    ...costBreakdown.billingMode ? { billingMode: costBreakdown.billingMode } : {},
+    ...costBreakdown.billingSource ? { billingSource: costBreakdown.billingSource } : {},
+    ...costBreakdown.originalModelId ? { originalModelId: costBreakdown.originalModelId } : {},
+    ...costBreakdown.canonicalModelId ? { canonicalModelId: costBreakdown.canonicalModelId } : {},
+    ...costBreakdown.pricingVersion ? { pricingVersion: costBreakdown.pricingVersion } : {}
+  };
+}
+function cacheReadBasis(usage) {
+  const included = usage?.cacheReadTokensIncludedInInput;
+  return included === void 0 ? {} : { cacheReadTokensIncludedInInput: included };
+}
+function costBreakdownToMetrics(costBreakdown) {
+  const availableTotal = resolveAvailableTotalCostUsd(costBreakdown);
+  const pricingUnavailable = availableTotal === null;
+  return {
+    tokenUsageSource: "measured",
+    inputTokens: costBreakdown.usage.inputTokens,
+    outputTokens: costBreakdown.usage.outputTokens,
+    cacheReadTokens: costBreakdown.usage.cacheReadTokens,
+    cacheWriteTokens: costBreakdown.usage.cacheWriteTokens,
+    ...cacheReadBasis(costBreakdown.usage),
+    // CostMetrics.totalCost remains a bare number for downstream display types;
+    // when unavailable, keep structural 0 and set pricingStatus so callers do not
+    // treat it as known zero.
+    totalCost: availableTotal ?? 0,
+    costBreakdown: {
+      inputCost: pricingUnavailable ? 0 : costBreakdown.inputCost,
+      outputCost: pricingUnavailable ? 0 : costBreakdown.outputCost,
+      cacheCost: pricingUnavailable ? 0 : costBreakdown.cacheCost,
+      toolCosts: pricingUnavailable ? 0 : costBreakdown.toolCosts,
+      infrastructureCost: pricingUnavailable ? 0 : costBreakdown.infrastructureCost
+    },
+    currency: costBreakdown.currency,
+    ...costBreakdownMetadata(costBreakdown)
+  };
+}
+function resolveTokenAccounting(metrics) {
+  const inputTokens = Math.max(0, metrics?.inputTokens ?? 0);
+  const outputTokens = Math.max(0, metrics?.outputTokens ?? 0);
+  const totalTokens = sumTokenUsage({
+    inputTokens,
+    outputTokens,
+    cachedInputTokens: Math.max(0, metrics?.cacheReadTokens ?? 0),
+    cacheCreationInputTokens: Math.max(0, metrics?.cacheWriteTokens ?? 0),
+    cacheReadTokensIncludedInInput: metrics?.cacheReadTokensIncludedInInput
+  }) ?? 0;
+  if (totalTokens > 0) {
+    return {
+      inputTokens,
+      outputTokens,
+      totalTokens,
+      source: metrics?.tokenUsageSource ?? "measured"
+    };
+  }
+  const totalCost = metrics?.totalCost ?? 0;
+  if (Number.isFinite(totalCost) && totalCost > 0) {
+    return {
+      inputTokens: 0,
+      outputTokens: Math.floor(totalCost / APPROX_USD_PER_TOKEN),
+      totalTokens: Math.floor(totalCost / APPROX_USD_PER_TOKEN),
+      source: "inferred"
+    };
+  }
+  return {
+    inputTokens: 0,
+    outputTokens: 0,
+    totalTokens: 0,
+    source: "unavailable"
+  };
+}
+function formatTokens(tokens) {
+  if (tokens >= 1e6) {
+    return `${(tokens / 1e6).toFixed(1)}M`;
+  } else if (tokens >= 1e3) {
+    return `${(tokens / 1e3).toFixed(1)}K`;
+  }
+  return tokens.toString();
+}
+
+export {
+  normalizeProviderRunDiagnostics,
+  providerDiagnosticsReportFatalRuntimeIssue,
+  cacheReadBasis,
+  costBreakdownToMetrics,
+  resolveTokenAccounting,
+  formatTokens
+};
+//# sourceMappingURL=chunk-MW2DWWVA.js.map

package/dist/chunk-MY3ZPUN4.js

@@ -0,0 +1,151 @@
+import {
+  selectFastCommitPaths
+} from "./chunk-ZMLOC3DW.js";
+import {
+  filterWorktreeRunSentinelStatusEntries
+} from "./chunk-2NMNFUQA.js";
+import {
+  addPathsByNulPathspec
+} from "./chunk-YO5BAJ55.js";
+import {
+  parseGitStatus
+} from "./chunk-5KQETTNS.js";
+import {
+  execGit
+} from "./chunk-MHLEZQQI.js";
+
+// src/orchestrator/executors/commit-utils.ts
+import path2 from "path";
+
+// src/orchestrator/executors/fast-snapshot-paths.ts
+import * as fs from "fs/promises";
+import * as path from "path";
+async function resolveFastSnapshotPaths(worktreePath, filesToAdd, deletionPaths, logger) {
+  const existingFiles = [];
+  const skippedPaths = [];
+  for (const file of filesToAdd) {
+    if (deletionPaths.has(file)) {
+      existingFiles.push(file);
+      continue;
+    }
+    try {
+      await fs.lstat(path.join(worktreePath, file));
+      existingFiles.push(file);
+    } catch (error) {
+      skippedPaths.push(file);
+      const reason = error instanceof Error ? error.message : String(error);
+      logger?.(`Skipping unresolvable path during git add: ${file} (${reason})`);
+    }
+  }
+  return { existingFiles, skippedPaths };
+}
+
+// src/orchestrator/executors/commit-utils.ts
+async function computeCommitFiles(options) {
+  const statusArgs = ["status", "--porcelain"];
+  if (options.includeAllUntrackedPaths) {
+    statusArgs.push("--untracked-files=all");
+  }
+  const statusResult = await execGit(statusArgs, {
+    cwd: options.worktreePath
+  });
+  if (statusResult.exitCode !== 0) {
+    throw new Error(
+      `git ${statusArgs.join(" ")} failed (cwd: ${options.worktreePath}): ${statusResult.stderr}`
+    );
+  }
+  const statusEntries = parseGitStatus(statusResult.stdout);
+  const selected = await selectFastCommitPaths(
+    options.worktreePath,
+    filterWorktreeRunSentinelStatusEntries(statusEntries)
+  );
+  const statusPaths = selected.filesToAdd;
+  const deletionPaths = selected.deletionPaths;
+  const filesToAdd = new Set(statusPaths);
+  for (const file of options.forceIncludeFiles ?? []) {
+    const normalized = file.replace(/\\/g, "/").replace(/^\.\//, "");
+    if (normalized.length === 0 || normalized.endsWith("/") || normalized === ".." || normalized.startsWith("../") || path2.posix.isAbsolute(normalized)) {
+      continue;
+    }
+    filesToAdd.add(path2.posix.normalize(normalized));
+  }
+  const resolution = await resolveFastSnapshotPaths(
+    options.worktreePath,
+    filesToAdd,
+    deletionPaths,
+    options.logger
+  );
+  return {
+    eligibleFiles: resolution.existingFiles,
+    deletionPaths,
+    allStatusEntries: statusEntries,
+    skippedPaths: resolution.skippedPaths.filter((file) => statusPaths.has(file))
+  };
+}
+async function stageAndCommit(options) {
+  const { execa } = await import("execa");
+  if (options.filesToStage.length === 0) {
+    return { committed: false, reason: "no-changes" };
+  }
+  await execa("git", ["reset"], {
+    cwd: options.worktreePath,
+    reject: false
+  });
+  try {
+    const add = await addPathsByNulPathspec(options.worktreePath, options.filesToStage, {
+      force: options.forceAdd
+    });
+    if (add.exitCode !== 0) {
+      options.logger?.(`Git add failed: ${add.stderr.trim()}`);
+      return { committed: false, reason: "git-error" };
+    }
+  } catch (addError) {
+    const error = addError;
+    options.logger?.(`Git add failed: ${error.message}`);
+    return { committed: false, reason: "git-error" };
+  }
+  const stagedDiff = await execa("git", ["diff", "--cached", "--quiet", "--exit-code"], {
+    cwd: options.worktreePath,
+    reject: false
+  });
+  if (stagedDiff.exitCode === 0) {
+    options.logger?.("No staged changes to commit after staging");
+    return { committed: false, reason: "no-changes" };
+  }
+  if (stagedDiff.exitCode !== 1) {
+    options.logger?.(`Git staged-diff check failed with exit code ${stagedDiff.exitCode}`);
+    return { committed: false, reason: "git-error" };
+  }
+  try {
+    await execa("git", ["commit", "--no-verify", "--no-gpg-sign", "-m", options.commitMessage], {
+      cwd: options.worktreePath
+    });
+  } catch (commitError) {
+    const error = commitError;
+    const msg = error.message;
+    if (msg.includes("nothing to commit") || msg.includes("working tree clean")) {
+      options.logger?.("No changes to commit after staging");
+      return { committed: false, reason: "no-changes" };
+    }
+    if (msg.includes("hook") && msg.includes("rejected")) {
+      options.logger?.(`Git commit rejected by hook: ${msg}`);
+      return { committed: false, reason: "hook-failure" };
+    }
+    options.logger?.(`Git commit failed: ${msg}`);
+    throw error;
+  }
+  const { stdout: sha } = await execa("git", ["rev-parse", "HEAD"], {
+    cwd: options.worktreePath
+  });
+  return {
+    committed: true,
+    commitSha: sha.trim()
+  };
+}
+
+export {
+  resolveFastSnapshotPaths,
+  computeCommitFiles,
+  stageAndCommit
+};
+//# sourceMappingURL=chunk-MY3ZPUN4.js.map

package/dist/chunk-MYLH2S4G.js

@@ -0,0 +1,64 @@
+// src/core/providers/shared/recoverable-stderr.ts
+var GROK_RECOVERABLE_STDERR_PATTERNS = [
+  /worker quit with fatal: Transport channel closed, when Auth\(AuthorizationRequired\)/i,
+  /sandbox initialization failed:/i,
+  /^(?:\S+\s+(?:ERROR|WARN|WARNING|INFO|DEBUG|TRACE)\s+)?tool_error:\s*tool[_\s-]?output[_\s-]?error\b.*\btool_name=/i
+];
+var CODEX_RECOVERABLE_STDERR_PATTERNS = [
+  /codex_models_manager::cache: failed to write models cache: Operation not permitted \(os error 1\)/i,
+  /codex_models_manager::manager: failed to renew cache TTL: Operation not permitted \(os error 1\)/i
+];
+var RECOVERABLE_STDERR_PATTERNS_BY_PROVIDER = {
+  codex: CODEX_RECOVERABLE_STDERR_PATTERNS,
+  grok: GROK_RECOVERABLE_STDERR_PATTERNS
+};
+function normalizeProviderId(providerId) {
+  const normalized = providerId?.trim().toLowerCase();
+  return normalized && normalized.length > 0 ? normalized : void 0;
+}
+function recoverablePatternsForProvider(providerId) {
+  return RECOVERABLE_STDERR_PATTERNS_BY_PROVIDER[normalizeProviderId(providerId) ?? ""] ?? [];
+}
+function stripAnsiControlSequences(input) {
+  return input.replace(new RegExp(String.raw`\x1B\[[0-?]*[ -/]*[@-~]`, "g"), "");
+}
+function isRecoverableProviderStderrChunk(providerId, chunk) {
+  if (!chunk || chunk.trim().length === 0) return true;
+  const patterns = recoverablePatternsForProvider(providerId);
+  if (patterns.length === 0) return false;
+  const cleaned = stripAnsiControlSequences(chunk);
+  const lines = cleaned.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  if (lines.length === 0) return true;
+  return lines.every((line) => patterns.some((re) => re.test(line)));
+}
+function isProviderStderrOnlyRecoverableNoise(providerId, stderr) {
+  if (!stderr || stderr.trim().length === 0) return true;
+  return isRecoverableProviderStderrChunk(providerId, stderr);
+}
+function stripRecoverableProviderStderrForSummary(providerId, stderr) {
+  const patterns = recoverablePatternsForProvider(providerId);
+  if (patterns.length === 0) return stderr;
+  const cleaned = stripAnsiControlSequences(stderr);
+  const substantive = cleaned.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0 && !patterns.some((re) => re.test(line)));
+  return substantive.join("\n").trim();
+}
+var DEFAULT_PROVIDER_OUTPUT_EXCERPT_LIMIT = 2e4;
+function buildProviderOutputExcerpt(providerId, stdout, stderr, limit = DEFAULT_PROVIDER_OUTPUT_EXCERPT_LIMIT) {
+  const stdoutText = stdout ?? "";
+  const filteredStderr = stripRecoverableProviderStderrForSummary(providerId, stderr ?? "");
+  const combined = filteredStderr ? `${stdoutText}
+
+=== stderr ===
+${filteredStderr}` : stdoutText;
+  const trimmed = combined.trim();
+  return trimmed.length > limit ? trimmed.slice(-limit) : trimmed;
+}
+
+export {
+  stripAnsiControlSequences,
+  isRecoverableProviderStderrChunk,
+  isProviderStderrOnlyRecoverableNoise,
+  stripRecoverableProviderStderrForSummary,
+  buildProviderOutputExcerpt
+};
+//# sourceMappingURL=chunk-MYLH2S4G.js.map

package/dist/chunk-MZ5WYKNA.js

@@ -0,0 +1,28 @@
+// src/core/loop/autoloop-wall-clock.ts
+function resolveAutoloopElapsedMs(handoff, nowMs = Date.now()) {
+  if (typeof handoff.wallClockRunStartMs === "number" && Number.isFinite(handoff.wallClockRunStartMs)) {
+    return Math.max(0, nowMs - handoff.wallClockRunStartMs);
+  }
+  if (typeof handoff.preControllerElapsedMs === "number" && Number.isFinite(handoff.preControllerElapsedMs)) {
+    return Math.max(0, Math.floor(handoff.preControllerElapsedMs));
+  }
+  return 0;
+}
+function resolveAutoloopRemainingMs(timeboxMs, handoff, nowMs = Date.now()) {
+  const effectiveTimeboxMs = typeof timeboxMs === "number" && Number.isFinite(timeboxMs) && timeboxMs > 0 ? timeboxMs : 0;
+  return Math.max(0, Math.floor(effectiveTimeboxMs - resolveAutoloopElapsedMs(handoff, nowMs)));
+}
+function buildAutoloopWallClockHandoff(runStartMs, nowMs = Date.now()) {
+  const preControllerElapsedMs = Math.max(0, nowMs - runStartMs);
+  return {
+    wallClockRunStartMs: runStartMs,
+    preControllerElapsedMs
+  };
+}
+
+export {
+  resolveAutoloopElapsedMs,
+  resolveAutoloopRemainingMs,
+  buildAutoloopWallClockHandoff
+};
+//# sourceMappingURL=chunk-MZ5WYKNA.js.map