codiedev 0.9.6 → 0.9.7-beta.1

package/dist/hook.js

@@ -252,6 +252,15 @@ async function main() {
             ? { messageCount: 0, toolCallCount: 0 }
             : (0, utils_1.parseClaudeCodeStats)(transcriptContent);
     const transcriptBase64 = Buffer.from(transcriptContent, "utf8").toString("base64");
+    // Session→merge join keys: the branch + HEAD sha the work happened on. Matched
+    // server-side against a merged MR/PR's source_branch / commits for AI attribution.
+    const branch = (0, utils_1.getGitBranch)(workspaceRoot);
+    const headSha = (0, utils_1.getGitHeadSha)(workspaceRoot);
+    // Cost/velocity/steering signals parsed straight from the transcript we're
+    // already holding — no extra hooks, no extra git/process calls.
+    const usage = (0, utils_1.parseUsage)(transcriptContent, mode);
+    const sessionStartedAt = (0, utils_1.parseSessionStart)(transcriptContent);
+    const steering = (0, utils_1.parseSteering)(transcriptContent, mode);
     const payload = (0, utils_1.buildCapturePayload)({
         sessionId: session_id,
         transcriptBase64,
@@ -262,6 +271,15 @@ async function main() {
         toolCallCount: stats.toolCallCount,
         capturedAt: Date.now(),
         source: mode,
+        branch,
+        headSha,
+        inputTokens: usage.inputTokens,
+        outputTokens: usage.outputTokens,
+        cacheTokens: usage.cacheTokens,
+        model: usage.model,
+        sessionStartedAt,
+        interruptCount: steering.interrupts,
+        rejectionCount: steering.rejections,
     });
     // Fire the upload from a fully detached child and exit immediately. Awaiting
     // it inline let Claude Code's SessionEnd shutdown window elapse and kill the

package/dist/utils.d.ts

@@ -27,6 +27,8 @@ export declare function matchRepo(remoteUrl: string, repos: Array<{
     url: string;
     fullName: string;
 } | null;
+export declare function getGitBranch(cwd: string): string | null;
+export declare function getGitHeadSha(cwd: string): string | null;
 export interface CapturePayloadInput {
     sessionId?: string;
     transcriptBase64: string;
@@ -37,6 +39,15 @@ export interface CapturePayloadInput {
     toolCallCount: number;
     capturedAt: number;
     source: string;
+    branch?: string | null;
+    headSha?: string | null;
+    inputTokens?: number;
+    outputTokens?: number;
+    cacheTokens?: number;
+    model?: string | null;
+    sessionStartedAt?: number | null;
+    interruptCount?: number;
+    rejectionCount?: number;
 }
 export declare function buildCapturePayload(input: CapturePayloadInput): Record<string, unknown>;
 export declare function hashToken(token: string): string;
@@ -115,6 +126,21 @@ export interface ParsedStats {
     messageCount: number;
     toolCallCount: number;
 }
+export interface SteeringStats {
+    interrupts: number;
+    rejections: number;
+}
+export declare function parseClaudeSteering(content: string): SteeringStats;
+export declare function parseCodexSteering(content: string): SteeringStats;
+export declare function parseSteering(content: string, mode: "claude-code" | "codex" | "cursor"): SteeringStats;
+export interface UsageStats {
+    inputTokens: number;
+    outputTokens: number;
+    cacheTokens: number;
+    model: string | null;
+}
+export declare function parseUsage(content: string, mode: "claude-code" | "codex" | "cursor"): UsageStats;
+export declare function parseSessionStart(content: string): number | null;
 export declare function parseClaudeCodeStats(content: string): ParsedStats;
 export declare function parseCodexStats(content: string): ParsedStats;
 export declare function extractCodexRepoUrl(content: string): string | null;

package/dist/utils.js

@@ -40,6 +40,8 @@ exports.readGitRemoteFromConfig = readGitRemoteFromConfig;
 exports.getGitRemoteUrl = getGitRemoteUrl;
 exports.normalizeRepoUrl = normalizeRepoUrl;
 exports.matchRepo = matchRepo;
+exports.getGitBranch = getGitBranch;
+exports.getGitHeadSha = getGitHeadSha;
 exports.buildCapturePayload = buildCapturePayload;
 exports.hashToken = hashToken;
 exports.claudeCodeInstalled = claudeCodeInstalled;
@@ -63,6 +65,11 @@ exports.cleanupCodexMcp = cleanupCodexMcp;
 exports.installCodexMcp = installCodexMcp;
 exports.installCodexHook = installCodexHook;
 exports.installCursorHook = installCursorHook;
+exports.parseClaudeSteering = parseClaudeSteering;
+exports.parseCodexSteering = parseCodexSteering;
+exports.parseSteering = parseSteering;
+exports.parseUsage = parseUsage;
+exports.parseSessionStart = parseSessionStart;
 exports.parseClaudeCodeStats = parseClaudeCodeStats;
 exports.parseCodexStats = parseCodexStats;
 exports.extractCodexRepoUrl = extractCodexRepoUrl;
@@ -247,17 +254,115 @@ function matchRepo(remoteUrl, repos) {
     }
     return null;
 }
+// Current branch via direct .git/HEAD read (no git binary required, same
+// robustness as getGitRemoteUrl). Returns null on detached HEAD or when
+// unresolvable. This is the session→merge join key: a captured session's
+// branch is matched against a merged MR/PR's source_branch.
+function getGitBranch(cwd) {
+    const gitDir = resolveGitDir(cwd);
+    if (gitDir) {
+        try {
+            const head = fs.readFileSync(path.join(gitDir, "HEAD"), "utf8").trim();
+            const m = head.match(/^ref:\s*refs\/heads\/(.+)$/);
+            if (m)
+                return m[1].trim();
+            // raw sha => detached HEAD, no branch
+        }
+        catch {
+            // fall through to git
+        }
+    }
+    try {
+        const b = (0, child_process_1.execSync)("git rev-parse --abbrev-ref HEAD", {
+            cwd,
+            stdio: ["pipe", "pipe", "pipe"],
+        })
+            .toString()
+            .trim();
+        return b && b !== "HEAD" ? b : null;
+    }
+    catch {
+        return null;
+    }
+}
+// Current commit SHA (HEAD), direct-read first then git fallback. Exact join
+// key — survives branch renames that branch-matching would miss.
+function getGitHeadSha(cwd) {
+    const gitDir = resolveGitDir(cwd);
+    if (gitDir) {
+        try {
+            const head = fs.readFileSync(path.join(gitDir, "HEAD"), "utf8").trim();
+            if (/^[0-9a-f]{40}$/i.test(head))
+                return head.toLowerCase();
+            const m = head.match(/^ref:\s*(.+)$/);
+            if (m) {
+                const ref = m[1].trim();
+                for (const cfg of gitConfigCandidates(gitDir)) {
+                    const baseDir = path.dirname(cfg);
+                    try {
+                        const sha = fs.readFileSync(path.join(baseDir, ref), "utf8").trim();
+                        if (/^[0-9a-f]{40}$/i.test(sha))
+                            return sha.toLowerCase();
+                    }
+                    catch {
+                        /* try packed-refs */
+                    }
+                    try {
+                        const packed = fs.readFileSync(path.join(baseDir, "packed-refs"), "utf8");
+                        const line = packed
+                            .split("\n")
+                            .find((l) => l.endsWith(" " + ref));
+                        if (line) {
+                            const sha = line.split(" ")[0].trim();
+                            if (/^[0-9a-f]{40}$/i.test(sha))
+                                return sha.toLowerCase();
+                        }
+                    }
+                    catch {
+                        /* ignore */
+                    }
+                }
+            }
+        }
+        catch {
+            // fall through to git
+        }
+    }
+    try {
+        const sha = (0, child_process_1.execSync)("git rev-parse HEAD", {
+            cwd,
+            stdio: ["pipe", "pipe", "pipe"],
+        })
+            .toString()
+            .trim();
+        return /^[0-9a-f]{40}$/i.test(sha) ? sha.toLowerCase() : null;
+    }
+    catch {
+        return null;
+    }
+}
 function buildCapturePayload(input) {
     return {
         sessionId: input.sessionId,
         repoUrl: input.remoteUrl ?? "",
         repoId: input.matchedRepoId,
         companyId: input.companyId,
+        branch: input.branch ?? "",
+        headSha: input.headSha ?? "",
         transcript: input.transcriptBase64,
         messageCount: input.messageCount,
         toolCallCount: input.toolCallCount,
         capturedAt: input.capturedAt,
         source: input.source,
+        // New capture signals (cost / velocity / steering). Optional — omitted
+        // (undefined) keys drop out of the JSON body, so older servers ignore them.
+        inputTokens: input.inputTokens,
+        outputTokens: input.outputTokens,
+        cacheTokens: input.cacheTokens,
+        model: input.model ?? undefined,
+        sessionStartedAt: input.sessionStartedAt ?? undefined,
+        interruptCount: input.interruptCount,
+        rejectionCount: input.rejectionCount,
     };
 }
 function hashToken(token) {
@@ -941,6 +1046,137 @@ function installCursorHook() {
     hooks.sessionEnd = filtered;
     fs.writeFileSync(CURSOR_HOOKS_PATH, JSON.stringify(hooksFile, null, 2), "utf8");
 }
+function parseClaudeSteering(content) {
+    let interrupts = 0;
+    let rejections = 0;
+    for (const line of content.split("\n")) {
+        if (!line.trim())
+            continue;
+        // "[Request interrupted by user]" / "...for tool use" — Claude Code markers
+        if (line.includes("[Request interrupted by user"))
+            interrupts++;
+        // Standard Claude Code tool-rejection sentinels in tool_result content
+        if (line.includes("doesn't want to take this action") ||
+            line.includes("user doesn't want to proceed"))
+            rejections++;
+    }
+    return { interrupts, rejections };
+}
+function parseCodexSteering(content) {
+    let interrupts = 0;
+    let rejections = 0;
+    for (const line of content.split("\n")) {
+        if (!line.trim())
+            continue;
+        try {
+            const e = JSON.parse(line);
+            const pt = e?.payload?.type;
+            if (e?.type === "event_msg" && pt === "turn_aborted")
+                interrupts++;
+            if (e?.type === "response_item" && pt === "function_call_output") {
+                const out = String(e.payload?.output ?? "");
+                if (/\b(rejected|denied|not approved)\b/i.test(out))
+                    rejections++;
+            }
+        }
+        catch {
+            // skip malformed
+        }
+    }
+    return { interrupts, rejections };
+}
+function parseSteering(content, mode) {
+    return mode === "codex"
+        ? parseCodexSteering(content)
+        : parseClaudeSteering(content);
+}
+function parseClaudeUsage(content) {
+    // Claude Code logs per-turn usage; sum across the session. `input_tokens` is
+    // already fresh (cache read/creation are reported separately).
+    let inputTokens = 0;
+    let outputTokens = 0;
+    let cacheTokens = 0;
+    let model = null;
+    for (const line of content.split("\n")) {
+        if (!line.trim())
+            continue;
+        try {
+            const e = JSON.parse(line);
+            const m = e?.message;
+            const u = m?.usage;
+            if (u) {
+                inputTokens += u.input_tokens ?? 0;
+                outputTokens += u.output_tokens ?? 0;
+                cacheTokens += (u.cache_creation_input_tokens ?? 0) + (u.cache_read_input_tokens ?? 0);
+            }
+            if (typeof m?.model === "string" && m.model)
+                model = m.model;
+        }
+        catch {
+            // skip malformed
+        }
+    }
+    return { inputTokens, outputTokens, cacheTokens, model };
+}
+function parseCodexUsage(content) {
+    // Codex reports a CUMULATIVE token_count per turn — the last one is the
+    // session total. `input_tokens` includes the cached portion, so subtract it.
+    let model = null;
+    let last = null;
+    for (const line of content.split("\n")) {
+        if (!line.trim())
+            continue;
+        try {
+            const e = JSON.parse(line);
+            if (e?.type === "turn_context" && typeof e.payload?.model === "string" && e.payload.model) {
+                model = e.payload.model;
+            }
+            if (e?.type === "event_msg" && e.payload?.type === "token_count") {
+                const t = e.payload?.info?.total_token_usage;
+                if (t)
+                    last = t;
+            }
+        }
+        catch {
+            // skip malformed
+        }
+    }
+    if (!last)
+        return { inputTokens: 0, outputTokens: 0, cacheTokens: 0, model };
+    const cached = last.cached_input_tokens ?? 0;
+    const input = last.input_tokens ?? 0;
+    return {
+        inputTokens: Math.max(0, input - cached),
+        outputTokens: (last.output_tokens ?? 0) + (last.reasoning_output_tokens ?? 0),
+        cacheTokens: cached,
+        model,
+    };
+}
+function parseUsage(content, mode) {
+    return mode === "codex" ? parseCodexUsage(content) : parseClaudeUsage(content);
+}
+// Lead-time start proxy: the earliest top-level `timestamp` in the transcript.
+// Both Claude Code and Codex stamp every line, so this is mode-agnostic.
+function parseSessionStart(content) {
+    let min = null;
+    for (const line of content.split("\n")) {
+        if (!line.trim())
+            continue;
+        try {
+            const e = JSON.parse(line);
+            const ts = e?.timestamp;
+            if (typeof ts === "string") {
+                const ms = Date.parse(ts);
+                if (!Number.isNaN(ms) && (min === null || ms < min))
+                    min = ms;
+            }
+        }
+        catch {
+            // skip malformed
+        }
+    }
+    return min;
+}
 function parseClaudeCodeStats(content) {
     let messageCount = 0;
     let toolCallCount = 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codiedev",
-  "version": "0.9.6",
+  "version": "0.9.7-beta.1",
   "description": "Connect Claude Code, Codex, Cursor, or VS Code Copilot to Codiedev for org-wide session capture and artifact collaboration",
   "bin": {
     "codiedev": "dist/cli.js",