@echomem/mcp 1.4.9 → 1.4.10

package/dist/hud/adapters.js

@@ -1,8 +1,12 @@
 import fs from "node:fs";
 import path from "node:path";
+import { calculateContextMetrics } from "../context-metrics/calculate.js";
+import { estimateResidentWaste } from "../context-metrics/estimator.js";
+import { parseCodexSession } from "../context-metrics/parse-codex.js";
+import { parseClaudeSession } from "../context-metrics/parse-claude.js";
 import { resolveClaudeProjectsDir, resolveCodexSessionsDir } from "../local-data-paths.js";
-import { homePath, newestFile, readJsonl, walkFiles } from "./fs.js";
-import { bumpTurn, newMetricState, recordEdit, recordRead, recordTool, scoreMetric, shellRead, } from "./metric.js";
+import { homePath, newestFile, resolveClaudeTranscript, walkFiles } from "./fs.js";
+import { BUCKETS, newMetricState, qualityColor, scoreMetric } from "./metric.js";
 export const adapters = {
     codex: {
         client: "codex",
@@ -39,87 +43,7 @@ function findActiveCodex() {
     return newestFile(listCodex());
 }
 function scoreCodex(file) {
-    const state = newMetricState();
-    let ctTokens = 0;
-    let modelContextWindow = 0;
-    let compactMarkers = 0;
-    let patchEdits = 0;
-    let functionOutputs = 0;
-    let largeFunctionOutputs = 0;
-    let lastTool = "";
-    const largeByTool = {};
-    const outputTokensByTool = {};
-    const filesByTool = {};
-    let updatedAt = new Date().toISOString();
-    for (const record of readJsonl(file)) {
-        const top = isRecord(record) ? record : {};
-        const payload = isRecord(top.payload) ? top.payload : {};
-        const payloadType = typeof payload.type === "string" ? payload.type : "";
-        if (typeof top.timestamp === "string")
-            updatedAt = top.timestamp;
-        if (payloadType === "task_started")
-            bumpTurn(state);
-        else if (payloadType === "token_count") {
-            const info = isRecord(payload.info) ? payload.info : {};
-            const last = isRecord(info.last_token_usage) ? info.last_token_usage : {};
-            ctTokens = readNumber(last.input_tokens) || ctTokens;
-            modelContextWindow = readNumber(info.model_context_window) || modelContextWindow;
-        }
-        else if (payloadType === "function_call") {
-            const name = typeof payload.name === "string" ? payload.name : "";
-            recordTool(state, name);
-            if (name)
-                lastTool = name;
-            const args = parseArguments(payload.arguments);
-            const cmd = isRecord(args) && typeof args.cmd === "string" ? args.cmd : "";
-            if ((name === "exec_command" || name === "shell") && cmd) {
-                const read = shellRead(cmd);
-                if (read) {
-                    recordRead(state, read.file, read.start, read.end);
-                    addToolFile(filesByTool, name, read.file);
-                }
-            }
-        }
-        else if (payloadType === "function_call_output") {
-            functionOutputs += 1;
-            const outTool = lastTool || "output";
-            const osize = outputSize(payload.output);
-            // Image outputs (base64 PNGs) cost ~IMG_TOK, not their byte length — Kobe's calibration.
-            const outTok = /image/i.test(outTool) ? 4000 : Math.round(osize / 4);
-            outputTokensByTool[outTool] = (outputTokensByTool[outTool] || 0) + outTok;
-            if (osize > 12_000) {
-                largeFunctionOutputs += 1;
-                largeByTool[outTool] = (largeByTool[outTool] || 0) + 1;
-            }
-        }
-        else if (payloadType === "patch_apply_end") {
-            const changes = isRecord(payload.changes) ? payload.changes : {};
-            for (const changed of Object.keys(changes)) {
-                recordEdit(state, changed);
-                patchEdits += 1;
-            }
-        }
-        else if (payloadType === "context_compacted" || top.type === "compacted") {
-            compactMarkers += 1;
-        }
-    }
-    const score = scoreMetric({
-        client: "codex",
-        sourcePath: file,
-        state,
-        ctTokens,
-        ctSource: "token_count",
-        modelContextWindow,
-        updatedAt,
-        stats: { compactMarkers, patchEdits, functionOutputs, largeFunctionOutputs },
-    });
-    if (Object.keys(largeByTool).length)
-        score.largeOutputsByTool = largeByTool;
-    if (Object.keys(outputTokensByTool).length)
-        score.outputTokensByTool = outputTokensByTool;
-    if (Object.keys(filesByTool).length)
-        score.filesByTool = topFilesByTool(filesByTool);
-    return score;
+    return scoreFromParsed("codex", file, parseCodexSession(fs.readFileSync(file, "utf8")), "token_count");
 }
 function listClaudeCode() {
     const root = resolveClaudeProjectsDir();
@@ -135,6 +59,12 @@ function findActiveClaudeCode() {
 }
 function scoreClaudeCode(file) {
     if (file.includes(`${path.sep}.claude${path.sep}echo-ctx${path.sep}`) || file.endsWith(".json")) {
+        // statusline cache: the transcript is the real data source; the cache only locates it
+        const transcript = resolveClaudeTranscript(file);
+        if (transcript) {
+            const score = scoreClaudeTranscript(transcript, "claude-code", "usage_estimate");
+            return { ...score, sourcePath: file };
+        }
         const raw = JSON.parse(fs.readFileSync(file, "utf8"));
         return normalizeCachedClaudeScore(raw, file, "claude-code", "statusline");
     }
@@ -151,101 +81,64 @@ function scoreClaudeDesktop(file) {
     return scoreClaudeTranscript(file, "claude-desktop", "usage_estimate");
 }
 function scoreClaudeTranscript(file, client, ctSource) {
-    const state = newMetricState();
-    let ctTokens = 0;
-    let updatedAt = new Date().toISOString();
-    const toolById = new Map();
-    const outputTokensByTool = {};
-    const filesByTool = {};
-    for (const record of readJsonl(file)) {
-        const obj = isRecord(record) ? record : {};
-        if (typeof obj.timestamp === "string")
-            updatedAt = obj.timestamp;
-        const message = isRecord(obj.message) ? obj.message : obj;
-        const role = typeof obj.type === "string" ? obj.type : typeof message.role === "string" ? message.role : "";
-        if (role === "assistant")
-            bumpTurn(state);
-        const usage = isRecord(message.usage) ? message.usage : isRecord(obj.usage) ? obj.usage : null;
-        if (usage) {
-            const input = readNumber(usage.input_tokens) || 0;
-            const cacheRead = readNumber(usage.cache_read_input_tokens) || 0;
-            const cacheCreate = readNumber(usage.cache_creation_input_tokens) || 0;
-            ctTokens = input + cacheRead + cacheCreate || ctTokens;
-        }
-        const content = Array.isArray(message.content) ? message.content : [];
-        for (const block of content) {
-            if (!isRecord(block))
-                continue;
-            if (block.type === "tool_use") {
-                const name = typeof block.name === "string" ? block.name : "";
-                if (typeof block.id === "string" && name)
-                    toolById.set(block.id, name);
-                const input = isRecord(block.input) ? block.input : {};
-                recordTool(state, name);
-                if (name === "Read" && typeof input.file_path === "string") {
-                    const start = readNumber(input.offset) || 1;
-                    const end = input.limit ? start + (readNumber(input.limit) || 1) - 1 : 1e9;
-                    recordRead(state, input.file_path, start, end);
-                    addToolFile(filesByTool, name, input.file_path);
-                }
-                else if ((name === "Edit" || name === "Write" || name === "MultiEdit") && typeof input.file_path === "string") {
-                    recordEdit(state, input.file_path);
-                    addToolFile(filesByTool, name, input.file_path);
-                }
-                else if (name === "Bash" && typeof input.command === "string") {
-                    const read = shellRead(input.command);
-                    if (read) {
-                        recordRead(state, read.file, read.start, read.end);
-                        addToolFile(filesByTool, "Bash", read.file);
-                    }
-                }
-            }
-            else if (block.type === "tool_result") {
-                const id = typeof block.tool_use_id === "string" ? block.tool_use_id : "";
-                const tool = toolById.get(id) || "tool";
-                outputTokensByTool[tool] = (outputTokensByTool[tool] || 0) + claudeResultTokens(block.content);
-            }
-        }
-    }
-    const score = scoreMetric({ client, sourcePath: file, state, ctTokens, ctSource, updatedAt });
-    if (Object.keys(outputTokensByTool).length)
-        score.outputTokensByTool = outputTokensByTool;
-    if (Object.keys(filesByTool).length)
-        score.filesByTool = topFilesByTool(filesByTool);
+    return scoreFromParsed(client, file, parseClaudeSession(fs.readFileSync(file, "utf8")), ctSource);
+}
+// Assemble the HUD Score from a parsed ledger: the latest local-live partition supplies resident
+// waste, the shared calculator turns it into pollution/useful/health, and the ledger extras carry
+// the session facts (tools, files, stats) the capsule and panels display.
+function scoreFromParsed(client, file, parsed, ctSource) {
+    const estimate = estimateResidentWaste(parsed.ledger);
+    const empty = {
+        turn: 0, latestInputTokens: 0, wasteTokens: 0, usefulTokens: 0, trackedWasteTokens: 0,
+        dupTokens: 0, refindTokens: 0, deadReadTokens: 0, deadImageTokens: 0, dupCount: 0,
+        turnsSeen: 0, anchorSource: "none",
+    };
+    const e = estimate ?? empty;
+    const modelWindow = parsed.extras.modelContextWindow;
+    const metrics = calculateContextMetrics({
+        latestInputTokens: e.latestInputTokens,
+        modelContextLimitTokens: modelWindow,
+        currentResidentWasteTokens: e.wasteTokens,
+    });
+    const pollution = Math.min(0.95, metrics.noisePct);
+    const pollutionPct = Math.round(pollution * 100);
+    const saturationPct = metrics.contextFullnessPct !== undefined ? Math.round(metrics.contextFullnessPct * 100) : null;
+    const otherDead = Math.max(0, e.wasteTokens - e.dupTokens - e.refindTokens - e.deadReadTokens - e.deadImageTokens);
+    const buckets = {
+        [BUCKETS.rangeRedundant]: { tokens: e.dupTokens, count: e.dupCount },
+        [BUCKETS.staleRead]: { tokens: e.deadReadTokens + otherDead, count: 0 },
+        [BUCKETS.supersededImage]: { tokens: e.deadImageTokens, count: 0 },
+        [BUCKETS.staleToolOutput]: { tokens: e.refindTokens, count: 0 },
+        [BUCKETS.compactionRecoverable]: { tokens: 0, count: 0 },
+    };
+    const reads = parsed.ledger.items.reduce((n, it) => n + (it.kind === "read" ? 1 : 0), 0);
+    const score = {
+        client,
+        sourcePath: file,
+        turn: e.turnsSeen,
+        reads,
+        redundantCount: e.dupCount,
+        usefulPct: Math.round(Math.max(0, Math.min(1, metrics.usefulPct)) * 100),
+        healthScorePct: metrics.healthScorePct,
+        pollutionPct,
+        pollutionTok: e.wasteTokens,
+        ctTokens: e.latestInputTokens,
+        ctSource,
+        modelContextWindow: modelWindow,
+        saturationPct,
+        color: qualityColor(pollutionPct, saturationPct),
+        buckets,
+        honesty: "tracked lower bound",
+        updatedAt: parsed.extras.updatedAt,
+        stats: { ...parsed.extras.stats, trackedWasteTokens: e.trackedWasteTokens, anchorSource: e.anchorSource },
+        tools: parsed.extras.toolCounts,
+    };
+    if (Object.keys(parsed.extras.outputTokensByTool).length)
+        score.outputTokensByTool = parsed.extras.outputTokensByTool;
+    if (Object.keys(parsed.extras.filesByTool).length)
+        score.filesByTool = parsed.extras.filesByTool;
     return score;
 }
-function addToolFile(map, tool, file) {
-    if (!tool || !file)
-        return;
-    const inner = map[tool] || (map[tool] = {});
-    inner[file] = (inner[file] || 0) + 1;
-}
-function topFilesByTool(map) {
-    const out = {};
-    for (const tool of Object.keys(map)) {
-        out[tool] = Object.entries(map[tool]).sort((a, b) => b[1] - a[1]).slice(0, 12).map((entry) => entry[0]);
-    }
-    return out;
-}
-function claudeResultTokens(content) {
-    if (typeof content === "string")
-        return Math.round(outputSize(content) / 4);
-    if (Array.isArray(content)) {
-        let total = 0;
-        for (const block of content) {
-            if (!isRecord(block))
-                continue;
-            if (block.type === "image")
-                total += 4000; // IMG_TOK, not base64 byte-length
-            else if (typeof block.text === "string")
-                total += Math.round(outputSize(block.text) / 4);
-            else
-                total += Math.round(outputSize(block) / 4);
-        }
-        return total;
-    }
-    return Math.round(outputSize(content) / 4);
-}
 function normalizeCachedClaudeScore(raw, file, client, ctSource) {
     const ctTokens = readNumber(raw.ctTokens) || readNumber(raw.size) || readNumber(raw.contextTokens) || 0;
     const pollutionTok = readNumber(raw.pollutionTok) || readNumber(raw.redundantTok) || readNumber(raw.pollution_tokens) || 0;
@@ -265,28 +158,6 @@ function normalizeCachedClaudeScore(raw, file, client, ctSource) {
         updatedAt: new Date().toISOString(),
     });
 }
-function parseArguments(value) {
-    if (!value)
-        return {};
-    if (isRecord(value))
-        return value;
-    if (typeof value !== "string")
-        return {};
-    try {
-        return JSON.parse(value);
-    }
-    catch {
-        return {};
-    }
-}
-function outputSize(value) {
-    if (typeof value === "string")
-        return Buffer.byteLength(value);
-    return Buffer.byteLength(JSON.stringify(value || ""));
-}
 function readNumber(value) {
     return typeof value === "number" && Number.isFinite(value) ? value : undefined;
 }
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}