@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-QFLBRWCJ.js

@@ -0,0 +1,126 @@
+import {
+  mkBuildTempDir
+} from "./chunk-D6WTZMZB.js";
+import {
+  readTrackedToolOutputRoots,
+  shouldExcludeUntrackedFile
+} from "./chunk-5EQN56OZ.js";
+import {
+  safeRmDir
+} from "./chunk-ALDTFNZ3.js";
+import {
+  execGit
+} from "./chunk-MHLEZQQI.js";
+
+// src/core/git/untracked-intent-index.ts
+import { copyFile, stat, utimes, writeFile } from "fs/promises";
+import { tmpdir } from "os";
+import { isAbsolute, join } from "path";
+var NO_INTENT_INDEX = {
+  untrackedPaths: [],
+  dispose: async () => {
+  }
+};
+async function inheritIndexTimestamp(realIndexPath, copyPath) {
+  const real = await stat(realIndexPath);
+  const seconds = Math.floor(real.mtimeMs / 1e3);
+  await utimes(copyPath, seconds, seconds);
+}
+async function listAddableUntrackedFiles(params) {
+  const result = await execGit(["ls-files", "--others", "--exclude-standard", "-z"], {
+    cwd: params.worktreePath,
+    timeoutMs: params.timeoutMs
+  });
+  if (result.exitCode !== 0) {
+    throw new Error(
+      `git ls-files --others failed (exit ${result.exitCode}): ${result.stderr.trim() || "unknown error"}`
+    );
+  }
+  const trackedRoots = await readTrackedToolOutputRoots(params.worktreePath);
+  return result.stdout.split("\0").filter((entry) => entry.length > 0).filter((entry) => !entry.endsWith("/")).filter((entry) => !shouldExcludeUntrackedFile(entry, trackedRoots));
+}
+async function resolveIndexPath(worktreePath, timeoutMs) {
+  const absolute = await execGit(["rev-parse", "--path-format=absolute", "--git-path", "index"], {
+    cwd: worktreePath,
+    timeoutMs
+  });
+  if (absolute.exitCode === 0 && absolute.stdout.trim()) {
+    return absolute.stdout.trim();
+  }
+  const relative = await execGit(["rev-parse", "--git-path", "index"], {
+    cwd: worktreePath,
+    timeoutMs
+  });
+  const reported = relative.stdout.trim();
+  if (relative.exitCode !== 0 || !reported) {
+    throw new Error(
+      `git rev-parse --git-path index failed (exit ${relative.exitCode}): ${relative.stderr.trim() || "unknown error"}`
+    );
+  }
+  return isAbsolute(reported) ? reported : join(worktreePath, reported);
+}
+async function prepareUntrackedIntentIndex(params) {
+  const worktreePath = params.worktreePath.trim();
+  if (!worktreePath) {
+    throw new Error("untracked intent-to-add index requires a worktree path");
+  }
+  const untrackedPaths = await listAddableUntrackedFiles({
+    worktreePath,
+    timeoutMs: params.timeoutMs
+  });
+  if (untrackedPaths.length === 0) {
+    return NO_INTENT_INDEX;
+  }
+  const realIndexPath = await resolveIndexPath(worktreePath, params.timeoutMs);
+  const tempDir = await mkBuildTempDir("winner-intent-index");
+  const dispose = async () => {
+    try {
+      await safeRmDir(tempDir, {
+        protectedPaths: [tmpdir()],
+        managedRoots: [tmpdir()]
+      });
+    } catch {
+    }
+  };
+  try {
+    const indexPath = join(tempDir, "index");
+    await copyFile(realIndexPath, indexPath);
+    await inheritIndexTimestamp(realIndexPath, indexPath);
+    const pathspecFile = join(tempDir, "pathspecs");
+    await writeFile(
+      pathspecFile,
+      `${untrackedPaths.map((entry) => `:(literal)${entry}`).join("\0")}\0`,
+      "utf8"
+    );
+    const addResult = await execGit(
+      [
+        "add",
+        "--intent-to-add",
+        `--pathspec-from-file=${pathspecFile}`,
+        "--pathspec-file-nul",
+        "--"
+      ],
+      {
+        cwd: worktreePath,
+        timeoutMs: params.timeoutMs,
+        // Writes land in the COPY, never the worktree's own index.
+        env: { GIT_INDEX_FILE: indexPath }
+      }
+    );
+    if (addResult.exitCode !== 0) {
+      throw new Error(
+        `git add --intent-to-add failed (exit ${addResult.exitCode}): ${addResult.stderr.trim() || "unknown error"}`
+      );
+    }
+    await inheritIndexTimestamp(realIndexPath, indexPath);
+    return { indexPath, untrackedPaths, dispose };
+  } catch (error) {
+    await dispose();
+    throw error;
+  }
+}
+
+export {
+  prepareUntrackedIntentIndex
+};
+//# sourceMappingURL=chunk-QFLBRWCJ.js.map

package/dist/chunk-QILAQACE.js

@@ -0,0 +1,107 @@
+// src/core/providers/routing/generated/provider-concurrency.ts
+var GENERATED_PROVIDER_CONCURRENCY = {
+  claude: {
+    maxConcurrent: 2,
+    hybridBatching: false,
+    rationale: "Two concurrent local Claude CLI subprocesses - the shared local-provider baseline. This is a process count, not a request rate, so it does not encode the quota of any one backend or account. It is also not a promise about throughput, since an account that cannot sustain two concurrent runs surfaces its own throttling error from the provider CLI, after which the operator lowers this value. The observed-rate-limit penalty is a mitigation within a single run, not a justification for this number - it is reactive, recorded only after a leg completes, process-local, and matched on error text that does not cover every backend phrasing, so it cannot stop the first two legs from starting. Increase in user provider config after validating host resources and account quota."
+  },
+  codex: {
+    maxConcurrent: 2,
+    hybridBatching: false,
+    rationale: "Codex runs as a local CLI subprocess. Limit concurrency to two processes to avoid local CPU, memory, and state contention."
+  },
+  cursor: {
+    maxConcurrent: 2,
+    hybridBatching: false,
+    rationale: "Baseline local-provider concurrency. The previous 1 was never reconciled with any enforced limit. No measured per-seat licensing or host-resource limit is known that distinguishes Cursor from the other local CLI providers, so it takes the shared baseline. Lower it in user provider config if a seat limit surfaces from the provider CLI."
+  },
+  grok: {
+    maxConcurrent: 2,
+    hybridBatching: false,
+    rationale: 'Baseline local-provider concurrency. The previous 1 deferred to "broader smoke/A-B data", which was never gathered, so it was indefinite caution rather than a measured limit. Grok CLI also supports native subagent fanout, which multiplies WITHIN a single leg and is opt-in, so this number bounds Build-owned processes only and is independent of that fanout. Lower it in user provider config if host contention appears when subagents are enabled.'
+  },
+  opencode: {
+    maxConcurrent: 2,
+    hybridBatching: false,
+    rationale: "Baseline local-provider concurrency. OpenCode executes through a local CLI process model (one subprocess per run) with the same host cost profile as the other local providers, so it takes the shared baseline rather than a higher number. This LOWERS the previous default of 5, which was never measured and was the outlier in this file. Raise it in user provider config after validating host resources and upstream API quota. No internal batching support."
+  },
+  antigravity: {
+    maxConcurrent: 1,
+    hybridBatching: false,
+    rationale: "Google Antigravity CLI runs a local agent process with workspace tools and subagents. Keep default concurrency at one until workspace edit behavior is validated, to avoid competing file edits and local resource contention."
+  },
+  copilot: {
+    maxConcurrent: 2,
+    hybridBatching: false,
+    rationale: "Baseline local-provider concurrency. Copilot CLI runs locally with per-seat licensing and the same host cost profile as the other local providers. This LOWERS the previous default of 3. Raise it in user provider config after validating host resources and seat entitlement."
+  },
+  kiro: {
+    maxConcurrent: 1,
+    hybridBatching: false,
+    rationale: "Kiro CLI headless mode runs a local agent process with workspace tools. Keep default concurrency at one while experimental to avoid competing file edits and local resource contention."
+  },
+  gemini: {
+    maxConcurrent: 1,
+    hybridBatching: true,
+    rationale: "The only local provider below the shared baseline of 2. This was previously described as a CORRECTNESS ceiling on the grounds that concurrent Gemini CLI processes share mutable state under ~/.gemini because the CLI ignores GEMINI_CONFIG_DIR. That reasoning no longer holds as stated, because a launch that carries the Build set runs Gemini with a per-launch GEMINI_CLI_HOME, although a native launch still uses the shared home. So this is unverified caution rather than a correctness requirement - two concurrent Gemini legs have simply never been exercised. Raise it to the baseline after one live 2-concurrent run confirms the isolation holds. Internal batching remains enabled and is unaffected."
+  },
+  pi: {
+    maxConcurrent: 1,
+    hybridBatching: false,
+    rationale: "Pi runs a local agent process with workspace edit tools against an operator-configured backend of unknown rate limits. Keep concurrency at one while experimental to avoid competing file edits."
+  }
+};
+
+// src/orchestrator/provider-concurrency-limits.ts
+var PROVIDER_CONCURRENCY = GENERATED_PROVIDER_CONCURRENCY;
+var PENALTY_WINDOW_MS = 10 * 60 * 1e3;
+var MIN_PENALTY_FACTOR = 0.25;
+var providerPenalties = {};
+function getProviderConcurrencyLimit(provider) {
+  return applyProviderConcurrencyPenalty(provider, getProviderConcurrencyBaseline(provider));
+}
+function getProviderConcurrencyBaseline(provider) {
+  const config = PROVIDER_CONCURRENCY[provider];
+  return config ? config.maxConcurrent : DEFAULT_CONCURRENCY_LIMIT;
+}
+function applyProviderConcurrencyPenalty(provider, baselineLimit) {
+  const penalty = providerPenalties[provider];
+  const now = Date.now();
+  if (!penalty || penalty.expiresAt <= now) {
+    return baselineLimit;
+  }
+  return Math.max(1, Math.floor(baselineLimit * penalty.factor));
+}
+function getProviderConcurrencyConfig(provider) {
+  const config = PROVIDER_CONCURRENCY[provider];
+  if (!config) {
+    return {
+      maxConcurrent: DEFAULT_CONCURRENCY_LIMIT,
+      rationale: `No specific configuration for ${provider}; using default (${DEFAULT_CONCURRENCY_LIMIT})`,
+      hybridBatching: false
+    };
+  }
+  return config;
+}
+function recordProviderRateLimit(provider) {
+  const now = Date.now();
+  const existing = providerPenalties[provider];
+  const currentFactor = existing && existing.expiresAt > now ? existing.factor : 1;
+  const nextFactor = Math.max(MIN_PENALTY_FACTOR, currentFactor * 0.5);
+  providerPenalties[provider] = {
+    factor: nextFactor,
+    expiresAt: now + PENALTY_WINDOW_MS
+  };
+}
+var DEFAULT_CONCURRENCY_LIMIT = 4;
+
+export {
+  PROVIDER_CONCURRENCY,
+  getProviderConcurrencyLimit,
+  getProviderConcurrencyBaseline,
+  applyProviderConcurrencyPenalty,
+  getProviderConcurrencyConfig,
+  recordProviderRateLimit,
+  DEFAULT_CONCURRENCY_LIMIT
+};
+//# sourceMappingURL=chunk-QILAQACE.js.map