@usevalt/cli 0.7.3 → 0.7.4

package/dist/index.js

@@ -1035,7 +1035,7 @@ proxyCommand.command("stop").description("Stop the MCP proxy").action(() => {
 
 // src/commands/hook.ts
 import { Command as Command13 } from "commander";
-import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, unlinkSync as unlinkSync2, existsSync as existsSync3, readdirSync } from "fs";
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, unlinkSync as unlinkSync2, existsSync as existsSync3, readdirSync, statSync, openSync, readSync, closeSync } from "fs";
 import { createReadStream } from "fs";
 import { createInterface } from "readline";
 import { execSync } from "child_process";
@@ -1311,6 +1311,51 @@ async function parseTranscript(transcriptPath) {
   }
   return result;
 }
+function parseTranscriptIncremental(transcriptPath, fromByteOffset, model) {
+  const result = {
+    deltaPromptTokens: 0,
+    deltaCompletionTokens: 0,
+    deltaCacheReadTokens: 0,
+    deltaCostUsd: 0,
+    newByteOffset: fromByteOffset
+  };
+  try {
+    const fileSize = statSync(transcriptPath).size;
+    if (fileSize <= fromByteOffset) return result;
+    const bytesToRead = fileSize - fromByteOffset;
+    const buffer = Buffer.alloc(bytesToRead);
+    const fd = openSync(transcriptPath, "r");
+    try {
+      readSync(fd, buffer, 0, bytesToRead, fromByteOffset);
+    } finally {
+      closeSync(fd);
+    }
+    const chunk = buffer.toString("utf-8");
+    const lines = chunk.split("\n");
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      try {
+        const entry = JSON.parse(line);
+        const usage = entry.message?.usage ?? entry.usage;
+        if (usage) {
+          result.deltaPromptTokens += usage.input_tokens ?? 0;
+          result.deltaCompletionTokens += usage.output_tokens ?? 0;
+          result.deltaCacheReadTokens += usage.cache_read_input_tokens ?? 0;
+        }
+      } catch {
+      }
+    }
+    result.newByteOffset = fileSize;
+    result.deltaCostUsd = calculateCost(
+      model,
+      result.deltaPromptTokens,
+      result.deltaCompletionTokens,
+      result.deltaCacheReadTokens
+    );
+  } catch {
+  }
+  return result;
+}
 var sessionStartCommand = new Command13("session-start").description("Hook: called when a Claude Code session starts").action(async () => {
   try {
     const { apiKey, endpoint, apiEndpoint } = resolveConfig();
@@ -1322,6 +1367,7 @@ var sessionStartCommand = new Command13("session-start").description("Hook: call
     const model = hookData["model"] || process.env["CLAUDE_MODEL"] || "unknown";
     const startedAt = (/* @__PURE__ */ new Date()).toISOString();
     const cwd = hookData["cwd"] || process.cwd();
+    const transcriptPath = hookData["transcript_path"] || void 0;
     const state = {
       sessionId,
       claudeSessionId,
@@ -1331,7 +1377,8 @@ var sessionStartCommand = new Command13("session-start").description("Hook: call
       apiEndpoint,
       projectSlug,
       model,
-      cwd
+      cwd,
+      transcriptPath
     };
     writeFileSync3(getSessionFile(claudeSessionId), JSON.stringify(state, null, 2), { mode: 384 });
     let gitCommitBefore;
@@ -1500,6 +1547,45 @@ var postToolUseCommand = new Command13("post-tool-use").description("Hook: calle
         }
       }
     }
+    try {
+      const tPath = hookData["transcript_path"] ?? session.transcriptPath;
+      if (tPath && existsSync3(tPath)) {
+        if (!session.transcriptPath) session.transcriptPath = tPath;
+        const deltas = parseTranscriptIncremental(
+          tPath,
+          session.transcriptByteOffset ?? 0,
+          session.model ?? "unknown"
+        );
+        if (deltas.deltaPromptTokens > 0 || deltas.deltaCompletionTokens > 0) {
+          events.push({
+            event_id: crypto.randomUUID(),
+            session_id: session.sessionId,
+            event_type: "cost",
+            timestamp,
+            tool: "claude-code",
+            tokens_prompt: deltas.deltaPromptTokens,
+            tokens_completion: deltas.deltaCompletionTokens,
+            cost_usd: deltas.deltaCostUsd,
+            metadata: {
+              model: session.model,
+              source: "incremental",
+              cache_read_tokens: deltas.deltaCacheReadTokens
+            }
+          });
+        }
+        session.transcriptByteOffset = deltas.newByteOffset;
+        session.runningPromptTokens = (session.runningPromptTokens ?? 0) + deltas.deltaPromptTokens;
+        session.runningCompletionTokens = (session.runningCompletionTokens ?? 0) + deltas.deltaCompletionTokens;
+        session.runningCacheReadTokens = (session.runningCacheReadTokens ?? 0) + deltas.deltaCacheReadTokens;
+        session.runningCostUsd = (session.runningCostUsd ?? 0) + deltas.deltaCostUsd;
+        writeFileSync3(
+          getSessionFile(session.claudeSessionId),
+          JSON.stringify(session, null, 2),
+          { mode: 384 }
+        );
+      }
+    } catch {
+    }
     await sendEvents(session.endpoint, session.apiKey, events);
   } catch {
   }
@@ -1626,6 +1712,12 @@ var sessionEndCommand = new Command13("session-end").description("Hook: called w
     const durationMs = now.getTime() - startedAt.getTime();
     const transcriptPath = hookData["transcript_path"];
     const metrics = transcriptPath ? await parseTranscript(transcriptPath) : null;
+    if (metrics && (session.runningPromptTokens || session.runningCostUsd)) {
+      metrics.promptTokens = Math.max(0, metrics.promptTokens - (session.runningPromptTokens ?? 0));
+      metrics.completionTokens = Math.max(0, metrics.completionTokens - (session.runningCompletionTokens ?? 0));
+      metrics.cacheReadTokens = Math.max(0, metrics.cacheReadTokens - (session.runningCacheReadTokens ?? 0));
+      metrics.totalCostUsd = Math.max(0, metrics.totalCostUsd - (session.runningCostUsd ?? 0));
+    }
     let gitCommitAfter;
     try {
       gitCommitAfter = execSync("git rev-parse HEAD", {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@usevalt/cli",
-  "version": "0.7.3",
+  "version": "0.7.4",
   "description": "Valt CLI — trust layer for AI-assisted development",
   "license": "MIT",
   "repository": {