@jagit/hook-copilot 0.0.0 → 0.0.2

package/README.md

@@ -1,40 +1,57 @@
 # @jagit/hook-copilot
 
-Reports per-invocation GitHub Copilot CLI usage to JaGit.
+Reports GitHub Copilot agent session usage to JaGit. Supports two modes:
 
-## Setup
+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.
+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.
 
-The Copilot CLI has no hook mechanism and no persistent session telemetry, so
-install a shell function that wraps the real `copilot` binary and reports
-after each invocation ends:
+## Setup — VS Code Agent Hook (Recommended)
 
-    copilot() {
-      command copilot "$@"
-      local status=$?
-      npx -y @jagit/hook-copilot >/dev/null 2>&1 || true
-      return $status
-    }
+Add the hook to your workspace's `.github/hooks/jagit.json` (or any [supported hook location](https://code.visualstudio.com/docs/agent-customization/hooks#_hook-file-locations)):
 
-Add that function to your shell rc (`~/.zshrc`, `~/.bashrc`, etc.) — it must
-appear before any `alias`/`PATH` entry that would otherwise shadow it. (Users
-on the legacy `gh copilot` preview wrapper can apply the same pattern to a
-`gh` function instead.) Uninstall by removing the shell function.
+```json
+{
+  "hooks": {
+    "Stop": [
+      {
+        "type": "command",
+        "command": "npx -y @jagit/hook-copilot"
+      }
+    ]
+  }
+}
+```
 
-For a permanent binary instead of `npx -y`:
-`npm i -g @jagit/hook-copilot`, then call `jagit-hook-copilot` in the wrapper.
+VS Code automatically loads this file. When the Copilot agent session ends, JaGit receives the session report (session ID, model, aggregated token counts, tool call count).
+
+For a permanent binary instead of `npx -y`: `npm i -g @jagit/hook-copilot`, then use `jagit-hook-copilot` as the command.
+
+## Setup — Legacy Shell Wrapper (Copilot CLI)
+
+If you are using the Copilot CLI directly (not the VS Code agent), install a shell function that wraps the real `copilot` binary and reports after each invocation ends:
+
+```sh
+copilot() {
+  command copilot "$@"
+  local status=$?
+  npx -y @jagit/hook-copilot >/dev/null 2>&1 || true
+  return $status
+}
+```
+
+Add that function to your shell rc (`~/.zshrc`, `~/.bashrc`, etc.). Uninstall by removing the shell function.
 
 ## Environment
 
-    export JAGIT_BASE_URL="https://your-jagit-host"
-    export JAGIT_API_KEY="<your DASHBOARD_API_TOKEN>"
+```sh
+export JAGIT_BASE_URL="https://your-jagit-host"
+export JAGIT_API_KEY="<your DASHBOARD_API_TOKEN>"
+```
 
 Identity defaults to `git config user.email`; override with `JAGIT_GIT_USERNAME`.
 
 ## Notes
 
-- Copilot CLI exposes no local token/usage telemetry (billing is seat-based),
-  so each report uses a synthetic session id (`copilot-<timestamp>-<pid>`),
-  zero token counts, and `model: "copilot"` unless a future CLI version
-  surfaces real usage data.
-- `costUsd` is always `null` and will remain so — there is no per-invocation
-  cost to report under seat-based billing.
+- 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 **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

@@ -1,5 +1,37 @@
 #!/usr/bin/env node
 import { type AgentSessionPayload } from "@jagit/agent-reporter";
+export interface CopilotStopStdin {
+    /** Optional per VS Code spec — common hook field */
+    session_id?: string;
+    cwd?: string;
+    hook_event_name?: string;
+    /** Absolute path to session transcript. Format is unstable — may change in future VS Code releases. */
+    transcript_path?: string;
+    timestamp?: string;
+    /**
+     * true when the agent is already continuing as a result of a previous Stop hook.
+     * Check this to prevent the hook from reporting duplicate sessions.
+     */
+    stop_hook_active?: boolean;
+}
+export interface CopilotTranscriptEntry {
+    type?: string;
+    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;
+        };
+    };
+}
 export interface CopilotInfo {
     model?: string;
     inputTokens?: number;
@@ -7,4 +39,14 @@ export interface CopilotInfo {
     cachedInputTokens?: number;
     toolCallCount?: number | null;
 }
+/**
+ * Build payload from a real VS Code Copilot agent Stop-hook stdin.
+ * Reads the transcript to aggregate token usage and detect the model.
+ */
+export declare function buildPayloadFromStdin(stdin: CopilotStopStdin, read?: (path: string) => CopilotTranscriptEntry[]): 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;

package/dist/index.js

@@ -1,7 +1,81 @@
 #!/usr/bin/env node
-import { realpathSync } from "node:fs";
+import { readFileSync, realpathSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { resolveGitUsername, reportSession } from "@jagit/agent-reporter";
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+function readTranscript(path) {
+    return readFileSync(path, "utf-8")
+        .split("\n")
+        .filter((l) => l.trim().length > 0)
+        .map((l) => {
+        try {
+            return JSON.parse(l);
+        }
+        catch {
+            return {};
+        }
+    });
+}
+function hasToolUse(content) {
+    return Array.isArray(content) && content.some((b) => b?.type === "tool_use");
+}
+// ─── 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.
+ */
+export function buildPayloadFromStdin(stdin, read = readTranscript) {
+    let inputTokens = 0;
+    let cachedInputTokens = 0;
+    let cacheCreationInputTokens = 0;
+    let outputTokens = 0;
+    let toolCallCount = 0;
+    let model = "copilot";
+    const entries = stdin.transcript_path ? (() => {
+        try {
+            return read(stdin.transcript_path);
+        }
+        catch {
+            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();
+    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,
+        costUsd: null,
+        toolCallCount,
+        startedAt,
+    };
+}
+/**
+ * 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 function buildPayload(cwd, info) {
     return {
         tool: "copilot",
@@ -10,15 +84,47 @@ export function buildPayload(cwd, info) {
         model: info?.model ?? "copilot",
         inputTokens: info?.inputTokens ?? 0,
         cachedInputTokens: info?.cachedInputTokens ?? 0,
+        cacheCreationInputTokens: 0,
         outputTokens: info?.outputTokens ?? 0,
         costUsd: null,
         toolCallCount: info?.toolCallCount ?? null,
         startedAt: new Date().toISOString(),
     };
 }
+// ─── Try to read a JSON object from stdin (fd 0) ─────────────────────────────
+function tryReadStdin() {
+    try {
+        const raw = readFileSync(0, "utf-8").trim();
+        if (!raw)
+            return undefined;
+        const parsed = JSON.parse(raw);
+        // Accept any object that looks like a VS Code hook payload (session_id is optional per spec)
+        if (typeof parsed === "object" && parsed !== null && "hook_event_name" in parsed) {
+            return parsed;
+        }
+        // Also accept if session_id is present (legacy / Claude Code compat)
+        if (typeof parsed.session_id === "string") {
+            return parsed;
+        }
+        return undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+// ─── Entry point ─────────────────────────────────────────────────────────────
 async function main() {
     try {
-        await reportSession(buildPayload(process.cwd()));
+        const stdin = tryReadStdin();
+        // stop_hook_active=true means the agent is re-running because a previous Stop hook
+        // blocked it. Skip reporting to avoid duplicate session entries.
+        if (stdin?.stop_hook_active === true) {
+            process.exit(0);
+        }
+        const payload = stdin
+            ? buildPayloadFromStdin(stdin)
+            : buildPayload(process.cwd());
+        await reportSession(payload);
     }
     catch (err) {
         console.error("[hook-copilot]", err instanceof Error ? err.message : err);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jagit/hook-copilot",
-  "version": "0.0.0",
+  "version": "0.0.2",
   "type": "module",
   "bin": {
     "jagit-hook-copilot": "dist/index.js"
@@ -8,16 +8,16 @@
   "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"
   },
   "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"
   }
 }