@yhong91/vibetime 0.1.45 → 0.1.47

package/bin/vibetime.mjs

@@ -2047,7 +2047,7 @@ function claudeStyleFileMetrics(tool, input) {
 }
 
 // src/lib/constants.ts
-var PACKAGE_VERSION = true ? "0.1.45" : "0.1.1";
+var PACKAGE_VERSION = true ? "0.1.47" : "0.1.1";
 var DEFAULT_API_URL = "http://121.196.224.82:3001";
 var DEFAULT_BACKFILL_BATCH_SIZE = 50;
 var DEFAULT_BACKFILL_BATCH_BYTES = 800 * 1024;
@@ -6222,6 +6222,7 @@ function createCopilotAdapter() {
 import { readdir as readdir6, readFile as readFile8, stat as stat7 } from "node:fs/promises";
 import path13 from "node:path";
 init_fs();
+var GROK_COST_TICKS_PER_USD = 1e9;
 var SOURCE_ID = "grok-build";
 var AGENT_NAME = "grok-build";
 var HOOK_COMMAND = `vibetime hook --agent ${SOURCE_ID}`;
@@ -6488,18 +6489,76 @@ async function parseGrokSessionFile(filePath, options) {
       }), lineNumber, type, "permission");
     }
   }
+  let nextLine = lineNumber + 1;
+  const turnUsages = await loadTurnUsagesFromUpdates(updatesPath);
+  const hasTurnUsage = turnUsages.length > 0;
+  for (const turn of turnUsages) {
+    for (const entry of turn.entries) {
+      push(base({
+        ts: turn.ts,
+        type: "model.usage",
+        model: entry.model || model,
+        confidence: "exact",
+        metrics: entry.metrics,
+        refs: stringRefs({
+          sourceId: `${sessionId}:usage:${turn.promptId}:${entry.model || "model"}`,
+          promptId: turn.promptId
+        })
+      }), nextLine, "updates", "model.usage");
+      nextLine += 1;
+    }
+  }
+  const hunkPath = path13.join(sessionDir, "hunk_records.jsonl");
+  const hunkActivities = await loadHunkFileActivities(hunkPath, cwd);
+  if (hunkActivities.length > 0) {
+    for (const event of events) {
+      for (const file of event.fileActivities || []) {
+        delete file.linesAdded;
+        delete file.linesRemoved;
+      }
+    }
+  }
+  let hasFileLineData = hunkActivities.length > 0;
+  for (const activity of hunkActivities) {
+    push(base({
+      ts: activity.ts,
+      type: "file.changed",
+      confidence: "exact",
+      fileActivities: [activity],
+      metrics: {
+        linesAdded: activity.linesAdded,
+        linesRemoved: activity.linesRemoved,
+        filesChanged: 1
+      },
+      refs: stringRefs({
+        sourceId: `${sessionId}:hunk:${activity.fileActivityId || activity.path}`
+      })
+    }), nextLine, "hunk_records", "file.changed");
+    nextLine += 1;
+  }
+  if (!hasFileLineData) {
+    hasFileLineData = events.some(
+      (event) => (event.fileActivities || []).some(
+        (file) => (file.linesAdded || 0) > 0 || (file.linesRemoved || 0) > 0
+      )
+    );
+  }
   const signals = await readJsonIfExists(signalsPath);
   if (isPlainObject(signals) && updatedAt) {
-    const metrics = metricsFromSignals(signals);
+    const metrics = metricsFromSignals(signals, {
+      includeLines: !hasFileLineData,
+      includeModelCalls: !hasTurnUsage
+    });
     if (metrics) {
       push(base({
         ts: updatedAt,
-        type: "model.usage",
+        type: hasTurnUsage ? "agent.operation" : "model.usage",
         model: stringField(signals, "primaryModelId") || model,
         confidence: "partial",
         metrics,
-        refs: stringRefs({ sourceId: `${sessionId}:usage:signals` })
-      }), lineNumber + 1, "signals", "model.usage");
+        refs: stringRefs({ sourceId: `${sessionId}:signals` })
+      }), nextLine, "signals", hasTurnUsage ? "agent.operation" : "model.usage");
+      nextLine += 1;
     }
   }
   if (updatedAt) {
@@ -6508,7 +6567,7 @@ async function parseGrokSessionFile(filePath, options) {
       type: "session.ended",
       confidence: "derived",
       refs: stringRefs({ sourceId: `${sessionId}:ended` })
-    }), lineNumber + 2, "summary", "session.ended");
+    }), nextLine, "summary", "session.ended");
   }
   return events;
 }
@@ -6566,16 +6625,36 @@ function fileActivitiesFromTool(toolName, input, ts, cwd) {
       confidence: "exact"
     }];
   }
-  if (lower === "search_replace" || lower === "write" || lower.endsWith("__search_replace") || lower.endsWith("__write")) {
+  if (lower === "search_replace" || lower.endsWith("__search_replace")) {
     const target = stringField(input, "file_path") || stringField(input, "target_file") || stringField(input, "path");
     if (!target) {
       return [];
     }
+    const oldString = stringField(input, "old_string");
+    const newString = stringField(input, "new_string");
     return [{
       ts,
       path: displayPath(target, cwd),
       operation: "edit",
-      confidence: "exact"
+      confidence: "exact",
+      linesAdded: countTextLines(newString),
+      linesRemoved: countTextLines(oldString),
+      charsWritten: newString?.length
+    }];
+  }
+  if (lower === "write" || lower.endsWith("__write")) {
+    const target = stringField(input, "file_path") || stringField(input, "target_file") || stringField(input, "path");
+    if (!target) {
+      return [];
+    }
+    const content = stringField(input, "content");
+    return [{
+      ts,
+      path: displayPath(target, cwd),
+      operation: "write",
+      confidence: "exact",
+      linesAdded: countTextLines(content),
+      charsWritten: content?.length
     }];
   }
   return [];
@@ -6625,20 +6704,23 @@ async function loadToolInputsFromUpdates(updatesPath) {
   }
   return map;
 }
-function metricsFromSignals(signals) {
+function metricsFromSignals(signals, options = {}) {
+  const includeLines = options.includeLines !== false;
+  const includeModelCalls = options.includeModelCalls !== false;
   const toolCallCount = numberField(signals, "toolCallCount");
   const turnCount = numberField(signals, "turnCount");
   const durationSec = numberField(signals, "sessionDurationSeconds");
-  const linesAdded = numberField(signals, "agentLinesAdded");
-  const linesRemoved = numberField(signals, "agentLinesRemoved");
-  if (toolCallCount === void 0 && turnCount === void 0 && durationSec === void 0) {
+  const linesAdded = includeLines ? numberField(signals, "agentLinesAdded") : void 0;
+  const linesRemoved = includeLines ? numberField(signals, "agentLinesRemoved") : void 0;
+  const filesTouched = includeLines ? numberField(signals, "agentFilesTouched") : void 0;
+  if (toolCallCount === void 0 && (!includeModelCalls || turnCount === void 0) && durationSec === void 0 && linesAdded === void 0 && linesRemoved === void 0) {
     return void 0;
   }
   const metrics = {};
   if (toolCallCount !== void 0) {
     metrics.toolCalls = toolCallCount;
   }
-  if (turnCount !== void 0) {
+  if (includeModelCalls && turnCount !== void 0) {
     metrics.modelCalls = turnCount;
   }
   if (durationSec !== void 0) {
@@ -6650,8 +6732,146 @@ function metricsFromSignals(signals) {
   if (linesRemoved !== void 0) {
     metrics.linesRemoved = linesRemoved;
   }
+  if (filesTouched !== void 0) {
+    metrics.filesChanged = filesTouched;
+  }
+  return metrics;
+}
+async function loadTurnUsagesFromUpdates(updatesPath) {
+  const turns = [];
+  let text = "";
+  try {
+    text = await readFile8(updatesPath, "utf8");
+  } catch {
+    return turns;
+  }
+  for (const line of text.split("\n")) {
+    if (!line.trim()) {
+      continue;
+    }
+    const raw = parseJsonLine(line);
+    if (!raw) {
+      continue;
+    }
+    const params = objectField(raw, "params");
+    const update = objectField(params, "update");
+    if (stringField(update, "sessionUpdate") !== "turn_completed") {
+      continue;
+    }
+    const usage = objectField(update, "usage");
+    if (Object.keys(usage).length === 0) {
+      continue;
+    }
+    const meta = objectField(params, "_meta");
+    const ts = timestampFrom(meta.agentTimestampMs) || timestampFrom(raw.timestamp) || timestampFrom(raw.ts);
+    if (!ts) {
+      continue;
+    }
+    const promptId = stringField(update, "prompt_id") || stringField(meta, "eventId") || `turn_${turns.length + 1}`;
+    const entries = [];
+    const modelUsage = objectField(usage, "modelUsage");
+    const modelKeys = Object.keys(modelUsage);
+    if (modelKeys.length > 0) {
+      for (const modelName of modelKeys) {
+        const perModel = objectField(modelUsage, modelName);
+        const metrics = metricsFromGrokUsage(
+          Object.keys(perModel).length > 0 ? perModel : usage
+        );
+        if (!hasTokenMetrics(metrics)) {
+          continue;
+        }
+        entries.push({ model: modelName, metrics });
+      }
+    } else {
+      const metrics = metricsFromGrokUsage(usage);
+      if (hasTokenMetrics(metrics)) {
+        entries.push({ metrics });
+      }
+    }
+    if (entries.length > 0) {
+      turns.push({ ts, promptId, entries });
+    }
+  }
+  return turns;
+}
+function metricsFromGrokUsage(usage) {
+  const inputTokens = numberField(usage, "inputTokens") || 0;
+  const outputTokens = numberField(usage, "outputTokens") || 0;
+  const cachedRead = numberField(usage, "cachedReadTokens") || 0;
+  const cacheCreation = numberField(usage, "cacheCreationTokens") || 0;
+  const reasoning = numberField(usage, "reasoningTokens") || 0;
+  const totalTokens = numberField(usage, "totalTokens") || inputTokens + outputTokens;
+  const modelCalls = numberField(usage, "modelCalls");
+  const apiDurationMs = numberField(usage, "apiDurationMs");
+  const costTicks = numberField(usage, "costUsdTicks");
+  const metrics = {
+    tokensInput: inputTokens || void 0,
+    tokensOutput: outputTokens || void 0,
+    tokensCachedInput: cachedRead + cacheCreation || void 0,
+    tokensCacheReadInput: cachedRead || void 0,
+    tokensCacheCreationInput: cacheCreation || void 0,
+    tokensReasoningOutput: reasoning || void 0,
+    tokensTotal: totalTokens || void 0,
+    modelCalls: modelCalls || void 0,
+    modelDurationMs: apiDurationMs || void 0,
+    durationMs: apiDurationMs || void 0
+  };
+  if (costTicks !== void 0 && costTicks > 0) {
+    metrics.costUsd = costTicks / GROK_COST_TICKS_PER_USD;
+  }
   return metrics;
 }
+function hasTokenMetrics(metrics) {
+  return Boolean(
+    metrics.tokensInput || metrics.tokensOutput || metrics.tokensCachedInput || metrics.tokensTotal
+  );
+}
+async function loadHunkFileActivities(hunkPath, cwd) {
+  const activities = [];
+  let text = "";
+  try {
+    text = await readFile8(hunkPath, "utf8");
+  } catch {
+    return activities;
+  }
+  for (const line of text.split("\n")) {
+    if (!line.trim()) {
+      continue;
+    }
+    const raw = parseJsonLine(line);
+    if (!raw) {
+      continue;
+    }
+    const authorType = stringField(raw, "authorType");
+    if (authorType && authorType !== "agent") {
+      continue;
+    }
+    const filePath = stringField(raw, "filePath") || stringField(raw, "path");
+    if (!filePath) {
+      continue;
+    }
+    const ts = timestampFrom(raw.timestamp) || timestampFrom(raw.ts);
+    if (!ts) {
+      continue;
+    }
+    const linesAdded = numberField(raw, "linesAdded");
+    const linesRemoved = numberField(raw, "linesRemoved");
+    if ((linesAdded || 0) <= 0 && (linesRemoved || 0) <= 0) {
+      continue;
+    }
+    const hunkId = stringField(raw, "hunkId");
+    activities.push({
+      ts,
+      path: displayPath(filePath, cwd),
+      operation: "edit",
+      confidence: "exact",
+      fileActivityId: hunkId,
+      linesAdded: linesAdded || void 0,
+      linesRemoved: linesRemoved || void 0
+    });
+  }
+  return activities;
+}
 var grokHandler = (msg) => hookHandler(SOURCE_ID, msg);
 function hookConfig5() {
   const anyTool = [{ matcher: ".*", hooks: [grokHandler("Reporting tool activity")] }];
@@ -6949,6 +7169,7 @@ async function parseOpenCodeSessionFile(dbPath, options) {
                   }
                   const filePath = stringField(stateInput, "file_path") || stringField(stateInput, "filePath");
                   if (filePath) {
+                    const lineStats = opencodeLineStats(tool, state, stateInput);
                     events.push(baseOpenCodeEvent({
                       ts: msToIso(endMs || completedTs || createdTs),
                       type: toolFileActivityType(tool),
@@ -6963,8 +7184,10 @@ async function parseOpenCodeSessionFile(dbPath, options) {
                       fileActivities: [{
                         ts: msToIso(endMs || completedTs || createdTs),
                         path: filePath,
-                        operation: operationForTool(tool)
+                        operation: operationForTool(tool),
+                        ...lineStats
                       }],
+                      metrics: lineStats.linesAdded || lineStats.linesRemoved ? lineStats : void 0,
                       refs: stringRefs({ sourceId: callId })
                     }, assistantAgent));
                   }
@@ -7087,6 +7310,25 @@ function baseOpenCodeEvent(event, agentName) {
     ...event
   };
 }
+function opencodeLineStats(tool, state, input) {
+  const diff = stringField(objectField(state, "metadata"), "diff");
+  if (diff) {
+    return diffStats(diff);
+  }
+  const normalized = tool.toLowerCase();
+  if (normalized === "write") {
+    return { linesAdded: countTextLines(stringField(input, "content")) };
+  }
+  if (normalized === "edit" || normalized === "multiedit" || normalized === "patch") {
+    const newString = stringField(input, "newString") || stringField(input, "new_string");
+    const oldString = stringField(input, "oldString") || stringField(input, "old_string");
+    return {
+      linesAdded: countTextLines(newString),
+      linesRemoved: countTextLines(oldString)
+    };
+  }
+  return {};
+}
 function opencodeUsageFromInfo(info) {
   const tokensObj = objectField(info, "tokens");
   if (!tokensObj) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@yhong91/vibetime",
   "type": "module",
-  "version": "0.1.45",
+  "version": "0.1.47",
   "description": "vibetime CLI — install AI-agent hooks (Claude Code, Codex, OpenCode, Pi) and report activity to vibetime.",
   "license": "MIT",
   "publishConfig": {