@usevalt/cli 0.3.2 → 0.4.0

package/dist/index.js

@@ -996,10 +996,27 @@ 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 } from "fs";
+import { createReadStream } from "fs";
+import { createInterface } from "readline";
 import { execSync } from "child_process";
 import { basename } from "path";
 import os2 from "os";
 var SESSION_FILE = `${os2.tmpdir()}/valt-session-${process.getuid?.() ?? "default"}.json`;
+async function readStdin() {
+  if (process.stdin.isTTY) return {};
+  try {
+    const chunks = [];
+    const data = await new Promise((resolve4) => {
+      process.stdin.setEncoding("utf-8");
+      process.stdin.on("data", (chunk) => chunks.push(String(chunk)));
+      process.stdin.on("end", () => resolve4(chunks.join("")));
+      setTimeout(() => resolve4(chunks.join("")), 2e3);
+    });
+    return data.trim() ? JSON.parse(data) : {};
+  } catch {
+    return {};
+  }
+}
 function resolveConfig() {
   const apiKey = getApiKey();
   if (!apiKey) {
@@ -1050,13 +1067,50 @@ async function sendEvents(endpoint, apiKey, events) {
     return false;
   }
 }
+async function parseTranscript(transcriptPath) {
+  const result = {
+    totalCostUsd: 0,
+    promptTokens: 0,
+    completionTokens: 0,
+    cacheReadTokens: 0,
+    cacheCreationTokens: 0
+  };
+  if (!existsSync3(transcriptPath)) return result;
+  try {
+    const rl = createInterface({
+      input: createReadStream(transcriptPath, "utf-8"),
+      crlfDelay: Infinity
+    });
+    for await (const line of rl) {
+      if (!line.trim()) continue;
+      try {
+        const entry = JSON.parse(line);
+        if (entry.usage) {
+          result.promptTokens += entry.usage.input_tokens ?? 0;
+          result.completionTokens += entry.usage.output_tokens ?? 0;
+          result.cacheReadTokens += entry.usage.cache_read_input_tokens ?? 0;
+          result.cacheCreationTokens += entry.usage.cache_creation_input_tokens ?? 0;
+        }
+        if (typeof entry.costUSD === "number") {
+          result.totalCostUsd += entry.costUSD;
+        }
+      } catch {
+      }
+    }
+  } 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();
     const projectSlug = detectProjectSlug();
+    const hookData = await readStdin();
+    const claudeSessionId = hookData["session_id"];
     const sessionId = crypto.randomUUID();
+    const model = hookData["model"] || process.env["CLAUDE_MODEL"] || "unknown";
     const startedAt = (/* @__PURE__ */ new Date()).toISOString();
-    const state = { sessionId, startedAt, apiKey, endpoint, apiEndpoint, projectSlug };
+    const state = { sessionId, startedAt, apiKey, endpoint, apiEndpoint, projectSlug, model };
     writeFileSync3(SESSION_FILE, JSON.stringify(state, null, 2), { mode: 384 });
     const sent = await sendEvents(endpoint, apiKey, [
       {
@@ -1065,13 +1119,15 @@ var sessionStartCommand = new Command13("session-start").description("Hook: call
         event_type: "session.start",
         timestamp: startedAt,
         tool: "claude-code",
+        model,
         metadata: {
           tool: "claude-code",
-          model: process.env["CLAUDE_MODEL"] ?? "unknown",
+          model,
+          claude_session_id: claudeSessionId,
           repository: process.env["CLAUDE_REPO"],
           branch: process.env["CLAUDE_BRANCH"],
           project_slug: projectSlug,
-          cwd: process.cwd()
+          cwd: hookData["cwd"] || process.cwd()
         }
       }
     ]);
@@ -1088,24 +1144,7 @@ var toolCallCommand = new Command13("tool-call").description("Hook: called on ea
   try {
     const session = readSessionFile();
     if (!session) return;
-    let stdinData = "";
-    if (!process.stdin.isTTY) {
-      stdinData = await new Promise((resolve4) => {
-        const chunks = [];
-        process.stdin.setEncoding("utf-8");
-        process.stdin.on("data", (chunk) => chunks.push(String(chunk)));
-        process.stdin.on("end", () => resolve4(chunks.join("")));
-        setTimeout(() => resolve4(chunks.join("")), 1e3);
-      });
-    }
-    let toolData = {};
-    if (stdinData.trim()) {
-      try {
-        toolData = JSON.parse(stdinData);
-      } catch {
-        toolData = { raw_input: stdinData.trim() };
-      }
-    }
+    const toolData = await readStdin();
     const toolName = toolData["tool_name"] ?? toolData["name"] ?? "unknown";
     await sendEvents(session.endpoint, session.apiKey, [
       {
@@ -1125,10 +1164,13 @@ var sessionEndCommand = new Command13("session-end").description("Hook: called w
   try {
     const session = readSessionFile();
     if (!session) return;
+    const hookData = await readStdin();
     const now = /* @__PURE__ */ new Date();
     const startedAt = new Date(session.startedAt);
     const durationMs = now.getTime() - startedAt.getTime();
-    const sent = await sendEvents(session.endpoint, session.apiKey, [
+    const transcriptPath = hookData["transcript_path"];
+    const metrics = transcriptPath ? await parseTranscript(transcriptPath) : null;
+    const events = [
       {
         event_id: crypto.randomUUID(),
         session_id: session.sessionId,
@@ -1138,16 +1180,41 @@ var sessionEndCommand = new Command13("session-end").description("Hook: called w
         tool: "claude-code",
         metadata: {
           started_at: session.startedAt,
-          ended_at: now.toISOString()
+          ended_at: now.toISOString(),
+          reason: hookData["reason"] ?? "unknown",
+          ...metrics ? {
+            prompt_tokens: metrics.promptTokens,
+            completion_tokens: metrics.completionTokens,
+            cache_read_tokens: metrics.cacheReadTokens,
+            cache_creation_tokens: metrics.cacheCreationTokens
+          } : {}
         }
       }
-    ]);
+    ];
+    if (metrics && (metrics.totalCostUsd > 0 || metrics.promptTokens > 0)) {
+      events.push({
+        event_id: crypto.randomUUID(),
+        session_id: session.sessionId,
+        event_type: "cost",
+        timestamp: now.toISOString(),
+        tool: "claude-code",
+        tokens_prompt: metrics.promptTokens,
+        tokens_completion: metrics.completionTokens,
+        cost_usd: metrics.totalCostUsd,
+        metadata: {
+          cache_read_tokens: metrics.cacheReadTokens,
+          cache_creation_tokens: metrics.cacheCreationTokens
+        }
+      });
+    }
+    const sent = await sendEvents(session.endpoint, session.apiKey, events);
     try {
       unlinkSync2(SESSION_FILE);
     } catch {
     }
     if (sent) {
-      success(`Valt session ended: ${session.sessionId.slice(0, 8)} (${Math.round(durationMs / 1e3)}s)`);
+      const costStr = metrics?.totalCostUsd ? ` $${metrics.totalCostUsd.toFixed(4)}` : "";
+      success(`Valt session ended: ${session.sessionId.slice(0, 8)} (${Math.round(durationMs / 1e3)}s${costStr})`);
     } else {
       warn("Session ended locally but failed to send to Valt.");
     }

package/package.json

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