@jagit/hook-claude-code 0.0.0 → 0.0.2

package/dist/index.d.ts

@@ -20,5 +20,10 @@ interface TranscriptEntry {
         };
     };
 }
-export declare function buildPayload(stdin: StopStdin, read?: (path: string) => TranscriptEntry[]): AgentSessionPayload;
+export declare function calculateBaseTokens(costUsd: number | null): number | null;
+export declare function parseGitDiff(output: string): {
+    linesAdded: number;
+    linesRemoved: number;
+};
+export declare function buildPayload(stdin: StopStdin, read?: (path: string) => TranscriptEntry[], checkExists?: (path: string) => boolean, readFile?: (path: string, enc: BufferEncoding) => string): AgentSessionPayload;
 export {};

package/dist/index.js

@@ -1,8 +1,10 @@
 #!/usr/bin/env node
-import { readFileSync } from "node:fs";
+import { readFileSync, existsSync, rmSync } from "node:fs";
+import { execSync } from "node:child_process";
 import { realpathSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { resolveGitUsername, reportSession } from "@jagit/agent-reporter";
+import { createJiraWorklog } from "@jagit/shared";
 function readTranscript(path) {
     return readFileSync(path, "utf-8")
         .split("\n")
@@ -17,10 +19,58 @@ function readTranscript(path) {
 function hasToolUse(content) {
     return Array.isArray(content) && content.some((b) => b?.type === "tool_use");
 }
-export function buildPayload(stdin, read = readTranscript) {
+export function calculateBaseTokens(costUsd) {
+    if (costUsd === null)
+        return null;
+    // Fixed rate: 1 USD = 4,000,000 BT
+    return costUsd * 4000000;
+}
+export function parseGitDiff(output) {
+    let linesAdded = 0;
+    let linesRemoved = 0;
+    const lines = output.split("\n").filter((l) => l.trim().length > 0);
+    for (const line of lines) {
+        const parts = line.split("\t");
+        if (parts.length >= 2) {
+            if (parts[0] !== "-")
+                linesAdded += parseInt(parts[0], 10);
+            if (parts[1] !== "-")
+                linesRemoved += parseInt(parts[1], 10);
+        }
+    }
+    return { linesAdded, linesRemoved };
+}
+function getLocFromCommit(cwd, initialCommitSha) {
+    try {
+        const output = execSync(`git diff --numstat ${initialCommitSha} HEAD`, {
+            cwd,
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        return parseGitDiff(output);
+    }
+    catch (err) {
+        return undefined;
+    }
+}
+export function buildPayload(stdin, read = readTranscript, checkExists = existsSync, readFile = readFileSync) {
     const entries = read(stdin.transcript_path);
-    let inputTokens = 0, cachedInputTokens = 0, outputTokens = 0, toolCallCount = 0;
+    let inputTokens = 0, cachedInputTokens = 0, cacheCreationInputTokens = 0, outputTokens = 0, toolCallCount = 0;
     let model = "unknown";
+    let initialCommitSha = null;
+    let durationMs = undefined;
+    const statePath = stdin.cwd ? `${stdin.cwd}/.jigit-session-${stdin.session_id}.json` : "";
+    if (statePath && checkExists(statePath)) {
+        try {
+            const stateRaw = readFile(statePath, "utf-8");
+            const state = JSON.parse(stateRaw);
+            if (state.initialCommitSha)
+                initialCommitSha = state.initialCommitSha;
+            if (state.totalDurationMs !== undefined)
+                durationMs = state.totalDurationMs;
+        }
+        catch { }
+    }
     for (const e of entries) {
         if (e.message?.role !== "assistant")
             continue;
@@ -31,11 +81,21 @@ export function buildPayload(stdin, read = readTranscript) {
         const u = e.message.usage;
         if (u) {
             inputTokens += u.input_tokens ?? 0;
-            cachedInputTokens += (u.cache_read_input_tokens ?? 0) + (u.cache_creation_input_tokens ?? 0);
+            cachedInputTokens += u.cache_read_input_tokens ?? 0;
+            cacheCreationInputTokens += u.cache_creation_input_tokens ?? 0;
             outputTokens += u.output_tokens ?? 0;
         }
     }
     const startedAt = entries.find((e) => e.timestamp)?.timestamp ?? new Date().toISOString();
+    let linesAdded = undefined;
+    let linesRemoved = undefined;
+    if (stdin.cwd && initialCommitSha) {
+        const loc = getLocFromCommit(stdin.cwd, initialCommitSha);
+        if (loc) {
+            linesAdded = loc.linesAdded;
+            linesRemoved = loc.linesRemoved;
+        }
+    }
     return {
         tool: "claude-code",
         sessionId: stdin.session_id,
@@ -43,17 +103,58 @@ export function buildPayload(stdin, read = readTranscript) {
         model,
         inputTokens,
         cachedInputTokens,
+        cacheCreationInputTokens,
         outputTokens,
         costUsd: null,
         toolCallCount,
         startedAt,
+        initialCommitSha: initialCommitSha ?? undefined,
+        durationMs,
+        linesAdded,
+        linesRemoved,
     };
 }
 async function main() {
     try {
         const raw = readFileSync(0, "utf-8");
         const stdin = JSON.parse(raw);
-        await reportSession(buildPayload(stdin));
+        const payload = buildPayload(stdin);
+        await reportSession(payload);
+        if (payload.durationMs && stdin.cwd) {
+            const statePath = `${stdin.cwd}/.jigit-session-${stdin.session_id}.json`;
+            if (existsSync(statePath)) {
+                const baseUrl = process.env.JAGIT_BASE_URL?.trim();
+                const apiKey = process.env.JAGIT_API_KEY?.trim();
+                if (baseUrl && apiKey) {
+                    try {
+                        const res = await fetch(`${baseUrl}/api/agent-sessions?sessionId=${stdin.session_id}`, {
+                            headers: { "x-api-key": apiKey },
+                        });
+                        if (res.ok) {
+                            const data = await res.json();
+                            const session = data.rows?.[0];
+                            if (session?.jiraTicketId && session.costUsd) {
+                                const baseTokens = calculateBaseTokens(session.costUsd);
+                                if (baseTokens) {
+                                    await createJiraWorklog({
+                                        ticketId: session.jiraTicketId,
+                                        durationMs: payload.durationMs,
+                                        baseTokens,
+                                    });
+                                }
+                            }
+                        }
+                    }
+                    catch (err) {
+                        console.error("[hook-claude-code] Failed to create worklog:", err);
+                    }
+                }
+                try {
+                    rmSync(statePath, { force: true });
+                }
+                catch { }
+            }
+        }
     }
     catch (err) {
         console.error("[hook-claude-code]", err instanceof Error ? err.message : err);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jagit/hook-claude-code",
-  "version": "0.0.0",
+  "version": "0.0.2",
   "type": "module",
   "bin": {
     "jagit-hook-claude-code": "dist/index.js"
@@ -8,16 +8,17 @@
   "files": [
     "dist"
   ],
-  "scripts": {
-    "build": "tsc -p tsconfig.json",
-    "typecheck": "tsc -p tsconfig.json --noEmit",
-    "test": "vitest run"
-  },
   "dependencies": {
-    "@jagit/agent-reporter": "workspace:*"
+    "@jagit/agent-reporter": "0.0.2",
+    "@jagit/shared": "^0.0.2"
   },
   "devDependencies": {
     "@types/node": "^25.9.3",
     "vitest": "^2.1.9"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run"
   }
 }