hillclimb 0.5.1 → 0.5.3

package/README.md

@@ -1,43 +1,32 @@
 # hillclimb
 
-Extract AI coding tool sessions (Claude Code, Cursor, Codex, opencode, GitHub Copilot Chat) and upload them to a Hillclimb project.
+Capture AI coding sessions and upload agent traces, ATIF traces, git traces, and
+debug logs to Hillclimb.
 
-## Quickstart
+Supported tools: Claude Code, Cursor, Codex, opencode, and GitHub Copilot Chat.
 
-```sh
-npx hillclimb
-```
+## Quickstart
 
-Run in any git repo. Sessions auto-upload when they end.
+Run once from a git repo:
 
 ```sh
-npx hillclimb status
+npx hillclimb
 ```
 
-Shows login and hook status for the current repo.
-
-## Hooks
-
-`hillclimb` detects which tools you use (`~/.claude`, `~/.cursor`, `~/.codex`, `~/.local/share/opencode`, VS Code GitHub Copilot Chat storage) and installs upload + git-trace hooks for each. You might want to gitignore the respective directories for the tools you use in your repo.
-
-To manually export historical logs instead of configuring auto-upload, run:
-
-```sh
-npx hillclimb export
-```
+Hillclimb signs you in, connects the repo to a project, installs local hooks for
+detected tools, and uploads future sessions automatically.
 
 ## Logs
 
-Hillclimb writes one log file per day to `~/.hillclimb/logs/YYYY-MM-DD.log`. Timestamps and the daily filename are in Pacific Time, so logs line up with Hillclimb's internal clock regardless of your timezone.
-
-Each hook firing tags every line it writes (parent + worker) with a short correlation ID, e.g. `[a1b2c3]`. To follow one flow across interleaved hook runs:
+Daily logs are written to:
 
 ```sh
-grep '\[a1b2c3\]' ~/.hillclimb/logs/$(TZ=America/Los_Angeles date +%F).log
+~/.hillclimb/logs/YYYY-MM-DD.log
 ```
 
-HTTP calls log method, path, status, and latency. Auth codes and presigned-URL signatures are deliberately omitted.
+If a hook reports `npx: command not found`, install Node/npm or make sure `npx`
+is available to the agent hook shell.
 
 ## License
 
-MIT — see [LICENSE](LICENSE).
+MIT - see [LICENSE](LICENSE).

package/dist/cli.js

@@ -2319,6 +2319,7 @@ import crypto3 from "crypto";
 import fs11 from "fs";
 import os6 from "os";
 import path15 from "path";
+import readline from "readline";
 
 // src/debug-logs.ts
 import crypto from "crypto";
@@ -13384,8 +13385,8 @@ var DEFAULT_STATE_DIR = path14.join(
   ".hillclimb",
   "agent-uploads"
 );
-var LOCK_RETRIES2 = 120;
-var LOCK_RETRY_DELAY_MS2 = 500;
+var DEFAULT_LOCK_WAIT_MS = 5 * 60 * 1e3;
+var DEFAULT_LOCK_RETRY_DELAY_MS = 500;
 var DEFAULT_STATE_TTL_MS = 24 * 60 * 60 * 1e3;
 function stateDir2() {
   return process.env.HILLCLIMB_UPLOAD_STATE_DIR ?? DEFAULT_STATE_DIR;
@@ -13402,6 +13403,23 @@ function stateTtlMs() {
     DEFAULT_STATE_TTL_MS
   );
 }
+function lockRetryDelayMs() {
+  return Math.max(
+    1,
+    readPositiveEnvMs(
+      "HILLCLIMB_UPLOAD_LOCK_RETRY_DELAY_MS",
+      DEFAULT_LOCK_RETRY_DELAY_MS
+    )
+  );
+}
+function lockRetries() {
+  return Math.max(
+    1,
+    Math.ceil(
+      readPositiveEnvMs("HILLCLIMB_UPLOAD_LOCK_WAIT_MS", DEFAULT_LOCK_WAIT_MS) / lockRetryDelayMs()
+    )
+  );
+}
 function stateFileFor(repoRoot, tool, sessionId) {
   const hash = crypto2.createHash("sha256").update(`${path14.resolve(repoRoot)}\0${tool}\0${sessionId}`).digest("hex").slice(0, 16);
   return path14.join(stateDir2(), `${hash}.json`);
@@ -13437,7 +13455,7 @@ async function deleteUploadState(repoRoot, tool, sessionId) {
   } catch {
   }
 }
-async function acquireLock2(repoRoot, tool, sessionId, retries = LOCK_RETRIES2, delayMs = LOCK_RETRY_DELAY_MS2) {
+async function acquireLock2(repoRoot, tool, sessionId, retries = lockRetries(), delayMs = lockRetryDelayMs()) {
   const lockPath = lockFileFor(repoRoot, tool, sessionId);
   await fs10.promises.mkdir(stateDir2(), { recursive: true, mode: 448 });
   for (let i = 0; i < retries; i++) {
@@ -13457,10 +13475,13 @@ async function acquireLock2(repoRoot, tool, sessionId, retries = LOCK_RETRIES2,
         await new Promise((r) => setTimeout(r, delayMs));
         continue;
       }
+      if (err.code === "EEXIST") break;
       throw err;
     }
   }
-  throw new Error(`Failed to acquire upload lock after ${retries} retries`);
+  throw new Error(
+    `Failed to acquire upload lock for ${tool} session ${sessionId} after ${retries} retries (${delayMs}ms delay, lock=${lockPath})`
+  );
 }
 async function releaseLock2(repoRoot, tool, sessionId) {
   try {
@@ -13588,6 +13609,54 @@ function summarizePayload(payload) {
     cursor_version_present: !!payload.cursor_version
   });
 }
+async function codexSessionIdFromFile(filePath) {
+  const stream = fs11.createReadStream(filePath, { encoding: "utf-8" });
+  const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+  try {
+    for await (const line of rl) {
+      if (!line.trim()) continue;
+      try {
+        const obj = JSON.parse(line);
+        if (obj.type === "session_meta") return obj.payload?.id ?? null;
+      } catch {
+        return null;
+      }
+      return null;
+    }
+  } finally {
+    rl.close();
+    stream.destroy();
+  }
+  return null;
+}
+async function findCodexTranscriptPath(sessionId) {
+  const sessionsDir = process.env.HILLCLIMB_CODEX_SESSIONS_DIR ?? path15.join(os6.homedir(), ".codex", "sessions");
+  const candidates = [];
+  async function walk(dir) {
+    let entries;
+    try {
+      entries = await fs11.promises.readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const full = path15.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        await walk(full);
+      } else if (entry.isFile() && entry.name.endsWith(".jsonl") && entry.name.includes(sessionId)) {
+        candidates.push(full);
+      }
+    }
+  }
+  await walk(sessionsDir);
+  candidates.sort();
+  for (const filePath of candidates) {
+    if (await codexSessionIdFromFile(filePath) === sessionId) {
+      return filePath;
+    }
+  }
+  return void 0;
+}
 async function selfHealHook(repoRoot, tool) {
   if (process.env.HILLCLIMB_SKIP_HOOK_SELF_HEAL === "1") return;
   try {
@@ -13621,17 +13690,31 @@ function resolveCursorTranscriptPath(payload) {
     `${id}.jsonl`
   );
 }
+async function resolveTranscriptPath(payload, sourceTool, sessionId) {
+  if (payload.transcript_path) return payload.transcript_path;
+  if (sourceTool === "cursor") return resolveCursorTranscriptPath(payload);
+  if (sourceTool === "codex") {
+    const resolved = await findCodexTranscriptPath(sessionId);
+    if (resolved) {
+      appendLog(
+        "info",
+        `[${sessionId}] resolved missing Codex transcript_path via ~/.codex/sessions: ${resolved}`
+      );
+    }
+    return resolved;
+  }
+  return void 0;
+}
 async function runUploadInner(payload) {
   const sessionId = resolveHookSessionId(payload);
-  const transcriptPath = payload.transcript_path ?? resolveCursorTranscriptPath(payload);
   const cwd = resolveHookCwd(payload);
   const eventKind = classifyHookEvent(payload.hook_event_name);
-  if (!sessionId || !transcriptPath || !cwd) {
+  if (!sessionId || !cwd) {
     appendLog(
       "warn",
-      `Skipping upload: missing required hook fields (session_id=${!!sessionId}, transcript_path=${!!transcriptPath}, cwd=${!!cwd})`
+      `Skipping upload: missing required hook fields (session_id=${!!sessionId}, transcript_path=${!!payload.transcript_path}, cwd=${!!cwd})`
     );
-    return;
+    return false;
   }
   const match = await findProjectForCwd(cwd);
   if (!match) {
@@ -13639,13 +13722,13 @@ async function runUploadInner(payload) {
       "warn",
       `Skipping session ${sessionId}: no hillclimb config for cwd ${cwd}. Run \`npx hillclimb\` in the repo.`
     );
-    return;
+    return false;
   }
   const { repoRoot, config } = match;
   const sourceTool = await resolveSourceTool(payload, repoRoot);
   if (!sourceTool) {
     payload.tool = "unknown";
-    return;
+    return false;
   }
   payload.tool = sourceTool;
   appendLog(
@@ -13653,6 +13736,18 @@ async function runUploadInner(payload) {
     `[${sessionId}] payload parsed (tool=${sourceTool}, cwd=${cwd}, event=${eventKind ?? "?"})`
   );
   await selfHealHook(repoRoot, sourceTool);
+  const transcriptPath = await resolveTranscriptPath(
+    payload,
+    sourceTool,
+    sessionId
+  );
+  if (!transcriptPath) {
+    appendLog(
+      "warn",
+      `Skipping upload: missing required hook fields (session_id=true, transcript_path=false, cwd=true)`
+    );
+    return false;
+  }
   const transcriptResolved = path15.resolve(transcriptPath);
   try {
     const stat = await fs11.promises.stat(transcriptResolved);
@@ -13661,23 +13756,23 @@ async function runUploadInner(payload) {
         "warn",
         `Skipping session ${sessionId}: transcript_path is not a file: ${transcriptResolved}`
       );
-      return;
+      return false;
     }
   } catch (err) {
     appendLog(
       "warn",
       `Skipping session ${sessionId}: transcript_path not readable (${transcriptResolved}): ${err instanceof Error ? err.message : String(err)}`
     );
-    return;
+    return false;
   }
   if (!await hasAssistantMessage(transcriptResolved)) {
     appendLog(
       "info",
       `Skipping session ${sessionId}: transcript contains no assistant messages (nothing to upload).`
     );
-    return;
+    return false;
   }
-  await uploadSession({
+  return await uploadSession({
     sessionId,
     transcriptPath: transcriptResolved,
     repoRoot,
@@ -13689,7 +13784,7 @@ async function runUploadInner(payload) {
 async function uploadSession(args) {
   const { sessionId, transcriptPath, repoRoot, config, sourceTool, eventKind } = args;
   const isSessionEnd = eventKind === "sessionEnd";
-  await withUploadLock(repoRoot, sourceTool, sessionId, async () => {
+  return await withUploadLock(repoRoot, sourceTool, sessionId, async () => {
     const prior = await readUploadState(repoRoot, sourceTool, sessionId);
     let transcriptSize;
     let transcriptSha256;
@@ -13706,7 +13801,7 @@ async function uploadSession(args) {
       if (isSessionEnd) {
         await deleteUploadState(repoRoot, sourceTool, sessionId);
       }
-      return;
+      return true;
     }
     const now = /* @__PURE__ */ new Date();
     const sourceFile = {
@@ -13736,7 +13831,7 @@ async function uploadSession(args) {
         "error",
         `Session ${sessionId} upload skipped: no saved login for ${config.apiBaseUrl}. Run \`npx hillclimb login\`.`
       );
-      return;
+      return false;
     }
     const client = new PlatformClient(
       config.apiBaseUrl,
@@ -13803,13 +13898,13 @@ Uploaded: ${now.toISOString()}`;
           "error",
           `Session ${sessionId} upload failed: authentication expired. Re-run \`npx hillclimb\` in ${repoRoot}.`
         );
-        return;
+        return false;
       }
       appendLog(
         "error",
         `Session ${sessionId} upload failed: ${err instanceof Error ? err.message : String(err)}`
       );
-      return;
+      return false;
     }
     const next = {
       schemaVersion: CURRENT_SCHEMA_VERSION2,
@@ -13837,6 +13932,7 @@ Uploaded: ${now.toISOString()}`;
         `[${sessionId}] session complete \u2014 contribution ${contributionId}, ${seq} file(s); local state cleared`
       );
     }
+    return true;
   });
 }
 var WORKER_ENV_FLAG = "HILLCLIMB_UPLOAD_WORKER";
@@ -13940,19 +14036,22 @@ async function runUploadWorker() {
   const toolOverride = process.env[TOOL_ENV_FLAG];
   if (toolOverride) payload.tool = toolOverride;
   appendLog("info", `worker: payload summary: ${summarizePayload(payload)}`);
+  let completed = false;
   try {
-    await runUploadInner(payload);
+    completed = await runUploadInner(payload);
   } catch (err) {
     appendLog(
       "error",
       `worker: unexpected error: ${err instanceof Error ? err.stack ?? err.message : String(err)}`
     );
   } finally {
-    await recordDebugLogCompletion({
-      kind: "agent",
-      tool: fallbackSourceTool(payload),
-      payload
-    });
+    if (completed) {
+      await recordDebugLogCompletion({
+        kind: "agent",
+        tool: fallbackSourceTool(payload),
+        payload
+      });
+    }
     try {
       await sweepStaleUploadStates();
     } catch {
@@ -13981,7 +14080,11 @@ var EXEC_OPTS = {
 };
 var MAX_ERROR_OUTPUT_CHARS = 2e3;
 var MAX_SNAPSHOT_FILE_BYTES = 10 * 1024 * 1024;
+var EXCLUDED_SNAPSHOT_EXTENSIONS = /* @__PURE__ */ new Set([".pdf"]);
 var EMPTY_TREE_SHA = "4b825dc642cb6eb9a060e54bf8d69288fbee4904";
+function hasExcludedSnapshotExtension(filePath) {
+  return EXCLUDED_SNAPSHOT_EXTENSIONS.has(path16.extname(filePath).toLowerCase());
+}
 function quoteGitArg(arg) {
   if (/^[A-Za-z0-9_./:=@%+,-]+$/.test(arg)) return arg;
   return JSON.stringify(arg);
@@ -14085,10 +14188,8 @@ function recordOmittedSnapshotFile(omittedFiles, file, options = {}) {
   omittedFiles?.push(file);
   if (options.log === false) return;
   const action = file.tracked ? "omitting tracked" : "skipping untracked";
-  appendLog(
-    "warn",
-    `git-traces: ${action} ${file.path} (${file.sizeBytes} bytes > ${MAX_SNAPSHOT_FILE_BYTES} limit)`
-  );
+  const reason = file.reason === "file-over-limit" ? `${file.sizeBytes} bytes > ${MAX_SNAPSHOT_FILE_BYTES} limit` : "excluded extension";
+  appendLog("warn", `git-traces: ${action} ${file.path} (${reason})`);
 }
 function parseLsTreeLongZ(output) {
   const entries = [];
@@ -14106,24 +14207,25 @@ function parseLsTreeLongZ(output) {
   }
   return entries;
 }
-function listOversizedTreeFiles(repoRoot, treeSha, options = {}) {
+function listOmittedTreeFiles(repoRoot, treeSha, options = {}) {
   const output = gitBuffer(repoRoot, ["ls-tree", "-r", "-l", "-z", treeSha]);
-  const oversized = [];
+  const omitted = [];
   for (const entry of parseLsTreeLongZ(output)) {
-    if (entry.sizeBytes <= MAX_SNAPSHOT_FILE_BYTES) continue;
+    const reason = hasExcludedSnapshotExtension(entry.path) ? "excluded-extension" : entry.sizeBytes > MAX_SNAPSHOT_FILE_BYTES ? "file-over-limit" : null;
+    if (!reason) continue;
     const file = {
       path: entry.path,
       sizeBytes: entry.sizeBytes,
       tracked: true,
-      reason: "file-over-limit",
+      reason,
       gitObjectSha: entry.sha
     };
-    oversized.push(file);
+    omitted.push(file);
     recordOmittedSnapshotFile(options.omittedFiles, file, {
       log: options.log
     });
   }
-  return oversized;
+  return omitted;
 }
 function removePathsFromIndex(repoRoot, env, paths) {
   if (paths.length === 0) return;
@@ -14132,9 +14234,9 @@ function removePathsFromIndex(repoRoot, env, paths) {
     env
   });
 }
-function filterOversizedFilesFromTree(repoRoot, treeSha, options = {}) {
-  const oversizedFiles = listOversizedTreeFiles(repoRoot, treeSha, options);
-  if (oversizedFiles.length === 0) return treeSha;
+function filterOmittedFilesFromTree(repoRoot, treeSha, options = {}) {
+  const omittedFiles = listOmittedTreeFiles(repoRoot, treeSha, options);
+  if (omittedFiles.length === 0) return treeSha;
   const tmpIndex = path16.join(
     os7.tmpdir(),
     `hillclimb-filter-${Date.now()}-${process.pid}`
@@ -14145,7 +14247,7 @@ function filterOversizedFilesFromTree(repoRoot, treeSha, options = {}) {
     removePathsFromIndex(
       repoRoot,
       env,
-      oversizedFiles.map((file) => file.path)
+      omittedFiles.map((file) => file.path)
     );
     return gitWithEnv(repoRoot, ["write-tree"], env);
   } finally {
@@ -14168,12 +14270,13 @@ function buildUntrackedTree(repoRoot, omittedFiles) {
     if (!relPath) continue;
     try {
       const stat = fs12.lstatSync(path16.join(repoRoot, relPath));
-      if (stat.size > MAX_SNAPSHOT_FILE_BYTES) {
+      const reason = hasExcludedSnapshotExtension(relPath) ? "excluded-extension" : stat.size > MAX_SNAPSHOT_FILE_BYTES ? "file-over-limit" : null;
+      if (reason) {
         recordOmittedSnapshotFile(omittedFiles, {
           path: relPath,
           sizeBytes: stat.size,
           tracked: false,
-          reason: "file-over-limit"
+          reason
         });
         continue;
       }
@@ -14202,7 +14305,7 @@ function buildUntrackedTree(repoRoot, omittedFiles) {
 }
 function buildSnapshotTree(repoRoot, stashSha, options = {}) {
   const trackedTree = git(repoRoot, ["rev-parse", `${stashSha}^{tree}`]);
-  const filteredTrackedTree = filterOversizedFilesFromTree(
+  const filteredTrackedTree = filterOmittedFilesFromTree(
     repoRoot,
     trackedTree,
     {
@@ -14274,14 +14377,14 @@ function createBundleFromTree(repoRoot, treeSha, sessionId, label) {
 }
 function createTreeDiffPatchGz(repoRoot, fromTreeSha, toTreeSha) {
   if (fromTreeSha === toTreeSha) return null;
-  const filteredFromTreeSha = filterOversizedFilesFromTree(
+  const filteredFromTreeSha = filterOmittedFilesFromTree(
     repoRoot,
     fromTreeSha,
     {
       log: false
     }
   );
-  const filteredToTreeSha = filterOversizedFilesFromTree(repoRoot, toTreeSha, {
+  const filteredToTreeSha = filterOmittedFilesFromTree(repoRoot, toTreeSha, {
     log: false
   });
   if (filteredFromTreeSha === filteredToTreeSha) return null;
@@ -14527,8 +14630,8 @@ import os8 from "os";
 import path17 from "path";
 var CURRENT_SCHEMA_VERSION3 = 3;
 var DEFAULT_STATE_DIR2 = path17.join(os8.homedir(), ".hillclimb", "git-traces");
-var LOCK_RETRIES3 = 120;
-var LOCK_RETRY_DELAY_MS3 = 500;
+var LOCK_RETRIES2 = 120;
+var LOCK_RETRY_DELAY_MS2 = 500;
 function stateDir3() {
   return process.env.HILLCLIMB_GIT_TRACES_STATE_DIR ?? DEFAULT_STATE_DIR2;
 }
@@ -14656,7 +14759,7 @@ async function deleteSessionState(repoRoot, tool, sessionId) {
   }
   await deleteStateFile(stateFileForRepo(repoRoot, tool));
 }
-async function acquireLock3(repoRoot, tool, retries = LOCK_RETRIES3, delayMs = LOCK_RETRY_DELAY_MS3) {
+async function acquireLock3(repoRoot, tool, retries = LOCK_RETRIES2, delayMs = LOCK_RETRY_DELAY_MS2) {
   const lockPath = lockFileForRepo(repoRoot, tool);
   await fs13.promises.mkdir(stateDir3(), { recursive: true, mode: 448 });
   for (let i = 0; i < retries; i++) {
@@ -16058,7 +16161,7 @@ async function confirmExport(group, output) {
 import fs16 from "fs";
 import os10 from "os";
 import path21 from "path";
-import readline from "readline";
+import readline2 from "readline";
 var SKIP_DIRS = /* @__PURE__ */ new Set(["tool-results"]);
 async function resolveRepoPath(projectDir) {
   const indexPath = path21.join(projectDir, "sessions-index.json");
@@ -16096,7 +16199,7 @@ async function resolveRepoPath(projectDir) {
 }
 async function extractCwdFromJsonl(filePath) {
   const stream = fs16.createReadStream(filePath, { encoding: "utf-8" });
-  const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+  const rl = readline2.createInterface({ input: stream, crlfDelay: Infinity });
   try {
     for await (const line of rl) {
       if (!line.trim()) continue;
@@ -16177,10 +16280,10 @@ var ClaudeSource = class {
 import fs17 from "fs";
 import os11 from "os";
 import path22 from "path";
-import readline2 from "readline";
+import readline3 from "readline";
 async function parseSessionMeta(filePath) {
   const stream = fs17.createReadStream(filePath, { encoding: "utf-8" });
-  const rl = readline2.createInterface({ input: stream, crlfDelay: Infinity });
+  const rl = readline3.createInterface({ input: stream, crlfDelay: Infinity });
   try {
     for await (const line of rl) {
       if (!line.trim()) continue;
@@ -16228,7 +16331,7 @@ async function loadHistory(historyPath) {
     return map;
   }
   const stream = fs17.createReadStream(historyPath, { encoding: "utf-8" });
-  const rl = readline2.createInterface({ input: stream, crlfDelay: Infinity });
+  const rl = readline3.createInterface({ input: stream, crlfDelay: Infinity });
   try {
     for await (const line of rl) {
       if (!line.trim()) continue;

package/package.json

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