hillclimb 0.9.14 → 0.9.15

package/dist/main.js

@@ -16608,6 +16608,8 @@ function failureText(result) {
 // src/git-traces/git-ops.ts
 var DEFAULT_GIT_COMMAND_TIMEOUT_MS = 12e4;
 var DEFAULT_BUNDLE_TIMEOUT_MS = 3e5;
+var MAX_BASELINE_BUNDLE_BYTES = 1024 * 1024 * 1024;
+var DEFAULT_UNTRACKED_INDEX_TIMEOUT_MS = 3e5;
 var FULL_TREE_SCAN_TIMEOUT_MS = 3e5;
 function resolveGitCommandTimeoutMs(fallback = DEFAULT_GIT_COMMAND_TIMEOUT_MS) {
   const raw = process.env.HILLCLIMB_GIT_COMMAND_TIMEOUT_MS;
@@ -16901,6 +16903,7 @@ function createGitError(args, err, timeoutMs = GIT_COMMAND_TIMEOUT_MS, elapsedMs
   const stdout = outputToString(failure.stdout);
   wrapped.gitStdout = stdout ? truncateOutput(stdout) : void 0;
   wrapped.isGitMissingObject = !isTimeout && failure.code !== "ENOBUFS" && matchesMissingObject(stderr);
+  wrapped.isGitMissingWorktreeFile = args[0] === "update-index" && failure.status === 128 && !failure.signal && (!failure.code || failure.code === "EPIPE") && !!stderr?.includes("does not exist and --remove not passed");
   return wrapped;
 }
 function commitTree(repoRoot, treeSha, message) {
@@ -17560,6 +17563,9 @@ function buildUntrackedTree(repoRoot, options = {}, attempt = 1) {
       () => gitBuffer(repoRoot, ["update-index", "--add", "-z", "--stdin"], {
         input: `${kept.join("\0")}\0`,
         env,
+        timeoutMs: resolveGitCommandTimeoutMs(
+          DEFAULT_UNTRACKED_INDEX_TIMEOUT_MS
+        ),
         diagnostics: { stage: "untracked-hash-and-index" }
       })
     );
@@ -17570,8 +17576,7 @@ function buildUntrackedTree(repoRoot, options = {}, attempt = 1) {
     );
   } catch (err) {
     const failure = err;
-    if (attempt !== 1 || failure.gitExitStatus !== 128 || !failure.gitStderr?.includes("does not exist and --remove not passed"))
-      throw err;
+    if (attempt !== 1 || !failure.isGitMissingWorktreeFile) throw err;
     appendLog(
       "warn",
       `git-traces: retrying untracked capture after files disappeared (repo=${repoRoot}, attempt=${attempt}, maxAttempts=2)`
@@ -17708,6 +17713,12 @@ function createBundleFromTree(repoRoot, treeSha, sessionId, label) {
         diagnostics: { stage: "bundle-create", bundleFile: tmpFile }
       })
     );
+    const bytes = fs19.statSync(tmpFile).size;
+    if (bytes > MAX_BASELINE_BUNDLE_BYTES) {
+      throw new Error(
+        `Git baseline bundle exceeds the upload limit (bytes=${bytes}, maxBytes=${MAX_BASELINE_BUNDLE_BYTES}); capture retained`
+      );
+    }
     const bundle = fs19.readFileSync(tmpFile);
     appendLog(
       "info",
@@ -17723,7 +17734,21 @@ function createBundleFromTree(repoRoot, treeSha, sessionId, label) {
   }
 }
 var MAX_PATCH_GZ_BYTES = 500 * 1024 * 1024;
-function gitGzipStream(repoRoot, args, maxGzBytes) {
+var MAX_PATCH_RAW_BYTES = 1023 * 1024 * 1024 - 1;
+var GitPatchTooLargeError = class extends Error {
+  constructor(rawBytes, maxRawBytes) {
+    super(
+      `git diff raw output exceeded the ${maxRawBytes}-byte replay limit (observedBytes=${rawBytes}); a new baseline is required`
+    );
+    this.rawBytes = rawBytes;
+    this.maxRawBytes = maxRawBytes;
+    this.name = "GitPatchTooLargeError";
+  }
+};
+function resolveMaxPatchRawBytes(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value > 0 ? Math.min(value, MAX_PATCH_RAW_BYTES) : MAX_PATCH_RAW_BYTES;
+}
+function gitGzipStream(repoRoot, args, maxGzBytes, maxRawBytes) {
   return new Promise((resolve, reject) => {
     const started = Date.now();
     const child = spawn2("git", args, {
@@ -17740,6 +17765,7 @@ function gitGzipStream(repoRoot, args, maxGzBytes) {
     let settled = false;
     let timedOut = false;
     let overflowed = false;
+    let rawOverflowed = false;
     let streamError = null;
     let exitCode = null;
     let exitSignal = null;
@@ -17766,6 +17792,8 @@ function gitGzipStream(repoRoot, args, maxGzBytes) {
         );
         probeObjectStore(repoRoot, "timeout", wrapped.gitStderr, args);
         reject(wrapped);
+      } else if (rawOverflowed) {
+        reject(new GitPatchTooLargeError(rawBytes, maxRawBytes));
       } else if (overflowed) {
         reject(
           createGitError(args, { code: "ENOBUFS", maxBufferBytes: maxGzBytes })
@@ -17784,8 +17812,22 @@ function gitGzipStream(repoRoot, args, maxGzBytes) {
         resolve({ gz: Buffer.concat(gzChunks), rawBytes });
       }
     };
+    const stopForOverflow = () => {
+      child.stdout.unpipe(gzip);
+      child.stdout.resume();
+      child.kill("SIGTERM");
+      gzip.destroy();
+      gzChunks.length = 0;
+      gzipDone = true;
+      finish();
+    };
     child.stdout.on("data", (chunk) => {
+      if (rawOverflowed || overflowed) return;
       rawBytes += chunk.length;
+      if (rawBytes > maxRawBytes) {
+        rawOverflowed = true;
+        stopForOverflow();
+      }
     });
     child.stdout.on("error", (err) => {
       streamError ??= err;
@@ -17794,17 +17836,11 @@ function gitGzipStream(repoRoot, args, maxGzBytes) {
     });
     child.stdout.pipe(gzip);
     gzip.on("data", (chunk) => {
+      if (rawOverflowed || overflowed) return;
       gzBytes += chunk.length;
       if (gzBytes > maxGzBytes) {
-        if (!overflowed) {
-          overflowed = true;
-          child.stdout.unpipe(gzip);
-          child.stdout.resume();
-          child.kill("SIGTERM");
-          gzip.destroy();
-          gzipDone = true;
-          finish();
-        }
+        overflowed = true;
+        stopForOverflow();
         return;
       }
       gzChunks.push(chunk);
@@ -17814,7 +17850,7 @@ function gitGzipStream(repoRoot, args, maxGzBytes) {
       finish();
     });
     gzip.on("error", (err) => {
-      if (!overflowed) streamError ??= err;
+      if (!overflowed && !rawOverflowed) streamError ??= err;
       gzipDone = true;
       finish();
     });
@@ -17855,7 +17891,8 @@ async function createTreeDiffPatchGz(repoRoot, fromTreeSha, toTreeSha, options =
       const { gz, rawBytes } = await gitGzipStream(
         repoRoot,
         ["diff", "--binary", filteredFromTreeSha, filteredToTreeSha],
-        options.maxPatchGzBytes ?? MAX_PATCH_GZ_BYTES
+        options.maxPatchGzBytes ?? MAX_PATCH_GZ_BYTES,
+        resolveMaxPatchRawBytes(options.maxPatchRawBytes)
       );
       if (rawBytes === 0) return null;
       return gz;
@@ -18452,6 +18489,8 @@ async function sweepStaleLockFiles(ttlMs = STALE_LOCK_TTL_MS3, now = Date.now())
 // src/git-traces/pending-captures.ts
 var MAX_CAPTURES = 128;
 var MAX_PENDING_BYTES2 = 2 * 1024 * 1024 * 1024;
+var MAX_OVERSIZED_CAPTURE_BYTES = 4 * 1024 * 1024 * 1024;
+var MAX_OVERSIZED_ARTIFACT_BYTES = 4 * 1024 * 1024 * 1024;
 var PendingCaptureLimitError = class extends Error {
 };
 var STRANDED_MIN_AGE_MS = 10 * 60 * 1e3;
@@ -18664,6 +18703,11 @@ function pendingBytes(records) {
     0
   );
 }
+function artifactByteLimit(records, captureId) {
+  const record = records.length === 1 ? records[0] : void 0;
+  const retained = record ? chargedBytes(record) : 0;
+  return record?.id === captureId && record.oversized === true && retained >= 0 && retained <= MAX_OVERSIZED_CAPTURE_BYTES ? retained + MAX_OVERSIZED_ARTIFACT_BYTES : MAX_PENDING_BYTES2;
+}
 function warnMissingBase(repoRoot, base) {
   appendLog(
     "warn",
@@ -18818,10 +18862,15 @@ function storePendingCapture(params) {
     const pendingBefore = queueDiskBytes(
       queueDirectory(params.repoRoot, params.tool, params.sessionId)
     ) + existing.reduce((sum, item) => sum + chargedBytes(item), 0);
-    const incomingBytes = retainedBytes + Buffer.byteLength(JSON.stringify(record));
-    if (existing.length >= MAX_CAPTURES || pendingBefore + incomingBytes > MAX_PENDING_BYTES2) {
+    let incomingBytes = retainedBytes + Buffer.byteLength(JSON.stringify(record));
+    if (existing.length === 0 && pendingBefore === 0 && incomingBytes > MAX_PENDING_BYTES2) {
+      record.oversized = true;
+      incomingBytes = retainedBytes + Buffer.byteLength(JSON.stringify(record));
+    }
+    const maxBytes = record.oversized ? MAX_OVERSIZED_CAPTURE_BYTES : MAX_PENDING_BYTES2;
+    if (existing.some((item) => item.oversized === true) || existing.length >= MAX_CAPTURES || pendingBefore + incomingBytes > maxBytes) {
       throw new PendingCaptureLimitError(
-        `Pending Git capture limit reached (count=${existing.length}, maxCount=${MAX_CAPTURES}, pendingBytes=${pendingBefore}, incomingBytes=${incomingBytes}, retainedBytes=${retainedBytes}, maxBytes=${MAX_PENDING_BYTES2}); existing captures retained`
+        `Pending Git capture limit reached (count=${existing.length}, maxCount=${MAX_CAPTURES}, pendingBytes=${pendingBefore}, incomingBytes=${incomingBytes}, retainedBytes=${retainedBytes}, maxBytes=${maxBytes}); existing captures retained`
       );
     }
     const directory = captureDirectory(record);
@@ -18863,7 +18912,7 @@ function storePendingCapture(params) {
       durableDetails = `capture=${record.id}, durableCapturedAt=${durableCapturedAt}`;
       appendLog(
         "info",
-        `git-traces: capture queued (repo=${record.repoRoot}, session=${record.sessionId}, capture=${record.id}, recordedAt=${record.recordedAt}, captureStartedAt=${record.captureStartedAt}, capturedAt=${record.capturedAt}, sourceCapturedAt=${record.capturedAt}, durableCapturedAt=${durableCapturedAt}, pending=${existing.length + 1}, oldestPendingAgeMs=${Date.now() - (existing[0]?.capturedAt ?? record.capturedAt)}, retainedBytes=${record.retainedBytes}, pendingBytes=${pendingBefore + incomingBytes})`
+        `git-traces: capture queued (repo=${record.repoRoot}, session=${record.sessionId}, capture=${record.id}, recordedAt=${record.recordedAt}, captureStartedAt=${record.captureStartedAt}, capturedAt=${record.capturedAt}, sourceCapturedAt=${record.capturedAt}, durableCapturedAt=${durableCapturedAt}, pending=${existing.length + 1}, oldestPendingAgeMs=${Date.now() - (existing[0]?.capturedAt ?? record.capturedAt)}, retainedBytes=${record.retainedBytes}, pendingBytes=${pendingBefore + incomingBytes}, oversized=${record.oversized === true})`
       );
       return record;
     } finally {
@@ -18913,18 +18962,30 @@ async function preparePendingUpload(context, contributionId, filename, buffer) {
           context.record.tool,
           context.record.sessionId
         );
-        if (pendingBytes(records) + buffer.byteLength > MAX_PENDING_BYTES2) {
-          throw new Error(
-            `Pending Git artifact byte limit reached (${MAX_PENDING_BYTES2}); capture retained`
-          );
-        }
         const file = `${crypto7.createHash("sha256").update(key).digest("hex")}.artifact`;
-        writeDurable(path20.join(directory, file), buffer);
-        context.record.uploads[key] = {
+        const upload = {
           file,
           bytes: buffer.byteLength,
           sha256: crypto7.createHash("sha256").update(buffer).digest("hex")
         };
+        const nextRecordBytes = Buffer.byteLength(
+          JSON.stringify({
+            ...context.record,
+            uploads: { ...context.record.uploads, [key]: upload }
+          })
+        );
+        const recordGrowth = Math.max(
+          0,
+          nextRecordBytes - fs21.statSync(path20.join(directory, "capture.json")).size
+        );
+        const maxBytes = artifactByteLimit(records, context.record.id);
+        if (pendingBytes(records) + buffer.byteLength + recordGrowth > maxBytes) {
+          throw new Error(
+            `Pending Git artifact byte limit reached (${maxBytes}); capture retained`
+          );
+        }
+        writeDurable(path20.join(directory, file), buffer);
+        context.record.uploads[key] = upload;
         try {
           context.save();
         } catch (err) {
@@ -19054,7 +19115,7 @@ async function uploadArtifact(client, contributionId, filename, mimeType, buffer
 }
 
 // package.json
-var version = "0.9.14";
+var version = "0.9.15";
 
 // src/version.ts
 var CLI_VERSION = version;
@@ -20643,7 +20704,6 @@ import path22 from "path";
 var GIT_TRACES_SLUG = "git-traces";
 var MAX_FORK_SWEEP_THREADS2 = 8;
 var MAX_UPLOAD_BYTES = 500 * 1024 * 1024;
-var MAX_BASELINE_BUNDLE_UPLOAD_BYTES = 1024 * 1024 * 1024;
 var STALE_SCOPED_STATE_TTL_MS = 24 * 60 * 60 * 1e3;
 var REBASELINE_AFTER_DIFF_FAILURES = 2;
 async function withRepoCaptureLock(repoRoot, capture) {
@@ -20788,7 +20848,7 @@ function execGit(cwd, args) {
   }).toString("utf-8").trim();
 }
 function canUploadFile(filename, buffer) {
-  const limit = filename.endsWith("-baseline.bundle") ? MAX_BASELINE_BUNDLE_UPLOAD_BYTES : MAX_UPLOAD_BYTES;
+  const limit = filename.endsWith("-baseline.bundle") ? MAX_BASELINE_BUNDLE_BYTES : MAX_UPLOAD_BYTES;
   if (buffer.byteLength <= limit) return true;
   appendLog(
     "warn",
@@ -21871,6 +21931,75 @@ async function refreshLineageBaseline(params) {
     return false;
   }
 }
+async function uploadLargeCaptureBaseline(params) {
+  const { repo, state, tool, persistState, limits } = params;
+  const pending = currentPendingCapture(repo.repoRoot);
+  if (!pending) return "failed";
+  const client = await loadRepoClient(repo);
+  if (!client) return "skipped";
+  if (state.contributionId === null || !state.baselineUploaded) {
+    const initial = buildInitialBaselineArtifactsForState(
+      repo.repoRoot,
+      tool,
+      state,
+      limits
+    );
+    if (!initial || !canUploadEpochBaselineArtifacts(state.epoch, initial))
+      return "failed";
+    if (!await registerInitialContribution({
+      ...params,
+      client,
+      artifacts: initial
+    }))
+      return "failed";
+  }
+  if (state.contributionId === null) return "failed";
+  const nextEpoch = await reserveEpoch(state, persistState);
+  const artifacts = await openEpoch({
+    repoRoot: repo.repoRoot,
+    client,
+    contributionId: state.contributionId,
+    sessionId: state.sessionId,
+    tool,
+    epoch: nextEpoch,
+    prevHeadSha: state.headSha || null,
+    transitionKind: "initial",
+    startedAt: state.startedAt,
+    limits,
+    lineage: state.codexLineage,
+    previousScan: pending.record.scan,
+    provenance: {
+      recovery: {
+        reason: "patch-too-large",
+        trigger: "stop-diff",
+        detectedAt: new Date(pending.record.capturedAt).toISOString(),
+        abandonedEpoch: state.epoch,
+        abandonedBaselineSha: state.baselineSha,
+        abandonedUploadedTurns: state.turnCount
+      }
+    }
+  });
+  if (!artifacts) return "failed";
+  Object.assign(state, {
+    baselineSha: artifacts.baselineSha,
+    baselineTreeSha: artifacts.baselineTreeSha,
+    lastSnapshotSha: artifacts.baselineSha,
+    lastSnapshotTreeSha: artifacts.baselineTreeSha,
+    epoch: nextEpoch,
+    turnCount: 0,
+    headSha: artifacts.headSha,
+    omittedKeys: artifacts.omittedKeys,
+    omissionScan: artifacts.scan,
+    codexLineageStamped: artifacts.uploadedLineage
+  });
+  delete state.diffFailureCount;
+  await persistState(state);
+  appendLog(
+    "info",
+    `git-traces: large patch captured as baseline (repo=${repo.repoRoot}, session=${state.sessionId}, capture=${pending.record.id}, epoch=${nextEpoch}, tree=${artifacts.baselineTreeSha})`
+  );
+  return "uploaded";
+}
 async function recoverFromWedgedDiff(params) {
   const {
     repo,
@@ -22362,6 +22491,20 @@ async function processStopRepo(repo, tool, sessionId, recordedAt, lineageCheck,
         }
       );
     } catch (err) {
+      if (err instanceof GitPatchTooLargeError) {
+        appendLog(
+          "warn",
+          `git-traces: turn patch exceeds Git apply limit; attempting frozen baseline fallback (repo=${repoRoot}, session=${state.sessionId}, rawBytes=${err.rawBytes}, maxRawBytes=${err.maxRawBytes})`
+        );
+        const outcome = await uploadLargeCaptureBaseline({
+          repo,
+          state,
+          tool,
+          persistState,
+          limits
+        });
+        return outcome === "uploaded" ? await finishSuccessfulStop("uploaded") : outcome;
+      }
       if (isMissingObjectError(err)) {
         logMissingBaselineObjects(repoRoot, state, "stop-diff", err);
         state.diffFailureCount = REBASELINE_AFTER_DIFF_FAILURES;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hillclimb",
-  "version": "0.9.14",
+  "version": "0.9.15",
   "description": "Extract and export AI coding tool logs grouped by repo",
   "license": "MIT",
   "type": "module",