@jagit/hook-copilot 0.0.2 → 0.0.4

package/README.md

@@ -2,7 +2,7 @@
 
 Reports GitHub Copilot agent session usage to JaGit. Supports two modes:
 
-1. **VS Code agent hook** (recommended) — hooks into the VS Code Copilot agent `Stop` lifecycle event, receiving a structured JSON payload from stdin including `session_id`, `cwd`, and `transcript_path`. Token counts and model name are parsed from the session transcript.
+1. **VS Code agent hook** (recommended) — hooks into the VS Code Copilot agent `Stop` lifecycle event, receiving a structured JSON payload from stdin including `session_id`, `cwd`, and `transcript_path`. Token counts and model name are read from Copilot debug logs (`main.jsonl`) by mapping `session_id` to the debug-log session folder.
 2. **Legacy shell wrapper** — wraps the Copilot CLI binary and fires after each invocation. No per-call telemetry is available under seat-based billing, so token counts are always zero.
 
 ## Setup — VS Code Agent Hook (Recommended)
@@ -52,6 +52,7 @@ Identity defaults to `git config user.email`; override with `JAGIT_GIT_USERNAME`
 
 ## Notes
 
-- In **VS Code agent hook mode**, tokens and model are read from the session transcript at `transcript_path`. Both snake_case (`input_tokens`) and camelCase (`inputTokens`) transcript formats are supported.
+- In **VS Code agent hook mode**, tool-call count and start time are read from `transcript_path`; model/token usage is read from `~/.config/Code/User/workspaceStorage/<workspace-id>/GitHub.copilot-chat/debug-logs/<session-id>/main.jsonl`.
+- Workspace detection prefers a workspace that contains the incoming `session_id`. If no exact session match is found, it falls back to the most recently updated workspace debug-log directory near the Stop-hook timestamp.
 - In **legacy shell wrapper mode**, token counts are always zero (`costUsd: null`) since the Copilot CLI exposes no per-invocation telemetry under seat-based billing.
 - `costUsd` is always `null` — there is no per-session USD cost to report.

package/dist/index.d.ts

@@ -14,24 +14,40 @@ export interface CopilotStopStdin {
      */
     stop_hook_active?: boolean;
 }
-export interface CopilotTranscriptEntry {
+export interface CopilotTranscriptSessionStart {
+    type: "session.start";
+    timestamp?: string;
+    data: {
+        sessionId?: string;
+        version?: number;
+        producer?: string;
+        copilotVersion?: string;
+        vscodeVersion?: string;
+        startTime?: string;
+    };
+}
+export interface CopilotTranscriptToolRequest {
+    toolCallId?: string;
+    name?: string;
+    arguments?: string;
     type?: string;
+}
+export interface CopilotTranscriptAssistantMessage {
+    type: "assistant.message";
     timestamp?: string;
-    message?: {
-        role?: string;
-        model?: string;
-        content?: unknown;
-        usage?: {
-            input_tokens?: number;
-            cache_read_input_tokens?: number;
-            cache_creation_input_tokens?: number;
-            output_tokens?: number;
-            inputTokens?: number;
-            cachedInputTokens?: number;
-            outputTokens?: number;
-        };
+    id?: string;
+    data: {
+        messageId?: string;
+        content?: string;
+        /** Tool calls made in this assistant turn */
+        toolRequests?: CopilotTranscriptToolRequest[];
     };
 }
+export type CopilotTranscriptEntry = CopilotTranscriptSessionStart | CopilotTranscriptAssistantMessage | {
+    type: string;
+    timestamp?: string;
+    data?: unknown;
+};
 export interface CopilotInfo {
     model?: string;
     inputTokens?: number;
@@ -39,14 +55,44 @@ export interface CopilotInfo {
     cachedInputTokens?: number;
     toolCallCount?: number | null;
 }
+interface WorkspaceCandidate {
+    workspaceId: string;
+    debugLogsDir: string;
+    updatedAtMs: number;
+}
+interface ModelUsageBucket {
+    inputTokens: number;
+    cachedInputTokens: number;
+    outputTokens: number;
+    totalTokens: number;
+    observations: number;
+}
+interface CopilotDebugUsage {
+    sessionId: string;
+    workspaceId: string;
+    model: string;
+    inputTokens: number;
+    cachedInputTokens: number;
+    outputTokens: number;
+    totalTokens: number;
+    sourcePath: string;
+    modelUsage: Record<string, ModelUsageBucket>;
+}
+export declare function inferWorkspaceIdBySession(sessionId: string, hookTimestamp?: string, baseDir?: string): WorkspaceCandidate | undefined;
+export declare function resolveDebugUsageBySession(sessionId: string | undefined, hookTimestamp?: string, baseDir?: string): CopilotDebugUsage | undefined;
 /**
  * Build payload from a real VS Code Copilot agent Stop-hook stdin.
- * Reads the transcript to aggregate token usage and detect the model.
+ *
+ * Reads the transcript to count tool calls and extract the session start time.
+ * Token usage (input/cached/output) and model name are NOT available in the
+ * VS Code Copilot transcript — Copilot uses seat-based billing and does not
+ * expose per-call telemetry. These fields are reported as 0/null/"copilot".
  */
-export declare function buildPayloadFromStdin(stdin: CopilotStopStdin, read?: (path: string) => CopilotTranscriptEntry[]): AgentSessionPayload;
+export declare function buildPayloadFromStdin(stdin: CopilotStopStdin, read?: (path: string) => CopilotTranscriptEntry[], resolveUsage?: (sessionId: string | undefined, hookTimestamp?: string) => CopilotDebugUsage | undefined): AgentSessionPayload;
 /**
  * Build payload in legacy mode (no stdin) — used when hook-copilot is invoked
  * via the old shell-wrapper pattern around the Copilot CLI. Token counts are
  * not available in this mode (seat-based billing has no per-call telemetry).
  */
 export declare function buildPayload(cwd: string | undefined, info?: CopilotInfo): AgentSessionPayload;
+export {};

package/dist/index.js

@@ -1,7 +1,10 @@
 #!/usr/bin/env node
-import { readFileSync, realpathSync } from "node:fs";
+import { existsSync, readFileSync, readdirSync, realpathSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { resolveGitUsername, reportSession } from "@jagit/agent-reporter";
+const WORKSPACE_STORAGE_DIR = join(homedir(), ".config", "Code", "User", "workspaceStorage");
 // ─── Helpers ─────────────────────────────────────────────────────────────────
 function readTranscript(path) {
     return readFileSync(path, "utf-8")
@@ -12,25 +15,277 @@ function readTranscript(path) {
             return JSON.parse(l);
         }
         catch {
-            return {};
+            return { type: "__parse_error__" };
         }
     });
 }
-function hasToolUse(content) {
-    return Array.isArray(content) && content.some((b) => b?.type === "tool_use");
+function normalizeKey(key) {
+    return key.toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+function toFiniteNumber(value) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return value;
+    }
+    if (typeof value === "string" && value.trim().length > 0) {
+        const parsed = Number(value);
+        if (Number.isFinite(parsed)) {
+            return parsed;
+        }
+    }
+    return null;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function listWorkspaceCandidates(baseDir) {
+    if (!existsSync(baseDir)) {
+        return [];
+    }
+    const entries = readdirSync(baseDir, { withFileTypes: true });
+    const workspaces = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory()) {
+            continue;
+        }
+        const debugLogsDir = join(baseDir, entry.name, "GitHub.copilot-chat", "debug-logs");
+        if (!existsSync(debugLogsDir)) {
+            continue;
+        }
+        let updatedAtMs = 0;
+        try {
+            updatedAtMs = statSync(debugLogsDir).mtimeMs;
+        }
+        catch {
+            updatedAtMs = 0;
+        }
+        workspaces.push({
+            workspaceId: entry.name,
+            debugLogsDir,
+            updatedAtMs,
+        });
+    }
+    return workspaces;
+}
+function rankWorkspacesByRecency(workspaces, hookTimestamp) {
+    if (!hookTimestamp) {
+        return [...workspaces].sort((a, b) => b.updatedAtMs - a.updatedAtMs);
+    }
+    const hookMs = Date.parse(hookTimestamp);
+    if (Number.isNaN(hookMs)) {
+        return [...workspaces].sort((a, b) => b.updatedAtMs - a.updatedAtMs);
+    }
+    return [...workspaces].sort((a, b) => {
+        const aDelta = Math.abs(a.updatedAtMs - hookMs);
+        const bDelta = Math.abs(b.updatedAtMs - hookMs);
+        if (aDelta !== bDelta) {
+            return aDelta - bDelta;
+        }
+        return b.updatedAtMs - a.updatedAtMs;
+    });
+}
+export function inferWorkspaceIdBySession(sessionId, hookTimestamp, baseDir = WORKSPACE_STORAGE_DIR) {
+    const candidates = rankWorkspacesByRecency(listWorkspaceCandidates(baseDir), hookTimestamp);
+    for (const candidate of candidates) {
+        const sessionDir = join(candidate.debugLogsDir, sessionId);
+        if (existsSync(sessionDir)) {
+            return candidate;
+        }
+    }
+    return candidates[0];
+}
+function resolveModelFromObject(obj, fallbackModel) {
+    const keys = ["model", "modelName", "model_name", "resolvedModel", "deployment", "engine"];
+    for (const key of keys) {
+        const value = obj[key];
+        if (typeof value === "string" && value.trim().length > 0) {
+            return value.trim();
+        }
+    }
+    return fallbackModel;
+}
+function extractTokensFromObject(obj) {
+    let inputTokens = 0;
+    let cachedInputTokens = 0;
+    let outputTokens = 0;
+    let totalTokens = 0;
+    let foundAny = false;
+    for (const [rawKey, rawValue] of Object.entries(obj)) {
+        const key = normalizeKey(rawKey);
+        const value = toFiniteNumber(rawValue);
+        if (value === null) {
+            continue;
+        }
+        if (["inputtokens", "prompttokens", "requesttokens"].includes(key)) {
+            inputTokens += value;
+            foundAny = true;
+            continue;
+        }
+        if (["cachedinputtokens", "cachedtokens", "cachereadinputtokens", "promptcachehitstokens"].includes(key)) {
+            cachedInputTokens += value;
+            foundAny = true;
+            continue;
+        }
+        if (["outputtokens", "completiontokens", "responsetokens"].includes(key)) {
+            outputTokens += value;
+            foundAny = true;
+            continue;
+        }
+        if (["totaltokens", "alltokens"].includes(key)) {
+            totalTokens += value;
+            foundAny = true;
+            continue;
+        }
+    }
+    if (!foundAny) {
+        return null;
+    }
+    if (totalTokens === 0) {
+        totalTokens = inputTokens + outputTokens;
+    }
+    return { inputTokens, cachedInputTokens, outputTokens, totalTokens };
+}
+function collectModelUsage(value, usageByModel, currentModel = "copilot") {
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            collectModelUsage(item, usageByModel, currentModel);
+        }
+        return;
+    }
+    if (!isRecord(value)) {
+        return;
+    }
+    const resolvedModel = resolveModelFromObject(value, currentModel);
+    const tokens = extractTokensFromObject(value);
+    if (tokens) {
+        const existing = usageByModel.get(resolvedModel) ?? {
+            inputTokens: 0,
+            cachedInputTokens: 0,
+            outputTokens: 0,
+            totalTokens: 0,
+            observations: 0,
+        };
+        existing.inputTokens += tokens.inputTokens;
+        existing.cachedInputTokens += tokens.cachedInputTokens;
+        existing.outputTokens += tokens.outputTokens;
+        existing.totalTokens += tokens.totalTokens;
+        existing.observations += 1;
+        usageByModel.set(resolvedModel, existing);
+    }
+    for (const child of Object.values(value)) {
+        collectModelUsage(child, usageByModel, resolvedModel);
+    }
+}
+export function resolveDebugUsageBySession(sessionId, hookTimestamp, baseDir = WORKSPACE_STORAGE_DIR) {
+    if (!sessionId) {
+        return undefined;
+    }
+    const workspace = inferWorkspaceIdBySession(sessionId, hookTimestamp, baseDir);
+    if (!workspace) {
+        return undefined;
+    }
+    const mainJsonlPath = join(workspace.debugLogsDir, sessionId, "main.jsonl");
+    if (!existsSync(mainJsonlPath)) {
+        return undefined;
+    }
+    const usageByModel = new Map();
+    const lines = readFileSync(mainJsonlPath, "utf-8").split("\n");
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed) {
+            continue;
+        }
+        try {
+            const parsed = JSON.parse(trimmed);
+            collectModelUsage(parsed, usageByModel, "copilot");
+        }
+        catch {
+            // Ignore malformed lines to keep reporting resilient.
+        }
+    }
+    if (usageByModel.size === 0) {
+        return {
+            sessionId,
+            workspaceId: workspace.workspaceId,
+            model: "copilot",
+            inputTokens: 0,
+            cachedInputTokens: 0,
+            outputTokens: 0,
+            totalTokens: 0,
+            sourcePath: mainJsonlPath,
+            modelUsage: {},
+        };
+    }
+    let dominantModel = "copilot";
+    let dominantTotal = -1;
+    let dominantObs = -1;
+    let inputTokens = 0;
+    let cachedInputTokens = 0;
+    let outputTokens = 0;
+    let totalTokens = 0;
+    for (const [model, usage] of usageByModel.entries()) {
+        inputTokens += usage.inputTokens;
+        cachedInputTokens += usage.cachedInputTokens;
+        outputTokens += usage.outputTokens;
+        totalTokens += usage.totalTokens;
+        if (usage.totalTokens > dominantTotal || (usage.totalTokens === dominantTotal && usage.observations > dominantObs)) {
+            dominantModel = model;
+            dominantTotal = usage.totalTokens;
+            dominantObs = usage.observations;
+        }
+    }
+    const modelUsage = Object.fromEntries(usageByModel.entries());
+    return {
+        sessionId,
+        workspaceId: workspace.workspaceId,
+        model: dominantModel,
+        inputTokens,
+        cachedInputTokens,
+        outputTokens,
+        totalTokens,
+        sourcePath: mainJsonlPath,
+        modelUsage,
+    };
+}
+/**
+ * Count tool calls from assistant.message entries.
+ * Each assistant.message with at least one toolRequest counts as one tool-call turn;
+ * we sum the total number of individual tool requests across all turns.
+ */
+function countToolCalls(entries) {
+    let count = 0;
+    for (const e of entries) {
+        if (e.type !== "assistant.message")
+            continue;
+        const msg = e;
+        count += msg.data?.toolRequests?.length ?? 0;
+    }
+    return count;
+}
+/**
+ * Extract the earliest timestamp from the transcript.
+ * Prefers session.start data.startTime, then falls back to the first entry timestamp.
+ */
+function extractStartTime(entries) {
+    for (const e of entries) {
+        if (e.type === "session.start") {
+            const s = e;
+            if (s.data?.startTime)
+                return s.data.startTime;
+        }
+    }
+    // Fall back to the first entry with a timestamp
+    return entries.find((e) => e.timestamp)?.timestamp;
 }
 // ─── Payload builders ─────────────────────────────────────────────────────────
 /**
  * Build payload from a real VS Code Copilot agent Stop-hook stdin.
- * Reads the transcript to aggregate token usage and detect the model.
+ *
+ * Reads the transcript to count tool calls and extract the session start time.
+ * Token usage (input/cached/output) and model name are NOT available in the
+ * VS Code Copilot transcript — Copilot uses seat-based billing and does not
+ * expose per-call telemetry. These fields are reported as 0/null/"copilot".
  */
-export function buildPayloadFromStdin(stdin, read = readTranscript) {
-    let inputTokens = 0;
-    let cachedInputTokens = 0;
-    let cacheCreationInputTokens = 0;
-    let outputTokens = 0;
-    let toolCallCount = 0;
-    let model = "copilot";
+export function buildPayloadFromStdin(stdin, read = readTranscript, resolveUsage = resolveDebugUsageBySession) {
     const entries = stdin.transcript_path ? (() => {
         try {
             return read(stdin.transcript_path);
@@ -39,36 +294,31 @@ export function buildPayloadFromStdin(stdin, read = readTranscript) {
             return [];
         }
     })() : [];
-    for (const e of entries) {
-        if (e.message?.role !== "assistant")
-            continue;
-        if (e.message.model)
-            model = e.message.model;
-        if (hasToolUse(e.message.content))
-            toolCallCount += 1;
-        const u = e.message.usage;
-        if (u) {
-            // Prefer snake_case (Claude-compatible), fall back to camelCase (OpenAI-style)
-            inputTokens += u.input_tokens ?? u.inputTokens ?? 0;
-            cachedInputTokens += u.cache_read_input_tokens ?? u.cachedInputTokens ?? 0;
-            cacheCreationInputTokens += u.cache_creation_input_tokens ?? 0;
-            outputTokens += u.output_tokens ?? u.outputTokens ?? 0;
-        }
-    }
-    const startedAt = entries.find((e) => e.timestamp)?.timestamp ?? stdin.timestamp ?? new Date().toISOString();
+    const toolCallCount = countToolCalls(entries);
+    const startedAt = extractStartTime(entries) ?? stdin.timestamp ?? new Date().toISOString();
+    const usage = resolveUsage(stdin.session_id, stdin.timestamp);
     return {
         tool: "copilot",
         // session_id is optional per VS Code spec; synthesize a fallback if absent
         sessionId: stdin.session_id ?? `copilot-${Date.now()}-${process.pid}`,
         gitUsername: resolveGitUsername(stdin.cwd),
-        model,
-        inputTokens,
-        cachedInputTokens,
-        cacheCreationInputTokens,
-        outputTokens,
+        // Model/tokens are inferred from debug logs by session_id; falls back safely.
+        model: usage?.model ?? "copilot",
+        inputTokens: usage?.inputTokens ?? 0,
+        cachedInputTokens: usage?.cachedInputTokens ?? 0,
+        cacheCreationInputTokens: 0,
+        outputTokens: usage?.outputTokens ?? 0,
         costUsd: null,
         toolCallCount,
         startedAt,
+        rawPayload: usage ? {
+            source: "copilot-debug-logs",
+            workspaceId: usage.workspaceId,
+            debugLogPath: usage.sourcePath,
+            debugSessionId: usage.sessionId,
+            totalTokens: usage.totalTokens,
+            modelUsage: usage.modelUsage,
+        } : undefined,
     };
 }
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jagit/hook-copilot",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "type": "module",
   "bin": {
     "jagit-hook-copilot": "dist/index.js"
@@ -9,7 +9,7 @@
     "dist"
   ],
   "dependencies": {
-    "@jagit/agent-reporter": "0.0.2"
+    "@jagit/agent-reporter": "0.0.4"
   },
   "devDependencies": {
     "@types/node": "^25.9.3",