@jagit/hook-copilot 0.0.3 → 0.0.5

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

@@ -55,6 +55,38 @@ 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;
+    costUsd: number;
+    observations: number;
+}
+interface CopilotDebugUsage {
+    sessionId: string;
+    workspaceId: string;
+    model: string;
+    inputTokens: number;
+    cachedInputTokens: number;
+    outputTokens: number;
+    totalTokens: number;
+    costUsd: number | null;
+    sourcePath: string;
+    modelUsage: Record<string, ModelUsageBucket>;
+}
+export declare function inferWorkspaceIdBySession(sessionId: string, hookTimestamp?: string, baseDir?: string): WorkspaceCandidate | undefined;
+interface TranscriptPathLocation {
+    workspaceId: string;
+    sessionId: string;
+}
+export declare function parseTranscriptPathLocation(transcriptPath: string | undefined): TranscriptPathLocation | undefined;
+export declare function resolveDebugUsageBySession(sessionId: string | undefined, hookTimestamp?: string, baseDir?: string, workspaceIdFromTranscript?: string): CopilotDebugUsage | undefined;
 /**
  * Build payload from a real VS Code Copilot agent Stop-hook stdin.
  *
@@ -63,10 +95,11 @@ export interface CopilotInfo {
  * 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, baseDir?: string, workspaceIdFromTranscript?: 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")
@@ -16,6 +19,274 @@ function readTranscript(path) {
         }
     });
 }
+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];
+}
+export function parseTranscriptPathLocation(transcriptPath) {
+    if (!transcriptPath) {
+        return undefined;
+    }
+    const normalized = transcriptPath.replace(/\\/g, "/");
+    const match = normalized.match(/\/workspaceStorage\/([^/]+)\/GitHub\.copilot-chat\/transcripts\/([^/]+)\.jsonl$/);
+    if (!match) {
+        return undefined;
+    }
+    return {
+        workspaceId: match[1],
+        sessionId: match[2],
+    };
+}
+function buildMainLogPath(baseDir, workspaceId, sessionId) {
+    return join(baseDir, workspaceId, "GitHub.copilot-chat", "debug-logs", sessionId, "main.jsonl");
+}
+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 costUsd = 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 (["costusd", "cost", "usd", "usdcost"].includes(key)) {
+            costUsd += value;
+            foundAny = true;
+            continue;
+        }
+    }
+    if (!foundAny) {
+        return null;
+    }
+    if (totalTokens === 0) {
+        totalTokens = inputTokens + outputTokens;
+    }
+    return { inputTokens, cachedInputTokens, outputTokens, totalTokens, costUsd };
+}
+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,
+            costUsd: 0,
+            observations: 0,
+        };
+        existing.inputTokens += tokens.inputTokens;
+        existing.cachedInputTokens += tokens.cachedInputTokens;
+        existing.outputTokens += tokens.outputTokens;
+        existing.totalTokens += tokens.totalTokens;
+        existing.costUsd += tokens.costUsd;
+        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, workspaceIdFromTranscript) {
+    if (!sessionId) {
+        return undefined;
+    }
+    let workspaceId = workspaceIdFromTranscript;
+    let mainJsonlPath;
+    if (workspaceId) {
+        const pathFromTranscript = buildMainLogPath(baseDir, workspaceId, sessionId);
+        if (existsSync(pathFromTranscript)) {
+            mainJsonlPath = pathFromTranscript;
+        }
+    }
+    if (!mainJsonlPath) {
+        const workspace = inferWorkspaceIdBySession(sessionId, hookTimestamp, baseDir);
+        if (!workspace) {
+            return undefined;
+        }
+        workspaceId = workspace.workspaceId;
+        const fallbackPath = buildMainLogPath(baseDir, workspace.workspaceId, sessionId);
+        if (!existsSync(fallbackPath)) {
+            return undefined;
+        }
+        mainJsonlPath = fallbackPath;
+    }
+    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: workspaceId ?? "unknown",
+            model: "copilot",
+            inputTokens: 0,
+            cachedInputTokens: 0,
+            outputTokens: 0,
+            totalTokens: 0,
+            costUsd: null,
+            sourcePath: mainJsonlPath,
+            modelUsage: {},
+        };
+    }
+    let dominantModel = "copilot";
+    let dominantTotal = -1;
+    let dominantObs = -1;
+    let inputTokens = 0;
+    let cachedInputTokens = 0;
+    let outputTokens = 0;
+    let totalTokens = 0;
+    let totalCostUsd = 0;
+    for (const [model, usage] of usageByModel.entries()) {
+        inputTokens += usage.inputTokens;
+        cachedInputTokens += usage.cachedInputTokens;
+        outputTokens += usage.outputTokens;
+        totalTokens += usage.totalTokens;
+        totalCostUsd += usage.costUsd;
+        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: workspaceId ?? "unknown",
+        model: dominantModel,
+        inputTokens,
+        cachedInputTokens,
+        outputTokens,
+        totalTokens,
+        costUsd: totalCostUsd > 0 ? totalCostUsd : null,
+        sourcePath: mainJsonlPath,
+        modelUsage,
+    };
+}
 /**
  * Count tool calls from assistant.message entries.
  * Each assistant.message with at least one toolRequest counts as one tool-call turn;
@@ -55,7 +326,7 @@ function extractStartTime(entries) {
  * 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) {
+export function buildPayloadFromStdin(stdin, read = readTranscript, resolveUsage = resolveDebugUsageBySession) {
     const entries = stdin.transcript_path ? (() => {
         try {
             return read(stdin.transcript_path);
@@ -66,21 +337,31 @@ export function buildPayloadFromStdin(stdin, read = readTranscript) {
     })() : [];
     const toolCallCount = countToolCalls(entries);
     const startedAt = extractStartTime(entries) ?? stdin.timestamp ?? new Date().toISOString();
+    const parsedLocation = parseTranscriptPathLocation(stdin.transcript_path);
+    const sessionId = parsedLocation?.sessionId ?? stdin.session_id;
+    const usage = resolveUsage(sessionId, stdin.timestamp, WORKSPACE_STORAGE_DIR, parsedLocation?.workspaceId);
     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}`,
+        sessionId: sessionId ?? `copilot-${Date.now()}-${process.pid}`,
         gitUsername: resolveGitUsername(stdin.cwd),
-        // Model name is not exposed in the Copilot hook transcript (seat-based billing)
-        model: "copilot",
-        // Token usage is not available in the Copilot hook transcript
-        inputTokens: 0,
-        cachedInputTokens: 0,
+        // 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: 0,
-        costUsd: null,
+        outputTokens: usage?.outputTokens ?? 0,
+        costUsd: usage?.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.3",
+  "version": "0.0.5",
   "type": "module",
   "bin": {
     "jagit-hook-copilot": "dist/index.js"
@@ -9,7 +9,7 @@
     "dist"
   ],
   "dependencies": {
-    "@jagit/agent-reporter": "0.0.3"
+    "@jagit/agent-reporter": "0.0.5"
   },
   "devDependencies": {
     "@types/node": "^25.9.3",