hillclimb 0.8.8 → 0.8.10

package/dist/main.js

@@ -14711,8 +14711,11 @@ function createGitError(args, err, timeoutMs = GIT_COMMAND_TIMEOUT_MS) {
   const message = isTimeout ? `${command} timed out after ${timeoutMs}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;
+  wrapped.gitExitStatus = failure.code || failure.signal ? void 0 : failure.status;
   const stderr = outputToString(failure.stderr);
   wrapped.gitStderr = stderr ? truncateOutput(stderr) : void 0;
+  const stdout = outputToString(failure.stdout);
+  wrapped.gitStdout = stdout ? truncateOutput(stdout) : void 0;
   wrapped.isGitMissingObject = !isTimeout && failure.code !== "ENOBUFS" && matchesMissingObject(stderr);
   return wrapped;
 }
@@ -14751,25 +14754,64 @@ function isGitRepo(dir) {
     return false;
   }
 }
-function captureWorkingCommitSha(repoRoot) {
-  try {
-    const sha = timeCaptureStage(
-      repoRoot,
-      "stash-create",
-      () => git(repoRoot, ["stash", "create"])
-    );
-    if (sha) return sha;
-  } catch (err) {
-    if (isGitTimeoutError(err)) throw err;
+function stashRetryReason(failure) {
+  const status = failure.gitExitStatus;
+  if (status !== 1 && status !== 128) return null;
+  if (/Unable to create [^\n]*index\.lock[^\n]*: File exists/.test(
+    failure.gitStderr ?? ""
+  )) {
+    return "index-lock-contention";
   }
-  try {
-    return git(repoRoot, ["rev-parse", "HEAD"]);
-  } catch (err) {
-    if (isGitTimeoutError(err)) throw err;
-    const tree = git(repoRoot, ["write-tree"]);
-    return git(repoRoot, ["commit-tree", tree, "-m", "empty baseline"]);
+  if (status === 1 && !failure.gitStderr && !failure.gitStdout) {
+    return "empty-stash-failure";
+  }
+  return null;
+}
+function captureWorkingCommitSha(repoRoot) {
+  for (let attempt = 1; ; attempt++) {
+    let sha;
+    try {
+      sha = timeCaptureStage(
+        repoRoot,
+        "stash-create",
+        () => (
+          // Keep the two expected stderr classifications independent of locale.
+          gitWithEnv(repoRoot, ["stash", "create"], {
+            ...process.env,
+            LC_ALL: "C"
+          })
+        )
+      );
+    } catch (err) {
+      const failure = err;
+      const stderr = failure.gitStderr ?? "";
+      if (failure.gitExitStatus === 1 && stderr.includes("You do not have the initial commit yet") && hasUnbornHead(repoRoot)) {
+        appendLog(
+          "info",
+          `git-traces: stash create unavailable (repo=${repoRoot}, reason=unborn-head); capturing index tree`
+        );
+        const tree = git(repoRoot, ["write-tree"]);
+        return git(repoRoot, ["commit-tree", tree, "-m", "empty baseline"]);
+      }
+      const retryReason = stashRetryReason(failure);
+      if (!retryReason || attempt >= 5) throw err;
+      appendLog(
+        "warn",
+        `git-traces: retrying stash create after ${retryReason === "index-lock-contention" ? "index lock contention" : "empty Git failure (possible index contention)"} (repo=${repoRoot}, attempt=${attempt}, maxAttempts=5, reason=${retryReason}): ${failure.message}`
+      );
+      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 250);
+      continue;
+    }
+    return sha || git(repoRoot, ["rev-parse", "--verify", "HEAD"]);
   }
 }
+function hasUnbornHead(repoRoot) {
+  const ref = git(repoRoot, ["symbolic-ref", "--quiet", "HEAD"]);
+  const args = ["show-ref", "--verify", "--quiet", ref];
+  const result = spawnSync("git", args, { cwd: repoRoot, ...EXEC_OPTS });
+  if (result.error) throw createGitError(args, result.error);
+  return result.status === 1;
+}
 function captureBaselineSha(repoRoot) {
   return captureWorkingCommitSha(repoRoot);
 }
@@ -15040,39 +15082,53 @@ function filterOmittedFilesFromTree(repoRoot, treeSha, options = {}) {
 }
 function buildUntrackedTree(repoRoot, options = {}) {
   const limits = options.limits ?? DEFAULT_SNAPSHOT_LIMITS;
-  const list = git(repoRoot, [
-    "ls-files",
-    "--others",
-    "--exclude-standard",
-    "-z"
-  ]);
-  if (!list) return null;
+  const list = timeCaptureStage(
+    repoRoot,
+    "untracked-list",
+    () => git(repoRoot, ["ls-files", "--others", "--exclude-standard", "-z"])
+  );
   const kept = [];
-  for (const relPath of list.split("\0")) {
-    if (!relPath) continue;
-    try {
-      const absPath = path14.join(repoRoot, relPath);
-      const stat = fs14.lstatSync(absPath);
-      const reason = classifyOmission(
-        relPath,
-        stat.size,
-        () => readWorkingFileHead(absPath),
-        limits,
-        false
-      );
-      if (reason) {
-        options.omittedFiles?.push({
-          path: relPath,
-          sizeBytes: stat.size,
-          tracked: false,
-          reason
-        });
-        continue;
+  let candidates = 0;
+  let keptBytes = 0;
+  let omitted = 0;
+  let omittedBytes = 0;
+  let skipped = 0;
+  timeCaptureStage(repoRoot, "untracked-filter", () => {
+    for (const relPath of list.split("\0")) {
+      if (!relPath) continue;
+      candidates++;
+      try {
+        const absPath = path14.join(repoRoot, relPath);
+        const stat = fs14.lstatSync(absPath);
+        const reason = classifyOmission(
+          relPath,
+          stat.size,
+          () => readWorkingFileHead(absPath),
+          limits,
+          false
+        );
+        if (reason) {
+          omitted++;
+          omittedBytes += stat.size;
+          options.omittedFiles?.push({
+            path: relPath,
+            sizeBytes: stat.size,
+            tracked: false,
+            reason
+          });
+          continue;
+        }
+        kept.push(relPath);
+        keptBytes += stat.size;
+      } catch {
+        skipped++;
       }
-      kept.push(relPath);
-    } catch {
     }
-  }
+  });
+  appendLog(
+    "info",
+    `git-traces: untracked inventory (repo=${repoRoot}, candidates=${candidates}, kept=${kept.length}, keptBytes=${keptBytes}, omitted=${omitted}, omittedBytes=${omittedBytes}, skipped=${skipped})`
+  );
   if (kept.length === 0) return null;
   const tmpIndex = path14.join(
     os7.tmpdir(),
@@ -15080,11 +15136,19 @@ function buildUntrackedTree(repoRoot, options = {}) {
   );
   const env = { ...process.env, GIT_INDEX_FILE: tmpIndex };
   try {
-    gitBuffer(repoRoot, ["update-index", "--add", "-z", "--stdin"], {
-      input: `${kept.join("\0")}\0`,
-      env
-    });
-    return gitWithEnv(repoRoot, ["write-tree"], env);
+    timeCaptureStage(
+      repoRoot,
+      "untracked-hash-and-index",
+      () => gitBuffer(repoRoot, ["update-index", "--add", "-z", "--stdin"], {
+        input: `${kept.join("\0")}\0`,
+        env
+      })
+    );
+    return timeCaptureStage(
+      repoRoot,
+      "untracked-write-tree",
+      () => gitWithEnv(repoRoot, ["write-tree"], env)
+    );
   } finally {
     try {
       fs14.unlinkSync(tmpIndex);
@@ -15139,26 +15203,48 @@ function mergeSnapshotTrees(repoRoot, filteredTrackedTree, untrackedTree) {
   );
   const env = { ...process.env, GIT_INDEX_FILE: tmpIndex };
   try {
-    gitWithEnv(repoRoot, ["read-tree", filteredTrackedTree], env);
-    const untrackedList = gitBuffer(
+    timeCaptureStage(
       repoRoot,
-      ["ls-tree", "-r", untrackedTree],
-      {
-        env
-      }
-    ).toString("utf-8");
-    const indexInfo = untrackedList.split("\n").filter(Boolean).map((line) => {
-      const [meta, filePath] = line.split("	");
-      const [mode, , sha] = meta.split(/\s+/);
-      return `${mode} ${sha}	${filePath}`;
-    }).join("\n");
+      "assembly-read-tree",
+      () => gitWithEnv(repoRoot, ["read-tree", filteredTrackedTree], env)
+    );
+    const untrackedList = timeCaptureStage(
+      repoRoot,
+      "assembly-list-untracked",
+      () => gitBuffer(repoRoot, ["ls-tree", "-r", untrackedTree], { env }).toString(
+        "utf-8"
+      )
+    );
+    let overlayEntries = 0;
+    const indexInfo = timeCaptureStage(
+      repoRoot,
+      "assembly-prepare-index",
+      () => untrackedList.split("\n").filter(Boolean).map((line) => {
+        const [meta, filePath] = line.split("	");
+        const [mode, , sha] = meta.split(/\s+/);
+        overlayEntries++;
+        return `${mode} ${sha}	${filePath}`;
+      }).join("\n")
+    );
+    appendLog(
+      "info",
+      `git-traces: assembly inventory (repo=${repoRoot}, untrackedEntries=${overlayEntries})`
+    );
     if (indexInfo) {
-      gitBuffer(repoRoot, ["update-index", "--index-info"], {
-        input: indexInfo,
-        env
-      });
+      timeCaptureStage(
+        repoRoot,
+        "assembly-update-index",
+        () => gitBuffer(repoRoot, ["update-index", "--index-info"], {
+          input: indexInfo,
+          env
+        })
+      );
     }
-    return gitWithEnv(repoRoot, ["write-tree"], env);
+    return timeCaptureStage(
+      repoRoot,
+      "assembly-write-tree",
+      () => gitWithEnv(repoRoot, ["write-tree"], env)
+    );
   } finally {
     try {
       fs14.unlinkSync(tmpIndex);

package/package.json

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