@mmmjk/context-bridge 0.1.0

package/dist/src/adapters/claude-code/ingest.js

@@ -0,0 +1,142 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { isoNowZ, uuid7Str } from "../../canonical/ids.js";
+import { createSession } from "../../canonical/schema.js";
+import { ccToolToCanonical, translateArgs } from "./tool-map.js";
+import { readJsonl } from "../../utils/jsonl.js";
+const DROPPED_TYPES = new Set(["permission-mode", "file-history-snapshot", "last-prompt", "ai-title", "custom-title", "agent-name", "queue-operation"]);
+export function ingest(jsonlPath, opts = {}) {
+    const rows = readJsonl(jsonlPath);
+    if (!rows.length)
+        throw new Error(`Empty or unreadable CC session: ${jsonlPath}`);
+    const header = extractHeader(rows);
+    const moments = rows.flatMap((row) => translateLine(row, jsonlPath)).sort((a, b) => a.ts.localeCompare(b.ts));
+    inferAssistantPhase(moments);
+    const subagent_transcripts = {};
+    const subagent_meta = {};
+    if (opts.follow_subagents !== false) {
+        const sessDir = path.join(path.dirname(jsonlPath), path.basename(jsonlPath, ".jsonl"), "subagents");
+        if (existsSync(sessDir)) {
+            for (const file of readdirSync(sessDir).filter((f) => f.startsWith("agent-") && f.endsWith(".jsonl"))) {
+                const agentId = file.replace(/^agent-/, "").replace(/\.jsonl$/, "");
+                const full = path.join(sessDir, file);
+                const sub = readJsonl(full).flatMap((row) => translateLine(row, full).map((m) => ({ ...m, agent_scope: `subagent:${agentId}` }))).sort((a, b) => a.ts.localeCompare(b.ts));
+                inferAssistantPhase(sub);
+                subagent_transcripts[agentId] = sub;
+                const metaPath = full.replace(/\.jsonl$/, ".meta.json");
+                if (existsSync(metaPath)) {
+                    try {
+                        subagent_meta[agentId] = JSON.parse(readFileSync(metaPath, "utf8"));
+                    }
+                    catch {
+                        subagent_meta[agentId] = {};
+                    }
+                }
+            }
+        }
+    }
+    return createSession({
+        id: uuid7Str(),
+        source_harness: "claude-code",
+        source_session_id: String(header.session_id ?? path.basename(jsonlPath, ".jsonl")),
+        source_session_path: jsonlPath,
+        cwd: String(header.cwd ?? process.cwd()),
+        git: { branch: header.git_branch, commit: null, repo_url: null },
+        model_hint: { provider: "anthropic", name: header.model, reasoning_effort: null },
+        started_at: String(header.started_at),
+        ended_at: header.ended_at ? String(header.ended_at) : null,
+        moments,
+        subagent_transcripts,
+        source_metadata: { claude_code: { version: header.version, userType: header.user_type, entrypoint: header.entrypoint, custom_title: header.custom_title, agent_name: header.agent_name, subagent_meta } },
+    });
+}
+function extractHeader(rows) {
+    const h = {};
+    for (const row of rows) {
+        if (row.sessionId && !h.session_id)
+            h.session_id = row.sessionId;
+        if (row.cwd && !h.cwd)
+            h.cwd = row.cwd;
+        if (row.gitBranch && !h.git_branch)
+            h.git_branch = row.gitBranch;
+        if (row.version && !h.version)
+            h.version = row.version;
+        if (row.userType && !h.user_type)
+            h.user_type = row.userType;
+        if (row.entrypoint && !h.entrypoint)
+            h.entrypoint = row.entrypoint;
+        if (row.type === "custom-title" && row.customTitle)
+            h.custom_title = row.customTitle;
+        if (row.type === "agent-name" && row.agentName)
+            h.agent_name = row.agentName;
+        const msg = row.message;
+        if (msg?.model && !h.model)
+            h.model = msg.model;
+    }
+    const timestamps = rows.map((r) => r.timestamp).filter(Boolean).map(String);
+    h.started_at = timestamps.length ? timestamps.sort()[0] : isoNowZ();
+    h.ended_at = timestamps.length ? timestamps.sort()[timestamps.length - 1] : null;
+    return h;
+}
+function translateLine(row, srcFile) {
+    const type = row.type;
+    if (DROPPED_TYPES.has(String(type)))
+        return [];
+    const ts = String(row.timestamp ?? isoNowZ());
+    const source_ref = { file: srcFile, uuid: row.uuid };
+    if (type === "user")
+        return translateUser(row, ts, source_ref);
+    if (type === "assistant")
+        return translateAssistant(row, ts, source_ref);
+    if (type === "attachment")
+        return [{ kind: "attachment", ts, source_ref, subtype: String(row.attachment?.type ?? "unknown"), data: row.attachment }];
+    return [];
+}
+function translateUser(row, ts, source_ref) {
+    const msg = row.message;
+    const content = msg?.content;
+    const prompt_id = row.promptId ? String(row.promptId) : null;
+    if (typeof content === "string")
+        return [{ kind: "user_text", ts, source_ref, text: content, prompt_id }];
+    if (Array.isArray(content)) {
+        const out = [];
+        for (const block of content) {
+            if (block.type === "text")
+                out.push({ kind: "user_text", ts, source_ref, text: String(block.text ?? ""), prompt_id });
+            if (block.type === "tool_result")
+                out.push({ kind: "tool_result", ts, source_ref, call_id: String(block.tool_use_id ?? ""), output_text: typeof block.content === "string" ? block.content : JSON.stringify(block.content ?? ""), is_error: Boolean(block.is_error) });
+        }
+        return out;
+    }
+    return [];
+}
+function translateAssistant(row, ts, source_ref) {
+    const msg = row.message;
+    const content = msg?.content;
+    const out = [];
+    if (!Array.isArray(content))
+        return out;
+    for (const block of content) {
+        if (block.type === "text")
+            out.push({ kind: "assistant_text", ts, source_ref, text: String(block.text ?? ""), phase: null });
+        if (block.type === "tool_use") {
+            const tool = ccToolToCanonical(String(block.name ?? ""));
+            out.push({ kind: "tool_call", ts, source_ref, tool, call_id: String(block.id ?? ""), args: translateArgs(tool, block.input ?? {}), wire_native: { harness: "claude-code", name: block.name, input: block.input } });
+        }
+    }
+    return out;
+}
+function inferAssistantPhase(moments) {
+    for (let i = 0; i < moments.length; i++) {
+        const m = moments[i];
+        if (m.kind !== "assistant_text")
+            continue;
+        let end = moments.length;
+        for (let j = i + 1; j < moments.length; j++)
+            if (moments[j].kind === "user_text") {
+                end = j;
+                break;
+            }
+        m.phase = moments.slice(i + 1, end).some((x) => x.kind === "tool_call") ? "commentary" : "final_answer";
+    }
+}

package/dist/src/adapters/claude-code/render.js

@@ -0,0 +1,95 @@
+import { existsSync, mkdirSync, readFileSync, utimesSync } from "node:fs";
+import path from "node:path";
+import { homedir } from "node:os";
+import { uuid4Str } from "../../canonical/ids.js";
+import { writeJsonl } from "../../utils/jsonl.js";
+export let CC_PROJECTS = path.join(homedir(), ".claude", "projects");
+export function setCcProjects(p) { CC_PROJECTS = p; }
+export function encodeCwd(cwd) {
+    let resolved = path.resolve(cwd).normalize("NFC");
+    return resolved.replace(/\//g, "-");
+}
+export function render(session, opts = {}) {
+    const sessId = opts.session_id ?? uuid4Str();
+    const root = opts.target_dir ?? CC_PROJECTS;
+    const outDir = path.join(root, encodeCwd(session.cwd));
+    const outPath = path.join(outDir, `${sessId}.jsonl`);
+    if (existsSync(outPath) && !isAgentBridgeCc(outPath))
+        throw new Error(`Refusing to overwrite real Claude Code session: ${outPath}`);
+    const lines = [];
+    if (!opts.copy_mode)
+        lines.push({ type: "context-bridge-meta", sessionId: sessId, source_harness: session.source_harness, originator: "context-bridge" });
+    const title = makeTitle(session, opts.title_prefix);
+    if (title)
+        lines.push({ type: "custom-title", customTitle: title, sessionId: sessId });
+    let parent = null;
+    for (const moment of session.moments) {
+        for (const row of renderMoment(moment, session, sessId, parent, opts.cc_version ?? "2.1.107")) {
+            lines.push(row);
+            parent = String(row.uuid ?? parent);
+        }
+    }
+    mkdirSync(outDir, { recursive: true });
+    writeJsonl(outPath, lines);
+    backdateMtime(outPath, session.ended_at ?? session.started_at);
+    return { session_id: sessId, primary_path: outPath, resume_command: `claude --resume ${sessId} -p "<your prompt>"`, warnings: [] };
+}
+function renderMoment(moment, session, sessId, parent, version) {
+    const base = { parentUuid: parent, isSidechain: false, uuid: uuid4Str(), timestamp: moment.ts, userType: "external", entrypoint: "cli", cwd: session.cwd, sessionId: sessId, version, gitBranch: session.git?.branch ?? "HEAD" };
+    if (moment.kind === "user_text")
+        return [{ ...base, type: "user", message: { role: "user", content: moment.text } }];
+    if (moment.kind === "assistant_text")
+        return [{ ...base, type: "assistant", message: { content: [{ text: moment.text, type: "text" }], id: `msg_${uuid4Str().replaceAll("-", "").slice(0, 32)}`, role: "assistant", stop_reason: "end_turn", type: "message" } }];
+    if (moment.kind === "tool_call") {
+        const [name, input] = canonicalToCcTool(moment);
+        return [{ ...base, type: "assistant", message: { content: [{ id: moment.call_id, input, name, type: "tool_use" }], id: `msg_${uuid4Str().replaceAll("-", "").slice(0, 32)}`, role: "assistant", stop_reason: "tool_use", type: "message" } }];
+    }
+    if (moment.kind === "tool_result")
+        return [{ ...base, type: "user", message: { role: "user", content: [{ tool_use_id: moment.call_id, type: "tool_result", content: moment.output_text ?? "", is_error: moment.is_error ?? false }] } }];
+    if (moment.kind === "attachment")
+        return [{ ...base, type: "attachment", attachment: { type: moment.subtype, ...(moment.data ?? {}) } }];
+    return [];
+}
+function canonicalToCcTool(call) {
+    const args = call.args ?? {};
+    if (call.wire_native?.harness === "claude-code")
+        return [String(call.wire_native.name), call.wire_native.input ?? args];
+    if (call.tool === "shell")
+        return ["Bash", { command: args.command ?? "" }];
+    if (call.tool === "read_file")
+        return ["Read", { file_path: args.path ?? "" }];
+    if (call.tool === "write_file")
+        return ["Write", { file_path: args.path ?? "", content: args.content ?? "" }];
+    if (call.tool === "edit_file")
+        return ["Edit", { file_path: args.path ?? "", old_string: args.old ?? "", new_string: args.new ?? "", replace_all: args.replace_all ?? false }];
+    if (call.tool === "multi_edit_file")
+        return ["MultiEdit", { file_path: args.path ?? "", edits: args.edits ?? [] }];
+    if (call.tool === "delete_file")
+        return ["Delete", { file_path: args.path ?? "" }];
+    if (call.tool === "move_file")
+        return ["Move", { source: args.source ?? args.from ?? "", destination: args.destination ?? args.to ?? "" }];
+    if (call.tool === "search_text")
+        return ["Grep", { pattern: args.pattern ?? "", path: args.path ?? "." }];
+    if (call.tool === "find_files")
+        return ["Glob", { pattern: args.pattern ?? "*", path: args.path ?? "." }];
+    return ["Bash", { command: `echo '(translated unknown tool: ${call.tool})'` }];
+}
+function makeTitle(session, prefix) {
+    const custom = session.source_metadata?.codex?.thread_name;
+    const body = typeof custom === "string" && custom ? custom : session.moments.find((m) => m.kind === "user_text")?.text.slice(0, 80);
+    return body ? `${prefix ?? ""}${body}` : null;
+}
+function isAgentBridgeCc(p) {
+    try {
+        const head = readFileSync(p, "utf8").slice(0, 4096);
+        return head.includes('"customTitle":"[from ') || head.includes('"customTitle": "[from ');
+    }
+    catch {
+        return false;
+    }
+}
+function backdateMtime(p, iso) {
+    const d = new Date(iso);
+    if (!Number.isNaN(d.getTime()))
+        utimesSync(p, d, d);
+}

package/dist/src/adapters/claude-code/tool-map.js

@@ -0,0 +1,52 @@
+export const CC_TO_CANONICAL = {
+    Bash: "shell",
+    Read: "read_file",
+    Write: "write_file",
+    Edit: "edit_file",
+    MultiEdit: "multi_edit_file",
+    Delete: "delete_file",
+    Move: "move_file",
+    Glob: "find_files",
+    Grep: "search_text",
+    WebSearch: "web_search",
+    Task: "subagent_dispatch",
+    TodoWrite: "update_plan",
+};
+export function ccToolToCanonical(name) {
+    return CC_TO_CANONICAL[name] ?? name;
+}
+export function translateArgs(canonicalName, ccInput) {
+    switch (canonicalName) {
+        case "shell":
+            return { command: ccInput.command ?? "" };
+        case "read_file":
+            return { path: ccInput.file_path ?? ccInput.path ?? "" };
+        case "write_file":
+            return { path: ccInput.file_path ?? ccInput.path ?? "", content: ccInput.content ?? "" };
+        case "edit_file":
+            return {
+                path: ccInput.file_path ?? ccInput.path ?? "",
+                old: ccInput.old_string ?? ccInput.old ?? "",
+                new: ccInput.new_string ?? ccInput.new ?? "",
+                replace_all: ccInput.replace_all ?? false,
+            };
+        case "multi_edit_file":
+            return { path: ccInput.file_path ?? ccInput.path ?? "", edits: ccInput.edits ?? [] };
+        case "delete_file":
+            return { path: ccInput.file_path ?? ccInput.path ?? "" };
+        case "move_file":
+            return { source: ccInput.source ?? ccInput.old_path ?? "", destination: ccInput.destination ?? ccInput.new_path ?? "" };
+        case "find_files":
+            return { pattern: ccInput.pattern ?? "*", path: ccInput.path ?? "." };
+        case "search_text":
+            return { pattern: ccInput.pattern ?? "", path: ccInput.path ?? "." };
+        case "web_search":
+            return { query: ccInput.query ?? "" };
+        case "subagent_dispatch":
+            return { agent_type: ccInput.subagent_type ?? "general-purpose", task: ccInput.description ?? "", prompt: ccInput.prompt ?? "" };
+        case "update_plan":
+            return { items: ccInput.todos ?? [] };
+        default:
+            return { ...ccInput };
+    }
+}

package/dist/src/adapters/codex/apply-patch-parser.js

@@ -0,0 +1,61 @@
+export class ApplyPatchParseError extends Error {
+}
+export function parseApplyPatch(patchText) {
+    const lines = patchText.split(/\r?\n/);
+    const start = lines.findIndex((l) => l.trim() === "*** Begin Patch");
+    const end = lines.findIndex((l) => l.trim() === "*** End Patch");
+    if (start < 0 || end < 0)
+        throw new ApplyPatchParseError("missing *** Begin Patch / *** End Patch envelope");
+    const body = lines.slice(start + 1, end);
+    const ops = [];
+    let i = 0;
+    while (i < body.length) {
+        const line = body[i];
+        if (line.startsWith("*** Add File: ")) {
+            const filePath = line.slice("*** Add File: ".length);
+            const add_lines = [];
+            i++;
+            while (i < body.length && !body[i].startsWith("*** ")) {
+                if (body[i].startsWith("+"))
+                    add_lines.push(body[i].slice(1));
+                i++;
+            }
+            ops.push({ kind: "add", path: filePath, add_lines });
+        }
+        else if (line.startsWith("*** Delete File: ")) {
+            ops.push({ kind: "delete", path: line.slice("*** Delete File: ".length) });
+            i++;
+        }
+        else if (line.startsWith("*** Update File: ")) {
+            const filePath = line.slice("*** Update File: ".length);
+            let move_to;
+            i++;
+            if (i < body.length && body[i].startsWith("*** Move to: ")) {
+                move_to = body[i].slice("*** Move to: ".length);
+                i++;
+            }
+            const hunks = [];
+            let cur;
+            while (i < body.length && !body[i].startsWith("*** ")) {
+                const l = body[i];
+                if (l.startsWith("@@")) {
+                    if (cur)
+                        hunks.push(cur);
+                    cur = { header: l.slice(2).trim() || undefined, lines: [] };
+                }
+                else if (l && [" ", "+", "-"].includes(l[0])) {
+                    cur ??= { lines: [] };
+                    cur.lines.push({ op: l[0], text: l.slice(1) });
+                }
+                i++;
+            }
+            if (cur)
+                hunks.push(cur);
+            ops.push({ kind: "update", path: filePath, move_to, hunks });
+        }
+        else {
+            i++;
+        }
+    }
+    return ops;
+}

package/dist/src/adapters/codex/apply-patch.js

@@ -0,0 +1,163 @@
+import path from "node:path";
+export class FileStateCache {
+    contents = new Map();
+    get(filePath) {
+        return this.contents.get(filePath);
+    }
+    set(filePath, content) {
+        this.contents.set(filePath, content);
+    }
+    drop(filePath) {
+        this.contents.delete(filePath);
+    }
+    rename(oldPath, newPath) {
+        if (this.contents.has(oldPath)) {
+            this.contents.set(newPath, this.contents.get(oldPath) ?? "");
+            this.contents.delete(oldPath);
+        }
+    }
+    clone() {
+        const c = new FileStateCache();
+        c.contents = new Map(this.contents);
+        return c;
+    }
+}
+export function stripCatN(text) {
+    const suffix = text.endsWith("\n") ? "\n" : "";
+    return text
+        .split(/\r?\n/)
+        .filter((_, i, arr) => !(i === arr.length - 1 && arr[i] === ""))
+        .map((line) => line.replace(/^\s*\d+\t/, ""))
+        .join("\n") + suffix;
+}
+export function buildFileState(moments) {
+    const snapshots = {};
+    const cache = new FileStateCache();
+    const pendingReads = new Map();
+    for (const m of moments) {
+        if (m.kind === "tool_call") {
+            const args = m.args ?? {};
+            if (m.tool === "read_file")
+                pendingReads.set(m.call_id, String(args.path ?? ""));
+            if (["write_file", "edit_file", "multi_edit_file", "delete_file", "move_file"].includes(m.tool)) {
+                snapshots[m.call_id] = cache.clone();
+                applyEditToCache(cache, m);
+            }
+        }
+        else if (m.kind === "tool_result" && pendingReads.has(m.call_id)) {
+            cache.set(pendingReads.get(m.call_id) ?? "", stripCatN(m.output_text ?? ""));
+            pendingReads.delete(m.call_id);
+        }
+    }
+    return snapshots;
+}
+function applyEditToCache(cache, call) {
+    const args = call.args ?? {};
+    const filePath = String(args.path ?? "");
+    if (!filePath)
+        return;
+    if (call.tool === "write_file")
+        cache.set(filePath, String(args.content ?? ""));
+    if (call.tool === "edit_file") {
+        const cur = cache.get(filePath);
+        const oldText = String(args.old ?? "");
+        const newText = String(args.new ?? "");
+        if (cur !== undefined && oldText) {
+            cache.set(filePath, args.replace_all ? cur.split(oldText).join(newText) : cur.replace(oldText, newText));
+        }
+    }
+    if (call.tool === "multi_edit_file") {
+        let cur = cache.get(filePath);
+        if (cur !== undefined) {
+            for (const ed of args.edits ?? []) {
+                cur = cur.replace(String(ed.old ?? ed.old_string ?? ""), String(ed.new ?? ed.new_string ?? ""));
+            }
+            cache.set(filePath, cur);
+        }
+    }
+    if (call.tool === "delete_file")
+        cache.drop(filePath);
+    if (call.tool === "move_file")
+        cache.rename(String(args.from ?? args.source ?? filePath), String(args.to ?? args.destination ?? filePath));
+}
+export function toRelative(absPath, cwd) {
+    const rel = path.relative(path.resolve(cwd), path.resolve(absPath));
+    return rel && !rel.startsWith("..") && !path.isAbsolute(rel) ? rel : absPath;
+}
+export function composePatchEnvelope(body) {
+    return `*** Begin Patch\n${body.endsWith("\n") ? body : `${body}\n`}*** End Patch\n`;
+}
+function composeAddFile(relPath, content) {
+    const body = content.split(/\r?\n/).filter((line, i, arr) => !(i === arr.length - 1 && line === "")).map((line) => `+${line}`).join("\n");
+    return `*** Add File: ${relPath}\n${body}${body ? "\n" : ""}`;
+}
+function composeDeleteFile(relPath) {
+    return `*** Delete File: ${relPath}\n`;
+}
+function composeUpdateFile(relPath, hunks, moveTo) {
+    const lines = [`*** Update File: ${relPath}`];
+    if (moveTo)
+        lines.push(`*** Move to: ${moveTo}`);
+    for (const [ctx, removed, added] of hunks) {
+        lines.push("@@");
+        for (const c of ctx.slice(-3))
+            lines.push(` ${c}`);
+        for (const r of removed)
+            lines.push(`-${r}`);
+        for (const a of added)
+            lines.push(`+${a}`);
+    }
+    return `${lines.join("\n")}\n`;
+}
+export function patchForWrite(relPath, content, fileExisted) {
+    return composePatchEnvelope(fileExisted ? composeDeleteFile(relPath) + composeAddFile(relPath, content) : composeAddFile(relPath, content));
+}
+export function patchForEdit(relPath, oldText, newText, fileContent, replaceAll = false) {
+    const hunks = [];
+    if (fileContent === undefined) {
+        hunks.push([[], oldText.split(/\r?\n/), newText.split(/\r?\n/)]);
+    }
+    else {
+        const positions = [];
+        if (replaceAll) {
+            let start = 0;
+            while (oldText) {
+                const idx = fileContent.indexOf(oldText, start);
+                if (idx < 0)
+                    break;
+                positions.push(idx);
+                start = idx + oldText.length;
+            }
+        }
+        else {
+            const idx = fileContent.indexOf(oldText);
+            if (idx >= 0)
+                positions.push(idx);
+        }
+        if (!positions.length)
+            positions.push(-1);
+        for (const idx of positions) {
+            hunks.push([idx >= 0 ? fileContent.slice(0, idx).split(/\r?\n/) : [], oldText.split(/\r?\n/), newText.split(/\r?\n/)]);
+        }
+    }
+    return composePatchEnvelope(composeUpdateFile(relPath, hunks));
+}
+export function patchForMultiEdit(relPath, edits, fileContent) {
+    const hunks = [];
+    let cur = fileContent;
+    for (const ed of edits) {
+        const oldText = String(ed.old ?? ed.old_string ?? "");
+        const newText = String(ed.new ?? ed.new_string ?? "");
+        const idx = cur?.indexOf(oldText) ?? -1;
+        hunks.push([cur !== undefined && idx >= 0 ? cur.slice(0, idx).split(/\r?\n/) : [], oldText.split(/\r?\n/), newText.split(/\r?\n/)]);
+        if (cur !== undefined && idx >= 0)
+            cur = cur.slice(0, idx) + newText + cur.slice(idx + oldText.length);
+    }
+    return composePatchEnvelope(composeUpdateFile(relPath, hunks));
+}
+export function patchForDelete(relPath) {
+    return composePatchEnvelope(composeDeleteFile(relPath));
+}
+export function patchForMove(oldRel, newRel) {
+    return composePatchEnvelope(composeUpdateFile(oldRel, [], newRel));
+}

package/dist/src/adapters/codex/index.js

@@ -0,0 +1,3 @@
+export { ingest, readCodexThreadName } from "./ingest.js";
+export { render } from "./render.js";
+export { codexPath, setCodexHome } from "./paths.js";