hillclimb 0.8.7 → 0.8.9

package/dist/main.js

@@ -14402,6 +14402,35 @@ import fs14 from "fs";
 import os7 from "os";
 import path14 from "path";
 import { createGzip } from "zlib";
+
+// src/git-traces/timing.ts
+import { performance } from "perf_hooks";
+function startCaptureStage(stage, context) {
+  appendLog(
+    "info",
+    `git-traces: capture timing (${context}, stage=${stage}, status=started)`
+  );
+  const started = performance.now();
+  return (status) => {
+    appendLog(
+      "info",
+      `git-traces: capture timing (${context}, stage=${stage}, status=${status}, elapsedMs=${Math.round(performance.now() - started)})`
+    );
+  };
+}
+function timeCaptureStage(repoRoot, stage, run) {
+  const finish = startCaptureStage(stage, `repo=${repoRoot}`);
+  let status = "failed";
+  try {
+    const result = run();
+    status = "ok";
+    return result;
+  } finally {
+    finish(status);
+  }
+}
+
+// src/git-traces/git-ops.ts
 var DEFAULT_GIT_COMMAND_TIMEOUT_MS = 12e4;
 var FULL_TREE_SCAN_TIMEOUT_MS = 3e5;
 function resolveGitCommandTimeoutMs() {
@@ -14682,6 +14711,7 @@ 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.status;
   const stderr = outputToString(failure.stderr);
   wrapped.gitStderr = stderr ? truncateOutput(stderr) : void 0;
   wrapped.isGitMissingObject = !isTimeout && failure.code !== "ENOBUFS" && matchesMissingObject(stderr);
@@ -14723,20 +14753,50 @@ function isGitRepo(dir) {
   }
 }
 function captureWorkingCommitSha(repoRoot) {
-  try {
-    const sha = git(repoRoot, ["stash", "create"]);
-    if (sha) return sha;
-  } catch (err) {
-    if (isGitTimeoutError(err)) throw err;
-  }
-  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"]);
+  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"]);
+      }
+      if (failure.gitExitStatus !== 1 || !/Unable to create [^\n]*index\.lock[^\n]*: File exists/.test(stderr) || attempt >= 5)
+        throw err;
+      appendLog(
+        "warn",
+        `git-traces: retrying stash create after index lock contention (repo=${repoRoot}, attempt=${attempt}, maxAttempts=5): ${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);
 }
@@ -14971,69 +15031,89 @@ function removePathsFromIndex(repoRoot, env, paths) {
   });
 }
 function filterOmittedFilesFromTree(repoRoot, treeSha, options = {}) {
-  const omittedFiles = listOmittedTreeFiles(
+  const omittedFiles = timeCaptureStage(
     repoRoot,
-    treeSha,
-    options.limits ?? DEFAULT_SNAPSHOT_LIMITS,
-    options.previousScan
+    "omission-scan",
+    () => listOmittedTreeFiles(
+      repoRoot,
+      treeSha,
+      options.limits ?? DEFAULT_SNAPSHOT_LIMITS,
+      options.previousScan
+    )
   );
   options.omittedFiles?.push(...omittedFiles);
-  if (omittedFiles.length === 0) return treeSha;
-  const tmpIndex = path14.join(
-    os7.tmpdir(),
-    `hillclimb-filter-${Date.now()}-${process.pid}`
-  );
-  const env = { ...process.env, GIT_INDEX_FILE: tmpIndex };
-  try {
-    gitWithEnv(repoRoot, ["read-tree", treeSha], env);
-    removePathsFromIndex(
-      repoRoot,
-      env,
-      omittedFiles.map((file) => file.path)
+  return timeCaptureStage(repoRoot, "tracked-tree-filter", () => {
+    if (omittedFiles.length === 0) return treeSha;
+    const tmpIndex = path14.join(
+      os7.tmpdir(),
+      `hillclimb-filter-${Date.now()}-${process.pid}`
     );
-    return gitWithEnv(repoRoot, ["write-tree"], env);
-  } finally {
+    const env = { ...process.env, GIT_INDEX_FILE: tmpIndex };
     try {
-      fs14.unlinkSync(tmpIndex);
-    } catch {
+      gitWithEnv(repoRoot, ["read-tree", treeSha], env);
+      removePathsFromIndex(
+        repoRoot,
+        env,
+        omittedFiles.map((file) => file.path)
+      );
+      return gitWithEnv(repoRoot, ["write-tree"], env);
+    } finally {
+      try {
+        fs14.unlinkSync(tmpIndex);
+      } catch {
+      }
     }
-  }
+  });
 }
 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(),
@@ -15041,11 +15121,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);
@@ -15056,7 +15144,11 @@ function buildUntrackedTree(repoRoot, options = {}) {
 function buildSnapshotTree(repoRoot, stashSha, options = {}) {
   const omittedFiles = options.omittedFiles ?? [];
   const limits = options.limits ?? DEFAULT_SNAPSHOT_LIMITS;
-  const trackedTree = git(repoRoot, ["rev-parse", `${stashSha}^{tree}`]);
+  const trackedTree = timeCaptureStage(
+    repoRoot,
+    "tracked-tree-resolve",
+    () => git(repoRoot, ["rev-parse", `${stashSha}^{tree}`])
+  );
   const trackedOmitted = [];
   const filteredTrackedTree = filterOmittedFilesFromTree(
     repoRoot,
@@ -15068,12 +15160,16 @@ function buildSnapshotTree(repoRoot, stashSha, options = {}) {
     }
   );
   omittedFiles.push(...trackedOmitted);
-  const untrackedTree = buildUntrackedTree(repoRoot, { omittedFiles, limits });
+  const untrackedTree = timeCaptureStage(
+    repoRoot,
+    "untracked-capture",
+    () => buildUntrackedTree(repoRoot, { omittedFiles, limits })
+  );
   if (options.log !== false) logOmittedSnapshotSummary(omittedFiles);
-  const snapshotTree = mergeSnapshotTrees(
+  const snapshotTree = timeCaptureStage(
     repoRoot,
-    filteredTrackedTree,
-    untrackedTree
+    "tree-assembly",
+    () => mergeSnapshotTrees(repoRoot, filteredTrackedTree, untrackedTree)
   );
   options.scanOut?.push({
     trackedTreeSha: trackedTree,
@@ -15092,26 +15188,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);
@@ -15709,6 +15827,27 @@ async function deleteLegacySessionState(repoRoot, tool, sessionId) {
   if (legacy?.sessionId === sessionId) await deleteStateFile(legacyFile);
 }
 async function acquireLock3(repoRoot, tool, sessionId, retries, delayMs, options = {}) {
+  const finish = startCaptureStage(
+    "lock-wait",
+    `repo=${repoRoot}, tool=${tool}, session=${sessionId || "<legacy>"}`
+  );
+  let status = "failed";
+  try {
+    const result = await acquireLockWithoutTiming(
+      repoRoot,
+      tool,
+      sessionId,
+      retries,
+      delayMs,
+      options
+    );
+    status = "ok";
+    return result;
+  } finally {
+    finish(status);
+  }
+}
+async function acquireLockWithoutTiming(repoRoot, tool, sessionId, retries, delayMs, options = {}) {
   const lockPath = lockFileForRepo(repoRoot, tool, sessionId);
   await fs15.promises.mkdir(stateDir3(), { recursive: true, mode: 448 });
   const bounded = retries !== void 0 || delayMs !== void 0;

package/package.json

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