@yhong91/vibetime 0.1.46 → 0.1.48

package/bin/vibetime.mjs

@@ -2047,7 +2047,7 @@ function claudeStyleFileMetrics(tool, input) {
 }
 
 // src/lib/constants.ts
-var PACKAGE_VERSION = true ? "0.1.46" : "0.1.1";
+var PACKAGE_VERSION = true ? "0.1.48" : "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;
@@ -5157,7 +5157,7 @@ async function parseCodexSessionFile(filePath, options) {
   let sessionId = sessionIdFromFilePath(filePath, "codex");
   let cwd;
   let project;
-  let model;
+  let model = firstTurnContextModel(lines);
   let sessionStartEmitted = false;
   let serviceTier;
   let reasoningEffort;
@@ -5191,7 +5191,6 @@ async function parseCodexSessionFile(filePath, options) {
       sessionId = stringField(payload, "id") || sessionId;
       cwd = inherited?.cwd || stringField(payload, "cwd") || cwd;
       project = inherited?.project || (cwd ? path11.basename(cwd) : project);
-      model = stringField(payload, "model_provider") || model;
       events.push(withBackfillRefs({
         schemaVersion: AGENT_TIME_SCHEMA_VERSION,
         ts,
@@ -5599,6 +5598,21 @@ async function parseCodexSessionFile(filePath, options) {
   }
   return events.filter((event) => validateCanonicalEvent(event).valid);
 }
+function firstTurnContextModel(lines) {
+  for (const line of lines) {
+    if (!line.includes("turn_context")) {
+      continue;
+    }
+    const raw = parseJsonLine(line);
+    if (raw && stringField(raw, "type") === "turn_context") {
+      const model = stringField(objectField(raw, "payload"), "model");
+      if (model) {
+        return model;
+      }
+    }
+  }
+  return void 0;
+}
 function rewriteCodexModelForTier(model, serviceTier) {
   if (!model) {
     return model;
@@ -6222,6 +6236,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 +6503,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 +6581,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 +6639,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 +6718,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 +6746,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")] }];

package/package.json

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