@echomem/mcp 1.4.18 → 1.4.19

package/dist/context-analysis/claude-canonical-adapter.js

@@ -0,0 +1,315 @@
+import fs from "node:fs";
+import path from "node:path";
+/**
+ * Convert a Claude Code transcript into the event vocabulary consumed by the
+ * vendored canonical scorer. The scorer itself remains provider-independent:
+ * this adapter is the only place where Claude's JSONL shape is interpreted.
+ */
+export function normalizeClaudeSessionForCanonical(file) {
+    const rows = readRows(file);
+    const sessionId = firstString(rows, "sessionId") || path.basename(file, ".jsonl");
+    const cwd = firstString(rows, "cwd");
+    const dynamicTools = collectToolNames(rows).map((name) => ({ name }));
+    const inferredOverheadTokens = inferClaudeOverheadTokens(rows);
+    const toolTokens = Math.round(JSON.stringify(dynamicTools).length / 3.3);
+    const instructionTokens = Math.max(0, inferredOverheadTokens - toolTokens);
+    const records = [codexRecord("session_meta", {
+            type: "session_meta",
+            id: sessionId,
+            cwd,
+            base_instructions: { text: "x".repeat(instructionTokens * 4) },
+            dynamic_tools: dynamicTools,
+        }, firstTimestamp(rows))];
+    const calls = new Map();
+    let hasUserTurn = false;
+    for (const row of rows) {
+        const timestamp = stringValue(row.timestamp) || firstTimestamp(rows);
+        const type = stringValue(row.type);
+        if (type === "user") {
+            const message = recordValue(row.message);
+            const content = message.content;
+            if (isToolResultContent(content)) {
+                if (!hasUserTurn)
+                    continue;
+                for (const block of arrayValue(content)) {
+                    if (!isRecord(block) || block.type !== "tool_result")
+                        continue;
+                    const callId = stringValue(block.tool_use_id);
+                    const call = calls.get(callId);
+                    if (!call || call.mode === "write")
+                        continue;
+                    records.push(codexRecord("response_item", {
+                        type: "function_call_output",
+                        call_id: callId,
+                        output: normalizeToolResult(block.content),
+                    }, timestamp));
+                }
+                continue;
+            }
+            const messageText = extractText(content);
+            const imageCount = countImages(content);
+            records.push(codexRecord("event_msg", {
+                type: "user_message",
+                message: messageText,
+                ...(imageCount > 0 ? { images: Array.from({ length: imageCount }, () => ({ type: "input_image" })) } : {}),
+            }, timestamp));
+            hasUserTurn = true;
+            continue;
+        }
+        if (type === "system" && hasUserTurn && (row.subtype === "compact_boundary" || row.subtype === "context_compacted")) {
+            records.push(codexRecord("event_msg", { type: "context_compacted" }, timestamp));
+            continue;
+        }
+        if (type !== "assistant" || !hasUserTurn)
+            continue;
+        const message = recordValue(row.message);
+        const usage = recordValue(message.usage);
+        const inputTokens = claudeOfficialInputTokens(usage);
+        if (inputTokens > 0) {
+            records.push(codexRecord("event_msg", {
+                type: "token_count",
+                info: {
+                    last_token_usage: {
+                        input_tokens: inputTokens,
+                        cached_input_tokens: numberValue(usage.cache_read_input_tokens),
+                        output_tokens: numberValue(usage.output_tokens),
+                    },
+                },
+            }, timestamp));
+        }
+        for (const block of arrayValue(message.content)) {
+            if (!isRecord(block))
+                continue;
+            if (block.type === "thinking") {
+                records.push(codexRecord("response_item", { type: "reasoning" }, timestamp));
+                continue;
+            }
+            if (block.type === "text") {
+                const text = stringValue(block.text);
+                if (text)
+                    records.push(codexRecord("event_msg", { type: "agent_message", message: text }, timestamp));
+                continue;
+            }
+            if (block.type !== "tool_use")
+                continue;
+            const normalized = normalizeToolUse(block);
+            if (!normalized)
+                continue;
+            calls.set(normalized.call.callId, normalized.call);
+            records.push(...normalized.records.map((record) => ({ ...record, timestamp })));
+        }
+    }
+    return {
+        jsonl: `${records.map((record) => JSON.stringify(record)).join("\n")}\n`,
+        sessionId,
+        cwd,
+        inferredOverheadTokens,
+    };
+}
+function normalizeToolUse(block) {
+    const name = stringValue(block.name);
+    const callId = stringValue(block.id);
+    if (!name || !callId)
+        return null;
+    const input = recordValue(block.input);
+    if (/^(Write|Edit|MultiEdit|NotebookEdit)$/i.test(name)) {
+        const file = stringValue(input.file_path) || stringValue(input.notebook_path) || stringValue(input.path) || "unknown";
+        const patch = syntheticPatch(name, file, input);
+        return {
+            call: { mode: "write", callId },
+            records: [
+                codexRecord("response_item", { type: "custom_tool_call", name: "apply_patch", call_id: callId, input: patch }, ""),
+                codexRecord("event_msg", { type: "patch_apply_end", changes: { [file]: { kind: /^Write$/i.test(name) ? "added" : "modified" } } }, ""),
+            ],
+        };
+    }
+    const command = commandForClaudeTool(name, input);
+    if (command) {
+        return {
+            call: { mode: "function", callId },
+            records: [codexRecord("response_item", {
+                    type: "function_call",
+                    name: "exec_command",
+                    call_id: callId,
+                    arguments: JSON.stringify({ cmd: command }),
+                }, "")],
+        };
+    }
+    return {
+        call: { mode: "function", callId },
+        records: [codexRecord("response_item", {
+                type: "function_call",
+                name: visualToolName(name) ? "view_image" : name,
+                call_id: callId,
+                arguments: JSON.stringify(input),
+            }, "")],
+    };
+}
+function commandForClaudeTool(name, input) {
+    if (/^Bash$/i.test(name))
+        return stringValue(input.command) || "bash";
+    if (/^(Read|NotebookRead)$/i.test(name)) {
+        const file = stringValue(input.file_path) || stringValue(input.notebook_path) || stringValue(input.path) || "unknown";
+        const offset = Math.max(1, numberValue(input.offset) || 1);
+        const limit = Math.max(1, numberValue(input.limit) || 2000);
+        return `sed -n '${offset},${offset + limit - 1}p' ${quoteArg(file)}`;
+    }
+    if (/^Grep$/i.test(name)) {
+        const pattern = stringValue(input.pattern) || stringValue(input.query) || "unknown";
+        const target = stringValue(input.path) || ".";
+        return `rg -n ${quoteArg(pattern)} ${quoteArg(target)}`;
+    }
+    if (/^Glob$/i.test(name))
+        return `rg --files ${quoteArg(stringValue(input.path) || ".")}`;
+    if (/^(LS|ListFiles)$/i.test(name))
+        return `ls ${quoteArg(stringValue(input.path) || ".")}`;
+    if (/^(WebSearch|WebFetch)$/i.test(name)) {
+        const query = stringValue(input.query) || stringValue(input.url) || "web";
+        return `rg ${quoteArg(`web:${query}`)} web`;
+    }
+    return null;
+}
+function syntheticPatch(name, file, input) {
+    const chunks = [];
+    const content = stringValue(input.content) || stringValue(input.new_string) || stringValue(input.new_source);
+    if (content)
+        chunks.push(content);
+    for (const edit of arrayValue(input.edits)) {
+        if (!isRecord(edit))
+            continue;
+        const value = stringValue(edit.new_string) || stringValue(edit.new_source) || stringValue(edit.content);
+        if (value)
+            chunks.push(value);
+    }
+    const body = chunks.join("\n") || `${name} ${file}`;
+    return `*** Begin Patch\n*** ${/^Write$/i.test(name) ? "Add" : "Update"} File: ${file}\n@@\n${body}\n*** End Patch\n`;
+}
+function inferClaudeOverheadTokens(rows) {
+    let firstUserTokens = 0;
+    let firstUserImages = 0;
+    let awaitingUsage = false;
+    for (const row of rows) {
+        const type = stringValue(row.type);
+        if (type === "user" && !isToolResultContent(recordValue(row.message).content)) {
+            if (!awaitingUsage) {
+                const content = recordValue(row.message).content;
+                firstUserTokens = Math.round(extractText(content).length / 4);
+                firstUserImages = countImages(content);
+                awaitingUsage = true;
+            }
+            continue;
+        }
+        if (type !== "assistant" || !awaitingUsage)
+            continue;
+        const total = claudeOfficialInputTokens(recordValue(recordValue(row.message).usage));
+        if (total <= 0)
+            continue;
+        const structureFloor = Math.round(total * 0.03);
+        return Math.max(0, total - firstUserTokens - firstUserImages * 4000 - structureFloor);
+    }
+    return 0;
+}
+function claudeOfficialInputTokens(usage) {
+    return numberValue(usage.input_tokens)
+        + numberValue(usage.cache_read_input_tokens)
+        + numberValue(usage.cache_creation_input_tokens);
+}
+function normalizeToolResult(value) {
+    if (typeof value === "string")
+        return value;
+    const output = [];
+    for (const block of arrayValue(value)) {
+        if (!isRecord(block))
+            continue;
+        if (block.type === "text" && typeof block.text === "string")
+            output.push(block.text);
+        else if (block.type === "image")
+            output.push({ type: "input_image" });
+        else
+            output.push(block);
+    }
+    return output.length === 1 ? output[0] : output;
+}
+function extractText(value) {
+    if (typeof value === "string")
+        return value;
+    return arrayValue(value).map((block) => {
+        if (!isRecord(block))
+            return "";
+        if (typeof block.text === "string")
+            return block.text;
+        return "";
+    }).filter(Boolean).join("\n");
+}
+function countImages(value) {
+    if (!value)
+        return 0;
+    if (Array.isArray(value))
+        return value.reduce((sum, item) => sum + countImages(item), 0);
+    if (!isRecord(value))
+        return 0;
+    const own = value.type === "image" || value.type === "input_image" ? 1 : 0;
+    return own + Object.values(value).reduce((sum, item) => sum + countImages(item), 0);
+}
+function collectToolNames(rows) {
+    const names = new Set();
+    for (const row of rows) {
+        for (const block of arrayValue(recordValue(row.message).content)) {
+            if (isRecord(block) && block.type === "tool_use" && typeof block.name === "string")
+                names.add(block.name);
+        }
+    }
+    return [...names].sort();
+}
+function readRows(file) {
+    const rows = [];
+    for (const line of fs.readFileSync(file, "utf8").split(/\n/)) {
+        if (!line.trim())
+            continue;
+        try {
+            const value = JSON.parse(line);
+            if (isRecord(value))
+                rows.push(value);
+        }
+        catch {
+            // Claude may leave a partial final line while a session is active.
+        }
+    }
+    return rows;
+}
+function firstString(rows, key) {
+    for (const row of rows)
+        if (typeof row[key] === "string" && row[key])
+            return row[key];
+    return null;
+}
+function firstTimestamp(rows) {
+    return firstString(rows, "timestamp") || new Date(0).toISOString();
+}
+function codexRecord(type, payload, timestamp) {
+    return { timestamp, type, payload };
+}
+function isToolResultContent(value) {
+    return arrayValue(value).some((block) => isRecord(block) && block.type === "tool_result");
+}
+function visualToolName(name) {
+    return /screenshot|image|browser|playwright/i.test(name);
+}
+function quoteArg(value) {
+    return `"${value.replace(/["\\]/g, "_")}"`;
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function recordValue(value) {
+    return isRecord(value) ? value : {};
+}
+function arrayValue(value) {
+    return Array.isArray(value) ? value : [];
+}
+function stringValue(value) {
+    return typeof value === "string" ? value : "";
+}
+function numberValue(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}