@echomem/mcp 1.4.9 → 1.4.12

package/dist/context-metrics/parse-claude.js

@@ -0,0 +1,227 @@
+// Claude Code / Claude Desktop transcript JSONL -> SessionLedger (+ HUD Score extras), single pass.
+//
+// Structure facts this parser relies on (verified against real ~/.claude/projects transcripts):
+// - assistant lines carry message.usage; resident context = input + cache_read + cache_creation.
+// - tool_use blocks live in assistant messages; their tool_result comes back in user lines.
+// - system lines with subtype "compact_boundary" mark compactions; the replacement summary is a
+//   user line flagged isCompactSummary.
+// - prior-turn thinking blocks are not carried into later payloads (same-turn resident only).
+// - isSidechain lines belong to subagents, not the main thread's context window.
+import { IMG_TOK, R_CODE, R_TEXT, TRUNC_CAP } from "./ledger.js";
+import { addToolFile, baseName, cmdKind, normalizeCommand, readFileArg, readRange, searchPattern, topFilesByTool, } from "./parse-codex.js";
+const READ_TEXT_CAP = 60000;
+const WRITE_CORPUS_CAP = 400000;
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const num = (value) => (typeof value === "number" && Number.isFinite(value) ? value : 0);
+export function parseClaudeSession(text) {
+    let turn = 0;
+    const items = [];
+    const editEpoch = new Map();
+    const compactionTurns = [];
+    const usage = new Map();
+    const commitTurns = new Set();
+    const commitMessages = new Map();
+    const userMessages = new Map();
+    const readChunks = [];
+    const writeChunks = [];
+    const readLenByFile = new Map();
+    let writeCorpusLen = 0;
+    const toolById = new Map();
+    let overheadBase = 0, firstUserTokens = 0, sawFirstUsage = false;
+    let updatedAt = new Date().toISOString();
+    let compactMarkers = 0, patchEdits = 0;
+    const toolCounts = {};
+    const outputTokensByTool = {};
+    const filesByTool = new Map();
+    const push = (item) => { items.push({ ...item, seq: items.length }); };
+    for (const line of text.split(/\n/)) {
+        if (!line.trim())
+            continue;
+        let r;
+        try {
+            r = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (!isRecord(r) || r.isSidechain)
+            continue;
+        if (typeof r.timestamp === "string")
+            updatedAt = r.timestamp;
+        const t = r.type;
+        if (t === "system") {
+            if (r.subtype === "compact_boundary") {
+                compactionTurns.push(turn);
+                compactMarkers += 1;
+            }
+            continue;
+        }
+        if (t !== "user" && t !== "assistant")
+            continue;
+        const msg = isRecord(r.message) ? r.message : {};
+        const content = Array.isArray(msg.content)
+            ? msg.content
+            : typeof msg.content === "string" ? [{ type: "text", text: msg.content }] : [];
+        if (t === "user") {
+            const hasToolResult = content.some((b) => isRecord(b) && b.type === "tool_result");
+            if (r.isCompactSummary) {
+                const txt = content.map((b) => (isRecord(b) && typeof b.text === "string" ? b.text : "")).join("");
+                push({ turn: Math.max(turn, 1), kind: "conv_user", compactSummary: true, tokens: Math.round(txt.length / R_TEXT) });
+                continue;
+            }
+            if (!hasToolResult && r.userType === "external" && !r.isMeta) {
+                const txt = content.filter((b) => isRecord(b) && b.type === "text").map((b) => String(b.text || "")).join("\n");
+                const isCommand = /^<(command-name|local-command|bash-input)/.test(txt.trim());
+                if (txt.trim() && !isCommand) {
+                    turn++;
+                    userMessages.set(turn, txt);
+                    push({ turn, kind: "conv_user", tokens: Math.round(txt.length / R_TEXT) });
+                    if (!firstUserTokens)
+                        firstUserTokens = Math.round(txt.length / R_TEXT);
+                    for (const b of content)
+                        if (isRecord(b) && b.type === "image")
+                            push({ turn, kind: "image", source: "user_reference", target: "user_reference", tokens: IMG_TOK });
+                    continue;
+                }
+            }
+            if (turn === 0)
+                continue;
+            for (const b of content) {
+                if (!isRecord(b) || b.type !== "tool_result")
+                    continue;
+                const reg = toolById.get(String(b.tool_use_id || "")) || { kind: "command", name: "tool" };
+                const blocks = Array.isArray(b.content) ? b.content : typeof b.content === "string" ? [{ type: "text", text: b.content }] : [];
+                let resultText = "";
+                let images = 0;
+                for (const cb of blocks) {
+                    if (!isRecord(cb))
+                        continue;
+                    if (cb.type === "image")
+                        images++;
+                    else if (typeof cb.text === "string")
+                        resultText += cb.text;
+                }
+                for (let i = 0; i < images; i++) {
+                    push({ turn, kind: "image", source: "tool_screenshot", target: reg.name || "tool_image", tokens: IMG_TOK });
+                    outputTokensByTool[reg.name] = (outputTokensByTool[reg.name] || 0) + IMG_TOK;
+                }
+                if (resultText) {
+                    const tok = Math.min(Math.round(resultText.length / R_CODE), TRUNC_CAP);
+                    const kind = reg.kind === "read" ? "read" : reg.kind === "search" ? "search" : "command";
+                    push({ turn, kind, file: reg.file, range: reg.range, normalizedCommand: reg.normalizedCommand, searchPattern: reg.searchPattern, tokens: tok });
+                    outputTokensByTool[reg.name] = (outputTokensByTool[reg.name] || 0) + tok;
+                    if (kind === "read" && reg.file) {
+                        const seen = readLenByFile.get(reg.file) || 0;
+                        if (seen < READ_TEXT_CAP) {
+                            readChunks.push({ file: reg.file, turn, text: resultText.slice(0, READ_TEXT_CAP) });
+                            readLenByFile.set(reg.file, seen + resultText.length);
+                        }
+                    }
+                }
+            }
+            continue;
+        }
+        // assistant line
+        if (turn === 0)
+            continue;
+        const u = msg.usage;
+        if (isRecord(u)) {
+            const total = num(u.input_tokens) + num(u.cache_read_input_tokens) + num(u.cache_creation_input_tokens);
+            if (total > (usage.get(turn) || 0))
+                usage.set(turn, total);
+            if (!sawFirstUsage) {
+                sawFirstUsage = true;
+                overheadBase = Math.max(0, total - firstUserTokens);
+            }
+        }
+        for (const b of content) {
+            if (!isRecord(b))
+                continue;
+            if (b.type === "text" && typeof b.text === "string") {
+                push({ turn, kind: "conv_agent", tokens: Math.round(b.text.length / R_TEXT) });
+            }
+            else if (b.type === "thinking" && typeof b.thinking === "string") {
+                push({ turn, kind: "reasoning", tokens: Math.round(b.thinking.length / R_TEXT) });
+            }
+            else if (b.type === "tool_use") {
+                const name = typeof b.name === "string" ? b.name : "tool";
+                const input = isRecord(b.input) ? b.input : {};
+                toolCounts[name] = (toolCounts[name] || 0) + 1;
+                let reg = { kind: "command", name, normalizedCommand: name };
+                if (name === "Read" && typeof input.file_path === "string") {
+                    const start = num(input.offset) || 1;
+                    const end = input.limit ? start + (num(input.limit) || 1) - 1 : null;
+                    reg = { kind: "read", name, file: baseName(input.file_path), range: end ? [start, end] : null, normalizedCommand: normalizeCommand(`Read ${input.file_path}`) };
+                    addToolFile(filesByTool, name, input.file_path);
+                }
+                else if ((name === "Edit" || name === "Write" || name === "MultiEdit" || name === "NotebookEdit") && typeof input.file_path === "string") {
+                    const body = typeof input.content === "string" ? input.content : typeof input.new_string === "string" ? input.new_string : JSON.stringify(input.edits || "");
+                    const f = baseName(input.file_path);
+                    if (f) {
+                        editEpoch.set(f, [...(editEpoch.get(f) || []), turn]);
+                        patchEdits += 1;
+                        push({ turn, kind: "written", file: f, files: [f], tokens: Math.round(body.length / R_CODE) });
+                        if (writeCorpusLen < WRITE_CORPUS_CAP) {
+                            writeChunks.push({ turn, text: body });
+                            writeCorpusLen += body.length;
+                        }
+                        reg = { kind: "edit", name, file: f };
+                        addToolFile(filesByTool, name, input.file_path);
+                    }
+                }
+                else if (name === "Bash" && typeof input.command === "string") {
+                    const cmd = input.command;
+                    const cm = cmd.match(/commit[^"']*-m\s+["']([^"']+)["']/) || cmd.match(/-m\s+["']([^"']+)["']/);
+                    // unlike the golden codex regex, also accept flag-with-argument forms
+                    // (git -C <path> commit, git -c k=v commit) — a real multi-repo pattern in Claude sessions
+                    if (/git\s+(?:-[cC]\s+\S+\s+|--?[\w-]+(?:=\S+)?\s+)*commit\b/.test(cmd)) {
+                        commitTurns.add(turn);
+                        if (cm)
+                            commitMessages.set(turn, cm[1]);
+                    }
+                    const file = baseName(readFileArg(cmd) || undefined);
+                    reg = { kind: cmdKind(cmd), name, file, range: readRange(cmd), normalizedCommand: normalizeCommand(cmd), searchPattern: searchPattern(cmd) };
+                    if (file)
+                        addToolFile(filesByTool, name, file);
+                }
+                else if ((name === "Grep" || name === "Glob") && (typeof input.pattern === "string" || typeof input.query === "string")) {
+                    const pat = String(input.pattern || input.query || "");
+                    reg = { kind: "search", name, searchPattern: pat.slice(0, 80), normalizedCommand: normalizeCommand(`${name} ${pat}`) };
+                }
+                else if (name === "WebSearch" || name === "WebFetch") {
+                    const q = String(input.query || input.url || "");
+                    reg = { kind: "search", name, searchPattern: q.slice(0, 80), normalizedCommand: normalizeCommand(`${name} ${q}`) };
+                }
+                if (typeof b.id === "string")
+                    toolById.set(b.id, reg);
+            }
+        }
+    }
+    const extras = {
+        updatedAt,
+        modelContextWindow: null,
+        toolCounts,
+        outputTokensByTool,
+        filesByTool: topFilesByTool(filesByTool),
+        stats: { compactMarkers, patchEdits },
+    };
+    return {
+        ledger: {
+            client: "claude",
+            overhead: overheadBase,
+            items,
+            usage,
+            reasoningCalls: [],
+            compactionTurns,
+            editEpoch,
+            commitTurns,
+            commitMessages,
+            userMessages,
+            readChunks,
+            writeChunks,
+            reasoningStyle: "items",
+            hardCompactionDrop: true,
+        },
+        extras,
+    };
+}

package/dist/context-metrics/parse-codex.js

@@ -0,0 +1,276 @@
+// Codex rollout JSONL -> SessionLedger (+ HUD Score extras), single pass.
+// Event handling and token sizing ported 1:1 from the Context Golden Standard parser.
+import { IMG_TOK, R_CODE, R_TEXT, TRUNC_CAP } from "./ledger.js";
+const READ_VERBS = new Set(["cat", "head", "tail", "sed", "nl", "less", "more", "bat", "strings", "view"]);
+const SEARCH_VERBS = new Set(["rg", "grep", "ag", "ack", "find", "fd", "fgrep", "egrep"]);
+const reTok = /Original token count:\s*(\d+)/;
+const READ_TEXT_CAP = 60000;
+const WRITE_CORPUS_CAP = 400000;
+export const baseName = (p) => {
+    if (!p)
+        return undefined;
+    const out = String(p).split("/").pop();
+    return out ? out.toLowerCase() : undefined;
+};
+export function readFileArg(cmd) {
+    const seg = cmd.split("|")[0].split(">")[0].trim();
+    const t = seg.split(/\s+/);
+    const v = (t[0] || "").split("/").pop() || "";
+    if (!READ_VERBS.has(v))
+        return null;
+    for (let i = t.length - 1; i >= 1; i--) {
+        const x = t[i].replace(/^['"]|['"]$/g, "");
+        if (x && !x.startsWith("-") && (x.includes("/") || x.includes(".")))
+            return x;
+    }
+    return null;
+}
+export function readRange(cmd) {
+    const ms = [...cmd.matchAll(/(\d+),(\d+)\s*p/g)];
+    if (!ms.length)
+        return null;
+    return [Math.min(...ms.map((m) => +m[1])), Math.max(...ms.map((m) => +m[2]))];
+}
+export function cmdKind(cmd) {
+    const v = (cmd.split("|")[0].split(">")[0].trim().split(/\s+/)[0] || "").split("/").pop() || "";
+    if (SEARCH_VERBS.has(v))
+        return "search";
+    if (READ_VERBS.has(v))
+        return "read";
+    return "command";
+}
+export function normalizeCommand(cmd) {
+    return cmd.replace(/\s+/g, " ").trim().replace(/["'][^"']{40,}["']/g, '"..."').replace(/\b\d{4,}\b/g, "N").slice(0, 220);
+}
+export function searchPattern(cmd) {
+    const match = cmd.match(/(?:rg|grep|ag|ack)\s+(?:-[^\s]+\s+)*['"]?([^'"\s][^'"]{0,80})/);
+    return match ? match[1].replace(/\s+/g, " ").trim() : normalizeCommand(cmd).slice(0, 80);
+}
+function patchFiles(input) {
+    const files = new Set();
+    for (const line of input.split(/\n/)) {
+        const match = line.match(/^\*\*\* (?:Add|Update|Delete) File: (.+)$/) || line.match(/^\*\*\* Move to: (.+)$/);
+        const file = baseName(match?.[1]);
+        if (file)
+            files.add(file);
+    }
+    return [...files];
+}
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const num = (value) => (typeof value === "number" && Number.isFinite(value) ? value : 0);
+function isImageOut(out) {
+    return Array.isArray(out) && out.some((b) => isRecord(b) && (b.type === "input_image" || "image_url" in b));
+}
+function countImagesDeep(value) {
+    if (!value)
+        return 0;
+    if (typeof value === "string") {
+        return (value.match(/"type"\s*:\s*"input_image"/g) || []).length + (value.match(/data:image\//g) || []).length;
+    }
+    if (Array.isArray(value))
+        return value.reduce((a, x) => a + countImagesDeep(x), 0);
+    if (isRecord(value))
+        return (value.type === "input_image" ? 1 : 0) + Object.values(value).reduce((a, x) => a + countImagesDeep(x), 0);
+    return 0;
+}
+export function addToolFile(map, tool, file) {
+    if (!tool || !file)
+        return;
+    const inner = map.get(tool) || new Map();
+    inner.set(file, (inner.get(file) || 0) + 1);
+    map.set(tool, inner);
+}
+export function topFilesByTool(map) {
+    const out = {};
+    for (const [tool, files] of map) {
+        out[tool] = [...files.entries()].sort((a, b) => b[1] - a[1]).slice(0, 12).map((entry) => entry[0]);
+    }
+    return out;
+}
+export function parseCodexSession(text) {
+    let turn = 0, baseTok = 0, toolsTok = 0, turnCtxTok = 0;
+    const items = [];
+    const editEpoch = new Map();
+    const compactionTurns = [];
+    const usage = new Map();
+    const reasoningCalls = [];
+    const callKind = new Map();
+    const commitTurns = new Set();
+    const commitMessages = new Map();
+    const userMessages = new Map();
+    const readChunks = [];
+    const writeChunks = [];
+    const readLenByFile = new Map();
+    let writeCorpusLen = 0;
+    let updatedAt = new Date().toISOString();
+    let modelContextWindow = 0;
+    let lastTool = "";
+    let compactMarkers = 0, patchEdits = 0, functionOutputs = 0, largeFunctionOutputs = 0;
+    const toolCounts = {};
+    const outputTokensByTool = {};
+    const filesByTool = new Map();
+    const push = (item) => { items.push({ ...item, seq: items.length }); };
+    for (const line of text.split(/\n/)) {
+        if (!line.trim())
+            continue;
+        let r;
+        try {
+            r = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (!isRecord(r))
+            continue;
+        const p = isRecord(r.payload) ? r.payload : {};
+        const pt = typeof p.type === "string" ? p.type : "";
+        if (typeof r.timestamp === "string")
+            updatedAt = r.timestamp;
+        if (r.type === "session_meta" || pt === "session_meta") {
+            const base = isRecord(p.base_instructions) && typeof p.base_instructions.text === "string" ? p.base_instructions.text : "";
+            baseTok = Math.max(baseTok, Math.round(base.length / R_TEXT));
+            toolsTok = Math.max(toolsTok, Math.round(JSON.stringify(p.dynamic_tools || []).length / R_CODE));
+        }
+        else if (r.type === "turn_context" || p.collaboration_mode) {
+            turnCtxTok = Math.max(turnCtxTok, Math.round(JSON.stringify(p).length / R_TEXT));
+        }
+        else if (pt === "user_message") {
+            turn++;
+            const txt = typeof p.message === "string" ? p.message : JSON.stringify(p.message || "");
+            userMessages.set(turn, txt);
+            push({ turn, kind: "conv_user", tokens: Math.round(txt.length / R_TEXT) });
+            const images = (Array.isArray(p.images) ? p.images.length : 0) + (Array.isArray(p.local_images) ? p.local_images.length : 0) + countImagesDeep(p.message || "");
+            for (let i = 0; i < images; i++)
+                push({ turn, kind: "image", source: "user_reference", target: "user_reference", tokens: IMG_TOK });
+        }
+        else if (turn === 0) {
+            continue;
+        }
+        else if (pt === "token_count" && isRecord(p.info)) {
+            const lu = isRecord(p.info.last_token_usage) ? p.info.last_token_usage : {};
+            const input = num(lu.input_tokens);
+            if (input > (usage.get(turn) || 0))
+                usage.set(turn, input);
+            modelContextWindow = num(p.info.model_context_window) || modelContextWindow;
+            if (num(lu.reasoning_output_tokens))
+                reasoningCalls.push({ turn, tokens: num(lu.reasoning_output_tokens) });
+        }
+        else if (pt === "message" && p.role === "developer") {
+            const txt = Array.isArray(p.content) ? p.content.map((b) => (isRecord(b) && typeof b.text === "string" ? b.text : "")).join("") : "";
+            push({ turn, kind: "conv_agent", tokens: Math.round(txt.length / R_TEXT) });
+        }
+        else if (pt === "context_compacted") {
+            compactionTurns.push(turn);
+            compactMarkers += 1;
+        }
+        else if (pt === "agent_message") {
+            push({ turn, kind: "conv_agent", tokens: Math.round(String(p.message || "").length / R_TEXT) });
+        }
+        else if (pt === "patch_apply_end" && isRecord(p.changes)) {
+            for (const f of Object.keys(p.changes)) {
+                const file = baseName(f);
+                if (!file)
+                    continue;
+                editEpoch.set(file, [...(editEpoch.get(file) || []), turn]);
+                patchEdits += 1;
+            }
+        }
+        else if (pt === "custom_tool_call" && typeof p.input === "string") {
+            const files = patchFiles(p.input);
+            push({ turn, kind: "written", file: files.length === 1 ? files[0] : undefined, files, tokens: Math.round(p.input.length / R_CODE) });
+            if (writeCorpusLen < WRITE_CORPUS_CAP) {
+                writeChunks.push({ turn, text: p.input });
+                writeCorpusLen += p.input.length;
+            }
+        }
+        else if (pt === "function_call") {
+            const name = typeof p.name === "string" ? p.name : "";
+            toolCounts[name || "tool"] = (toolCounts[name || "tool"] || 0) + 1;
+            if (name)
+                lastTool = name;
+            const callId = typeof p.call_id === "string" ? p.call_id : "";
+            if (name === "exec_command") {
+                let a = p.arguments;
+                if (typeof a === "string") {
+                    try {
+                        a = JSON.parse(a);
+                    }
+                    catch {
+                        a = { cmd: a };
+                    }
+                }
+                const cmd = isRecord(a) ? String(a.cmd || a.command || "") : "";
+                const cm = cmd.match(/commit[^"']*-m\s+["']([^"']+)["']/) || cmd.match(/-m\s+["']([^"']+)["']/);
+                if (/git\s+(?:-[^\s]+\s+)*commit/.test(cmd)) {
+                    commitTurns.add(turn);
+                    if (cm)
+                        commitMessages.set(turn, cm[1]);
+                }
+                if (callId) {
+                    const file = baseName(readFileArg(cmd) || undefined);
+                    callKind.set(callId, { kind: cmdKind(cmd), file, range: readRange(cmd), normalizedCommand: normalizeCommand(cmd), searchPattern: searchPattern(cmd) });
+                    if (file && (name === "exec_command" || name === "shell"))
+                        addToolFile(filesByTool, name, file);
+                }
+            }
+            else if (callId) {
+                callKind.set(callId, { kind: "command", target: name || "tool_image", imageProducer: name === "view_image" || name === "js", normalizedCommand: name || "tool_image" });
+            }
+        }
+        else if (pt === "function_call_output") {
+            functionOutputs += 1;
+            const callId = typeof p.call_id === "string" ? p.call_id : "";
+            const m = callKind.get(callId) || { kind: "command" };
+            const out = p.output;
+            const imageCount = countImagesDeep(out);
+            const outTool = lastTool || "output";
+            if (isImageOut(out) || (m.imageProducer && typeof out !== "string")) {
+                push({ turn, kind: "image", source: "tool_screenshot", target: m.target || "tool_image", tokens: IMG_TOK });
+                outputTokensByTool[outTool] = (outputTokensByTool[outTool] || 0) + IMG_TOK * Math.max(1, imageCount);
+            }
+            else {
+                const str = typeof out === "string" ? out : JSON.stringify(out || "");
+                const mm = str.match(reTok);
+                const tok = Math.min(mm ? +mm[1] : Math.round(str.length / R_CODE), TRUNC_CAP);
+                const kind = m.kind === "read" ? "read" : m.kind === "search" ? "search" : "command";
+                push({ turn, kind, file: m.file, range: m.range, normalizedCommand: m.normalizedCommand, searchPattern: m.searchPattern, tokens: tok });
+                outputTokensByTool[outTool] = (outputTokensByTool[outTool] || 0) + tok;
+                if (str.length > 12000)
+                    largeFunctionOutputs += 1;
+                if (kind === "read" && m.file) {
+                    const seen = readLenByFile.get(m.file) || 0;
+                    if (seen < READ_TEXT_CAP) {
+                        readChunks.push({ file: m.file, turn, text: str.slice(0, READ_TEXT_CAP) });
+                        readLenByFile.set(m.file, seen + str.length);
+                    }
+                }
+            }
+        }
+    }
+    return {
+        ledger: {
+            client: "codex",
+            overhead: baseTok + toolsTok + turnCtxTok,
+            items,
+            usage,
+            reasoningCalls,
+            compactionTurns,
+            editEpoch,
+            commitTurns,
+            commitMessages,
+            userMessages,
+            readChunks,
+            writeChunks,
+            reasoningStyle: "cumulative",
+            hardCompactionDrop: false,
+        },
+        extras: {
+            updatedAt,
+            modelContextWindow: modelContextWindow || null,
+            toolCounts,
+            outputTokensByTool,
+            filesByTool: topFilesByTool(filesByTool),
+            stats: { compactMarkers, patchEdits, functionOutputs, largeFunctionOutputs },
+        },
+    };
+}