@mmmjk/context-bridge 0.1.0

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

@@ -0,0 +1,167 @@
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { isoNowZ, uuid7Str } from "../../canonical/ids.js";
+import { createSession } from "../../canonical/schema.js";
+import { readJsonl } from "../../utils/jsonl.js";
+import { CODEX_HOME } from "./paths.js";
+import { parseApplyPatch } from "./apply-patch-parser.js";
+const SKIP_TYPES = new Set(["session_meta", "turn_context"]);
+const EVENT_DUPES = new Set(["user_message", "agent_message", "exec_command_end", "patch_apply_end", "web_search_end", "task_started", "task_complete", "turn_started", "turn_complete", "token_count", "thread_name_updated", "thread_rolled_back", "turn_aborted", "view_image_tool_call", "context_compacted"]);
+export function ingest(jsonlPath) {
+    const rows = readJsonl(jsonlPath);
+    if (!rows.length)
+        throw new Error(`Empty or unreadable Codex session: ${jsonlPath}`);
+    const metaLine = rows.find((r) => r.type === "session_meta") ?? rows[0];
+    const meta = metaLine.payload ?? {};
+    const turn = (rows.find((r) => r.type === "turn_context")?.payload ?? {});
+    const cwd = String(meta.cwd ?? path.dirname(jsonlPath));
+    const moments = rows.flatMap((row) => translateLine(row, jsonlPath, cwd)).sort((a, b) => a.ts.localeCompare(b.ts));
+    return createSession({
+        id: uuid7Str(),
+        source_harness: "codex",
+        source_session_id: String(meta.id ?? path.basename(jsonlPath, ".jsonl")),
+        source_session_path: jsonlPath,
+        cwd,
+        git: {
+            branch: meta.git?.branch ?? null,
+            commit: meta.git?.commit_hash ?? null,
+            repo_url: meta.git?.repository_url ?? null,
+        },
+        model_hint: { provider: "openai", name: turn.model, reasoning_effort: turn.effort },
+        started_at: String(meta.timestamp ?? isoNowZ()),
+        ended_at: rows.at(-1)?.timestamp ? String(rows.at(-1)?.timestamp) : null,
+        permissions: { approval: turn.approval_policy, sandbox: turn.sandbox_policy?.type },
+        moments,
+        source_metadata: { codex: { originator: meta.originator, cli_version: meta.cli_version, source: meta.source, model_provider: meta.model_provider, thread_name: readCodexThreadName(meta.id ? String(meta.id) : null) } },
+    });
+}
+export function readCodexThreadName(sessionId) {
+    if (!sessionId)
+        return null;
+    const idx = path.join(CODEX_HOME, "session_index.jsonl");
+    if (!existsSync(idx))
+        return null;
+    let found = null;
+    for (const line of readFileSync(idx, "utf8").split(/\r?\n/)) {
+        if (!line.trim())
+            continue;
+        try {
+            const ev = JSON.parse(line);
+            const name = String(ev.thread_name ?? "");
+            if (ev.id === sessionId && name && !name.startsWith("[from "))
+                found = name;
+        }
+        catch { }
+    }
+    return found;
+}
+function translateLine(row, srcFile, cwd) {
+    if (SKIP_TYPES.has(String(row.type)))
+        return [];
+    const ts = String(row.timestamp ?? isoNowZ());
+    const payload = row.payload ?? {};
+    const source_ref = { file: srcFile };
+    if (row.type === "event_msg") {
+        const sub = payload.type;
+        if (EVENT_DUPES.has(String(sub)))
+            return [];
+        if (sub === "error")
+            return [{ kind: "error", ts, source_ref, message: String(payload.message ?? "") }];
+        return [];
+    }
+    if (row.type === "compacted")
+        return [{ kind: "summary_compaction", ts, source_ref, summary_text: "(codex remote compaction; encrypted_content not portable)", lossy: true, lossy_reason: "pre-compaction history not preserved across harnesses" }];
+    if (row.type !== "response_item")
+        return [];
+    return translateResponseItem(payload, ts, source_ref, cwd);
+}
+function translateResponseItem(payload, ts, source_ref, cwd) {
+    if (payload.type === "message")
+        return translateMessage(payload, ts, source_ref);
+    if (payload.type === "reasoning") {
+        const text = (payload.summary ?? []).map((s) => s.text).filter(Boolean).join("\n");
+        return text ? [{ kind: "thinking", ts, source_ref, text, format: "summary", lossy: true, lossy_reason: "harness-specific signature/encrypted_content not portable" }] : [];
+    }
+    if (payload.type === "function_call") {
+        const raw = payload.arguments;
+        let args = {};
+        try {
+            args = typeof raw === "string" ? JSON.parse(raw) : raw ?? {};
+        }
+        catch {
+            args = { _raw: raw };
+        }
+        const [tool, mapped] = codexFnToCanonical(String(payload.name ?? ""), args, cwd, payload.namespace ? String(payload.namespace) : undefined);
+        return [{ kind: "tool_call", ts, source_ref, tool, call_id: String(payload.call_id ?? ""), args: mapped, wire_native: { harness: "codex", name: payload.name, namespace: payload.namespace, input: args } }];
+    }
+    if (payload.type === "function_call_output" || payload.type === "custom_tool_call_output")
+        return [{ kind: "tool_result", ts, source_ref, call_id: String(payload.call_id ?? ""), output_text: normalizeOutput(payload.output) }];
+    if (payload.type === "custom_tool_call")
+        return translateCustomToolCall(payload, ts, source_ref);
+    if (payload.type === "web_search_call")
+        return [{ kind: "tool_call", ts, source_ref, tool: "web_search", call_id: String(payload.call_id ?? `ws_${ts}`), args: { query: (payload.action?.query ?? "") }, wire_native: { harness: "codex", name: "web_search", input: payload } }];
+    return [];
+}
+function translateMessage(payload, ts, source_ref) {
+    const text = (payload.content ?? []).filter((c) => c.type === "input_text" || c.type === "output_text").map((c) => String(c.text ?? "")).join("\n");
+    if (payload.role === "user")
+        return [{ kind: "user_text", ts, source_ref, text }];
+    if (payload.role === "assistant")
+        return [{ kind: "assistant_text", ts, source_ref, text, phase: payload.phase ?? null }];
+    return [{ kind: "attachment", ts, source_ref, subtype: `${String(payload.role ?? "unknown")}_note`, data: { text } }];
+}
+function codexFnToCanonical(name, args, cwd, namespace) {
+    if (namespace)
+        return ["mcp_call", { server: namespace, tool: name, args }];
+    if (["exec_command", "shell", "shell_command", "local_shell"].includes(name))
+        return classifyShellCmd(String(args.cmd ?? args.command ?? ""), args, cwd);
+    if (name === "update_plan")
+        return ["update_plan", { items: (args.plan ?? []).map((p) => ({ title: p.step ?? "", status: p.status ?? "pending" })) }];
+    if (name === "view_image")
+        return ["view_image", { path: args.path ?? "" }];
+    return ["shell", { command: `echo '(codex tool ${name} args: ${JSON.stringify(args)})'` }];
+}
+function classifyShellCmd(cmd, args, cwd) {
+    const s = cmd.trim();
+    if (s.startsWith("rg --files"))
+        return ["find_files", { pattern: "*", path: "." }];
+    if (s.startsWith("rg "))
+        return ["search_text", { pattern: s.split(/\s+/)[1] ?? "", path: "." }];
+    if (s.startsWith("cat "))
+        return ["read_file", { path: s.split(/\s+/).at(-1) ?? "" }];
+    return ["shell", { command: cmd, workdir: args.workdir ?? cwd }];
+}
+function translateCustomToolCall(payload, ts, source_ref) {
+    if (payload.name !== "apply_patch")
+        return [{ kind: "tool_call", ts, source_ref, tool: "shell", call_id: String(payload.call_id ?? ""), args: { command: `echo '(custom tool ${payload.name})'` } }];
+    const out = [];
+    const ops = parseApplyPatch(String(payload.input ?? ""));
+    ops.forEach((op, idx) => {
+        const call_id = `${String(payload.call_id ?? "call_p")}__${idx}`;
+        if (op.kind === "add")
+            out.push({ kind: "tool_call", ts, source_ref, tool: "write_file", call_id, args: { path: op.path, content: (op.add_lines ?? []).join("\n") + ((op.add_lines?.length ?? 0) ? "\n" : "") } });
+        if (op.kind === "delete")
+            out.push({ kind: "tool_call", ts, source_ref, tool: "delete_file", call_id, args: { path: op.path } });
+        if (op.kind === "update" && op.move_to)
+            out.push({ kind: "tool_call", ts, source_ref, tool: "move_file", call_id, args: { from: op.path, to: op.move_to } });
+        else if (op.kind === "update") {
+            const hunks = op.hunks ?? [];
+            if (hunks.length > 1)
+                out.push({ kind: "tool_call", ts, source_ref, tool: "multi_edit_file", call_id, args: { path: op.path, edits: hunks.map((h) => ({ old: h.lines.filter((l) => l.op === "-").map((l) => l.text).join("\n"), new: h.lines.filter((l) => l.op === "+").map((l) => l.text).join("\n") })) } });
+            else
+                out.push({ kind: "tool_call", ts, source_ref, tool: "edit_file", call_id, args: { path: op.path, old: hunks[0]?.lines.filter((l) => l.op === "-").map((l) => l.text).join("\n") ?? "", new: hunks[0]?.lines.filter((l) => l.op === "+").map((l) => l.text).join("\n") ?? "" } });
+        }
+    });
+    return out;
+}
+function normalizeOutput(v) {
+    if (typeof v !== "string")
+        return JSON.stringify(v ?? "");
+    try {
+        const parsed = JSON.parse(v);
+        if (typeof parsed === "object" && parsed && "output" in parsed)
+            return String(parsed.output ?? "");
+    }
+    catch { }
+    return v;
+}

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

@@ -0,0 +1,21 @@
+import path from "node:path";
+import { homedir } from "node:os";
+import { existsSync, statSync, unlinkSync } from "node:fs";
+import { readJsonFile, writeJsonFile } from "../../utils/jsonl.js";
+export let MANIFEST_PATH = path.join(homedir(), ".cache", "context-bridge", "codex-write-manifest.json");
+export function setManifestPath(p) { MANIFEST_PATH = p; }
+export function recordWrite(rolloutPath, codexId) {
+    if (!existsSync(rolloutPath))
+        return;
+    const st = statSync(rolloutPath);
+    const data = readJsonFile(MANIFEST_PATH, {});
+    data[codexId] = { path: rolloutPath, size: st.size, mtime: st.mtimeMs / 1000 };
+    writeJsonFile(MANIFEST_PATH, data);
+}
+export function get(codexId) {
+    return readJsonFile(MANIFEST_PATH, {})[codexId];
+}
+export function clear() {
+    if (existsSync(MANIFEST_PATH))
+        unlinkSync(MANIFEST_PATH);
+}

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

@@ -0,0 +1,15 @@
+import path from "node:path";
+import { homedir } from "node:os";
+export let CODEX_HOME = path.join(homedir(), ".codex");
+export function setCodexHome(p) { CODEX_HOME = p; }
+export function codexPath(uuid, tsIso, codexHome) {
+    const home = codexHome ?? CODEX_HOME;
+    const d = new Date(tsIso);
+    const yyyy = String(d.getUTCFullYear()).padStart(4, "0");
+    const mm = String(d.getUTCMonth() + 1).padStart(2, "0");
+    const dd = String(d.getUTCDate()).padStart(2, "0");
+    const hh = String(d.getUTCHours()).padStart(2, "0");
+    const mi = String(d.getUTCMinutes()).padStart(2, "0");
+    const ss = String(d.getUTCSeconds()).padStart(2, "0");
+    return path.join(home, "sessions", yyyy, mm, dd, `rollout-${yyyy}-${mm}-${dd}T${hh}-${mi}-${ss}-${uuid}.jsonl`);
+}

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

@@ -0,0 +1,90 @@
+import { appendFileSync, existsSync, mkdirSync, utimesSync } from "node:fs";
+import path from "node:path";
+import { uuid7Str } from "../../canonical/ids.js";
+import { writeJsonl } from "../../utils/jsonl.js";
+import { buildFileState, patchForDelete, patchForEdit, patchForMove, patchForMultiEdit, patchForWrite, toRelative } from "./apply-patch.js";
+import { codexPath, CODEX_HOME } from "./paths.js";
+import { recordWrite } from "./manifest.js";
+export function render(session, opts = {}) {
+    const id = opts.session_id ?? uuid7Str();
+    const home = opts.target_dir ?? CODEX_HOME;
+    const outPath = codexPath(id, session.started_at, home);
+    const rows = [];
+    rows.push({ timestamp: session.started_at, type: "session_meta", payload: { id, timestamp: session.started_at, cwd: session.cwd, ...(opts.copy_mode ? {} : { originator: "context-bridge", source_harness: session.source_harness }), cli_version: "0.1.0", source: "cli", model_provider: opts.model_provider ?? "openai" } });
+    rows.push({ timestamp: bumpMs(session.started_at, 1), type: "turn_context", payload: { turn_id: uuid7Str(), cwd: session.cwd, current_date: session.started_at.slice(0, 10), timezone: opts.timezone_name ?? "Asia/Shanghai", approval_policy: session.permissions?.approval ?? "never", sandbox_policy: { type: session.permissions?.sandbox ?? "danger-full-access" }, summary: "none" } });
+    const snaps = buildFileState(session.moments);
+    for (const m of session.moments)
+        rows.push(...renderMoment(m, session, snaps[m.kind === "tool_call" ? m.call_id : ""]));
+    mkdirSync(path.dirname(outPath), { recursive: true });
+    writeJsonl(outPath, rows);
+    appendThreadName(home, id, makeThreadName(session, opts.copy_mode));
+    backdateMtime(outPath, session.ended_at ?? session.started_at);
+    recordWrite(outPath, id);
+    return { session_id: id, primary_path: outPath, resume_command: `codex exec resume ${id} "<your prompt>" -o /tmp/context-bridge-resume.md`, warnings: [] };
+}
+function renderMoment(m, session, fileState) {
+    if (m.kind === "user_text") {
+        const payload = { type: "message", role: "user", content: [{ type: "input_text", text: m.text }] };
+        return [{ timestamp: m.ts, type: "response_item", payload }, { timestamp: bumpMs(m.ts, 1), type: "event_msg", payload: { type: "user_message", message: m.text } }];
+    }
+    if (m.kind === "assistant_text") {
+        const payload = { type: "message", role: "assistant", content: [{ type: "output_text", text: m.text }], phase: m.phase ?? "final_answer" };
+        return [{ timestamp: m.ts, type: "response_item", payload }, { timestamp: bumpMs(m.ts, 1), type: "event_msg", payload: { type: "agent_message", message: m.text } }];
+    }
+    if (m.kind === "attachment") {
+        const text = m.subtype === "skill_listing" ? summarizeSkillListing(String(m.data?.content ?? "")) : JSON.stringify(m.data ?? {});
+        return [{ timestamp: m.ts, type: "response_item", payload: { type: "message", role: "developer", content: [{ type: "input_text", text }] } }];
+    }
+    if (m.kind === "tool_call")
+        return [{ timestamp: m.ts, type: "response_item", payload: renderToolCall(m, session.cwd, fileState) }];
+    if (m.kind === "tool_result")
+        return [{ timestamp: m.ts, type: "response_item", payload: { type: "function_call_output", call_id: m.call_id, output: m.output_text ?? "" } }];
+    return [];
+}
+function renderToolCall(m, cwd, fileState) {
+    const args = m.args ?? {};
+    if (m.tool === "shell")
+        return { type: "function_call", name: "exec_command", arguments: JSON.stringify({ cmd: args.command ?? "", workdir: cwd, yield_time_ms: 1000 }), call_id: m.call_id };
+    if (m.tool === "read_file")
+        return { type: "function_call", name: "exec_command", arguments: JSON.stringify({ cmd: `cat -n ${args.path}`, workdir: cwd, yield_time_ms: 1000 }), call_id: m.call_id };
+    if (["write_file", "edit_file", "multi_edit_file", "delete_file", "move_file"].includes(m.tool)) {
+        const p = String(args.path ?? args.from ?? "");
+        const rel = toRelative(p, cwd);
+        let input = "";
+        if (m.tool === "write_file")
+            input = patchForWrite(rel, String(args.content ?? ""), fileState?.get(p) !== undefined);
+        if (m.tool === "edit_file")
+            input = patchForEdit(rel, String(args.old ?? ""), String(args.new ?? ""), fileState?.get(p), Boolean(args.replace_all));
+        if (m.tool === "multi_edit_file")
+            input = patchForMultiEdit(rel, args.edits ?? [], fileState?.get(p));
+        if (m.tool === "delete_file")
+            input = patchForDelete(rel);
+        if (m.tool === "move_file")
+            input = patchForMove(toRelative(String(args.from ?? args.source ?? ""), cwd), toRelative(String(args.to ?? args.destination ?? ""), cwd));
+        return { type: "custom_tool_call", name: "apply_patch", call_id: m.call_id, input, status: "completed" };
+    }
+    return { type: "function_call", name: "exec_command", arguments: JSON.stringify({ cmd: `echo '(translated ${m.tool} call; canonical args: ${JSON.stringify(args)})'`, workdir: cwd }), call_id: m.call_id };
+}
+function summarizeSkillListing(content) {
+    const names = [...content.matchAll(/^- ([^:]+):/gm)].map((m) => `- ${m[1]}`);
+    return `Available skills (translated from Claude Code skill_listing attachment):\n${names.join("\n") || content.slice(0, 2000)}`;
+}
+function makeThreadName(session, copyMode = false) {
+    const custom = session.source_metadata?.claude_code?.custom_title;
+    const body = typeof custom === "string" && custom ? custom : session.moments.find((m) => m.kind === "user_text")?.text.slice(0, 80) ?? session.source_session_id;
+    return copyMode ? body : `[from ${session.source_harness}] ${body}`;
+}
+function appendThreadName(home, id, name) {
+    const p = path.join(home, "session_index.jsonl");
+    mkdirSync(path.dirname(p), { recursive: true });
+    appendFileSync(p, JSON.stringify({ id, thread_name: name, updated_at: new Date().toISOString() }) + "\n", "utf8");
+}
+function bumpMs(iso, ms) {
+    const d = new Date(iso);
+    return new Date(d.getTime() + ms).toISOString();
+}
+function backdateMtime(p, iso) {
+    const d = new Date(iso);
+    if (!Number.isNaN(d.getTime()) && existsSync(p))
+        utimesSync(p, d, d);
+}

package/dist/src/adapters/codex/tool-map.js

@@ -0,0 +1,16 @@
+export function renderToolResult(callId, outputText = "", isError = false) {
+    return {
+        type: "function_call_output",
+        call_id: callId,
+        output: isError ? JSON.stringify({ output: outputText, metadata: { exit_code: 1 } }) : outputText,
+    };
+}
+export function renderShellTool(call) {
+    const args = call.args ?? {};
+    return {
+        type: "function_call",
+        name: "exec_command",
+        arguments: JSON.stringify({ cmd: args.command ?? "", workdir: args.workdir }),
+        call_id: call.call_id,
+    };
+}

package/dist/src/canonical/ids.js

@@ -0,0 +1,44 @@
+import { createHash, randomBytes, randomUUID } from "node:crypto";
+export function isoNowZ() {
+    return new Date().toISOString();
+}
+export function uuid7Str() {
+    const ms = BigInt(Date.now());
+    const rand = randomBytes(10);
+    const randA = ((rand[0] << 4) | (rand[1] >> 4)) & 0x0fff;
+    let randB = BigInt(rand[1] & 0x0f);
+    for (const b of rand.slice(2))
+        randB = (randB << 8n) | BigInt(b);
+    return formatUuid7(ms, randA, randB);
+}
+export function deterministicUuid7(seed, tsIso) {
+    const ms = BigInt(Date.parse(tsIso || new Date().toISOString()));
+    const h = createHash("sha256").update(seed).digest();
+    const randA = ((h[0] << 4) | (h[1] >> 4)) & 0x0fff;
+    let randB = BigInt(h[1] & 0x0f);
+    for (const b of h.slice(2, 10))
+        randB = (randB << 8n) | BigInt(b);
+    return formatUuid7(ms, randA, randB);
+}
+export function deterministicUuid4(seed) {
+    const b = Buffer.from(createHash("md5").update(seed).digest());
+    b[6] = (b[6] & 0x0f) | 0x40;
+    b[8] = (b[8] & 0x3f) | 0x80;
+    return bytesToUuid(b);
+}
+export function uuid4Str() {
+    return randomUUID();
+}
+function formatUuid7(ms, randA, randB) {
+    const value = ((ms & 0xffffffffffffn) << 80n) |
+        (0x7n << 76n) |
+        (BigInt(randA) << 64n) |
+        (0x2n << 62n) |
+        (randB & 0x3fffffffffffffffn);
+    const hex = value.toString(16).padStart(32, "0");
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+function bytesToUuid(b) {
+    const hex = b.toString("hex");
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20, 32)}`;
+}

package/dist/src/canonical/schema.js

@@ -0,0 +1,28 @@
+export function createSession(input) {
+    return {
+        schema_version: input.schema_version ?? "1.0.0",
+        git: {},
+        model_hint: {},
+        permissions: { writable_roots: [], network_access: false },
+        skills_inventory: [],
+        mcp_servers: [],
+        memory_files: [],
+        subagent_transcripts: {},
+        artifacts: [],
+        source_metadata: {},
+        ...input,
+        moments: input.moments ?? [],
+    };
+}
+export function isUserText(m) {
+    return m.kind === "user_text";
+}
+export function isAssistantText(m) {
+    return m.kind === "assistant_text";
+}
+export function isToolCall(m) {
+    return m.kind === "tool_call";
+}
+export function isToolResult(m) {
+    return m.kind === "tool_result";
+}

package/dist/src/canonical/tools.js

@@ -0,0 +1,21 @@
+export const CANONICAL_TOOLS = {
+    shell: { description: "Run a shell command" },
+    read_file: { description: "Read a file" },
+    write_file: { description: "Write a file" },
+    edit_file: { description: "Edit a file" },
+    multi_edit_file: { description: "Apply multiple edits to a file" },
+    delete_file: { description: "Delete a file" },
+    move_file: { description: "Move or rename a file" },
+    find_files: { description: "Find files by pattern" },
+    search_text: { description: "Search text in files" },
+    web_search: { description: "Search the web" },
+    web_fetch: { description: "Fetch a web page" },
+    update_plan: { description: "Update the task plan" },
+    ask_user: { description: "Ask the user for input" },
+    subagent_dispatch: { description: "Dispatch a subagent" },
+    mcp_call: { description: "Call an MCP tool" },
+    view_image: { description: "View a local image" },
+};
+export function isCanonicalTool(name) {
+    return Object.prototype.hasOwnProperty.call(CANONICAL_TOOLS, name);
+}