@echomem/mcp 1.3.2 → 1.4.1

package/dist/forensics.js

@@ -17,7 +17,26 @@
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
+import { execFileSync } from "node:child_process";
 import { eachLine, walk } from "./report.js";
+/** Fast, safe per-repo commit count since a date. Metadata only (no diffs) so it stays cheap;
+ * `rev-list --count` is git-indexed. Any failure (not a repo, git missing, timeout) → 0. */
+function gitCommitCount(cwd, sinceIso) {
+    if (!cwd)
+        return 0;
+    try {
+        const args = ["-C", cwd, "rev-list", "--count"];
+        if (sinceIso)
+            args.push(`--since=${sinceIso}`);
+        args.push("HEAD");
+        const out = execFileSync("git", args, { timeout: 3000, stdio: ["ignore", "pipe", "ignore"] }).toString().trim();
+        const n = parseInt(out, 10);
+        return Number.isFinite(n) ? n : 0;
+    }
+    catch {
+        return 0;
+    }
+}
 // ---------------------------------------------------------------------------
 // Constants (named on purpose — no magic numbers downstream)
 // ---------------------------------------------------------------------------
@@ -85,7 +104,7 @@ function round(value, digits = 1) {
 function tokensFromChars(chars = 0) {
     return Math.round((chars || 0) / CHARS_PER_TOKEN);
 }
-function repoLabel(cwd) {
+export function repoLabel(cwd) {
     if (!cwd)
         return "home";
     const m = cwd.match(/worktrees\/[^/]+\/(.+)$/);
@@ -172,9 +191,11 @@ class Forensics {
         const name = repoLabel(cwd);
         let r = this.repos.get(name);
         if (!r) {
-            r = { name, sessions: new Set(), assistantMessages: 0, cold: 0, cacheWrite: 0, cacheRead: 0, output: 0, reads: 0, rereads: 0, staleRereads: 0, userTimestamps: [] };
+            r = { name, cwd: null, sessions: new Set(), assistantMessages: 0, cold: 0, cacheWrite: 0, cacheRead: 0, output: 0, codexTokens: 0, claudeTokens: 0, reads: 0, rereads: 0, staleRereads: 0, userTimestamps: [], byDay: new Map() };
             this.repos.set(name, r);
         }
+        if (cwd && !r.cwd)
+            r.cwd = cwd; // remember a real working dir for this repo (for the git pass)
         return r;
     }
     fileRecord(p, repo) {
@@ -201,7 +222,7 @@ class Forensics {
             this.allSessionIds.add(id);
     }
     /** assistant-turn token usage (already split into cold/cacheWrite/cacheRead/output). */
-    recordUsage(model, cwd, session, u) {
+    recordUsage(model, cwd, session, u, provider, ms) {
         const m = this.modelBucket(model);
         m.messages += 1;
         m.cold += u.cold;
@@ -217,6 +238,16 @@ class Forensics {
             r.cacheWrite += u.cacheWrite;
             r.cacheRead += u.cacheRead;
             r.output += u.output;
+            // per-repo provider split → drives the city's per-cube colour (Codex green / Claude orange)
+            const turnTokens = u.cold + u.cacheWrite + u.cacheRead + u.output;
+            if (provider === "codex")
+                r.codexTokens += turnTokens;
+            else
+                r.claudeTokens += turnTokens;
+            if (ms != null && turnTokens > 0) {
+                const d = localDay(ms);
+                r.byDay.set(d, (r.byDay.get(d) || 0) + turnTokens);
+            }
         }
     }
     recordEdit(target, cwd) {
@@ -369,9 +400,13 @@ class Forensics {
         const allUserTimestamps = [];
         const dayAttention = new Map();
         const repoOut = [];
+        const sinceIso = this.minTs != null ? new Date(this.minTs).toISOString() : null;
+        let totalCommits = 0;
         for (const repo of this.repos.values()) {
             allUserTimestamps.push(...repo.userTimestamps);
             const wb = this.workBlocks(repo.userTimestamps);
+            const commits = gitCommitCount(repo.cwd, sinceIso); // fast git pass: commits landed in this repo during the scan window
+            totalCommits += commits;
             repoOut.push({
                 name: repo.name, sessions: repo.sessions.size, assistantMessages: repo.assistantMessages,
                 attentionHours: round(wb.attentionHours, 1), activeAttentionDays: wb.activeDays,
@@ -380,6 +415,10 @@ class Forensics {
                 tokens: repo.cold + repo.cacheWrite + repo.cacheRead + repo.output,
                 cost: round(costOf({ cold: repo.cold, cacheWrite: repo.cacheWrite, cacheRead: repo.cacheRead, output: repo.output }, CLAUDE_DEFAULT), 2),
                 reads: repo.reads, rereads: repo.rereads, staleRereads: repo.staleRereads,
+                dominantProvider: repo.codexTokens >= repo.claudeTokens ? "codex" : "claude",
+                codexTokens: repo.codexTokens, claudeTokens: repo.claudeTokens,
+                commits,
+                daily: [...repo.byDay.entries()].sort((a, b) => (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0)),
             });
             for (const b of wb.blocks) {
                 const d = localDay(b.start);
@@ -445,6 +484,7 @@ class Forensics {
                 sessionCount: this.allSessionIds.size,
                 repoCount: repoOut.length,
                 activeDays: activeAttentionDays,
+                totalCommits,
                 totalTokens, totalInputTokens: totalInput, coldInputTokens: cold, cacheWriteTokens: cacheWrite,
                 cacheReadTokens: cacheRead, outputTokens: output,
                 inputPct: totalTokens ? Math.round((totalInput / totalTokens) * 100) : 0,
@@ -493,7 +533,7 @@ function feedClaude(file, eng) {
             eng.recordUsage(o.message.model || "unknown", cwd, session, {
                 cold: u.input_tokens || 0, cacheWrite: u.cache_creation_input_tokens || 0,
                 cacheRead: u.cache_read_input_tokens || 0, output: u.output_tokens || 0,
-            });
+            }, "claude", Number.isFinite(ts) ? ts : undefined);
             const blocks = Array.isArray(o.message.content) ? o.message.content : [];
             for (const b of blocks) {
                 if (b?.type !== "tool_use")
@@ -626,8 +666,9 @@ function replayFile(eng, fe) {
     if (fe.lastTs != null)
         eng.noteTs(fe.lastTs);
     eng.noteSession(fe.session);
+    const provider = fe.source === "codex" ? "codex" : "claude";
     for (const u of fe.usage)
-        eng.recordUsage(u.model, fe.cwd, fe.session, { cold: u.cold, cacheWrite: 0, cacheRead: u.cacheRead, output: u.output });
+        eng.recordUsage(u.model, fe.cwd, fe.session, { cold: u.cold, cacheWrite: 0, cacheRead: u.cacheRead, output: u.output }, provider, fe.firstTs ?? undefined);
     for (const e of fe.ev) {
         if (e.t === "m")
             eng.recordUserMsg(fe.cwd, fe.session, e.ms);

package/dist/migrate.js

@@ -249,13 +249,16 @@ function hasClaudeText(content) {
 function fastSessionInfo(file, source) {
     let conversationKey = `${source === "codex" ? "codex" : "claude-code"}:${sha16(file)}`;
     let hasTextTurn = false;
+    let hasRealKey = false;
     for (const obj of initialJsonObjects(file)) {
         if (!isRecord(obj))
             continue;
         if (source === "codex" && obj.type === "session_meta") {
             const payload = isRecord(obj.payload) ? obj.payload : {};
-            if (typeof payload.id === "string" && payload.id)
+            if (typeof payload.id === "string" && payload.id) {
                 conversationKey = `codex:${payload.id}`;
+                hasRealKey = true;
+            }
             continue;
         }
         if (source === "codex") {
@@ -268,6 +271,7 @@ function fastSessionInfo(file, source) {
         }
         if (source === "claude-code" && typeof obj.sessionId === "string" && obj.sessionId) {
             conversationKey = `claude-code:${obj.sessionId}`;
+            hasRealKey = true;
         }
         if (source === "claude-code" && (obj.type === "user" || obj.type === "assistant")) {
             const message = isRecord(obj.message) ? obj.message : {};
@@ -275,7 +279,7 @@ function fastSessionInfo(file, source) {
                 hasTextTurn = true;
         }
     }
-    return { conversationKey, hasTextTurn };
+    return { conversationKey, hasTextTurn, hasRealKey };
 }
 function fastSessionEntries(opts = {}) {
     const out = [];
@@ -283,14 +287,19 @@ function fastSessionEntries(opts = {}) {
     for (const filePath of walk(codexRoot, (p) => /rollout-.*\.jsonl$/.test(p), () => false)) {
         const stat = statSafe(filePath);
         const info = fastSessionInfo(filePath, "codex");
-        if (info.hasTextTurn)
+        // Include if we found text OR a real session id (big sessions can have their first text turn beyond
+        // the 1MB probe window — gating only on text dropped them entirely; exact discovery refines later).
+        // We require a real key so the fast/exact conversationKey match (no sha16 fallback mismatch).
+        if (info.hasTextTurn || info.hasRealKey)
             out.push({ filePath, source: "codex", conversationKey: info.conversationKey, size: stat.size, mtimeMs: stat.mtimeMs });
     }
     const claudeRoot = opts.claudeRoot ?? path.join(os.homedir(), ".claude", "projects");
     for (const filePath of walk(claudeRoot, (p) => p.endsWith(".jsonl"), (name) => name === "subagents" || name === "workflows")) {
         const stat = statSafe(filePath);
         const info = fastSessionInfo(filePath, "claude-code");
-        if (info.hasTextTurn)
+        // Same rule as codex: include on text OR a real session id so large sessions aren't undercounted,
+        // while keeping the key stable (claude-code sessionId appears on every line, so hasRealKey is reliable).
+        if (info.hasTextTurn || info.hasRealKey)
             out.push({ filePath, source: "claude-code", conversationKey: info.conversationKey, size: stat.size, mtimeMs: stat.mtimeMs });
     }
     return out;
@@ -759,6 +768,39 @@ export function discoverMigratableSessions(opts = {}) {
         claudeCount: sessions.length - codexCount,
     };
 }
+/**
+ * Targeted sizing for extraction start. The fast (stat-only) scan already knows WHICH sessions are
+ * pending — by conversation key + file path — without reading any content. This assembles full content
+ * for ONLY those pending sessions, never the whole local history. That keeps "start extraction" fast even
+ * when a user has gigabytes of already-processed logs (reading all of them just to prepare a few new jobs
+ * is what made sizing hang for 30s+).
+ *
+ * `processedKeys` (from the account import-status check) yields the accurate pending set; without it we
+ * fall back to the local-ledger pending. Either way we read at most the pending files, not the archive.
+ */
+export function discoverPendingSessionsTargeted(processedKeys, opts = {}) {
+    const fast = discoverMigratableFastDiscovery(opts);
+    const filtered = processedKeys ? applyFastAccountImportStatus(fast, processedKeys, opts) : fast;
+    const pending = [];
+    for (const entry of filtered.pending) {
+        const s = entry.source === "codex" ? assembleCodex(entry.filePath) : assembleClaude(entry.filePath);
+        if (s)
+            pending.push(s);
+    }
+    return {
+        sessions: pending,
+        pending,
+        pendingTotal: filtered.pendingTotal,
+        alreadyMigrated: filtered.alreadyMigrated,
+        skippedActive: filtered.skippedActive,
+        limited: filtered.limited,
+        codexCount: filtered.codexCount,
+        claudeCount: filtered.claudeCount,
+        accountChecked: filtered.accountChecked,
+        accountCheckFailed: filtered.accountCheckFailed,
+        accountCheckUnavailable: filtered.accountCheckUnavailable,
+    };
+}
 export function applyAccountImportStatus(discovery, processedKeys, opts = {}) {
     const selectableSessions = opts.includeActive
         ? discovery.sessions