@jagit/hook-claude-code-time-tracking 0.0.2

package/dist/git.d.ts

@@ -0,0 +1 @@
+export declare function getHeadSha(cwd?: string): string | null;

package/dist/git.js

@@ -0,0 +1,14 @@
+import { execSync } from "node:child_process";
+export function getHeadSha(cwd) {
+    try {
+        const sha = execSync("git rev-parse HEAD", {
+            cwd: cwd ?? process.cwd(),
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "pipe"],
+        }).trim();
+        return sha;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+interface UserPromptSubmitStdin {
+    session_id: string;
+    timestamp: string;
+    cwd?: string;
+}
+export interface TimeTrackingPayload {
+    sessionId: string;
+    initialCommitSha: string | null;
+    totalDurationMs: number;
+}
+export declare function buildPayload(stdin: UserPromptSubmitStdin): Promise<TimeTrackingPayload>;
+export {};

package/dist/index.js

@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+import { readFileSync, realpathSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { getStatePath, readState, writeState } from "./state.js";
+import { getHeadSha } from "./git.js";
+export async function buildPayload(stdin) {
+    const { session_id, timestamp, cwd } = stdin;
+    const statePath = cwd ? getStatePath(cwd, session_id) : "";
+    let state;
+    if (!statePath) {
+        // No cwd available, just return minimal payload
+        return {
+            sessionId: session_id,
+            initialCommitSha: null,
+            totalDurationMs: 0,
+        };
+    }
+    const existingState = readState(statePath);
+    if (!existingState) {
+        // Initialize new state
+        const initialCommitSha = getHeadSha(cwd);
+        state = {
+            sessionId: session_id,
+            initialCommitSha,
+            totalDurationMs: 0,
+            lastUpdateTime: timestamp,
+        };
+        writeState(statePath, state);
+    }
+    else {
+        // Accumulate duration
+        const lastTime = new Date(existingState.lastUpdateTime).getTime();
+        const currentTime = new Date(timestamp).getTime();
+        const elapsed = currentTime - lastTime;
+        state = {
+            ...existingState,
+            totalDurationMs: existingState.totalDurationMs + elapsed,
+            lastUpdateTime: timestamp,
+        };
+        writeState(statePath, state);
+    }
+    // Async sync to API (fire and forget)
+    syncToApi(state).catch((err) => {
+        console.error("[time-tracking] Failed to sync to API:", err);
+    });
+    return {
+        sessionId: state.sessionId,
+        initialCommitSha: state.initialCommitSha,
+        totalDurationMs: state.totalDurationMs,
+    };
+}
+async function syncToApi(state) {
+    const baseUrl = process.env.JAGIT_BASE_URL?.trim();
+    const apiKey = process.env.JAGIT_API_KEY?.trim();
+    if (!baseUrl || !apiKey) {
+        return; // Silently skip if not configured
+    }
+    const url = `${baseUrl.replace(/\/+$/, "")}/api/agent-sessions/${state.sessionId}/time-tracking`;
+    const body = {};
+    if (state.initialCommitSha)
+        body.initialCommitSha = state.initialCommitSha;
+    if (state.totalDurationMs > 0)
+        body.durationMs = state.totalDurationMs;
+    if (Object.keys(body).length === 0)
+        return;
+    await fetch(url, {
+        method: "PATCH",
+        headers: {
+            "content-type": "application/json",
+            "x-api-key": apiKey,
+        },
+        body: JSON.stringify(body),
+    });
+}
+async function main() {
+    try {
+        const raw = readFileSync(0, "utf-8");
+        const stdin = JSON.parse(raw);
+        await buildPayload(stdin);
+    }
+    catch (err) {
+        console.error("[time-tracking]", err instanceof Error ? err.message : err);
+    }
+    finally {
+        process.exit(0);
+    }
+}
+const isMain = import.meta.url.startsWith("file://") &&
+    realpathSync(fileURLToPath(import.meta.url)) === realpathSync(process.argv[1]);
+if (isMain)
+    void main();

package/dist/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.test.js

@@ -0,0 +1,67 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { buildPayload } from "./index.js";
+import * as state from "./state.js";
+import * as git from "./git.js";
+vi.mock("./state.js", () => ({
+    readState: vi.fn(),
+    writeState: vi.fn(),
+    getStatePath: (cwd, sessionId) => `${cwd}/.jigit-session-${sessionId}.json`,
+}));
+vi.mock("./git.js", () => ({
+    getHeadSha: vi.fn(),
+}));
+vi.mock("@jigit/agent-reporter", () => ({
+    reportSession: vi.fn(),
+}));
+describe("buildPayload", () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it("should initialize state on first call", async () => {
+        vi.mocked(state.readState).mockReturnValue(null);
+        vi.mocked(git.getHeadSha).mockReturnValue("abc123");
+        vi.mocked(state.writeState).mockImplementation(() => { });
+        const stdin = {
+            session_id: "test-session-1",
+            timestamp: "2026-06-21T10:00:00Z",
+            cwd: "/tmp/test",
+        };
+        const result = await buildPayload(stdin);
+        expect(result.sessionId).toBe("test-session-1");
+        expect(result.initialCommitSha).toBe("abc123");
+        expect(result.totalDurationMs).toBe(0);
+        expect(state.writeState).toHaveBeenCalledWith("/tmp/test/.jigit-session-test-session-1.json", expect.objectContaining({
+            sessionId: "test-session-1",
+            initialCommitSha: "abc123",
+            totalDurationMs: 0,
+        }));
+    });
+    it("should accumulate duration on subsequent calls", async () => {
+        vi.mocked(state.readState).mockReturnValue({
+            sessionId: "test-session-1",
+            initialCommitSha: "abc123",
+            totalDurationMs: 3600000,
+            lastUpdateTime: "2026-06-21T10:00:00Z",
+        });
+        vi.mocked(state.writeState).mockImplementation(() => { });
+        const stdin = {
+            session_id: "test-session-1",
+            timestamp: "2026-06-21T11:00:00Z",
+            cwd: "/tmp/test",
+        };
+        const result = await buildPayload(stdin);
+        expect(result.totalDurationMs).toBe(7200000); // 2 hours total
+    });
+    it("should handle missing cwd", async () => {
+        vi.mocked(state.readState).mockReturnValue(null);
+        vi.mocked(git.getHeadSha).mockImplementation(() => {
+            throw new Error("Not a git repository");
+        });
+        const stdin = {
+            session_id: "test-session-2",
+            timestamp: "2026-06-21T10:00:00Z",
+        };
+        const result = await buildPayload(stdin);
+        expect(result.initialCommitSha).toBeNull();
+    });
+});

package/dist/state.d.ts

@@ -0,0 +1,9 @@
+export interface TimeTrackingState {
+    sessionId: string;
+    initialCommitSha: string | null;
+    totalDurationMs: number;
+    lastUpdateTime: string;
+}
+export declare function getStatePath(cwd: string, sessionId: string): string;
+export declare function readState(path: string): TimeTrackingState | null;
+export declare function writeState(path: string, state: TimeTrackingState): void;

package/dist/state.js

@@ -0,0 +1,29 @@
+import { readFileSync, writeFileSync, existsSync, renameSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+export function getStatePath(cwd, sessionId) {
+    return join(cwd, `.jigit-session-${sessionId}.json`);
+}
+export function readState(path) {
+    try {
+        if (!existsSync(path))
+            return null;
+        const data = readFileSync(path, "utf-8");
+        return JSON.parse(data);
+    }
+    catch {
+        return null;
+    }
+}
+export function writeState(path, state) {
+    try {
+        // Atomic write: write to temp file, then rename
+        const dir = tmpdir();
+        const tempPath = join(dir, `jigit-session-${Date.now()}.json`);
+        writeFileSync(tempPath, JSON.stringify(state, null, 2), "utf-8");
+        renameSync(tempPath, path);
+    }
+    catch (err) {
+        console.error("[time-tracking] Failed to write state:", err);
+    }
+}

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@jagit/hook-claude-code-time-tracking",
+  "version": "0.0.2",
+  "type": "module",
+  "bin": {
+    "jagit-hook-claude-code-time-tracking": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@jagit/agent-reporter": "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"
+  }
+}