@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-RI4EX2QE.js

@@ -0,0 +1,18 @@
+// src/core/sandbox/blocked-paths.ts
+var KNOWN_SANDBOX_BLOCKED_PREFIXES = [".claude/"];
+function pathMatchesSandboxBlockedPrefix(filePath, prefixes = KNOWN_SANDBOX_BLOCKED_PREFIXES) {
+  const normalized = filePath.replace(/^\/+/, "").replace(/\\/g, "/");
+  for (const prefix of prefixes) {
+    if (prefix.endsWith("/")) {
+      if (normalized.startsWith(prefix)) return true;
+    } else if (normalized === prefix || normalized.startsWith(`${prefix}/`)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+export {
+  pathMatchesSandboxBlockedPrefix
+};
+//# sourceMappingURL=chunk-RI4EX2QE.js.map

package/dist/chunk-RIMARPCF.js

@@ -0,0 +1,152 @@
+import {
+  getDefaultPaths
+} from "./chunk-56WPYDJH.js";
+import {
+  emitWarning
+} from "./chunk-7VRJHTGZ.js";
+
+// src/core/steering/user-agents.ts
+import { createHash as createHash2 } from "crypto";
+import { existsSync, readFileSync, statSync } from "fs";
+import { join } from "path";
+
+// src/core/steering/template.ts
+import { createHash } from "crypto";
+var DEFAULT_USER_AGENTS_TEMPLATE = `# Build Global Instructions
+
+The agents Build runs on this machine inherit these instructions.
+Keep them short, durable, and broadly applicable across repositories.
+
+- Read existing code before modifying it. Check for existing helpers and local patterns.
+- Prefer standard well-known solutions. Avoid adding algorithmic or data-structure complexity for small inputs unless the task explicitly justifies it.
+`;
+var DEFAULT_USER_AGENTS_TEMPLATE_SHA256 = createHash("sha256").update(DEFAULT_USER_AGENTS_TEMPLATE).digest("hex");
+var PREVIOUS_USER_AGENTS_TEMPLATE_SHA256 = [
+  "4db62a2d07783f635b824543ed6d298693f7c5a263e7bf4d405c58894cebc826"
+];
+function isShippedUserAgentsTemplate(sha256) {
+  return sha256 === DEFAULT_USER_AGENTS_TEMPLATE_SHA256 || PREVIOUS_USER_AGENTS_TEMPLATE_SHA256.includes(sha256);
+}
+
+// src/core/steering/user-agents.ts
+var unreadableWarnings = /* @__PURE__ */ new Set();
+var cachedUserGlobal = null;
+function sha256Text(text) {
+  return createHash2("sha256").update(text).digest("hex");
+}
+function byteLength(text) {
+  return Buffer.byteLength(text, "utf8");
+}
+var USER_INSTRUCTIONS_FILENAME = "instructions.md";
+var LEGACY_USER_INSTRUCTIONS_FILENAME = "AGENTS.md";
+function instructionsFileOverride() {
+  return process.env.BUILD_AGENTS_FILE?.trim() || void 0;
+}
+function userInstructionsCandidates() {
+  const configDir = getDefaultPaths().userConfigDir;
+  return {
+    current: join(configDir, USER_INSTRUCTIONS_FILENAME),
+    legacy: join(configDir, LEGACY_USER_INSTRUCTIONS_FILENAME)
+  };
+}
+function getUserInstructionsPath() {
+  const override = instructionsFileOverride();
+  if (override) return override;
+  const { current, legacy } = userInstructionsCandidates();
+  return !existsSync(current) && existsSync(legacy) ? legacy : current;
+}
+function getUserInstructionsTargetPath() {
+  return instructionsFileOverride() ?? userInstructionsCandidates().current;
+}
+function getShadowedLegacyInstructionsPath() {
+  if (instructionsFileOverride()) return void 0;
+  const { current, legacy } = userInstructionsCandidates();
+  return existsSync(current) && existsSync(legacy) ? legacy : void 0;
+}
+function warnUnreadableInstructionsFile(path, error) {
+  if (unreadableWarnings.has(path)) return;
+  unreadableWarnings.add(path);
+  emitWarning(
+    "CFG-001",
+    {
+      taskId: "runtime-steering",
+      subsystem: "steering",
+      executionPhase: "setup"
+    },
+    {
+      severity: "WARN" /* WARN */,
+      metadata: {
+        operation: "loadUserGlobalAgents",
+        path,
+        error: error instanceof Error ? error.message : String(error)
+      }
+    }
+  );
+}
+function loadUserInstructionsFile() {
+  const path = getUserInstructionsPath();
+  if (!existsSync(path)) {
+    return null;
+  }
+  try {
+    const stats = statSync(path);
+    if (!stats.isFile()) {
+      throw new Error("Path exists but is not a regular file");
+    }
+    if (cachedUserGlobal?.path === path && cachedUserGlobal.mtimeMs === stats.mtimeMs) {
+      return cachedUserGlobal.loaded;
+    }
+    const text = readFileSync(path, "utf8");
+    const sha256 = sha256Text(text);
+    const loaded = {
+      text,
+      source: {
+        kind: "user-global",
+        path,
+        mtime: stats.mtimeMs,
+        sha256,
+        bytes: byteLength(text),
+        editedByUser: !isShippedUserAgentsTemplate(sha256)
+      }
+    };
+    cachedUserGlobal = { path, mtimeMs: stats.mtimeMs, loaded };
+    return loaded;
+  } catch (error) {
+    warnUnreadableInstructionsFile(path, error);
+    return null;
+  }
+}
+function loadProjectInstructionsFile(path) {
+  try {
+    const stats = statSync(path);
+    if (!stats.isFile()) throw new Error("Path exists but is not a regular file");
+    const text = readFileSync(path, "utf8");
+    return {
+      text,
+      source: {
+        kind: "project",
+        path,
+        mtime: stats.mtimeMs,
+        sha256: sha256Text(text),
+        bytes: byteLength(text)
+      }
+    };
+  } catch (error) {
+    warnUnreadableInstructionsFile(path, error);
+    return null;
+  }
+}
+
+export {
+  DEFAULT_USER_AGENTS_TEMPLATE,
+  isShippedUserAgentsTemplate,
+  sha256Text,
+  byteLength,
+  USER_INSTRUCTIONS_FILENAME,
+  getUserInstructionsPath,
+  getUserInstructionsTargetPath,
+  getShadowedLegacyInstructionsPath,
+  loadUserInstructionsFile,
+  loadProjectInstructionsFile
+};
+//# sourceMappingURL=chunk-RIMARPCF.js.map

package/dist/chunk-RJ6RSNT6.js

@@ -0,0 +1,42 @@
+// src/utils/build-package-root.ts
+import { existsSync, readFileSync } from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+function findBuildPackageRoot(startFile = fileURLToPath(import.meta.url), deps = {}) {
+  const exists = deps.existsSync ?? existsSync;
+  const read = deps.readFileSync ?? readFileSync;
+  let current = path.dirname(startFile);
+  for (let depth = 0; depth < 8; depth += 1) {
+    const packageJson = path.join(current, "package.json");
+    if (exists(packageJson)) {
+      try {
+        const parsed = JSON.parse(read(packageJson, "utf8"));
+        if (parsed.name === "@ebrindley/build") {
+          return current;
+        }
+      } catch {
+      }
+    }
+    const parent = path.dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return void 0;
+}
+function readBuildPackageVersion(startFile = fileURLToPath(import.meta.url), deps = {}) {
+  const root = findBuildPackageRoot(startFile, deps);
+  if (!root) return void 0;
+  try {
+    const read = deps.readFileSync ?? readFileSync;
+    const parsed = JSON.parse(read(path.join(root, "package.json"), "utf8"));
+    return typeof parsed.version === "string" && parsed.version.trim().length > 0 ? parsed.version.trim() : void 0;
+  } catch {
+    return void 0;
+  }
+}
+
+export {
+  findBuildPackageRoot,
+  readBuildPackageVersion
+};
+//# sourceMappingURL=chunk-RJ6RSNT6.js.map

package/dist/chunk-RNI2GUIF.js

@@ -0,0 +1,131 @@
+import {
+  RUNTIME_ESTIMATOR_VERSION,
+  provenanceForTier
+} from "./chunk-CE5OZBYY.js";
+import {
+  MAX_TIMEOUT_MS,
+  MIN_TIMEOUT_MS,
+  clampTimeout
+} from "./chunk-RWQQIKIC.js";
+
+// src/core/estimation/runtime-estimator.ts
+var DEFAULT_TIMEOUT_SAFETY_FACTOR = 1 / 0.35;
+var EXPECTED_RUNTIME_FLOOR_MS = 6e4;
+var SERIAL_PHASE_BASE_TAIL_MS = 3 * 6e4;
+var SERIAL_PHASE_PER_VARIANT_MS = 3e4;
+function deriveTimeoutCeilingMs(expectedRuntimeMs, options = {}) {
+  const safetyFactor = options.safetyFactor ?? DEFAULT_TIMEOUT_SAFETY_FACTOR;
+  const minTimeoutMs = options.minTimeoutMs ?? MIN_TIMEOUT_MS;
+  const maxTimeoutMs = options.maxTimeoutMs ?? MAX_TIMEOUT_MS;
+  const safeExpected = Number.isFinite(expectedRuntimeMs) ? Math.max(0, expectedRuntimeMs) : 0;
+  const raw = Math.max(safeExpected * Math.max(1, safetyFactor), safeExpected);
+  const clamped = clampTimeout(Math.round(raw), minTimeoutMs, maxTimeoutMs);
+  return Math.max(clamped, Math.round(Math.min(safeExpected, maxTimeoutMs)));
+}
+function resolveProvenanceAndConfidence(input) {
+  const { calibration, historicalMultiplier } = input;
+  if (calibration) {
+    const provenance = provenanceForTier(calibration.tier);
+    const confidence = calibration.tier === "exact" || calibration.sampleCount >= 8 ? "high" : calibration.sampleCount >= 3 ? "medium" : "low";
+    return { provenance, confidence };
+  }
+  if (historicalMultiplier !== void 0 && historicalMultiplier !== 1) {
+    return { provenance: "blended", confidence: "medium" };
+  }
+  return { provenance: "heuristic", confidence: "low" };
+}
+function estimateRuntime(input) {
+  const minTimeoutMs = input.minTimeoutMs ?? MIN_TIMEOUT_MS;
+  const maxTimeoutMs = input.maxTimeoutMs ?? MAX_TIMEOUT_MS;
+  const safetyFactor = input.safetyFactor ?? DEFAULT_TIMEOUT_SAFETY_FACTOR;
+  const complexityMultiplier = input.complexityMultiplier ?? 1;
+  const providerMultiplier = input.providerMultiplier ?? 1;
+  const modeMultiplier = input.modeMultiplier ?? 1;
+  const telemetryMultiplier = input.calibration ? input.calibration.multiplier : input.historicalMultiplier ?? 1;
+  const baseExpected = Number.isFinite(input.baseExpectedRuntimeMs) ? Math.max(0, input.baseExpectedRuntimeMs) : 0;
+  let expected = baseExpected * complexityMultiplier * providerMultiplier * modeMultiplier * telemetryMultiplier;
+  expected += Math.max(0, input.serialPhaseTailMs ?? 0);
+  if (!Number.isFinite(expected) || expected < 0) {
+    expected = EXPECTED_RUNTIME_FLOOR_MS;
+  }
+  const expectedRuntimeMs = Math.round(
+    Math.min(Math.max(expected, EXPECTED_RUNTIME_FLOOR_MS), maxTimeoutMs)
+  );
+  const timeoutCeilingMs = deriveTimeoutCeilingMs(expectedRuntimeMs, {
+    safetyFactor,
+    minTimeoutMs,
+    maxTimeoutMs
+  });
+  const { provenance, confidence } = resolveProvenanceAndConfidence(input);
+  const expectedMinutes = Math.max(1, Math.round(expectedRuntimeMs / 6e4));
+  const ceilingMinutes = Math.max(1, Math.round(timeoutCeilingMs / 6e4));
+  const factorStr = input.factors && input.factors.length > 0 ? ` (${input.factors.join(", ")})` : "";
+  const explanation = `Expected runtime ~${expectedMinutes} minutes; timeout ceiling ${ceilingMinutes} minutes${factorStr}`;
+  return {
+    expectedRuntimeMs,
+    timeoutCeilingMs,
+    confidence,
+    provenance,
+    estimatorVersion: RUNTIME_ESTIMATOR_VERSION,
+    explanation
+  };
+}
+function serialPhaseTailMsForVariants(variantCount) {
+  if (variantCount < 2) return 0;
+  return SERIAL_PHASE_BASE_TAIL_MS + variantCount * SERIAL_PHASE_PER_VARIANT_MS;
+}
+function combineCompetitiveEstimates(variantEstimates, options = {}) {
+  const minTimeoutMs = options.minTimeoutMs ?? MIN_TIMEOUT_MS;
+  const maxTimeoutMs = options.maxTimeoutMs ?? MAX_TIMEOUT_MS;
+  const safetyFactor = options.safetyFactor ?? DEFAULT_TIMEOUT_SAFETY_FACTOR;
+  if (variantEstimates.length === 0) {
+    return estimateRuntime({
+      baseExpectedRuntimeMs: EXPECTED_RUNTIME_FLOOR_MS,
+      minTimeoutMs,
+      maxTimeoutMs,
+      safetyFactor
+    });
+  }
+  const variantCount = options.variantCount ?? variantEstimates.length;
+  const parallelExpectedMs = Math.max(...variantEstimates.map((e) => e.expectedRuntimeMs));
+  const parallelCeilingMs = Math.max(...variantEstimates.map((e) => e.timeoutCeilingMs));
+  const rawSerialPhaseTailMs = options.serialPhaseTailMs ?? serialPhaseTailMsForVariants(variantCount);
+  const serialPhaseTailMs = options.serialPhaseTailMs !== void 0 ? rawSerialPhaseTailMs : Math.min(rawSerialPhaseTailMs, Math.max(3e4, Math.round(parallelExpectedMs * 0.75)));
+  const expectedRuntimeMs = Math.round(
+    Math.min(parallelExpectedMs + serialPhaseTailMs, maxTimeoutMs)
+  );
+  const timeoutCeilingMs = Math.max(
+    parallelCeilingMs,
+    deriveTimeoutCeilingMs(expectedRuntimeMs, { safetyFactor, minTimeoutMs, maxTimeoutMs })
+  );
+  const confidenceRank = { low: 0, medium: 1, high: 2 };
+  const confidence = variantEstimates.reduce((weakest, e) => {
+    return confidenceRank[e.confidence] < confidenceRank[weakest] ? e.confidence : weakest;
+  }, "high");
+  const provenanceRank = {
+    heuristic: 0,
+    explicit: 1,
+    blended: 2,
+    telemetry: 3
+  };
+  const provenance = variantEstimates.reduce((best, e) => {
+    return provenanceRank[e.provenance] > provenanceRank[best] ? e.provenance : best;
+  }, "heuristic");
+  const expectedMinutes = Math.max(1, Math.round(expectedRuntimeMs / 6e4));
+  const ceilingMinutes = Math.max(1, Math.round(timeoutCeilingMs / 6e4));
+  const tailNote = serialPhaseTailMs > 0 ? `; +${Math.max(1, Math.round(serialPhaseTailMs / 6e4))}m serial phases` : "";
+  return {
+    expectedRuntimeMs,
+    timeoutCeilingMs,
+    confidence,
+    provenance,
+    estimatorVersion: RUNTIME_ESTIMATOR_VERSION,
+    explanation: `Expected runtime ~${expectedMinutes} minutes (parallel wall-clock max${tailNote}); timeout ceiling ${ceilingMinutes} minutes`
+  };
+}
+
+export {
+  estimateRuntime,
+  combineCompetitiveEstimates
+};
+//# sourceMappingURL=chunk-RNI2GUIF.js.map

package/dist/chunk-RPHUWJ3K.js

@@ -0,0 +1,264 @@
+import {
+  DEFAULT_LOCAL_CI_STATUS_CONTEXT
+} from "./chunk-VBENAHDA.js";
+import {
+  RepositorySchema,
+  repositoryFromGitHubRemoteUrl
+} from "./chunk-BDPYFAB4.js";
+import {
+  buildProjectVerificationGuidance,
+  deriveProjectDependencySetupPlan,
+  detectPackageManager,
+  parseProjectDependencySetupCommand
+} from "./chunk-AHU3FKPA.js";
+import {
+  describeVerificationCommand,
+  parseVerificationCommandArgv
+} from "./chunk-EPAMVGI3.js";
+import {
+  readCanonicalBuildConfig,
+  selectedBuildConfigCandidate
+} from "./chunk-FKCG7K6H.js";
+import {
+  execGit
+} from "./chunk-MHLEZQQI.js";
+
+// src/core/project/ci-plan.ts
+import { lstatSync } from "fs";
+import path from "path";
+function resolveProjectCiPlan(root, options = {}) {
+  const guidance = buildProjectVerificationGuidance(root);
+  const setup = deriveProjectDependencySetupPlan(root, {
+    capabilities: guidance.capabilities,
+    // A hosted runner has no uv just because this machine does; no setup-uv step is rendered.
+    ...options.hosted ? { useHostUv: false } : {}
+  });
+  const file = selectedBuildConfigCandidate(
+    path.join(root, ".build-project/config/build.config.jsonc")
+  );
+  const config = readCanonicalBuildConfig(file);
+  if (config.status === "invalid") throw new Error("Invalid project configuration.");
+  const ci = config.status === "valid" ? config.config.ci : void 0;
+  const explicit = typeof ci?.commands === "string" ? [ci.commands] : ci?.commands;
+  if (explicit !== void 0 && (!Array.isArray(explicit) || !explicit.every((c) => typeof c === "string")))
+    throw new Error("Invalid CI commands.");
+  const commands = Array.isArray(explicit) && explicit.length ? explicit : guidance.commands.map((c) => c.command);
+  return {
+    enabled: ci?.enabled !== false,
+    statusContext: ci?.statusContext ?? DEFAULT_LOCAL_CI_STATUS_CONTEXT,
+    commands: [...new Set(commands.map((c) => c.trim()).filter(Boolean))],
+    setupCommands: setup.commands,
+    explicitLocalCommands: ci?.commands !== void 0,
+    setupUnavailable: setup.unavailable.map((item) => item.reason)
+  };
+}
+function resolveHostedProjectCiPlan(root) {
+  const plan = resolveProjectCiPlan(root, { hosted: true });
+  return {
+    ...plan,
+    setupCommands: plan.setupCommands.map((command) => {
+      const argv = parseProjectDependencySetupCommand(command);
+      return argv?.file === "npm" ? [argv.file, ...argv.args.filter((arg) => arg !== "--ignore-scripts")].join(" ") : command;
+    })
+  };
+}
+function workflowRunsProjectVerification(runs, plan) {
+  const normalize = (command) => command.trim().replace(/^npm (test|start)(?=\s|$)/, "npm run $1");
+  const expected = new Set(plan.commands.map(normalize));
+  return runs.some((run) => run.split("\n").some((line) => expected.has(normalize(line))));
+}
+function resolveHostedCiRuntime(root) {
+  const { capabilities } = buildProjectVerificationGuidance(root);
+  const node = capabilities.manifests.rootPackageJson === true;
+  const python = ["pyproject", "requirements"].some(
+    (name) => capabilities.manifests[name] === true
+  );
+  const other = [
+    "denoJson",
+    "goMod",
+    "cargoToml",
+    "pomXml",
+    "gradle",
+    "composerJson",
+    "gemfile",
+    "packageSwift",
+    "pubspecYaml",
+    "dotnetProject",
+    "dotnetSolution",
+    "cmakeLists",
+    "cmakePresets",
+    "mesonBuild",
+    "gemspec",
+    "rakefile",
+    "rDescription",
+    "renvLock",
+    "rProject"
+  ].some((name) => capabilities.manifests[name] === true);
+  if (other || node === python) {
+    return {
+      reason: "Generation supports a single Node or Python project; existing workflows can still be adopted."
+    };
+  }
+  if (node && detectPackageManager(root) !== "npm") {
+    return {
+      reason: "The initial Node workflow recipe supports npm; adopt an existing workflow for other package managers."
+    };
+  }
+  const kind = node ? "node" : "python";
+  const candidates = node ? [".node-version", ".nvmrc"] : [".python-version"];
+  const versionFile = candidates.find((name) => {
+    try {
+      return lstatSync(path.join(root, name)).isFile();
+    } catch {
+      return false;
+    }
+  });
+  return { runtime: { kind, ...versionFile ? { versionFile } : {} } };
+}
+function hostedCiPlanProblem(plan) {
+  if (plan.explicitLocalCommands)
+    return "Explicit Local CI commands own their complete setup chain; provide a hosted workflow instead of copying them automatically.";
+  if (!plan.commands.length) return "No meaningful project verification commands were found.";
+  if (plan.setupUnavailable?.length)
+    return `Dependency setup is incomplete: ${plan.setupUnavailable.join("; ")}`;
+  for (const command of [...plan.setupCommands, ...plan.commands]) {
+    const argv = parseVerificationCommandArgv(command);
+    if (!Array.isArray(argv) || /[$\r\n]/.test(command) || argv.some(
+      (arg) => path.isAbsolute(arg) || arg.includes("../") || arg.includes(".venv/") || /^[A-Za-z_][A-Za-z0-9_]*=/.test(arg)
+    )) {
+      return "The resolved plan contains local-only or shell-dependent commands; provide a hosted workflow explicitly.";
+    }
+  }
+  if (plan.commands.some((command) => describeVerificationCommand(command).kind === "unknown")) {
+    return "A verification command has no known role; provide an explicit hosted workflow.";
+  }
+  return void 0;
+}
+
+// src/core/ci/integration/location.ts
+import { constants, existsSync, lstatSync as lstatSync3, readFileSync as readFileSync2 } from "fs";
+import { access } from "fs/promises";
+import path3 from "path";
+
+// src/core/ci/integration/intent.ts
+import { lstatSync as lstatSync2, readFileSync } from "fs";
+import path2 from "path";
+import { z } from "zod";
+var CI_INTENT_PATH = ".build-project/config/ci-integration.json";
+var workflowPath = z.string().regex(/^\.github\/workflows\/[^/\\\0\r\n]+\.(?:yml|yaml)$/);
+var checkName = z.string().trim().min(1).max(200).refine(
+  (value) => [...value].every((char) => char.charCodeAt(0) >= 32 && char.charCodeAt(0) !== 127)
+);
+var CiIntegrationIntentSchema = z.object({
+  schemaVersion: z.literal(1),
+  primary: z.enum(["local", "github-actions", "unmanaged"]),
+  repository: z.object({ host: z.literal("github.com"), fullName: RepositorySchema }).strict(),
+  githubActions: z.object({
+    workflows: z.array(workflowPath).min(1).max(20),
+    selectedChecks: z.array(checkName).min(1).max(100)
+  }).strict().optional()
+}).strict().superRefine((value, ctx) => {
+  if (value.primary === "github-actions" && !value.githubActions) {
+    ctx.addIssue({ code: "custom", message: "Hosted CI needs a workflow and selected checks." });
+  }
+});
+function readCiIntegrationIntent(root) {
+  try {
+    const file = path2.join(root, CI_INTENT_PATH);
+    if (!lstatSync2(file).isFile()) return { error: `${CI_INTENT_PATH} is not a regular file.` };
+    const result = CiIntegrationIntentSchema.safeParse(JSON.parse(readFileSync(file, "utf8")));
+    return result.success ? { intent: result.data } : { error: `${CI_INTENT_PATH} is invalid or uses an unsupported version.` };
+  } catch (error) {
+    if (error.code === "ENOENT") return {};
+    return { error: `${CI_INTENT_PATH} could not be read.` };
+  }
+}
+
+// src/core/ci/integration/location.ts
+async function inspectCiLocation(input, repositoryOverride) {
+  let root = path3.resolve(input);
+  try {
+    const top = await execGit(["rev-parse", "--show-toplevel"], { cwd: root });
+    if (top.exitCode === 0 && top.stdout.trim()) root = path3.resolve(top.stdout.trim());
+  } catch {
+  }
+  const intentRead = readCiIntegrationIntent(root);
+  const result = {
+    root,
+    remotes: [],
+    intent: intentRead.intent,
+    intentError: intentRead.error,
+    hook: { installed: false, executable: false },
+    notes: []
+  };
+  try {
+    const remotes = await execGit(["remote"], { cwd: root });
+    if (remotes.exitCode === 0)
+      for (const name of remotes.stdout.trim().split("\n").filter(Boolean)) {
+        const url = await execGit(["remote", "get-url", name], { cwd: root });
+        const repository = url.exitCode === 0 ? repositoryFromGitHubRemoteUrl(url.stdout) : null;
+        if (repository) result.remotes.push({ name, repository });
+      }
+    const expected = repositoryOverride ?? intentRead.intent?.repository.fullName;
+    const identities = [
+      ...new Map(result.remotes.map((r) => [r.repository.toLowerCase(), r.repository])).values()
+    ];
+    result.repository = expected ? identities.find((id) => id.toLowerCase() === expected.toLowerCase()) : identities.length === 1 ? identities[0] : void 0;
+    if (expected && !result.repository)
+      result.notes.push("No Git remote matches the recorded CI repository.");
+    else if (identities.length > 1 && !expected)
+      result.notes.push(
+        "Several GitHub repositories are configured; choose the CI repository during build init."
+      );
+    const hook = await execGit(["rev-parse", "--git-path", "hooks/pre-push"], { cwd: root });
+    if (hook.exitCode === 0 && hook.stdout.trim()) {
+      const hookPath = path3.resolve(root, hook.stdout.trim());
+      result.hook.hookPath = hookPath;
+      if (existsSync(hookPath) && lstatSync3(hookPath).isFile()) {
+        result.hook.installed = readFileSync2(hookPath, "utf8").includes(
+          "BUILD_LOCAL_CI_HOOK_START"
+        );
+        try {
+          await access(hookPath, constants.X_OK);
+          result.hook.executable = true;
+        } catch {
+        }
+      }
+    }
+  } catch {
+    result.notes.push("Git repository or hook inspection is unavailable.");
+  }
+  return result;
+}
+
+// src/core/ci/integration/workflow-triggers.ts
+function inspectPullRequestTrigger(events) {
+  if (typeof events === "string") return { present: events === "pull_request", filtered: false };
+  if (Array.isArray(events)) return { present: events.includes("pull_request"), filtered: false };
+  if (!events || typeof events !== "object" || !Object.hasOwn(events, "pull_request"))
+    return { present: false, filtered: false };
+  const pr = events.pull_request;
+  if (pr === null || pr === void 0) return { present: true, filtered: false };
+  if (typeof pr !== "object" || Array.isArray(pr)) return { present: true, filtered: true };
+  const options = pr;
+  const types = options.types;
+  return {
+    present: true,
+    filtered: ["paths", "paths-ignore", "branches", "branches-ignore"].some(
+      (key) => Object.hasOwn(options, key)
+    ) || types !== void 0 && (!Array.isArray(types) || !["opened", "synchronize", "reopened"].every((type) => types.includes(type)))
+  };
+}
+
+export {
+  resolveProjectCiPlan,
+  resolveHostedProjectCiPlan,
+  workflowRunsProjectVerification,
+  resolveHostedCiRuntime,
+  hostedCiPlanProblem,
+  CI_INTENT_PATH,
+  CiIntegrationIntentSchema,
+  inspectCiLocation,
+  inspectPullRequestTrigger
+};
+//# sourceMappingURL=chunk-RPHUWJ3K.js.map