hillclimb 0.8.4 → 0.8.5

package/dist/main.js

@@ -13945,7 +13945,7 @@ async function runUploadWorker() {
 }
 
 // src/git-traces/index.ts
-import { spawn as spawn3 } from "child_process";
+import { spawn as spawn4 } from "child_process";
 import crypto7 from "crypto";
 
 // src/git-traces/handlers.ts
@@ -13953,11 +13953,11 @@ import { execFileSync as execFileSync3 } from "child_process";
 import path18 from "path";
 
 // src/git-traces/git-ops.ts
-import { execFileSync as execFileSync2, spawnSync } from "child_process";
+import { execFileSync as execFileSync2, spawn as spawn3, spawnSync } from "child_process";
 import fs16 from "fs";
 import os8 from "os";
 import path16 from "path";
-import { gzipSync as gzipSync2 } from "zlib";
+import { createGzip } from "zlib";
 var GIT_COMMAND_TIMEOUT_MS = 12e4;
 var EXEC_OPTS = {
   timeout: GIT_COMMAND_TIMEOUT_MS,
@@ -14185,7 +14185,7 @@ function createGitError(args, err) {
   const failure = err;
   const command = formatGitCommand(args);
   const isTimeout = failure.code === "ETIMEDOUT";
-  const message = isTimeout ? `${command} timed out after ${GIT_COMMAND_TIMEOUT_MS}ms` : formatGitFailure(command, failure, err);
+  const message = isTimeout ? `${command} timed out after ${GIT_COMMAND_TIMEOUT_MS}ms` : failure.code === "ENOBUFS" ? `${command} output exceeded the ${formatSize(failure.maxBufferBytes ?? EXEC_OPTS.maxBuffer)} limit` : formatGitFailure(command, failure, err);
   const wrapped = new Error(message);
   wrapped.isGitTimeout = isTimeout;
   return wrapped;
@@ -14477,7 +14477,111 @@ function createBundleFromTree(repoRoot, treeSha, sessionId, label) {
     deleteRef(repoRoot, orphanRef);
   }
 }
-function createTreeDiffPatchGz(repoRoot, fromTreeSha, toTreeSha, options = {}) {
+var MAX_PATCH_GZ_BYTES = 500 * 1024 * 1024;
+function gitGzipStream(repoRoot, args, maxGzBytes) {
+  return new Promise((resolve, reject) => {
+    const child = spawn3("git", args, {
+      cwd: repoRoot,
+      stdio: ["ignore", "pipe", "pipe"],
+      windowsHide: true
+    });
+    const gzip = createGzip();
+    const gzChunks = [];
+    const stderrChunks = [];
+    let gzBytes = 0;
+    let rawBytes = 0;
+    let stderrBytes = 0;
+    let settled = false;
+    let timedOut = false;
+    let overflowed = false;
+    let streamError = null;
+    let exitCode = null;
+    let exitSignal = null;
+    let childClosed = false;
+    let gzipDone = false;
+    const timer = setTimeout(() => {
+      timedOut = true;
+      child.kill("SIGTERM");
+    }, GIT_COMMAND_TIMEOUT_MS);
+    const finish = () => {
+      if (settled || !childClosed || !gzipDone) return;
+      settled = true;
+      clearTimeout(timer);
+      if (timedOut) {
+        reject(createGitError(args, { code: "ETIMEDOUT" }));
+      } else if (overflowed) {
+        reject(
+          createGitError(args, { code: "ENOBUFS", maxBufferBytes: maxGzBytes })
+        );
+      } else if (streamError) {
+        reject(createGitError(args, streamError));
+      } else if (exitCode !== 0 || exitSignal) {
+        reject(
+          createGitError(args, {
+            status: exitCode,
+            signal: exitSignal,
+            stderr: Buffer.concat(stderrChunks)
+          })
+        );
+      } else {
+        resolve({ gz: Buffer.concat(gzChunks), rawBytes });
+      }
+    };
+    child.stdout.on("data", (chunk) => {
+      rawBytes += chunk.length;
+    });
+    child.stdout.on("error", (err) => {
+      streamError ??= err;
+      gzipDone = true;
+      finish();
+    });
+    child.stdout.pipe(gzip);
+    gzip.on("data", (chunk) => {
+      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();
+        }
+        return;
+      }
+      gzChunks.push(chunk);
+    });
+    gzip.on("end", () => {
+      gzipDone = true;
+      finish();
+    });
+    gzip.on("error", (err) => {
+      if (!overflowed) streamError ??= err;
+      gzipDone = true;
+      finish();
+    });
+    child.stderr.on("data", (chunk) => {
+      if (stderrBytes < 16 * 1024) {
+        stderrChunks.push(chunk);
+        stderrBytes += chunk.length;
+      }
+    });
+    child.on("error", (err) => {
+      streamError ??= err;
+      childClosed = true;
+      gzipDone = true;
+      finish();
+    });
+    child.on("close", (code, signal) => {
+      exitCode = code;
+      exitSignal = signal;
+      childClosed = true;
+      finish();
+    });
+  });
+}
+async function createTreeDiffPatchGz(repoRoot, fromTreeSha, toTreeSha, options = {}) {
   if (fromTreeSha === toTreeSha) return null;
   const filteredFromTreeSha = filterOmittedFilesFromTree(
     repoRoot,
@@ -14488,14 +14592,13 @@ function createTreeDiffPatchGz(repoRoot, fromTreeSha, toTreeSha, options = {}) {
     limits: options.limits
   });
   if (filteredFromTreeSha === filteredToTreeSha) return null;
-  const diff = gitBuffer(repoRoot, [
-    "diff",
-    "--binary",
-    filteredFromTreeSha,
-    filteredToTreeSha
-  ]);
-  if (diff.length === 0) return null;
-  return Buffer.from(gzipSync2(diff));
+  const { gz, rawBytes } = await gitGzipStream(
+    repoRoot,
+    ["diff", "--binary", filteredFromTreeSha, filteredToTreeSha],
+    options.maxPatchGzBytes ?? MAX_PATCH_GZ_BYTES
+  );
+  if (rawBytes === 0) return null;
+  return gz;
 }
 function detectTransitionKind(repoRoot, prevHeadSha, nextHeadSha) {
   if (!prevHeadSha) return "initial";
@@ -14996,6 +15099,7 @@ var CLI_VERSION2 = "0.8.0";
 var GIT_TRACES_SLUG = "git-traces";
 var MAX_UPLOAD_BYTES = 500 * 1024 * 1024;
 var STALE_SCOPED_STATE_TTL_MS = 24 * 60 * 60 * 1e3;
+var REBASELINE_AFTER_DIFF_FAILURES = 2;
 function formatEpochSeconds3(date) {
   return String(Math.floor(date.getTime() / 1e3));
 }
@@ -15879,6 +15983,107 @@ async function refreshLineageBaseline(params) {
     return false;
   }
 }
+async function recoverFromWedgedDiff(params) {
+  const {
+    repo,
+    state,
+    tool,
+    persistState,
+    limits,
+    currentSha,
+    currentTreeSha,
+    turnOmittedFiles
+  } = params;
+  const { repoRoot, config } = repo;
+  if (state.contributionId === null || !state.baselineUploaded) {
+    const prefix = epochPrefix2(state.epoch);
+    pinRef(
+      repoRoot,
+      `refs/hillclimb/baseline/${state.sessionId}/${prefix}/tracked`,
+      currentSha
+    );
+    pinRef(
+      repoRoot,
+      `refs/hillclimb/scoped/${state.sessionId}/baseline/${prefix}/tracked`,
+      currentSha
+    );
+    pinFrozenBaselineTree(
+      repoRoot,
+      state.sessionId,
+      state.epoch,
+      currentTreeSha
+    );
+    const metadata = buildBaselineMetadata(
+      repoRoot,
+      state.sessionId,
+      tool,
+      currentSha,
+      CLI_VERSION2,
+      state.epoch,
+      null,
+      "initial",
+      state.startedAt,
+      turnOmittedFiles,
+      state.codexLineage
+    );
+    Object.assign(state, {
+      baselineSha: currentSha,
+      baselineTreeSha: currentTreeSha,
+      baselineMetadata: metadata,
+      lastSnapshotSha: currentSha,
+      lastSnapshotTreeSha: currentTreeSha,
+      headSha: captureHeadSha(repoRoot),
+      turnCount: 0,
+      omittedKeys: omissionKeys(turnOmittedFiles)
+    });
+    delete state.diffFailureCount;
+    await persistState(state);
+    appendLog(
+      "warn",
+      `git-traces: wedge-recovery replaced the unuploaded ${prefix} baseline at the current state; the wedged interval is not recoverable (repo=${repoRoot}, project=${config.projectId}, session=${state.sessionId})`
+    );
+    return "skipped";
+  }
+  const client = await loadRepoClient(repo);
+  if (!client) return "skipped";
+  const nextEpoch = await reserveEpoch(state, persistState);
+  appendLog(
+    "warn",
+    `git-traces: wedge-recovery abandoning the incremental chain after ${state.diffFailureCount} consecutive diff failures (repo=${repoRoot}, project=${config.projectId}, contribution=${state.contributionId}, abandonedEpoch=${state.epoch}, lastUploadedTurn=${state.turnCount}, openingEpoch=${nextEpoch})`
+  );
+  const artifacts = await openEpoch({
+    repoRoot,
+    client,
+    contributionId: state.contributionId,
+    sessionId: state.sessionId,
+    tool,
+    epoch: nextEpoch,
+    prevHeadSha: state.headSha || null,
+    transitionKind: "initial",
+    startedAt: state.startedAt,
+    limits,
+    lineage: state.codexLineage
+  });
+  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,
+    codexLineageStamped: state.codexLineage
+  });
+  delete state.diffFailureCount;
+  await persistState(state);
+  appendLog(
+    "info",
+    `git-traces: wedge-recovery baseline uploaded (repo=${repoRoot}, project=${config.projectId}, contribution=${state.contributionId}, epoch=${nextEpoch}, baseline=${artifacts.baselineSha.slice(0, 8)})`
+  );
+  return "uploaded";
+}
 async function registerInitialContribution(params) {
   const { repo, state, tool, persistState, client, artifacts } = params;
   const contributionId = await createGitTracesContribution({
@@ -16111,6 +16316,7 @@ async function processStopRepo(repo, tool, sessionId, recordedAt, lineageCheck,
         omittedKeys: artifacts.omittedKeys,
         codexLineageStamped: state.codexLineage
       };
+      delete next.diffFailureCount;
       await persistState(next);
       appendLog(
         "info",
@@ -16125,19 +16331,55 @@ async function processStopRepo(repo, tool, sessionId, recordedAt, lineageCheck,
       log: false,
       limits
     });
+    const previousOmittedKeys = state.omittedKeys;
     const omissionsChanged = reportNewlyOmittedFiles(
       state,
       turnOmittedFiles,
       repoRoot
     );
-    const patchBuffer = createTreeDiffPatchGz(
-      repoRoot,
-      lastSnapshotTreeSha,
-      currentTreeSha,
-      { limits }
-    );
+    const attemptWedgeRecovery = async () => {
+      const outcome = await recoverFromWedgedDiff({
+        repo,
+        state: cleanupState,
+        tool,
+        persistState,
+        limits,
+        currentSha,
+        currentTreeSha,
+        turnOmittedFiles
+      });
+      return outcome === "uploaded" ? await finishSuccessfulStop("uploaded") : outcome;
+    };
+    if ((state.diffFailureCount ?? 0) >= REBASELINE_AFTER_DIFF_FAILURES) {
+      appendLog(
+        "warn",
+        `git-traces: skipping turn diff after ${state.diffFailureCount} consecutive failures; retrying wedge recovery (repo=${repoRoot}, project=${config.projectId})`
+      );
+      return await attemptWedgeRecovery();
+    }
+    let patchBuffer;
+    try {
+      patchBuffer = await createTreeDiffPatchGz(
+        repoRoot,
+        lastSnapshotTreeSha,
+        currentTreeSha,
+        { limits }
+      );
+    } catch (err) {
+      const failures = (state.diffFailureCount ?? 0) + 1;
+      state.diffFailureCount = failures;
+      await persistState({ ...state, omittedKeys: previousOmittedKeys });
+      appendLog(
+        "error",
+        `git-traces: turn diff failed (repo=${repoRoot}, project=${config.projectId}, consecutiveFailures=${failures}): ${formatError(err)}`
+      );
+      if (failures < REBASELINE_AFTER_DIFF_FAILURES) return "failed";
+      return await attemptWedgeRecovery();
+    }
+    const diffFailuresCleared = state.diffFailureCount !== void 0;
+    delete state.diffFailureCount;
     if (!patchBuffer) {
-      if (omissionsChanged) {
+      if (omissionsChanged || diffFailuresCleared) {
         await persistState(state);
       } else {
         await touchSessionState(state.repoRoot, tool, sessionId);
@@ -16653,7 +16895,7 @@ async function runGitTraces() {
   };
   await applyDebugLogParentEnv(workerEnv, raw);
   try {
-    const child = spawn3(
+    const child = spawn4(
       process.execPath,
       [entrypoint, "git-traces", `--tool=${tool}`],
       {

package/package.json

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