hillclimb 0.1.9 → 0.2.0

package/README.md

@@ -1,6 +1,6 @@
 # hillclimb
 
-Extract AI coding tool sessions (Claude Code, Cursor, Codex, opencode) and upload them to a Hillclimb project.
+Extract AI coding tool sessions (Claude Code, Cursor, Codex, opencode, GitHub Copilot Chat) and upload them to a Hillclimb project.
 
 ## Quickstart
 
@@ -18,7 +18,7 @@ Shows login and hook status for the current repo.
 
 ## Hooks
 
-`hillclimb` detects which tools you use (`~/.claude`, `~/.cursor`, `~/.codex`, `~/.local/share/opencode`) and installs upload + git-trace hooks for each. You might want to gitignore the respective directories for the tools you use in your repo.
+`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:
 

package/dist/cli.js

@@ -850,7 +850,7 @@ function copilotUninstall(settings, eventName, command) {
   }
   return true;
 }
-var OPENCODE_PLUGIN_VERSION = 3;
+var OPENCODE_PLUGIN_VERSION = 4;
 var OPENCODE_PLUGIN_MARKER = `// HILLCLIMB_OPENCODE_PLUGIN_VERSION=${OPENCODE_PLUGIN_VERSION}`;
 var OPENCODE_PLUGIN_CONTENT = `${OPENCODE_PLUGIN_MARKER}
 // Auto-installed by \`npx hillclimb\`. Do not edit manually \u2014 re-running
@@ -864,20 +864,54 @@ import path from "node:path";
 const TOOL = "opencode";
 const TRANSCRIPT_DIR = path.join(os.homedir(), ".hillclimb", "opencode-transcripts");
 
-// sessionID -> Map<messageID, messageInfo>. Using a Map-of-Maps so late
-// message.updated events (streaming deltas) overwrite earlier versions of
-// the same message instead of appending duplicates.
+// sessionID -> Map<messageID, { info, parts }>. Using a Map-of-Maps so late
+// message.updated / message.part.updated events overwrite earlier versions
+// instead of appending duplicates.
 const sessionMessages = new Map();
 
-function ingestMessage(sessionID, info) {
-  if (!sessionID || !info) return;
+function ensureRecord(sessionID, messageID, info) {
+  if (!sessionID || !messageID) return null;
   let bucket = sessionMessages.get(sessionID);
   if (!bucket) {
     bucket = new Map();
     sessionMessages.set(sessionID, bucket);
   }
-  const id = info.id || ((info.role || "unknown") + "-" + bucket.size);
-  bucket.set(id, info);
+  let record = bucket.get(messageID);
+  if (!record) {
+    record = {
+      info: info || { id: messageID, sessionID },
+      parts: new Map(),
+    };
+    bucket.set(messageID, record);
+  } else if (info) {
+    record.info = Object.assign({}, record.info || {}, info);
+  }
+  return record;
+}
+
+function ingestMessage(sessionID, info) {
+  if (!sessionID || !info) return;
+  const id = info.id || ((info.role || "unknown") + "-" + Date.now());
+  ensureRecord(sessionID, id, info);
+}
+
+function ingestPart(sessionID, part) {
+  if (!part) return;
+  const sid = sessionID || part.sessionID;
+  const messageID = part.messageID;
+  if (!sid || !messageID) return;
+  const record = ensureRecord(sid, messageID, { id: messageID, sessionID: sid });
+  if (!record) return;
+  const partID = part.id || ((part.type || "part") + "-" + record.parts.size);
+  record.parts.set(partID, part);
+}
+
+function serializeRecord(record) {
+  const info = record.info || {};
+  const parts = Array.from(record.parts.values());
+  if (parts.length === 0) return info;
+  // Preserve the old top-level message-info shape while adding parts.
+  return Object.assign({}, info, { parts });
 }
 
 function writeTranscript(sessionID) {
@@ -887,7 +921,7 @@ function writeTranscript(sessionID) {
     fs.mkdirSync(TRANSCRIPT_DIR, { recursive: true });
     const file = path.join(TRANSCRIPT_DIR, sessionID + ".jsonl");
     const lines = [];
-    for (const msg of bucket.values()) lines.push(JSON.stringify(msg));
+    for (const record of bucket.values()) lines.push(JSON.stringify(serializeRecord(record)));
     fs.writeFileSync(file, lines.join("\\n") + "\\n");
     return file;
   } catch {
@@ -917,17 +951,24 @@ export const HillclimbPlugin = async ({ directory }) => ({
   event: async ({ event }) => {
     const type = event && event.type;
     const props = (event && event.properties) || {};
-    const sessionID = props.sessionID;
+    const info = props.info || {};
+    const sessionID = props.sessionID || info.sessionID || info.id;
+    const cwd = directory || props.directory || info.directory;
 
     if (type === "message.updated") {
-      ingestMessage(sessionID, props.info);
+      ingestMessage(sessionID, info);
+      return;
+    }
+
+    if (type === "message.part.updated") {
+      ingestPart(sessionID, props.part);
       return;
     }
 
     if (type === "session.created" && sessionID) {
       spawnHillclimb("git-traces --tool=opencode", {
         session_id: sessionID,
-        cwd: directory,
+        cwd,
         hook_event_name: "session.created",
         tool: TOOL,
       });
@@ -940,7 +981,7 @@ export const HillclimbPlugin = async ({ directory }) => ({
       // so a single session produces one contribution, not one per turn.
       spawnHillclimb("git-traces --tool=opencode", {
         session_id: sessionID,
-        cwd: directory,
+        cwd,
         hook_event_name: "session.idle",
         tool: TOOL,
       });
@@ -958,7 +999,7 @@ export const HillclimbPlugin = async ({ directory }) => ({
       if (transcriptPath) {
         spawnHillclimb("upload", {
           session_id: sessionID,
-          cwd: directory,
+          cwd,
           transcript_path: transcriptPath,
           hook_event_name: "session.deleted",
           tool: TOOL,
@@ -978,7 +1019,7 @@ export const HillclimbPlugin = async ({ directory }) => ({
         if (transcriptPath) {
           spawnHillclimb("upload", {
             session_id: sid,
-            cwd: directory,
+            cwd,
             transcript_path: transcriptPath,
             hook_event_name: "server.instance.disposed",
             tool: TOOL,
@@ -987,7 +1028,7 @@ export const HillclimbPlugin = async ({ directory }) => ({
       }
       sessionMessages.clear();
       spawnHillclimb("git-traces --tool=opencode", {
-        cwd: directory,
+        cwd,
         hook_event_name: "server.instance.disposed",
         tool: TOOL,
       });
@@ -1070,7 +1111,7 @@ async function installHooksForTool(repoRoot, def) {
   const file = settingsPath(repoRoot, def);
   if (def.format === "opencode") {
     const r = await opencodeInstall(file);
-    return { settingsFile: file, ...r };
+    return { settingsFile: file, ...r, changed: r.installed > 0 };
   }
   const settings = await readJson(file);
   let installed = 0;
@@ -1093,7 +1134,7 @@ async function installHooksForTool(repoRoot, def) {
     }
   }
   if (mutated) await writeJson(file, settings);
-  return { settingsFile: file, installed, alreadyPresent };
+  return { settingsFile: file, installed, alreadyPresent, changed: mutated };
 }
 async function checkHooksForTool(repoRoot, def) {
   const file = settingsPath(repoRoot, def);
@@ -1133,6 +1174,29 @@ async function installDetectedHooks(repoRoot) {
   }
   return results;
 }
+async function healHookForTool(repoRoot, tool) {
+  const def = TOOLS.find((candidate) => candidate.tool === tool);
+  if (!def) {
+    return {
+      tool,
+      changed: false,
+      alreadyCurrent: false,
+      installed: 0,
+      alreadyPresent: 0,
+      skipped: "unsupported-tool"
+    };
+  }
+  const r = await installHooksForTool(repoRoot, def);
+  return {
+    tool: def.tool,
+    label: def.label,
+    settingsFile: r.settingsFile,
+    changed: r.changed,
+    alreadyCurrent: !r.changed,
+    installed: r.installed,
+    alreadyPresent: r.alreadyPresent
+  };
+}
 async function checkAllHooks(repoRoot) {
   const results = [];
   for (const def of TOOLS) {
@@ -11488,6 +11552,288 @@ function convertEventToStep2(event, stepId, defaultModelName) {
   return null;
 }
 
+// src/normalizer/types.ts
+var ATIF_VERSION = "ATIF-v1.6";
+function excludeNone(obj) {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (value === void 0 || value === null) continue;
+    if (Array.isArray(value)) {
+      result[key] = value.map(
+        (item) => typeof item === "object" && item !== null && !Array.isArray(item) ? excludeNone(item) : item
+      );
+    } else if (typeof value === "object" && !Array.isArray(value)) {
+      result[key] = excludeNone(value);
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+
+// src/normalizer/copilotChat.ts
+function asObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+function asNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function compactExtra(extra) {
+  const result = {};
+  for (const [key, value] of Object.entries(extra)) {
+    if (value !== void 0 && value !== null) result[key] = value;
+  }
+  return Object.keys(result).length > 0 ? result : void 0;
+}
+function parseJsonLines(content) {
+  const entries = [];
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      const parsed = asObject(JSON.parse(trimmed));
+      if (!parsed) continue;
+      entries.push({
+        type: typeof parsed.type === "string" ? parsed.type : void 0,
+        data: asObject(parsed.data),
+        id: typeof parsed.id === "string" ? parsed.id : void 0,
+        timestamp: typeof parsed.timestamp === "string" ? parsed.timestamp : void 0
+      });
+    } catch {
+    }
+  }
+  return entries;
+}
+function parseArguments(value) {
+  const obj = asObject(value);
+  if (obj) return obj;
+  if (typeof value === "string") {
+    try {
+      const parsed = asObject(JSON.parse(value));
+      if (parsed) return parsed;
+    } catch {
+      return value ? { input: value } : {};
+    }
+  }
+  return value === void 0 || value === null ? {} : { value };
+}
+function buildMetrics2(data) {
+  const inputTokens = asNumber(data.inputTokens) ?? 0;
+  const outputTokens = asNumber(data.outputTokens) ?? 0;
+  const cacheReadTokens = asNumber(data.cacheReadTokens) ?? 0;
+  const cacheWriteTokens = asNumber(data.cacheWriteTokens) ?? 0;
+  const cost = asNumber(data.cost);
+  if (!inputTokens && !outputTokens && !cacheReadTokens && !cacheWriteTokens && !cost) {
+    return void 0;
+  }
+  return {
+    prompt_tokens: inputTokens + cacheReadTokens || void 0,
+    completion_tokens: outputTokens || void 0,
+    cached_tokens: cacheReadTokens || void 0,
+    cost_usd: cost || void 0,
+    extra: compactExtra({
+      cache_write_tokens: cacheWriteTokens || void 0,
+      duration_ms: data.duration,
+      initiator: data.initiator,
+      api_call_id: data.apiCallId,
+      provider_call_id: data.providerCallId,
+      parent_tool_call_id: data.parentToolCallId,
+      quota_snapshots: data.quotaSnapshots,
+      copilot_usage: data.copilotUsage
+    })
+  };
+}
+function finalMetricsFromSteps(steps) {
+  let prompt = 0;
+  let completion = 0;
+  let cached = 0;
+  let cost = 0;
+  for (const step of steps) {
+    prompt += step.metrics?.prompt_tokens ?? 0;
+    completion += step.metrics?.completion_tokens ?? 0;
+    cached += step.metrics?.cached_tokens ?? 0;
+    cost += step.metrics?.cost_usd ?? 0;
+  }
+  return {
+    total_prompt_tokens: prompt || void 0,
+    total_completion_tokens: completion || void 0,
+    total_cached_tokens: cached || void 0,
+    total_cost_usd: cost || void 0,
+    total_steps: steps.length
+  };
+}
+function makeToolCall(request) {
+  const req = asObject(request);
+  if (!req) return null;
+  const callId = typeof req.toolCallId === "string" && req.toolCallId || typeof req.id === "string" && req.id || "";
+  const name = typeof req.name === "string" && req.name || typeof req.toolName === "string" && req.toolName || "tool";
+  return {
+    tool_call_id: callId,
+    function_name: name,
+    arguments: parseArguments(req.arguments)
+  };
+}
+function toolCallFromExecutionStart(data) {
+  const callId = typeof data.toolCallId === "string" && data.toolCallId || typeof data.id === "string" && data.id || "";
+  const name = typeof data.toolName === "string" && data.toolName || typeof data.name === "string" && data.name || "tool";
+  return {
+    tool_call_id: callId,
+    function_name: name,
+    arguments: parseArguments(data.arguments)
+  };
+}
+function contentFromToolResult(data) {
+  const result = asObject(data.result);
+  if (typeof result?.content === "string") return result.content;
+  if (typeof data.content === "string") return data.content;
+  return void 0;
+}
+function convertCopilotChatToTrajectory(jsonlContent, sessionId) {
+  const entries = parseJsonLines(jsonlContent);
+  if (entries.length === 0) return null;
+  let sid = sessionId ?? "unknown";
+  let copilotVersion = "unknown";
+  let vscodeVersion;
+  let cwd;
+  let defaultModelName;
+  const steps = [];
+  const pendingReasoning = [];
+  const pendingToolSteps = /* @__PURE__ */ new Map();
+  let lastAgentStep;
+  for (const entry of entries) {
+    const data = entry.data ?? {};
+    if (entry.type === "session.start") {
+      if (!sessionId && typeof data.sessionId === "string")
+        sid = data.sessionId;
+      if (typeof data.copilotVersion === "string")
+        copilotVersion = data.copilotVersion;
+      if (typeof data.vscodeVersion === "string")
+        vscodeVersion = data.vscodeVersion;
+      const context = asObject(data.context);
+      if (typeof context?.cwd === "string") cwd = context.cwd;
+      continue;
+    }
+    if (entry.type === "user.message" || entry.type === "system.message") {
+      const content = typeof data.content === "string" && data.content || typeof data.transformedContent === "string" && data.transformedContent || "";
+      if (!content.trim()) continue;
+      const source = entry.type === "system.message" ? "system" : "user";
+      const step = {
+        step_id: steps.length + 1,
+        timestamp: entry.timestamp,
+        source,
+        message: content,
+        extra: compactExtra({
+          attachments: data.attachments,
+          source: data.source,
+          agent_mode: data.agentMode,
+          interaction_id: data.interactionId
+        })
+      };
+      steps.push(step);
+      continue;
+    }
+    if (entry.type === "assistant.reasoning") {
+      if (typeof data.content === "string" && data.content.trim()) {
+        pendingReasoning.push(data.content.trim());
+      }
+      continue;
+    }
+    if (entry.type === "assistant.message") {
+      const toolCalls = (Array.isArray(data.toolRequests) ? data.toolRequests : []).flatMap((request) => {
+        const call = makeToolCall(request);
+        return call ? [call] : [];
+      });
+      const content = typeof data.content === "string" && data.content.trim() ? data.content.trim() : "";
+      const reasoning = typeof data.reasoningText === "string" && data.reasoningText.trim() || pendingReasoning.join("\n\n") || void 0;
+      pendingReasoning.length = 0;
+      const step = {
+        step_id: steps.length + 1,
+        timestamp: entry.timestamp,
+        source: "agent",
+        message: content || (toolCalls.length > 0 ? "(tool use)" : ""),
+        model_name: defaultModelName,
+        extra: compactExtra({
+          message_id: data.messageId,
+          phase: data.phase,
+          output_tokens: data.outputTokens
+        })
+      };
+      if (reasoning) step.reasoning_content = reasoning;
+      if (toolCalls.length > 0) step.tool_calls = toolCalls;
+      if (step.message || step.tool_calls?.length || step.reasoning_content) {
+        steps.push(step);
+        lastAgentStep = step;
+        for (const call of toolCalls) {
+          if (call.tool_call_id) pendingToolSteps.set(call.tool_call_id, step);
+        }
+      }
+      continue;
+    }
+    if (entry.type === "tool.execution_start") {
+      const toolCall = toolCallFromExecutionStart(data);
+      const step = {
+        step_id: steps.length + 1,
+        timestamp: entry.timestamp,
+        source: "agent",
+        message: `Executed ${toolCall.function_name} ${toolCall.tool_call_id}`.trim(),
+        model_name: defaultModelName,
+        tool_calls: [toolCall]
+      };
+      steps.push(step);
+      lastAgentStep = step;
+      if (toolCall.tool_call_id)
+        pendingToolSteps.set(toolCall.tool_call_id, step);
+      continue;
+    }
+    if (entry.type === "tool.execution_complete") {
+      const callId = typeof data.toolCallId === "string" && data.toolCallId || typeof data.id === "string" && data.id || "";
+      const target = pendingToolSteps.get(callId);
+      const content = contentFromToolResult(data);
+      if (target && content !== void 0) {
+        const observation = target.observation ?? { results: [] };
+        observation.results.push({
+          source_call_id: callId || void 0,
+          content
+        });
+        target.observation = observation;
+        const extra = { ...target.extra ?? {} };
+        extra.tool_success = data.success;
+        target.extra = compactExtra(extra);
+      }
+      if (callId) pendingToolSteps.delete(callId);
+      continue;
+    }
+    if (entry.type === "assistant.usage") {
+      if (typeof data.model === "string" && !defaultModelName) {
+        defaultModelName = data.model;
+        if (lastAgentStep && !lastAgentStep.model_name) {
+          lastAgentStep.model_name = defaultModelName;
+        }
+      }
+      const metrics = buildMetrics2(data);
+      if (metrics && lastAgentStep && !lastAgentStep.metrics) {
+        lastAgentStep.metrics = metrics;
+      }
+    }
+  }
+  if (steps.length === 0) return null;
+  return {
+    schema_version: ATIF_VERSION,
+    session_id: sid,
+    agent: {
+      name: "github-copilot-chat",
+      version: copilotVersion,
+      model_name: defaultModelName,
+      extra: compactExtra({
+        vscode_version: vscodeVersion,
+        cwd
+      })
+    },
+    steps,
+    final_metrics: finalMetricsFromSteps(steps)
+  };
+}
+
 // src/normalizer/cursor.ts
 function convertCursorToTrajectory(jsonlContent, sessionId) {
   const lines = [];
@@ -11545,22 +11891,501 @@ function convertCursorToTrajectory(jsonlContent, sessionId) {
   };
 }
 
-// src/normalizer/types.ts
-function excludeNone(obj) {
+// src/normalizer/opencode.ts
+function asObject2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+function asArray(value) {
+  return Array.isArray(value) ? value : [];
+}
+function asNumber2(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function compactExtra2(extra) {
   const result = {};
-  for (const [key, value] of Object.entries(obj)) {
-    if (value === void 0 || value === null) continue;
-    if (Array.isArray(value)) {
-      result[key] = value.map(
-        (item) => typeof item === "object" && item !== null && !Array.isArray(item) ? excludeNone(item) : item
+  for (const [key, value] of Object.entries(extra)) {
+    if (value !== void 0 && value !== null) result[key] = value;
+  }
+  return Object.keys(result).length > 0 ? result : void 0;
+}
+function parseJsonLines2(content) {
+  const events = [];
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      const parsed = JSON.parse(trimmed);
+      const obj = asObject2(parsed);
+      if (obj) events.push(obj);
+    } catch {
+    }
+  }
+  return events;
+}
+function timestampToIso(value) {
+  const numeric = asNumber2(value);
+  if (numeric === void 0) return void 0;
+  const millis = numeric < 1e12 ? numeric * 1e3 : numeric;
+  const date = new Date(millis);
+  return Number.isNaN(date.getTime()) ? void 0 : date.toISOString();
+}
+function timeFromObject(value) {
+  const obj = asObject2(value);
+  if (!obj) return void 0;
+  return timestampToIso(obj.start ?? obj.created ?? obj.completed ?? obj.end);
+}
+function stringify2(value) {
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function argsFromUnknown(value) {
+  const obj = asObject2(value);
+  if (obj) return obj;
+  if (typeof value === "string") {
+    try {
+      const parsed = JSON.parse(value);
+      const parsedObj = asObject2(parsed);
+      if (parsedObj) return parsedObj;
+    } catch {
+      return value ? { input: value } : {};
+    }
+  }
+  return value === void 0 || value === null ? {} : { value };
+}
+function modelNameFromInfo(info) {
+  const model = asObject2(info.model);
+  const modelID = typeof info.modelID === "string" && info.modelID || typeof model?.modelID === "string" && model.modelID || void 0;
+  const providerID = typeof info.providerID === "string" && info.providerID || typeof model?.providerID === "string" && model.providerID || void 0;
+  if (providerID && modelID) return `${providerID}/${modelID}`;
+  return modelID;
+}
+function metricsFromTokens(tokens, cost) {
+  const t = asObject2(tokens);
+  if (!t) return void 0;
+  const cache = asObject2(t.cache);
+  const input = asNumber2(t.input) ?? 0;
+  const output = asNumber2(t.output) ?? 0;
+  const reasoning = asNumber2(t.reasoning) ?? 0;
+  const cacheRead = asNumber2(cache?.read) ?? 0;
+  const cacheWrite = asNumber2(cache?.write) ?? 0;
+  const costUsd = asNumber2(cost);
+  if (!input && !output && !cacheRead && !cacheWrite && !costUsd) {
+    return void 0;
+  }
+  const extra = compactExtra2({
+    reasoning_tokens: reasoning || void 0,
+    cache_write_tokens: cacheWrite || void 0
+  });
+  return {
+    prompt_tokens: input + cacheRead || void 0,
+    completion_tokens: output || void 0,
+    cached_tokens: cacheRead || void 0,
+    cost_usd: costUsd || void 0,
+    extra
+  };
+}
+function metricsFromInfo(info) {
+  return metricsFromTokens(info.tokens, info.cost);
+}
+function addFinalMetricTotals(totals, metrics) {
+  if (!metrics) return;
+  totals.total_prompt_tokens += metrics.prompt_tokens ?? 0;
+  totals.total_completion_tokens += metrics.completion_tokens ?? 0;
+  totals.total_cached_tokens += metrics.cached_tokens ?? 0;
+  totals.total_cost_usd += metrics.cost_usd ?? 0;
+}
+function finalMetricsFromSteps2(steps) {
+  const totals = {
+    total_prompt_tokens: 0,
+    total_completion_tokens: 0,
+    total_cached_tokens: 0,
+    total_cost_usd: 0,
+    total_steps: steps.length,
+    extra: {}
+  };
+  for (const step of steps) addFinalMetricTotals(totals, step.metrics);
+  return {
+    total_prompt_tokens: totals.total_prompt_tokens || void 0,
+    total_completion_tokens: totals.total_completion_tokens || void 0,
+    total_cached_tokens: totals.total_cached_tokens || void 0,
+    total_cost_usd: totals.total_cost_usd || void 0,
+    total_steps: steps.length
+  };
+}
+function entryFromLine(line) {
+  const info = asObject2(line.info);
+  if (info) {
+    return {
+      info,
+      parts: asArray(line.parts).flatMap((part) => {
+        const obj = asObject2(part);
+        return obj ? [obj] : [];
+      })
+    };
+  }
+  if (typeof line.role === "string" || typeof line.sessionID === "string") {
+    return {
+      info: line,
+      parts: asArray(line.parts).flatMap((part) => {
+        const obj = asObject2(part);
+        return obj ? [obj] : [];
+      })
+    };
+  }
+  return null;
+}
+function entriesFromEventWrappers(lines) {
+  const byMessage = /* @__PURE__ */ new Map();
+  function getEntry(messageID, sessionID) {
+    let entry = byMessage.get(messageID);
+    if (!entry) {
+      entry = { info: { id: messageID, sessionID }, parts: [] };
+      byMessage.set(messageID, entry);
+    }
+    return entry;
+  }
+  for (const line of lines) {
+    const type = line.type;
+    const props = asObject2(line.properties) ?? line;
+    if (type === "message.updated") {
+      const info = asObject2(props.info);
+      const id = typeof info?.id === "string" ? info.id : void 0;
+      if (!info || !id) continue;
+      const entry = getEntry(id, info.sessionID);
+      entry.info = info;
+      continue;
+    }
+    if (type === "message.part.updated") {
+      const part = asObject2(props.part);
+      const messageID = typeof part?.messageID === "string" && part.messageID || void 0;
+      if (!part || !messageID) continue;
+      const entry = getEntry(messageID, part.sessionID);
+      const partID = typeof part.id === "string" ? part.id : void 0;
+      const existingIndex = partID ? entry.parts.findIndex((p7) => p7.id === partID) : -1;
+      if (existingIndex >= 0) entry.parts[existingIndex] = part;
+      else entry.parts.push(part);
+    }
+  }
+  return [...byMessage.values()];
+}
+function getSessionId(sessionId, exportInfo, entries) {
+  if (sessionId) return sessionId;
+  if (typeof exportInfo?.id === "string") return exportInfo.id;
+  for (const entry of entries) {
+    if (typeof entry.info.sessionID === "string") return entry.info.sessionID;
+  }
+  return "unknown";
+}
+function getAgentVersion(exportInfo) {
+  return typeof exportInfo?.version === "string" && exportInfo.version || "unknown";
+}
+function sortEntries(entries) {
+  return [...entries].sort((a, b) => {
+    const at = asNumber2(asObject2(a.info.time)?.created) ?? 0;
+    const bt = asNumber2(asObject2(b.info.time)?.created) ?? 0;
+    return at - bt;
+  });
+}
+function splitAssistantParts(parts) {
+  let sawBoundary = false;
+  const groups = [];
+  let current = [];
+  for (const part of parts) {
+    const type = part.type;
+    if (type === "step-start") {
+      sawBoundary = true;
+      if (current.length > 0) groups.push(current);
+      current = [part];
+      continue;
+    }
+    current.push(part);
+    if (type === "step-finish") {
+      sawBoundary = true;
+      groups.push(current);
+      current = [];
+    }
+  }
+  if (current.length > 0) groups.push(current);
+  return sawBoundary ? groups : [parts];
+}
+function textFromFilePart(part) {
+  const filename = typeof part.filename === "string" ? part.filename : void 0;
+  const url = typeof part.url === "string" ? part.url : void 0;
+  const mime = typeof part.mime === "string" ? part.mime : void 0;
+  const label = filename ?? url;
+  if (!label) return void 0;
+  return mime ? `[file:${mime}] ${label}` : `[file] ${label}`;
+}
+function buildUserStep(entry, stepId, defaultModelName) {
+  const textParts = [];
+  const extra = {};
+  for (const part of entry.parts) {
+    if (part.type === "text" && typeof part.text === "string") {
+      if (part.text.trim()) textParts.push(part.text.trim());
+      continue;
+    }
+    if (part.type === "file") {
+      const fileText = textFromFilePart(part);
+      if (fileText) textParts.push(fileText);
+    }
+  }
+  const message = textParts.join("\n\n").trim();
+  if (!message) return null;
+  if (entry.info.agent) extra.agent = entry.info.agent;
+  if (entry.info.tools) extra.tools = entry.info.tools;
+  return {
+    step_id: stepId,
+    timestamp: timeFromObject(entry.info.time),
+    source: "user",
+    message,
+    model_name: defaultModelName,
+    extra: compactExtra2(extra)
+  };
+}
+function buildAgentStep(parts, info, stepId, defaultModelName, fallbackMetrics) {
+  const textParts = [];
+  const reasoningParts = [];
+  const toolCalls = [];
+  const observationResults = [];
+  const extra = {};
+  let metrics;
+  let timestamp = timeFromObject(info.time);
+  for (const part of parts) {
+    if (!timestamp) timestamp = timeFromObject(part.time);
+    switch (part.type) {
+      case "text":
+        if (typeof part.text === "string" && part.text.trim()) {
+          textParts.push(part.text.trim());
+        }
+        break;
+      case "reasoning":
+        if (typeof part.text === "string" && part.text.trim()) {
+          reasoningParts.push(part.text.trim());
+        }
+        break;
+      case "file": {
+        const fileText = textFromFilePart(part);
+        if (fileText) textParts.push(fileText);
+        break;
+      }
+      case "tool": {
+        const state = asObject2(part.state) ?? {};
+        const callID = typeof part.callID === "string" && part.callID || typeof part.id === "string" && part.id || "";
+        const toolName = typeof part.tool === "string" && part.tool || "tool";
+        const input = argsFromUnknown(state.input);
+        toolCalls.push({
+          tool_call_id: callID,
+          function_name: toolName,
+          arguments: input
+        });
+        const output = state.output ?? state.error;
+        if (output !== void 0 && output !== null) {
+          observationResults.push({
+            source_call_id: callID || void 0,
+            content: stringify2(output)
+          });
+        }
+        if (state.status) extra.status = state.status;
+        if (state.metadata) extra.tool_metadata = state.metadata;
+        if (part.metadata) extra.part_metadata = part.metadata;
+        break;
+      }
+      case "step-finish":
+        metrics = metricsFromTokens(part.tokens, part.cost) ?? metrics;
+        if (part.reason) extra.finish_reason = part.reason;
+        if (part.snapshot) extra.snapshot = part.snapshot;
+        break;
+      case "patch":
+        extra.patches = [...asArray(extra.patches), part];
+        break;
+      case "agent":
+        if (part.name) extra.agent = part.name;
+        break;
+      case "retry":
+        extra.retry = part;
+        break;
+    }
+  }
+  metrics = metrics ?? fallbackMetrics;
+  if (textParts.length === 0 && reasoningParts.length === 0 && toolCalls.length === 0 && !metrics) {
+    return null;
+  }
+  const observation = observationResults.length > 0 ? { results: observationResults } : void 0;
+  const step = {
+    step_id: stepId,
+    timestamp,
+    source: "agent",
+    message: textParts.length > 0 ? textParts.join("\n\n") : "(tool use)",
+    model_name: modelNameFromInfo(info) ?? defaultModelName
+  };
+  if (reasoningParts.length > 0)
+    step.reasoning_content = reasoningParts.join("\n\n");
+  if (toolCalls.length > 0) step.tool_calls = toolCalls;
+  if (observation) step.observation = observation;
+  if (metrics) step.metrics = metrics;
+  const compactedExtra = compactExtra2(extra);
+  if (compactedExtra) step.extra = compactedExtra;
+  return step;
+}
+function buildUnavailableAgentStep(info, stepId, defaultModelName) {
+  const metrics = metricsFromInfo(info);
+  if (!metrics && !modelNameFromInfo(info) && !info.error && !info.finish) {
+    return null;
+  }
+  return {
+    step_id: stepId,
+    timestamp: timeFromObject(info.time),
+    source: "agent",
+    message: "(message unavailable)",
+    model_name: modelNameFromInfo(info) ?? defaultModelName,
+    metrics,
+    extra: compactExtra2({
+      content_unavailable: true,
+      finish_reason: info.finish,
+      error: info.error
+    })
+  };
+}
+function convertMessageEntriesToTrajectory(entries, sessionId, exportInfo) {
+  if (entries.length === 0) return null;
+  const orderedEntries = sortEntries(entries);
+  const defaultModelName = orderedEntries.map((entry) => modelNameFromInfo(entry.info)).find((model) => typeof model === "string");
+  const steps = [];
+  for (const entry of orderedEntries) {
+    const role = entry.info.role;
+    if (role === "user") {
+      const step = buildUserStep(entry, steps.length + 1, defaultModelName);
+      if (step) steps.push(step);
+      continue;
+    }
+    if (role !== "assistant") continue;
+    if (entry.parts.length === 0) {
+      const step = buildUnavailableAgentStep(
+        entry.info,
+        steps.length + 1,
+        defaultModelName
       );
-    } else if (typeof value === "object" && !Array.isArray(value)) {
-      result[key] = excludeNone(value);
-    } else {
-      result[key] = value;
+      if (step) steps.push(step);
+      continue;
+    }
+    const groups = splitAssistantParts(entry.parts);
+    const hasPartMetrics = groups.some(
+      (group) => group.some((part) => part.type === "step-finish")
+    );
+    const fallbackMetrics = hasPartMetrics ? void 0 : metricsFromInfo(entry.info);
+    for (let i = 0; i < groups.length; i++) {
+      const step = buildAgentStep(
+        groups[i],
+        entry.info,
+        steps.length + 1,
+        defaultModelName,
+        i === 0 ? fallbackMetrics : void 0
+      );
+      if (step) steps.push(step);
     }
   }
-  return result;
+  if (steps.length === 0) return null;
+  return {
+    schema_version: ATIF_VERSION,
+    session_id: getSessionId(sessionId, exportInfo, orderedEntries),
+    agent: {
+      name: "opencode",
+      version: getAgentVersion(exportInfo),
+      model_name: defaultModelName
+    },
+    steps,
+    final_metrics: finalMetricsFromSteps2(steps)
+  };
+}
+function convertRunEventsToTrajectory(events, sessionId) {
+  const session = sessionId ?? (events.map((event) => event.sessionID).find((sid) => typeof sid === "string") || "unknown");
+  const turns = [];
+  let current = null;
+  for (const event of events) {
+    const type = event.type;
+    if (type === "step_start") {
+      current = { parts: [], timestamp: event.timestamp };
+      continue;
+    }
+    if (type === "step_finish") {
+      if (current) {
+        current.finish = asObject2(event.part) ?? {};
+        turns.push(current);
+        current = null;
+      }
+      continue;
+    }
+    if (current && (type === "text" || type === "reasoning" || type === "tool_use")) {
+      const part = asObject2(event.part);
+      if (part) current.parts.push(part);
+    }
+  }
+  const steps = [];
+  for (const turn of turns) {
+    const parts = [...turn.parts];
+    if (turn.finish) {
+      parts.push({ ...turn.finish, type: "step-finish" });
+    }
+    const step = buildAgentStep(
+      parts,
+      { time: { created: turn.timestamp } },
+      steps.length + 1,
+      void 0
+    );
+    if (step) steps.push(step);
+  }
+  if (steps.length === 0) return null;
+  return {
+    schema_version: ATIF_VERSION,
+    session_id: session,
+    agent: {
+      name: "opencode",
+      version: "unknown"
+    },
+    steps,
+    final_metrics: finalMetricsFromSteps2(steps)
+  };
+}
+function isRunEvent(lines) {
+  return lines.some(
+    (line) => ["step_start", "step_finish", "text", "reasoning", "tool_use"].includes(
+      String(line.type ?? "")
+    )
+  );
+}
+function convertOpenCodeToTrajectory(content, sessionId) {
+  const trimmed = content.trim();
+  if (!trimmed) return null;
+  try {
+    const parsed = JSON.parse(trimmed);
+    const parsedObj = asObject2(parsed);
+    const messages = asArray(parsedObj?.messages);
+    if (parsedObj && messages.length > 0) {
+      const entries2 = messages.flatMap((message) => {
+        const entry = entryFromLine(asObject2(message) ?? {});
+        return entry ? [entry] : [];
+      });
+      return convertMessageEntriesToTrajectory(
+        entries2,
+        sessionId,
+        asObject2(parsedObj.info)
+      );
+    }
+  } catch {
+  }
+  const lines = parseJsonLines2(content);
+  if (lines.length === 0) return null;
+  if (isRunEvent(lines)) return convertRunEventsToTrajectory(lines, sessionId);
+  const wrappedEntries = entriesFromEventWrappers(lines);
+  const entries = wrappedEntries.length > 0 ? wrappedEntries : lines.flatMap((line) => {
+    const entry = entryFromLine(line);
+    return entry ? [entry] : [];
+  });
+  return convertMessageEntriesToTrajectory(entries, sessionId);
 }
 
 // src/normalizer/index.ts
@@ -11572,6 +12397,10 @@ function normalizeContent(sourceName, content, sessionId) {
       return convertCodexToTrajectory(content, sessionId);
     case "cursor":
       return convertCursorToTrajectory(content, sessionId);
+    case "opencode":
+      return convertOpenCodeToTrajectory(content, sessionId);
+    case "copilot-chat":
+      return convertCopilotChatToTrajectory(content, sessionId);
     default:
       return null;
   }
@@ -11583,7 +12412,10 @@ var NormalizeMiddleware = class {
     for (const file of group.files) {
       newFiles.push(file);
       if (!file.absolutePath.endsWith(".jsonl")) continue;
-      if (!["claude", "codex", "cursor"].includes(file.sourceName)) continue;
+      if (!["claude", "codex", "cursor", "opencode", "copilot-chat"].includes(
+        file.sourceName
+      ))
+        continue;
       const content = file.content ? file.content.toString("utf-8") : null;
       if (!content) continue;
       const sessionId = file.metadata?.sessionId ?? path9.basename(file.absolutePath, ".jsonl");
@@ -11843,6 +12675,23 @@ function resolveSourceTool(payload) {
   if (payload.hook_event_name === "Stop") return "codex";
   return "claude";
 }
+async function selfHealHook(repoRoot, tool) {
+  try {
+    const result = await healHookForTool(repoRoot, tool);
+    if (result.skipped) {
+      appendLog("warn", `self-heal: skipped ${tool} hook (${result.skipped})`);
+      return;
+    }
+    if (result.changed) {
+      appendLog("info", `self-heal: updated ${tool} hook`);
+    }
+  } catch (err) {
+    appendLog(
+      "warn",
+      `self-heal: failed to repair ${tool} hook: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+}
 function resolveCursorTranscriptPath(payload) {
   const id = payload.conversation_id ?? payload.session_id;
   const workspace = payload.workspace_roots?.[0];
@@ -11874,6 +12723,16 @@ async function runUploadInner(payload) {
     );
     return;
   }
+  const match = await findProjectForCwd(cwd);
+  if (!match) {
+    appendLog(
+      "warn",
+      `Skipping session ${sessionId}: no hillclimb config for cwd ${cwd}. Run \`npx hillclimb\` in the repo.`
+    );
+    return;
+  }
+  const { repoRoot, config } = match;
+  await selfHealHook(repoRoot, sourceTool);
   const transcriptResolved = path12.resolve(transcriptPath);
   try {
     const stat = await fs9.promises.stat(transcriptResolved);
@@ -11891,14 +12750,6 @@ async function runUploadInner(payload) {
     );
     return;
   }
-  const match = await findProjectForCwd(cwd);
-  if (!match) {
-    appendLog(
-      "warn",
-      `Skipping session ${sessionId}: no hillclimb config for cwd ${cwd}. Run \`npx hillclimb\` in the repo.`
-    );
-    return;
-  }
   if (!await hasAssistantMessage(transcriptResolved)) {
     appendLog(
       "info",
@@ -11906,7 +12757,6 @@ async function runUploadInner(payload) {
     );
     return;
   }
-  const { repoRoot, config } = match;
   await uploadSession({
     sessionId,
     transcriptPath: transcriptResolved,
@@ -12606,7 +13456,7 @@ async function releaseLock(repoRoot, tool) {
 }
 
 // src/git-traces/handlers.ts
-var CLI_VERSION = "0.1.0";
+var CLI_VERSION = "0.2.0";
 var GIT_TRACES_SLUG = "git-traces";
 var MAX_UPLOAD_BYTES = 500 * 1024 * 1024;
 function formatEpochSeconds2(date) {
@@ -13034,6 +13884,30 @@ async function readStdin2() {
   }
   return Buffer.concat(chunks).toString("utf-8");
 }
+function resolveCwd2(payload) {
+  return payload.cwd ?? payload.workspace_roots?.[0] ?? null;
+}
+async function selfHealHook2(payload, tool) {
+  const cwd = resolveCwd2(payload);
+  if (!cwd) return;
+  try {
+    const project = await findProjectForCwd(cwd);
+    if (!project) return;
+    const result = await healHookForTool(project.repoRoot, tool);
+    if (result.skipped) {
+      appendLog("warn", `self-heal: skipped ${tool} hook (${result.skipped})`);
+      return;
+    }
+    if (result.changed) {
+      appendLog("info", `self-heal: updated ${tool} hook`);
+    }
+  } catch (err) {
+    appendLog(
+      "warn",
+      `self-heal: failed to repair ${tool} hook: ${formatError(err)}`
+    );
+  }
+}
 async function runGitTraces() {
   if (process.env[WORKER_ENV_FLAG2] === "1") {
     await runGitTracesWorker();
@@ -13148,6 +14022,7 @@ async function runGitTracesWorker() {
     );
     return;
   }
+  await selfHealHook2(payload, tool);
   try {
     switch (event) {
       case "SessionStart":

package/package.json

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