@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-HKO45NLZ.js

@@ -0,0 +1,286 @@
+import {
+  readLaunchInheritance
+} from "./chunk-43OKHTW4.js";
+import {
+  byteLength,
+  loadUserInstructionsFile,
+  sha256Text
+} from "./chunk-RIMARPCF.js";
+import {
+  emitWarning
+} from "./chunk-7VRJHTGZ.js";
+
+// src/core/providers/shared/quota-exhaustion.ts
+var USAGE_LIMIT_PATTERN = /\byou(?:'|’)ve hit your usage limit\b/i;
+var FREE_USAGE_LIMIT_PATTERN = /\bfree usage limit reached\b/i;
+var QUOTA_EXCEEDED_PATTERN = /\bquota exceeded\b/i;
+var SHORT_WINDOW_QUOTA_PATTERN = /per[\s_-]?(?:second|minute)|\b(?:retry|try again) in \d+(?:\.\d+)?\s*(?:s|sec|secs|seconds?|ms|m|min|mins|minutes?)\b/i;
+function extractResetTime(text) {
+  const match = /\btry again (at|in) ([^\n"'}]{1,80})/i.exec(text);
+  if (!match?.[1] || !match[2]) return void 0;
+  const value = match[2].split(/\.(?:\s|$)/)[0]?.trim();
+  return value ? `${match[1].toLowerCase()} ${value}` : void 0;
+}
+function detectQuotaExhaustion(text) {
+  const exhausted = USAGE_LIMIT_PATTERN.test(text) || FREE_USAGE_LIMIT_PATTERN.test(text) || QUOTA_EXCEEDED_PATTERN.test(text) && !SHORT_WINDOW_QUOTA_PATTERN.test(text);
+  if (!exhausted) return void 0;
+  const resetTime = extractResetTime(text);
+  return resetTime ? { resetTime } : {};
+}
+function formatQuotaExhaustedMessage(providerName, exhaustion) {
+  const reset = exhaustion.resetTime ? ` It resets ${exhaustion.resetTime}.` : "";
+  return `${providerName} usage limit or quota exhausted.${reset} Retrying now will not help.`;
+}
+function createQuotaExhaustedError(errorOutput, exitCode, providerName, exhaustion) {
+  return {
+    type: "rate_limit",
+    retryable: false,
+    userMessage: formatQuotaExhaustedMessage(providerName, exhaustion),
+    debugInfo: {
+      exitCode,
+      classification: "quota_exhausted",
+      ...exhaustion.resetTime ? { resetTime: exhaustion.resetTime } : {}
+    },
+    originalError: errorOutput
+  };
+}
+
+// src/core/steering/doctrine.ts
+var DOCTRINE_VERSION = "2026.05";
+var CORE_DOCTRINE = [
+  {
+    id: "boundary-validation",
+    applies: "always",
+    text: "Validate and handle failures at external process, file, network, and database boundaries.",
+    since: DOCTRINE_VERSION
+  },
+  {
+    id: "root-cause-scope",
+    applies: "always",
+    text: "Fix root causes within the same subsystem; otherwise keep the fix local and report the deeper issue.",
+    since: DOCTRINE_VERSION
+  }
+];
+
+// src/core/steering/guidance.ts
+var STAGE_EXECUTION_TEXT = "You are executing a Build Flywheel stage. Apply all requested file operations directly using your Write/Edit tools. Documentation discipline rules in CLAUDE.md (e.g. limits on new .md files) govern human developers committing to the repo, not automated stage execution. Do not let them prevent you from creating or modifying any file the task requires.";
+var SUBAGENTS_TEXT = "Use build-explorer to understand patterns before editing. Use build-verifier to validate changes.";
+function stageExecutionGuidance() {
+  return {
+    id: "stage:flywheel-execution",
+    kind: "stage",
+    text: STAGE_EXECUTION_TEXT
+  };
+}
+function subagentsGuidance() {
+  return {
+    id: "subagents:explorer-verifier",
+    kind: "subagents",
+    text: SUBAGENTS_TEXT
+  };
+}
+function recentContextGuidance(context) {
+  return {
+    id: "recent-context:custom",
+    kind: "recent-context",
+    text: `Recent Build context: ${context}`
+  };
+}
+function acceptanceGuidance(criteria) {
+  return {
+    id: "acceptance:custom",
+    kind: "acceptance",
+    text: `Acceptance: ${criteria}`
+  };
+}
+
+// src/core/steering/resolver.ts
+var STEERING_PROVIDERS = [
+  "antigravity",
+  "claude",
+  "cursor",
+  "gemini",
+  "opencode"
+];
+var PREAMBLE_PROVIDERS = /* @__PURE__ */ new Set([
+  "cursor",
+  "gemini",
+  "antigravity"
+]);
+var SYSTEM_CAPS = {
+  channel: "system",
+  softWarnBytes: 4 * 1024,
+  hardRefuseBytes: 16 * 1024
+};
+var PREAMBLE_CAPS = {
+  channel: "preamble",
+  softWarnBytes: 2 * 1024,
+  hardRefuseBytes: 8 * 1024
+};
+var warnedSteering = /* @__PURE__ */ new Set();
+function resolveSteeringChannelCaps(provider) {
+  return PREAMBLE_PROVIDERS.has(provider) ? PREAMBLE_CAPS : SYSTEM_CAPS;
+}
+function assessSteeringCap(provider, bytes) {
+  const caps = resolveSteeringChannelCaps(provider);
+  return {
+    ...caps,
+    bytes,
+    status: bytes > caps.hardRefuseBytes ? "hard-refuse" : bytes > caps.softWarnBytes ? "soft-warn" : "ok"
+  };
+}
+function omitsUserInstructions(env) {
+  return readLaunchInheritance(env)?.scope === "judge";
+}
+function isSteeringDisabled(env = process.env) {
+  return env.BUILD_STEERING_DISABLE === "1";
+}
+function emptyPayload(version) {
+  return {
+    systemChannel: "",
+    promptPreamble: "",
+    policyChannel: "",
+    version,
+    steeringHash: sha256Text(""),
+    bytesByChannel: { system: 0, preamble: 0, policy: 0 },
+    applied: { doctrine: [], guidance: [], sources: [] }
+  };
+}
+function maybeWarnCap(provider, status, overLimitMessage) {
+  if (status.status === "ok") return;
+  const key = `${provider}:${status.channel}:${status.bytes}`;
+  if (warnedSteering.has(key)) return;
+  warnedSteering.add(key);
+  emitWarning(
+    "CFG-001",
+    {
+      taskId: "runtime-steering",
+      subsystem: "steering",
+      executionPhase: "setup",
+      provider
+    },
+    {
+      severity: "WARN" /* WARN */,
+      ...status.status === "hard-refuse" ? { message: overLimitMessage() } : {},
+      metadata: {
+        operation: "assessSteeringCap",
+        channel: status.channel,
+        bytes: status.bytes,
+        softWarnBytes: status.softWarnBytes,
+        hardRefuseBytes: status.hardRefuseBytes
+      }
+    }
+  );
+}
+var SOURCE_LABELS = {
+  floor: "built-in floor",
+  "user-global": "user instructions",
+  project: "repo instructions"
+};
+function steeringCapWarning(provider, status, sources, otherBytes) {
+  const bySize = [...sources].sort((a, b) => b.bytes - a.bytes);
+  const listed = bySize.map(
+    (source) => `${SOURCE_LABELS[source.kind]}${source.path ? ` ${source.path}` : ""} (${source.bytes} bytes)`
+  );
+  if (otherBytes > 0) listed.push(`other text (${otherBytes} bytes)`);
+  const largestFile = bySize.find((source) => source.path);
+  const shorten = !largestFile ? "" : largestFile.kind === "user-global" ? ` Shorten ${largestFile.path} and check it with "build config instructions lint".` : ` Shorten ${largestFile.path}.`;
+  return `Build runtime steering is ${status.bytes} bytes for ${provider}, over its ${status.channel} limit of ${status.hardRefuseBytes} bytes; the launch continues. Sources, largest first: ${listed.join(", ")}.${shorten}`;
+}
+function assembleSteering(context) {
+  if (isSteeringDisabled()) {
+    return emptyPayload(DOCTRINE_VERSION);
+  }
+  const parts = [];
+  const appliedGuidance = [];
+  const appliedDoctrine = [];
+  const sources = [];
+  const set = context.instructionSet;
+  const addsFloor = !context.omitInstructionSet && !set;
+  const floorText = addsFloor ? CORE_DOCTRINE.map((entry) => entry.text).join("\n\n") : "";
+  if (floorText) {
+    parts.push(floorText);
+    appliedDoctrine.push(...CORE_DOCTRINE.map((entry) => entry.id));
+    sources.push({
+      kind: "floor",
+      sha256: sha256Text(floorText),
+      bytes: byteLength(floorText)
+    });
+  }
+  const userGlobal = addsFloor && !context.omitUserInstructions ? loadUserInstructionsFile() : null;
+  if (userGlobal) {
+    parts.push(userGlobal.text);
+    sources.push(userGlobal.source);
+  }
+  const setText = set?.text.trim();
+  if (set && setText) {
+    parts.push(setText);
+    sources.push(...set.sources);
+    if (set.sources.some((source) => source.kind === "floor")) {
+      appliedDoctrine.push(...CORE_DOCTRINE.map((entry) => entry.id));
+    }
+  }
+  const emitGuidance = (entry) => {
+    parts.push(entry.text);
+    appliedGuidance.push(entry.id);
+  };
+  if (context.guidance.stageExecution) {
+    emitGuidance(stageExecutionGuidance());
+  }
+  if (context.guidance.subagents) {
+    emitGuidance(subagentsGuidance());
+  }
+  if (context.guidance.recentContext) {
+    emitGuidance(recentContextGuidance(context.guidance.recentContext));
+  }
+  if (context.guidance.acceptanceCriteria) {
+    emitGuidance(acceptanceGuidance(context.guidance.acceptanceCriteria));
+  }
+  const assembled = parts.join("\n\n");
+  const usesPreamble = PREAMBLE_PROVIDERS.has(context.provider);
+  const systemChannel = usesPreamble ? "" : assembled;
+  const promptPreamble = usesPreamble ? assembled : "";
+  const policyChannel = "";
+  const bytesByChannel = {
+    system: byteLength(systemChannel),
+    preamble: byteLength(promptPreamble),
+    policy: byteLength(policyChannel)
+  };
+  const routedBytes = usesPreamble ? bytesByChannel.preamble : bytesByChannel.system;
+  const capStatus = assessSteeringCap(context.provider, routedBytes);
+  if (context.warnOnCaps !== false) {
+    maybeWarnCap(context.provider, capStatus, () => {
+      const separatorBytes = 2 * (parts.length - 1);
+      const sourceBytes = sources.reduce((total, source) => total + source.bytes, 0);
+      const otherBytes = routedBytes - separatorBytes - sourceBytes;
+      return steeringCapWarning(context.provider, capStatus, sources, otherBytes);
+    });
+  }
+  return {
+    systemChannel,
+    promptPreamble,
+    policyChannel,
+    version: DOCTRINE_VERSION,
+    steeringHash: sha256Text(assembled),
+    bytesByChannel,
+    applied: {
+      doctrine: appliedDoctrine,
+      guidance: appliedGuidance,
+      sources
+    }
+  };
+}
+
+export {
+  detectQuotaExhaustion,
+  formatQuotaExhaustedMessage,
+  createQuotaExhaustedError,
+  CORE_DOCTRINE,
+  STEERING_PROVIDERS,
+  resolveSteeringChannelCaps,
+  assessSteeringCap,
+  omitsUserInstructions,
+  isSteeringDisabled,
+  assembleSteering
+};
+//# sourceMappingURL=chunk-HKO45NLZ.js.map

package/dist/chunk-HLVTEA6A.js

@@ -0,0 +1,89 @@
+import {
+  hasUnfilledMarkers
+} from "./chunk-UAPHFJPN.js";
+import {
+  classifyExplicitNoEdit
+} from "./chunk-PPHXX4W7.js";
+
+// src/planning/backlog-execution-intent.ts
+import { promises as fs } from "fs";
+import * as path from "path";
+var BACKLOG_SPEC_FILE_PREFIX = "Backlog specification file:";
+var BACKLOG_EXECUTE_PREAMBLE = "Execute tracked backlog item and satisfy its acceptance criteria without drifting beyond its stated scope.";
+var BACKLOG_ANALYSIS_PREAMBLE_LINES = [
+  "Analyze the following tracked backlog item in read-only analysis-only mode.",
+  "Do not modify repository files. Satisfy acceptance criteria with analysis output only.",
+  "--analysis-only"
+];
+function shouldExecuteBacklogItemAsAnalysisOnly(body) {
+  const text = body.trim();
+  if (text.length === 0) {
+    return false;
+  }
+  return classifyExplicitNoEdit(text);
+}
+function isBacklogExecutionReferenceIntent(intent) {
+  return intent.includes(BACKLOG_SPEC_FILE_PREFIX);
+}
+function buildBacklogExecutionIntent(item, options = {}) {
+  const relativeSpecPath = options.projectRoot ? path.relative(options.projectRoot, item.filePath).split(path.sep).join("/") : item.filePath.split(path.sep).join("/");
+  const preamble = options.analysisOnly ? [...BACKLOG_ANALYSIS_PREAMBLE_LINES] : [BACKLOG_EXECUTE_PREAMBLE];
+  return [
+    ...preamble,
+    "",
+    `Title: ${item.yaml.title}`,
+    `Backlog item ID: ${item.yaml.id}`,
+    `${BACKLOG_SPEC_FILE_PREFIX} ${relativeSpecPath}`
+  ].join("\n");
+}
+function extractBacklogSpecFilePath(intent) {
+  const match = new RegExp(`^${BACKLOG_SPEC_FILE_PREFIX}\\s*(.+)$`, "m").exec(intent);
+  const raw = match?.[1]?.trim();
+  return raw && raw.length > 0 ? raw : void 0;
+}
+function buildExpandedBacklogExecutionIntent(intent, specBody) {
+  const titleMatch = /^Title:\s*(.+)$/m.exec(intent);
+  const title = titleMatch?.[1]?.trim() ?? "Untitled backlog item";
+  const analysisOnly = intent.includes("--analysis-only");
+  const preamble = analysisOnly ? [...BACKLOG_ANALYSIS_PREAMBLE_LINES] : [BACKLOG_EXECUTE_PREAMBLE];
+  return [...preamble, "", `Title: ${title}`, "", "Backlog specification:", specBody.trim()].join(
+    "\n"
+  );
+}
+async function resolveBacklogExecutionIntent(intent, projectRoot) {
+  if (!isBacklogExecutionReferenceIntent(intent)) {
+    return intent;
+  }
+  const specRelativePath = extractBacklogSpecFilePath(intent);
+  if (!specRelativePath) {
+    return intent;
+  }
+  const specPath = path.resolve(projectRoot, specRelativePath);
+  const normalizedRoot = path.resolve(projectRoot);
+  const relativeSpecPath = path.relative(normalizedRoot, specPath);
+  if (relativeSpecPath === ".." || relativeSpecPath.startsWith(`..${path.sep}`)) {
+    throw new Error(`Backlog specification path escapes project root: ${specRelativePath}`);
+  }
+  let specBody;
+  try {
+    specBody = await fs.readFile(specPath, "utf8");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to read backlog specification file ${specRelativePath}: ${message}`);
+  }
+  if (hasUnfilledMarkers(specBody)) {
+    throw new Error(
+      `Backlog specification file ${specRelativePath} still contains <<<FILL>>> placeholders. Run: build plan backlog refine <id>`
+    );
+  }
+  return buildExpandedBacklogExecutionIntent(intent, specBody);
+}
+
+export {
+  BACKLOG_SPEC_FILE_PREFIX,
+  shouldExecuteBacklogItemAsAnalysisOnly,
+  isBacklogExecutionReferenceIntent,
+  buildBacklogExecutionIntent,
+  resolveBacklogExecutionIntent
+};
+//# sourceMappingURL=chunk-HLVTEA6A.js.map

package/dist/chunk-HS3SY6HN.js

@@ -0,0 +1,160 @@
+// src/core/providers/cursor/preflight.ts
+import { existsSync } from "fs";
+import { access, mkdir, readFile, rm, writeFile } from "fs/promises";
+import path from "path";
+function isSafeTargetFilePath(target) {
+  if (!target || path.isAbsolute(target) || path.win32.isAbsolute(target)) {
+    return false;
+  }
+  return !target.split(/[\\/]+/).some((segment) => segment === "..");
+}
+async function canWriteProbe(dir) {
+  const probeDir = path.join(dir, ".build-cursor-preflight");
+  const probeFile = path.join(probeDir, "write-probe.tmp");
+  try {
+    await mkdir(probeDir, { recursive: true });
+    await writeFile(probeFile, "ok", "utf8");
+    await rm(probeFile, { force: true });
+    await rm(probeDir, { recursive: true, force: true });
+    return true;
+  } catch {
+    try {
+      await rm(probeDir, { recursive: true, force: true });
+    } catch {
+    }
+    return false;
+  }
+}
+function parseJsonObject(content) {
+  try {
+    const parsed = JSON.parse(content);
+    return parsed && typeof parsed === "object" ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function evaluateCursorConfigWriteRestrictions(config, scope) {
+  if (config.approvalMode === "manual" || config.approvalMode === "strict") {
+    return `approvalMode is '${String(config.approvalMode)}'`;
+  }
+  const sandbox = config.sandbox;
+  if (sandbox && typeof sandbox === "object") {
+    const mode = sandbox.mode;
+    if (mode === "strict") {
+      return `sandbox.mode is '${String(mode)}'`;
+    }
+  }
+  const permissions = config.permissions;
+  if (!permissions || typeof permissions !== "object") {
+    return scope === "project" ? void 0 : "permissions.allow is missing";
+  }
+  const allow = Array.isArray(permissions.allow) ? permissions.allow : [];
+  const deny = Array.isArray(permissions.deny) ? permissions.deny : [];
+  const hasWriteAllow = allow.some((entry) => typeof entry === "string" && /^Write\(/.test(entry));
+  const hasWriteDeny = deny.some((entry) => typeof entry === "string" && /^Write\(/.test(entry));
+  if (hasWriteDeny) {
+    return "permissions.deny contains Write(...) rules";
+  }
+  if (!hasWriteAllow) {
+    return allow.length > 0 ? "permissions.allow has no Write(...) rules" : "permissions.allow is empty or missing";
+  }
+  return void 0;
+}
+async function inspectCursorConfigFile(configPath, scope) {
+  if (!existsSync(configPath)) {
+    return void 0;
+  }
+  const content = await readFile(configPath, "utf8");
+  const config = parseJsonObject(content);
+  if (!config) {
+    return "config file is not valid JSON";
+  }
+  return evaluateCursorConfigWriteRestrictions(config, scope);
+}
+async function runCursorExecutionPreflight(input) {
+  const issues = [];
+  try {
+    await access(input.workingDir);
+  } catch {
+    issues.push({
+      code: "worktree_not_writable",
+      message: `Worktree path is not accessible: ${input.workingDir}`
+    });
+    return { ok: false, issues };
+  }
+  if (!await canWriteProbe(input.workingDir)) {
+    issues.push({
+      code: "worktree_not_writable",
+      message: `Worktree is not writable: ${input.workingDir}`
+    });
+  }
+  for (const target of input.targetFiles ?? []) {
+    if (!isSafeTargetFilePath(target)) {
+      issues.push({
+        code: "target_parent_not_creatable",
+        message: `Target path escapes worktree and cannot be probed: "${target}"`
+      });
+      continue;
+    }
+    const parentDir = path.join(input.workingDir, path.dirname(target));
+    if (parentDir === input.workingDir) {
+      continue;
+    }
+    const parentExisted = existsSync(parentDir);
+    if (!parentExisted) {
+      try {
+        await mkdir(parentDir, { recursive: true });
+      } catch {
+        issues.push({
+          code: "target_parent_not_creatable",
+          message: `Cannot create parent directory for target "${target}": ${parentDir}`
+        });
+        continue;
+      }
+    }
+    if (!await canWriteProbe(parentDir)) {
+      issues.push({
+        code: "target_parent_not_creatable",
+        message: `Parent directory is not writable for target "${target}": ${parentDir}`
+      });
+    }
+    if (!parentExisted) {
+      try {
+        await rm(parentDir, { recursive: true, force: true });
+      } catch {
+      }
+    }
+  }
+  const runtimeRestriction = await inspectCursorConfigFile(
+    path.join(input.cursorConfigDir, "cli-config.json"),
+    "runtime"
+  );
+  if (runtimeRestriction) {
+    issues.push({
+      code: "runtime_write_rules",
+      message: `Cursor runtime cli-config.json may block edits (${runtimeRestriction}).`
+    });
+  }
+  const projectCliPath = path.join(input.workingDir, ".cursor", "cli.json");
+  const projectRestriction = await inspectCursorConfigFile(projectCliPath, "project");
+  if (projectRestriction) {
+    issues.push({
+      code: "project_cli_restrictive",
+      message: `Project .cursor/cli.json may block edits (${projectRestriction}).`
+    });
+  }
+  return { ok: issues.length === 0, issues };
+}
+function formatCursorExecutionPreflightFailure(result) {
+  const headline = "Cursor preflight failed: likely target/permission/sandbox mismatch before provider launch.";
+  const details = result.issues.map((issue) => `- ${issue.message}`).join("\n");
+  return `${headline}
+${details}`;
+}
+
+export {
+  evaluateCursorConfigWriteRestrictions,
+  runCursorExecutionPreflight,
+  formatCursorExecutionPreflightFailure
+};
+//# sourceMappingURL=chunk-HS3SY6HN.js.map