@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-CSOPSYDY.js

@@ -0,0 +1,142 @@
+import {
+  assertMockProvidersAllowedInProduction
+} from "./chunk-VMFZEVVX.js";
+import {
+  assertSkipAuthAllowed
+} from "./chunk-33IGPPUI.js";
+import {
+  BUILD_MOCK_PROVIDERS,
+  BUILD_SKIP_AUTH,
+  readEnv
+} from "./chunk-7VRJHTGZ.js";
+
+// src/core/environment.ts
+import { spawnSync } from "child_process";
+import { existsSync } from "fs";
+import os from "os";
+import path from "path";
+var GH_AUTH_STATUS_ARGS = ["auth", "status", "--hostname", "github.com"];
+var DEFAULT_CLI_DETECTION_TIMEOUT_MS = 3e3;
+var MIN_CLI_DETECTION_TIMEOUT_MS = 500;
+var MAX_CLI_DETECTION_TIMEOUT_MS = 3e4;
+function getCliDetectionTimeoutMs() {
+  const rawTimeout = process.env.BUILD_CLI_DETECTION_TIMEOUT_MS;
+  if (!rawTimeout) return DEFAULT_CLI_DETECTION_TIMEOUT_MS;
+  const parsed = Number.parseInt(rawTimeout, 10);
+  if (!Number.isFinite(parsed)) return DEFAULT_CLI_DETECTION_TIMEOUT_MS;
+  return Math.min(MAX_CLI_DETECTION_TIMEOUT_MS, Math.max(MIN_CLI_DETECTION_TIMEOUT_MS, parsed));
+}
+function getCopilotConfigPaths() {
+  const paths = /* @__PURE__ */ new Set();
+  const explicit = process.env.GITHUB_COPILOT_CONFIG_DIR;
+  if (explicit) paths.add(explicit);
+  const xdgConfig = process.env.XDG_CONFIG_HOME;
+  if (xdgConfig) {
+    paths.add(path.join(xdgConfig, "github-copilot"));
+  }
+  const homeDirectory = os.homedir?.();
+  const platform = process.platform;
+  if (homeDirectory) {
+    if (platform === "win32") {
+      paths.add(path.join(homeDirectory, "AppData", "Roaming", "GitHub Copilot"));
+      paths.add(path.join(homeDirectory, "AppData", "Local", "GitHub", "Copilot"));
+    } else {
+      paths.add(path.join(homeDirectory, ".config", "github-copilot"));
+      paths.add(path.join(homeDirectory, ".config", "github-copilot-cli"));
+      if (platform === "darwin") {
+        paths.add(path.join(homeDirectory, "Library", "Application Support", "github-copilot"));
+      }
+    }
+  }
+  return Array.from(paths);
+}
+function hasCopilotConfigDirectory() {
+  try {
+    return getCopilotConfigPaths().some((candidate) => {
+      try {
+        return existsSync(candidate);
+      } catch {
+        return false;
+      }
+    });
+  } catch {
+    return false;
+  }
+}
+function hasCopilotEnvironmentToken() {
+  const candidates = [process.env.GITHUB_TOKEN, process.env.GH_TOKEN, process.env.COPILOT_TOKEN];
+  return candidates.some((value) => typeof value === "string" && value.trim().length > 0);
+}
+function isGhAuthenticated() {
+  try {
+    const timeoutMs = getCliDetectionTimeoutMs();
+    const result = spawnSync("gh", GH_AUTH_STATUS_ARGS, {
+      encoding: "utf8",
+      stdio: "pipe",
+      timeout: timeoutMs
+    });
+    return !result.error && result.status === 0;
+  } catch {
+    return false;
+  }
+}
+function getCopilotAvailabilityDiagnostics(options = {}) {
+  const envToken = hasCopilotEnvironmentToken();
+  const configDir = hasCopilotConfigDirectory();
+  const ghAuth = options.mode === "passive" ? false : isGhAuthenticated();
+  const isReady = ghAuth || configDir;
+  return {
+    isReady,
+    signals: {
+      envToken,
+      ghAuth,
+      configDir
+    }
+  };
+}
+
+// src/core/providers/copilot/auth.ts
+function assertAuthBypassAllowed() {
+  if (readEnv(BUILD_SKIP_AUTH).value) {
+    assertSkipAuthAllowed();
+  }
+  if (readEnv(BUILD_MOCK_PROVIDERS).value === "1") {
+    assertMockProvidersAllowedInProduction();
+  }
+}
+async function isAuthenticatedTriState(options) {
+  if (readEnv(BUILD_SKIP_AUTH).value || readEnv(BUILD_MOCK_PROVIDERS).value === "1") {
+    assertAuthBypassAllowed();
+    return "yes";
+  }
+  const mode = options?.mode ?? "passive";
+  const diagnostics = getCopilotAvailabilityDiagnostics({ mode });
+  if (diagnostics.signals.ghAuth) {
+    return "yes";
+  }
+  if (diagnostics.signals.configDir) {
+    return "unknown";
+  }
+  return "no";
+}
+async function isAuthenticatedInternal(options = {}) {
+  return await isAuthenticatedTriState(options) === "yes";
+}
+var auth = {
+  async isAuthenticated(options) {
+    return await isAuthenticatedInternal(options);
+  },
+  isAuthenticatedTriState
+};
+var auth_default = auth;
+async function isAuthenticated(options) {
+  return await auth.isAuthenticated(options);
+}
+
+export {
+  isAuthenticatedTriState,
+  auth,
+  auth_default,
+  isAuthenticated
+};
+//# sourceMappingURL=chunk-CSOPSYDY.js.map

package/dist/chunk-CSXLLEGB.js

@@ -0,0 +1,205 @@
+import {
+  clearIndexCache
+} from "./chunk-LJVH57G2.js";
+import {
+  generateIndexes
+} from "./chunk-VAG6GUBR.js";
+import {
+  acquireFencedFileLock,
+  ensureLockTargetFile
+} from "./chunk-QYQOVOLR.js";
+import {
+  slugify
+} from "./chunk-2VLJUXJU.js";
+import {
+  emitWarning,
+  getExecutionContext
+} from "./chunk-7VRJHTGZ.js";
+
+// src/planning/shared-utils.ts
+import { AsyncLocalStorage } from "async_hooks";
+import { realpathSync } from "fs";
+import * as fs from "fs/promises";
+import * as path from "path";
+function slugify2(title, maxWords = 5) {
+  return slugify(title).split("-").slice(0, maxWords).join("-");
+}
+function getPlanningRoot() {
+  return getExecutionContext().repoRoot;
+}
+async function getNextSequentialId(dir, prefix, slug, digits = 3) {
+  const files = await fs.readdir(dir).catch(() => []);
+  const escapedPrefix = prefix.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&");
+  const pattern = new RegExp(`^${escapedPrefix}(\\d+)-`);
+  let maxNum = 0;
+  for (const file of files) {
+    const match = file.match(pattern);
+    if (match?.[1]) {
+      const num = Number.parseInt(match[1], 10);
+      if (num > maxNum) {
+        maxNum = num;
+      }
+    }
+  }
+  const nextNum = (maxNum + 1).toString().padStart(digits, "0");
+  return `${prefix}${nextNum}-${slug}`;
+}
+var _planningQueues = /* @__PURE__ */ new Map();
+var _planningOwners = /* @__PURE__ */ new Map();
+var _planningOwnerContext = new AsyncLocalStorage();
+function getCanonicalKey(p) {
+  const resolved = path.resolve(p);
+  try {
+    return realpathSync(resolved);
+  } catch {
+    return resolved;
+  }
+}
+var PLANNING_LOCK_STALE_MS = 1e4;
+var PLANNING_LOCK_RETRIES = 50;
+var PLANNING_LOCK_MIN_TIMEOUT_MS = 100;
+var PLANNING_LOCK_MAX_TIMEOUT_MS = 1e3;
+function withPlanningLock(rootDir, operation) {
+  const key = getCanonicalKey(rootDir);
+  const lockPath = path.join(key, ".build-project", "state", "planning.lock");
+  const held = _planningOwnerContext.getStore();
+  const currentOwner = held?.get(key);
+  if (currentOwner && _planningOwners.get(key) === currentOwner) {
+    try {
+      return Promise.resolve(operation());
+    } catch (error) {
+      return Promise.reject(error);
+    }
+  }
+  const previous = (_planningQueues.get(key) ?? Promise.resolve()).catch(() => {
+  });
+  let releaseQueue;
+  const mySlot = new Promise((resolve2) => {
+    releaseQueue = resolve2;
+  });
+  const tail = previous.then(() => mySlot);
+  _planningQueues.set(key, tail);
+  return previous.then(async () => {
+    const owner = Symbol(key);
+    const nextHeld = new Map(held ?? []);
+    nextHeld.set(key, owner);
+    _planningOwners.set(key, owner);
+    let releaseFile;
+    try {
+      await fs.mkdir(path.dirname(lockPath), { recursive: true });
+      await ensureLockTargetFile(lockPath);
+      releaseFile = await acquireFencedFileLock(lockPath, {
+        stale: PLANNING_LOCK_STALE_MS,
+        realpath: false,
+        retries: {
+          retries: PLANNING_LOCK_RETRIES,
+          minTimeout: PLANNING_LOCK_MIN_TIMEOUT_MS,
+          maxTimeout: PLANNING_LOCK_MAX_TIMEOUT_MS
+        },
+        description: "Planning lock"
+      });
+      await releaseFile.assertOwned();
+      const result = await _planningOwnerContext.run(nextHeld, operation);
+      await releaseFile.assertOwned();
+      return result;
+    } finally {
+      try {
+        if (releaseFile) {
+          await releaseFile();
+          if (!releaseFile.isOwned()) {
+            await releaseFile.assertOwned();
+          }
+        }
+      } finally {
+        if (_planningOwners.get(key) === owner) {
+          _planningOwners.delete(key);
+        }
+        releaseQueue?.();
+        if (_planningQueues.get(key) === tail) {
+          _planningQueues.delete(key);
+        }
+      }
+    }
+  });
+}
+var _deferCounts = /* @__PURE__ */ new Map();
+function isIndexRegenerationDeferred(rootDir) {
+  const key = getCanonicalKey(rootDir);
+  return (_deferCounts.get(key) ?? 0) > 0;
+}
+async function withDeferredIndexRegeneration(rootDir, operation) {
+  return withPlanningLock(rootDir, async () => {
+    const key = getCanonicalKey(rootDir);
+    const prev = _deferCounts.get(key) ?? 0;
+    const isOutermost = prev === 0;
+    _deferCounts.set(key, prev + 1);
+    try {
+      return await operation();
+    } finally {
+      const current = _deferCounts.get(key) ?? 1;
+      if (current <= 1) {
+        _deferCounts.delete(key);
+      } else {
+        _deferCounts.set(key, current - 1);
+      }
+      if (isOutermost) {
+        await generateIndexes(rootDir).catch((error) => {
+          emitWarning(
+            "CFG-002",
+            {
+              taskId: "shared-utils",
+              subsystem: "planning",
+              executionPhase: "cleanup"
+            },
+            {
+              severity: "INFO" /* INFO */,
+              metadata: {
+                error: error instanceof Error ? error.message : String(error),
+                operation: "deferred-regenerate-indexes"
+              }
+            }
+          );
+        });
+        clearIndexCache();
+      }
+    }
+  });
+}
+async function withIndexRegeneration(rootDir, operation) {
+  return withPlanningLock(rootDir, async () => {
+    const result = await operation();
+    if (isIndexRegenerationDeferred(rootDir)) {
+      return result;
+    }
+    await generateIndexes(rootDir).catch((error) => {
+      emitWarning(
+        "CFG-002",
+        {
+          taskId: "shared-utils",
+          subsystem: "planning",
+          executionPhase: "cleanup"
+        },
+        {
+          severity: "INFO" /* INFO */,
+          metadata: {
+            error: error instanceof Error ? error.message : String(error),
+            operation: "regenerate-indexes"
+          }
+        }
+      );
+    });
+    clearIndexCache();
+    return result;
+  });
+}
+
+export {
+  slugify2 as slugify,
+  getPlanningRoot,
+  getNextSequentialId,
+  withPlanningLock,
+  isIndexRegenerationDeferred,
+  withDeferredIndexRegeneration,
+  withIndexRegeneration
+};
+//# sourceMappingURL=chunk-CSXLLEGB.js.map

package/dist/chunk-CTDLERWU.js

@@ -0,0 +1,293 @@
+import {
+  latestVerificationIteration
+} from "./chunk-3OPP2OZB.js";
+import {
+  parseDiffGitHeaderPaths,
+  parseUnifiedDiffPathLine
+} from "./chunk-5FKHIKTS.js";
+import {
+  isGeneratedLockfilePath
+} from "./chunk-D4VJFCGZ.js";
+import {
+  parseGitStatus
+} from "./chunk-5KQETTNS.js";
+
+// src/core/judge/signal-reliability.ts
+function hasUnavailableGate(variant) {
+  const last = latestVerificationIteration(variant.verificationLoop);
+  return [last?.build, last?.tests, last?.lint].some(
+    (gate) => gate?.status === "unavailable" || gate?.status === "skipped" && gate.verificationCoverage?.status !== "skipped_not_relevant"
+  );
+}
+function hasHardVerificationFinding(variant) {
+  return (variant.verification?.findings ?? []).some((finding) => finding.severity === "error");
+}
+function analyzeVerificationEvidenceQuality(variant) {
+  const reasons = [];
+  const last = latestVerificationIteration(variant.verificationLoop);
+  const verification = variant.verification;
+  if (!verification && !last && !variant.testStatus && !variant.testsExecuted) {
+    return {
+      quality: "unavailable",
+      reasons: ["no host verification, verification loop, or trusted test execution evidence"],
+      instruction: "Treat build/test verification as unavailable; judge from diff and deliverable evidence."
+    };
+  }
+  const unavailableGate = hasUnavailableGate(variant);
+  if (unavailableGate) {
+    reasons.push("one or more deterministic gates were unavailable or skipped");
+  }
+  const testsPassed = last?.tests?.status === "passed" || variant.testsExecuted && variant.testsExecuted.scope !== "none" && variant.testStatus === "passed";
+  const noHardFindings = !hasHardVerificationFinding(variant);
+  const passedBaseline = variant.verificationLoop?.passedBaseline === true;
+  const verificationFalse = verification?.passed === false || variant.verificationLoop?.passed === false;
+  if (verificationFalse && passedBaseline && noHardFindings) {
+    reasons.push(
+      "verification did not fully pass, but baseline-aware verification found no new hard failures"
+    );
+  }
+  if (verificationFalse && testsPassed && noHardFindings) {
+    reasons.push("test evidence passed while overall verification remained incomplete");
+  }
+  const findingContradictsPassedTest = testsPassed && (verification?.findings ?? []).some(
+    (finding) => finding.kind === "test" && finding.exitCode !== 0
+  );
+  if (findingContradictsPassedTest) {
+    return {
+      quality: "contradicted",
+      reasons: ["passed test evidence conflicts with test failure findings"],
+      instruction: "Do not treat the verification record as decisive until the contradiction is resolved."
+    };
+  }
+  if (reasons.length > 0) {
+    return {
+      // A single unavailable gate makes the verification record partial, not
+      // wholly unavailable, because other gates or baseline evidence may still
+      // provide useful factual signal.
+      quality: "partial",
+      reasons,
+      instruction: "Treat this as partial verification evidence, not as proof of a variant-introduced failure without independent diff or failure-output evidence."
+    };
+  }
+  if (verification?.passed === true || hasHardVerificationFinding(variant)) {
+    return {
+      quality: "trusted",
+      reasons: [
+        verification?.passed === true ? "host verification passed" : "host verification produced concrete failure findings"
+      ],
+      instruction: "Use verification evidence normally as factual input."
+    };
+  }
+  return {
+    quality: "unavailable",
+    reasons: ["verification state is present but does not contain decisive pass/fail evidence"],
+    instruction: "Treat build/test verification as unavailable; judge from diff and deliverable evidence."
+  };
+}
+function formatVerificationEvidenceQualitySummary(variant, options = {}) {
+  const summary = analyzeVerificationEvidenceQuality(variant);
+  const lines = [options.heading ?? "**Verification Evidence Quality**:"];
+  lines.push(`  quality: ${summary.quality}`);
+  for (const reason of summary.reasons) {
+    lines.push(`  - ${reason}`);
+  }
+  lines.push(`  instruction: ${summary.instruction}`);
+  return lines.join("\n");
+}
+function computeSignalReliabilitySummary(options, config = {}) {
+  const signals = options.empiricalSignals;
+  const rows = [];
+  if (signals?.buildSignal && (signals.buildSignal === "pass" || signals.buildSignal === "fail")) {
+    if (signals.baselineHealthy === false) {
+      rows.push({
+        signal: "buildGate",
+        reliability: "partial",
+        reason: "baseline unhealthy; delta unreliable"
+      });
+    } else {
+      rows.push({
+        signal: "buildGate",
+        reliability: "measured",
+        reason: "build gate executed with healthy baseline"
+      });
+    }
+  } else {
+    rows.push({ signal: "buildGate", reliability: "unavailable", reason: "build signal absent" });
+  }
+  if (signals?.testGate && signals.testGate.testsRun > 0) {
+    const totalAccounted = (signals.testGate.testsPassed ?? 0) + (signals.testGate.testsFailed ?? 0);
+    if (totalAccounted < signals.testGate.testsRun) {
+      rows.push({
+        signal: "testStatus",
+        reliability: "partial",
+        reason: "accounted tests < testsRun"
+      });
+    } else {
+      rows.push({
+        signal: "testStatus",
+        reliability: "measured",
+        reason: "test gate executed with results"
+      });
+    }
+  } else if (signals?.testStatus) {
+    rows.push({
+      signal: "testStatus",
+      reliability: "inferred",
+      reason: "testStatus present but no testGate verification"
+    });
+  } else {
+    rows.push({
+      signal: "testStatus",
+      reliability: "unavailable",
+      reason: "no test signals present"
+    });
+  }
+  rows.push({ signal: "diffStats", reliability: "measured", reason: "git-computed" });
+  if (typeof signals?.newErrorCount === "number") {
+    if (signals.baselineHealthy === true) {
+      rows.push({
+        signal: "newErrorCount",
+        reliability: "measured",
+        reason: "computed against healthy baseline"
+      });
+    } else {
+      rows.push({
+        signal: "newErrorCount",
+        reliability: "partial",
+        reason: "baseline unhealthy; delta may include pre-existing errors"
+      });
+    }
+  } else {
+    rows.push({ signal: "newErrorCount", reliability: "unavailable", reason: "not computed" });
+  }
+  const experimental = config.experimental !== false;
+  const lines = [
+    `${experimental ? "[EXPERIMENTAL] " : ""}# Signal Reliability`,
+    "",
+    "| Signal | Reliability | Reason |",
+    "|--------|------------|--------|"
+  ];
+  for (const row of rows) {
+    lines.push(`| ${row.signal} | ${row.reliability} | ${row.reason} |`);
+  }
+  lines.push("");
+  lines.push(
+    "Weight findings by signal reliability. Do NOT assert critical deficiencies based on 'inferred' or 'unavailable' signals without independent evidence from the diff."
+  );
+  return lines.join("\n");
+}
+
+// src/core/judge/file-inventory.ts
+var SUSPICIOUS_PATTERNS = [
+  /^\.build-project\//,
+  /(?:^|\/)node_modules\//,
+  /\.db$/,
+  /\.db-wal$/,
+  /\.db-shm$/,
+  /(?:^|\/)package-lock\.json$/,
+  /(?:^|\/)pnpm-lock\.yaml$/,
+  /(?:^|\/)yarn\.lock$/,
+  /(?:^|\/)dist\//,
+  /(?:^|\/)build\//,
+  /(?:^|\/)\.cache\//,
+  /\.log$/
+];
+function isSuspicious(filePath) {
+  if (SUSPICIOUS_PATTERNS.some((pattern) => pattern.test(filePath))) return true;
+  return isGeneratedLockfilePath(filePath);
+}
+function filePathFromStatusLine(statusLine) {
+  if (statusLine.length < 4) return null;
+  return parseGitStatus(statusLine)[0]?.path ?? null;
+}
+function normalizeInventoryPath(filePath) {
+  return filePath.replace(/\\/g, "/").replace(/^(\.\/)+/, "").replace(/\/+/g, "/").toLowerCase();
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function createTargetMatcher(normalizedTarget) {
+  if (normalizedTarget.endsWith("/")) {
+    return (normalizedArtifact) => normalizedArtifact.startsWith(normalizedTarget);
+  }
+  if (normalizedTarget.includes("*") || normalizedTarget.includes("?")) {
+    const wildcardPattern = escapeRegExp(normalizedTarget).replace(/\\\*\\\*\//g, "(?:.*/)?").replace(/\\\*\\\*/g, ".*").replace(/\\\*/g, "[^/]*").replace(/\\\?/g, "[^/]");
+    const pattern = `^${wildcardPattern}$`;
+    const regex = new RegExp(pattern);
+    return (normalizedArtifact) => regex.test(normalizedArtifact);
+  }
+  return (normalizedArtifact) => normalizedArtifact === normalizedTarget;
+}
+function computeFileTargetCoverage(artifactList, fileConstraint) {
+  if (!fileConstraint || fileConstraint.mode === "none" || fileConstraint.targets.length === 0) {
+    return void 0;
+  }
+  const targets = Array.from(new Set(fileConstraint.targets.map(normalizeInventoryPath))).filter(
+    Boolean
+  );
+  const targetMatchers = targets.map((target) => ({
+    target,
+    matches: createTargetMatcher(target)
+  }));
+  const normalizedArtifacts = artifactList.map((artifact) => ({
+    artifact,
+    normalized: normalizeInventoryPath(artifact)
+  }));
+  const touchedTargets = targetMatchers.filter(({ matches }) => normalizedArtifacts.some(({ normalized }) => matches(normalized))).map(({ target }) => target);
+  const missingTargets = targets.filter((target) => !touchedTargets.includes(target));
+  const offTargetArtifacts = fileConstraint.mode === "hard" ? normalizedArtifacts.filter(({ normalized }) => !targetMatchers.some(({ matches }) => matches(normalized))).map(({ artifact }) => artifact) : [];
+  return {
+    mode: fileConstraint.mode,
+    targetCount: targets.length,
+    touchedTargets,
+    missingTargets,
+    offTargetArtifacts
+  };
+}
+function buildVariantFileInventory(result, options) {
+  const diffSource = result.worktreeDiff ?? result.output ?? "";
+  const fileSet = /* @__PURE__ */ new Set();
+  for (const header of diffSource.match(/^diff --git .+$/gm) ?? []) {
+    const bPath = parseDiffGitHeaderPaths(header)?.bPath;
+    if (bPath) fileSet.add(bPath);
+  }
+  for (const line of result.worktreeSummary?.statusLines ?? []) {
+    const filePath = filePathFromStatusLine(line);
+    if (filePath) {
+      fileSet.add(filePath);
+    }
+  }
+  if (fileSet.size === 0) {
+    for (const line of diffSource.match(/^\+\+\+ "?b\/.+$/gm) ?? []) {
+      const filePath = parseUnifiedDiffPathLine(line);
+      if (filePath && filePath !== "/dev/null") fileSet.add(filePath);
+    }
+  }
+  const artifactList = Array.from(fileSet);
+  const suspiciousArtifacts = artifactList.filter(isSuspicious);
+  const total = artifactList.length;
+  const suspiciousCount = suspiciousArtifacts.length;
+  let scopeHygieneRisk;
+  if (suspiciousCount === 0) {
+    scopeHygieneRisk = "low";
+  } else if (suspiciousCount >= 3 || total > 0 && suspiciousCount / total > 0.2) {
+    scopeHygieneRisk = "high";
+  } else {
+    scopeHygieneRisk = "medium";
+  }
+  return {
+    totalArtifactsChanged: total,
+    artifactList,
+    suspiciousArtifacts,
+    scopeHygieneRisk,
+    fileTargetCoverage: computeFileTargetCoverage(artifactList, options?.fileConstraint)
+  };
+}
+
+export {
+  analyzeVerificationEvidenceQuality,
+  formatVerificationEvidenceQualitySummary,
+  computeSignalReliabilitySummary,
+  buildVariantFileInventory
+};
+//# sourceMappingURL=chunk-CTDLERWU.js.map