@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-GIJWHUWF.js

@@ -0,0 +1,191 @@
+import {
+  resolveReasoningEffort
+} from "./chunk-TGXXYDL4.js";
+import {
+  safeRmDir
+} from "./chunk-ALDTFNZ3.js";
+import {
+  normalizeReasoningEffortInput
+} from "./chunk-4BTDUT2S.js";
+import {
+  CredentialResidueError
+} from "./chunk-RRC5BL7B.js";
+import {
+  emitWarning
+} from "./chunk-7VRJHTGZ.js";
+import {
+  sanitizeString
+} from "./chunk-CPSVQR2I.js";
+
+// src/core/providers/shared/output-drift.ts
+var reported = /* @__PURE__ */ new Set();
+function reportOutputDrift(event) {
+  const key = `${event.provider}:${event.field}`;
+  if (reported.has(key)) return;
+  reported.add(key);
+  const warningSeverity = event.severity === "parse_fallback" ? "WARN" /* WARN */ : "INFO" /* INFO */;
+  emitWarning(
+    "PR-006",
+    {
+      provider: event.provider,
+      subsystem: "provider-output-drift",
+      executionPhase: "execution"
+    },
+    {
+      severity: warningSeverity,
+      metadata: {
+        provider: event.provider,
+        severity: event.severity,
+        field: event.field,
+        detail: event.detail,
+        ...event.outputShapeTag !== void 0 ? { outputShapeTag: event.outputShapeTag } : {}
+      }
+    }
+  );
+}
+
+// src/core/providers/shared/submitted-prompt.ts
+function notifySubmittedPrompt(observer, info) {
+  if (!observer) {
+    return;
+  }
+  try {
+    observer(info);
+  } catch {
+  }
+}
+
+// src/core/providers/runtime-root-ownership.ts
+import * as fs from "fs/promises";
+import * as os from "os";
+import * as path from "path";
+function markCallerOwnedRoot(pathValue) {
+  return { ownership: "caller-owned", path: pathValue };
+}
+function markRunOwnedRoot(pathValue) {
+  return { ownership: "run-owned", path: pathValue };
+}
+function resolveCallerOwnedPath(...candidates) {
+  for (const candidate of candidates) {
+    if (typeof candidate !== "string") {
+      continue;
+    }
+    const trimmed = candidate.trim();
+    if (trimmed.length === 0) {
+      continue;
+    }
+    return markCallerOwnedRoot(trimmed);
+  }
+  return void 0;
+}
+function toPathLabel(filePath) {
+  const segments = filePath.split(path.sep).filter(Boolean);
+  return sanitizeString(segments.slice(-4).join("/"));
+}
+async function assertPathAbsent(filePath, role) {
+  try {
+    await fs.lstat(filePath);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return;
+    }
+    throw new CredentialResidueError({
+      residualPaths: [toPathLabel(filePath)],
+      ownership: "run-owned",
+      role,
+      primaryError: error instanceof Error ? error.message : String(error),
+      cause: error
+    });
+  }
+  throw new CredentialResidueError({
+    residualPaths: [toPathLabel(filePath)],
+    ownership: "run-owned",
+    role
+  });
+}
+async function removeAndVerifyRunOwnedRoot(root, opts) {
+  if (root.ownership !== "run-owned") {
+    throw new CredentialResidueError({
+      residualPaths: [toPathLabel(root.path)],
+      ownership: root.ownership === "worktree-owned" ? "worktree-owned" : "run-owned",
+      role: opts?.role ?? `invalid-ownership:${root.ownership}`,
+      message: `Refusing to remove non-run-owned runtime root (ownership=${root.ownership})`
+    });
+  }
+  try {
+    await safeRmDir(root.path, {
+      protectedPaths: [os.tmpdir()],
+      managedRoots: [os.tmpdir()]
+    });
+  } catch (error) {
+    const code = error.code;
+    if (code !== "ENOENT") {
+      throw new CredentialResidueError({
+        residualPaths: [toPathLabel(root.path)],
+        ownership: "run-owned",
+        role: opts?.role,
+        primaryError: error instanceof Error ? error.message : String(error),
+        cause: error
+      });
+    }
+  }
+  await assertPathAbsent(root.path, opts?.role);
+}
+function contextualizeCredentialCleanupError(cleanupError, primaryError, role = cleanupError.role) {
+  return new CredentialResidueError({
+    residualPaths: cleanupError.residualPaths,
+    ownership: cleanupError.ownership,
+    role,
+    primaryError: primaryError instanceof Error ? primaryError.message : String(primaryError),
+    cause: primaryError
+  });
+}
+function aggregateCredentialResidueErrors(errors, options) {
+  const residualPaths = [...new Set(errors.flatMap((error) => error.residualPaths))];
+  const primaryError = options.primaryError ?? errors[0];
+  return new CredentialResidueError({
+    residualPaths,
+    ownership: options.ownership,
+    role: options.role,
+    primaryError: primaryError instanceof Error ? primaryError.message : String(primaryError),
+    cause: primaryError
+  });
+}
+
+// src/core/providers/opencode/reasoning-variant.ts
+function normalizeOpencodeReasoningEffort(value) {
+  return normalizeReasoningEffortInput(value);
+}
+function resolveOpencodeReasoningEffort(effort, isExplicitRequest, model) {
+  return resolveReasoningEffort("opencode", effort, isExplicitRequest, model);
+}
+function prepareOpencodeVariant(input) {
+  if (Object.keys(input.native ?? {}).length || input.serviceTier) {
+    throw new Error(
+      `Provider 'opencode' does not support structured native options or service tier requests.`
+    );
+  }
+  if (!input.effort || normalizeReasoningEffortInput(input.effort)) return input;
+  const variant = input.effort;
+  const { effort: _dropped, ...rest } = structuredClone(input);
+  return { ...rest, native: { variant } };
+}
+function opencodeNativeVariant(invocation) {
+  const variant = invocation?.resolution.resolved.native?.variant;
+  return typeof variant === "string" && variant ? variant : void 0;
+}
+
+export {
+  reportOutputDrift,
+  notifySubmittedPrompt,
+  markRunOwnedRoot,
+  resolveCallerOwnedPath,
+  removeAndVerifyRunOwnedRoot,
+  contextualizeCredentialCleanupError,
+  aggregateCredentialResidueErrors,
+  normalizeOpencodeReasoningEffort,
+  resolveOpencodeReasoningEffort,
+  prepareOpencodeVariant,
+  opencodeNativeVariant
+};
+//# sourceMappingURL=chunk-GIJWHUWF.js.map

package/dist/chunk-GO6DRECI.js

@@ -0,0 +1 @@
+//# sourceMappingURL=chunk-GO6DRECI.js.map

package/dist/chunk-GOFVBTMN.js

@@ -0,0 +1,314 @@
+import {
+  ValidationError
+} from "./chunk-RRC5BL7B.js";
+
+// src/automation/allowlist-grounding.ts
+import { execFileSync } from "child_process";
+import fs from "fs";
+import path from "path";
+var FILE_QUERY_STOP_WORDS = /* @__PURE__ */ new Set([
+  "a",
+  "an",
+  "and",
+  "are",
+  "by",
+  "for",
+  "from",
+  "how",
+  "into",
+  "its",
+  "new",
+  "not",
+  "that",
+  "the",
+  "their",
+  "this",
+  "via",
+  "with"
+]);
+var MAX_FILE_QUERY_TOKENS = 64;
+function extractQueryTokens(query) {
+  if (!query) return [];
+  return [
+    ...new Set(
+      query.toLowerCase().split(/[^a-z0-9]+/).filter((token) => token.length >= 3)
+    )
+  ].filter((token) => !FILE_QUERY_STOP_WORDS.has(token)).slice(0, MAX_FILE_QUERY_TOKENS);
+}
+function scoreRepoFileForQuery(file, queryTokens) {
+  if (queryTokens.length === 0) return { score: 0, matchedQuery: false };
+  const normalizedFile = file.toLowerCase();
+  const basename = path.basename(normalizedFile);
+  const segments = normalizedFile.split("/");
+  let score = 0;
+  for (const token of queryTokens) {
+    if (basename === token || basename.startsWith(`${token}.`) || basename.startsWith(`${token}-`)) {
+      score += 12;
+    } else if (basename.includes(token)) {
+      score += 8;
+    }
+    if (segments.includes(token)) {
+      score += 7;
+    } else if (normalizedFile.includes(token)) {
+      score += 4;
+    }
+  }
+  const queryMatchScore = score;
+  if (normalizedFile.startsWith("src/")) score += 2;
+  if (normalizedFile.startsWith("tests/")) score += 1;
+  if (normalizedFile.startsWith(".build-project/config/")) score += 2;
+  return { score, matchedQuery: queryMatchScore > 0 };
+}
+function prioritizeRepoFiles(files, query) {
+  const queryTokens = extractQueryTokens(query);
+  if (queryTokens.length === 0) return { files, relevanceRanked: false };
+  const scored = files.map((file, index) => ({
+    file,
+    index,
+    ...scoreRepoFileForQuery(file, queryTokens)
+  }));
+  return {
+    files: scored.sort((left, right) => right.score - left.score || left.index - right.index).map((entry) => entry.file),
+    // Non-empty tokens alone do not make the list ranked: with zero matches only the
+    // location bonuses apply, so files tie and raw listing order survives. Claiming
+    // relevance then would be the same lie this flag exists to prevent.
+    relevanceRanked: scored.some((entry) => entry.matchedQuery)
+  };
+}
+function getRepoFileTree(cwd, maxEntries = 500, options) {
+  const gitArgs = (extra) => {
+    try {
+      return execFileSync("git", ["ls-files", ...extra], {
+        cwd,
+        timeout: 1e4,
+        maxBuffer: 1024 * 1024,
+        stdio: ["pipe", "pipe", "pipe"]
+      }).toString().trim();
+    } catch {
+      return "";
+    }
+  };
+  const tracked = gitArgs([]);
+  const untracked = gitArgs(["--others", "--exclude-standard"]);
+  const combined = [tracked, untracked].filter(Boolean).flatMap((block) => block.split("\n")).map((line) => line.trim()).filter(Boolean);
+  const unique = [...new Set(combined)];
+  const prioritized = prioritizeRepoFiles(unique, options?.query);
+  return {
+    files: prioritized.files.slice(0, maxEntries),
+    truncated: unique.length > maxEntries,
+    relevanceRanked: prioritized.relevanceRanked
+  };
+}
+function isWithinRepo(repoRoot, candidate) {
+  const relative = path.relative(repoRoot, candidate);
+  return relative === "" || !relative.startsWith("..") && !path.isAbsolute(relative);
+}
+function normalizeDirectoryEntry(entry) {
+  const normalized = entry.replace(/\\/g, "/");
+  return normalized.endsWith("/") ? normalized : `${normalized}/`;
+}
+function getParentDirectoryEntry(entry) {
+  const normalized = normalizeDirectoryEntry(entry).slice(0, -1);
+  const parent = path.posix.dirname(normalized);
+  if (!parent || parent === "." || parent === normalized) {
+    return null;
+  }
+  return `${parent}/`;
+}
+function findPlannedAncestorDirectory(filePath, validDirectoryEntries) {
+  let current = path.posix.dirname(filePath.replace(/\\/g, "/"));
+  while (current && current !== "." && current !== "/") {
+    const candidate = `${current}/`;
+    if (validDirectoryEntries.has(candidate)) {
+      return candidate;
+    }
+    const parent = path.posix.dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return void 0;
+}
+function findExistingAncestorDirectory(repoRoot, resolved, includeRepoRoot = false) {
+  let current = path.dirname(resolved);
+  while (isWithinRepo(repoRoot, current) && (includeRepoRoot || current !== repoRoot)) {
+    if (fs.existsSync(current)) {
+      try {
+        return fs.statSync(current).isDirectory() ? current : void 0;
+      } catch {
+        return void 0;
+      }
+    }
+    const parent = path.dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return void 0;
+}
+function normalizeValidationArtifactEntry(entry) {
+  let normalized = entry.replace(/\\/g, "/").trim();
+  while (normalized.startsWith("./")) {
+    normalized = normalized.slice(2);
+  }
+  return normalized;
+}
+function isValidationArtifactEntry(entry) {
+  const normalized = normalizeValidationArtifactEntry(entry);
+  if (normalized === ".build-project/validation/" || normalized.startsWith(".build-project/validation/")) {
+    return true;
+  }
+  if (!normalized.startsWith("dogfood-validation-artifacts/")) return false;
+  const relative = normalized.slice("dogfood-validation-artifacts/".length);
+  return relative.length > 0 && !relative.split("/").includes("..");
+}
+function groundAllowlistEntries(entries, cwd) {
+  const kept = [];
+  const removed = [];
+  const warnings = [];
+  const repoRoot = path.resolve(cwd);
+  const normalizedEntries = entries.map((entry) => entry.trim()).filter(Boolean);
+  const plannedDirectoryEntries = new Set(
+    normalizedEntries.filter((entry) => entry.endsWith("/")).map(normalizeDirectoryEntry)
+  );
+  const plannedFileEntries = normalizedEntries.filter((entry) => !entry.endsWith("/")).map((entry) => entry.replace(/\\/g, "/"));
+  const validPlannedDirectoryCache = /* @__PURE__ */ new Map();
+  const isValidPlannedDirectory = (entry) => {
+    const normalizedEntry = normalizeDirectoryEntry(entry);
+    const cached = validPlannedDirectoryCache.get(normalizedEntry);
+    if (cached !== void 0) {
+      return cached;
+    }
+    const resolved = path.resolve(repoRoot, normalizedEntry);
+    let valid = false;
+    if (fs.existsSync(resolved)) {
+      try {
+        valid = fs.statSync(resolved).isDirectory();
+      } catch {
+        valid = false;
+      }
+    } else {
+      const parentDir = path.dirname(resolved);
+      if (fs.existsSync(parentDir)) {
+        valid = true;
+      } else {
+        const parentEntry = getParentDirectoryEntry(normalizedEntry);
+        valid = parentEntry !== null && plannedDirectoryEntries.has(parentEntry) && isValidPlannedDirectory(parentEntry) || !isValidationArtifactEntry(normalizedEntry) && plannedFileEntries.some((file) => file.startsWith(normalizedEntry));
+      }
+    }
+    validPlannedDirectoryCache.set(normalizedEntry, valid);
+    return valid;
+  };
+  const validPlannedDirectoryEntries = new Set(
+    [...plannedDirectoryEntries].filter((entry) => isValidPlannedDirectory(entry))
+  );
+  for (const entry of entries) {
+    const trimmedEntry = entry.trim();
+    if (!trimmedEntry) continue;
+    const resolved = path.resolve(repoRoot, trimmedEntry);
+    if (!isWithinRepo(repoRoot, resolved)) {
+      removed.push(trimmedEntry);
+      warnings.push(`Removed allowlist entry "${trimmedEntry}": resolves outside repository root`);
+      continue;
+    }
+    if (trimmedEntry.endsWith("/")) {
+      if (fs.existsSync(resolved)) {
+        try {
+          const stats = fs.statSync(resolved);
+          if (stats.isDirectory()) {
+            kept.push(trimmedEntry);
+          } else {
+            removed.push(trimmedEntry);
+            warnings.push(
+              `Removed allowlist directory "${trimmedEntry}": path exists but is not a directory`
+            );
+          }
+        } catch {
+          removed.push(trimmedEntry);
+          warnings.push(
+            `Removed allowlist directory "${trimmedEntry}": path exists but could not be inspected`
+          );
+        }
+      } else {
+        const parentDir = path.dirname(resolved);
+        if (fs.existsSync(parentDir)) {
+          kept.push(trimmedEntry);
+          warnings.push(
+            `Kept allowlist directory "${trimmedEntry}": planned new directory; parent directory exists`
+          );
+        } else {
+          const plannedAncestorDir = findPlannedAncestorDirectory(
+            trimmedEntry,
+            validPlannedDirectoryEntries
+          );
+          if (plannedAncestorDir) {
+            kept.push(trimmedEntry);
+            warnings.push(
+              `Kept allowlist directory "${trimmedEntry}": planned new directory under allowlisted directory "${plannedAncestorDir}" in this stage`
+            );
+          } else if (isValidationArtifactEntry(trimmedEntry)) {
+            kept.push(trimmedEntry);
+            warnings.push(
+              `Kept allowlist directory "${trimmedEntry}": planned validation artifact directory; parent directory will be created at runtime`
+            );
+          } else if (validPlannedDirectoryEntries.has(normalizeDirectoryEntry(trimmedEntry))) {
+            kept.push(trimmedEntry);
+            warnings.push(
+              `Kept allowlist directory "${trimmedEntry}": planned new directory with planned files in this stage`
+            );
+          } else if (findExistingAncestorDirectory(repoRoot, resolved)) {
+            kept.push(trimmedEntry);
+            warnings.push(
+              `Kept allowlist directory "${trimmedEntry}": planned new directory under an existing directory`
+            );
+          } else {
+            removed.push(trimmedEntry);
+            warnings.push(
+              `Removed allowlist directory "${trimmedEntry}": directory does not exist`
+            );
+          }
+        }
+      }
+      continue;
+    }
+    if (fs.existsSync(resolved)) {
+      kept.push(trimmedEntry);
+      continue;
+    }
+    const ancestor = findExistingAncestorDirectory(repoRoot, resolved, true);
+    if (ancestor) {
+      kept.push(trimmedEntry);
+      warnings.push(
+        ancestor === path.dirname(resolved) ? `Kept allowlist entry "${trimmedEntry}": planned new file; parent directory exists` : `Kept allowlist entry "${trimmedEntry}": planned new file in a new directory under an existing directory`
+      );
+    } else {
+      removed.push(trimmedEntry);
+      warnings.push(
+        `Removed allowlist entry "${trimmedEntry}": nearest existing ancestor is not a directory`
+      );
+    }
+  }
+  return { kept, removed, warnings };
+}
+var UngroundedAllowlistError = class extends ValidationError {
+  /** Allowlist entries (warning messages) that were removed during grounding */
+  removed;
+  /** Human-readable grounding warnings for all entries */
+  warnings;
+  constructor(removed, warnings) {
+    super(
+      "Decomposition plan contains ungrounded allowlist entries that were removed during grounding. Pass --allow-ungrounded to proceed anyway.\n" + removed.join("\n"),
+      { removed, warnings }
+    );
+    this.name = "UngroundedAllowlistError";
+    this.code = "UNGROUNDED_ALLOWLIST";
+    this.removed = removed;
+    this.warnings = warnings;
+  }
+};
+
+export {
+  getRepoFileTree,
+  isValidationArtifactEntry,
+  groundAllowlistEntries,
+  UngroundedAllowlistError
+};
+//# sourceMappingURL=chunk-GOFVBTMN.js.map

package/dist/chunk-GQIP72ZJ.js

@@ -0,0 +1,13 @@
+// src/orchestrator/autoloop-gate-presets.ts
+var PRESET_GATE_KINDS = {
+  fast: ["lint", "typecheck"],
+  safe: ["lint", "typecheck", "unit"]
+};
+function autoloopPresetIncludesGateKind(preset, kind) {
+  return preset === "full" || PRESET_GATE_KINDS[preset].includes(kind);
+}
+
+export {
+  autoloopPresetIncludesGateKind
+};
+//# sourceMappingURL=chunk-GQIP72ZJ.js.map

package/dist/chunk-GQXLXRFA.js

@@ -0,0 +1,28 @@
+// src/core/output/events.ts
+function createOutputEvent(level, message, options = {}) {
+  return {
+    level,
+    message,
+    ...options
+  };
+}
+function infoEvent(message, options) {
+  return createOutputEvent("info", message, options);
+}
+function successEvent(message, options) {
+  return createOutputEvent("success", message, options);
+}
+function warningEvent(message, options) {
+  return createOutputEvent("warning", message, options);
+}
+function errorEvent(message, options) {
+  return createOutputEvent("error", message, options);
+}
+
+export {
+  infoEvent,
+  successEvent,
+  warningEvent,
+  errorEvent
+};
+//# sourceMappingURL=chunk-GQXLXRFA.js.map

package/dist/chunk-GT6HFKJB.js

@@ -0,0 +1,48 @@
+// src/core/providers/dry-run-store.ts
+import fs from "fs";
+import path from "path";
+var DEFAULT_DRY_RUN_TTL_MS = 24 * 60 * 60 * 1e3;
+function resolveBuildDir(buildDirOrRepoRoot) {
+  const resolved = path.resolve(buildDirOrRepoRoot);
+  return path.basename(resolved) === ".build-project" ? resolved : path.join(resolved, ".build-project");
+}
+function resolveDryRunStorePath(buildDirOrRepoRoot) {
+  return path.join(resolveBuildDir(buildDirOrRepoRoot), "state", "provider-dry-runs.json");
+}
+function readStoreFile(filePath) {
+  try {
+    const raw = fs.readFileSync(filePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object" && parsed.providers && typeof parsed.providers === "object") {
+      return { version: 1, providers: parsed.providers };
+    }
+  } catch {
+  }
+  return { version: 1, providers: {} };
+}
+function readDryRunFreshness(providerId, options) {
+  const now = options.now ?? Date.now;
+  const ttlMs = options.ttlMs ?? DEFAULT_DRY_RUN_TTL_MS;
+  const file = readStoreFile(options.filePath);
+  const record = file.providers[providerId];
+  if (!record || typeof record.lastSuccessMs !== "number") {
+    return void 0;
+  }
+  const age = now() - record.lastSuccessMs;
+  return {
+    lastSuccessMs: record.lastSuccessMs,
+    fresh: age >= 0 && age < ttlMs
+  };
+}
+function readProviderDryRunFreshness(providerId, buildDirOrRepoRoot, options = {}) {
+  return readDryRunFreshness(providerId, {
+    filePath: resolveDryRunStorePath(buildDirOrRepoRoot),
+    ...options.ttlMs !== void 0 ? { ttlMs: options.ttlMs } : {},
+    ...options.now ? { now: options.now } : {}
+  });
+}
+
+export {
+  readProviderDryRunFreshness
+};
+//# sourceMappingURL=chunk-GT6HFKJB.js.map