atoo-studio 0.0.1 → 0.0.2

package/dist/src/agents/lib/claude/jsonl-writer.js

@@ -0,0 +1,342 @@
+/**
+ * Reconstruct Claude Code JSONL from SessionEvent[] for fork/resume.
+ *
+ * This is the critical cross-agent bridge: it builds proper Claude JSONL
+ * events from the canonical SessionEvent type. Events from ANY agent
+ * (Claude, future Codex/Gemini) can be reconstructed into Claude's format,
+ * enabling cross-agent session resumability.
+ *
+ * Claude Code JSONL format (what `claude --resume <uuid>` expects):
+ *   {"type":"user","uuid":"...","sessionId":"...","parentUuid":"...","message":{"role":"user","content":"..."}}
+ *   {"type":"assistant","uuid":"...","sessionId":"...","parentUuid":"...","message":{"role":"assistant","content":[...],"model":"...","stop_reason":"..."}}
+ *   {"type":"system","uuid":"...","sessionId":"...","subtype":"init","model":"...","permissionMode":"..."}
+ */
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import crypto from 'crypto';
+import { v4 as uuidv4 } from 'uuid';
+import { buildLinkedUuid } from '../session-id-utils.js';
+/**
+ * Convert an absolute directory path to the Claude project dir hash format.
+ * Replaces all non-alphanumeric chars with '-'.
+ * e.g. /home/furti/myproject -> -home-furti-myproject
+ */
+function projectDirHash(directory) {
+    const hashed = directory.replace(/[^a-zA-Z0-9]/g, '-');
+    if (hashed.length <= 200)
+        return hashed;
+    const suffix = crypto.createHash('sha256').update(directory).digest('hex').slice(0, 12);
+    return `${hashed.slice(0, 200)}-${suffix}`;
+}
+/**
+ * Build common envelope fields for a Claude JSONL event.
+ */
+function buildEnvelope(event, sessionId, uuid, parentUuid) {
+    const env = {
+        type: event.type,
+        uuid,
+        sessionId,
+        parentUuid,
+    };
+    if (event.timestamp)
+        env.timestamp = event.timestamp;
+    if (event.cwd)
+        env.cwd = event.cwd;
+    if (event.gitBranch)
+        env.gitBranch = event.gitBranch;
+    if (event.version)
+        env.version = event.version;
+    if (event.slug)
+        env.slug = event.slug;
+    if (event.userType)
+        env.userType = event.userType;
+    env.isSidechain = event.isSidechain ?? false;
+    if (event.isSynthetic)
+        env.isSynthetic = event.isSynthetic;
+    if (event.agentId)
+        env.agentId = event.agentId;
+    if (event.parent_tool_use_id)
+        env.parent_tool_use_id = event.parent_tool_use_id;
+    return env;
+}
+/**
+ * Reconstruct a UserEvent as a Claude JSONL event.
+ */
+function reconstructUser(event, sessionId, uuid, parentUuid) {
+    const out = buildEnvelope(event, sessionId, uuid, parentUuid);
+    out.message = {
+        role: 'user',
+        content: event.message.content,
+    };
+    if (event.toolUseResult)
+        out.toolUseResult = event.toolUseResult;
+    if (event.permissionMode)
+        out.permissionMode = event.permissionMode;
+    return out;
+}
+/**
+ * Reconstruct an AssistantEvent as a Claude JSONL event.
+ */
+function reconstructAssistant(event, sessionId, uuid, parentUuid) {
+    const out = buildEnvelope(event, sessionId, uuid, parentUuid);
+    out.message = {
+        role: 'assistant',
+        content: event.message.content,
+    };
+    if (event.message.model)
+        out.message.model = event.message.model;
+    if (event.message.stop_reason !== undefined)
+        out.message.stop_reason = event.message.stop_reason;
+    if (event.message.usage)
+        out.message.usage = event.message.usage;
+    return out;
+}
+/**
+ * Reconstruct a SystemEvent as a Claude JSONL event.
+ */
+function reconstructSystem(event, sessionId, uuid, parentUuid) {
+    const out = buildEnvelope(event, sessionId, uuid, parentUuid);
+    if (event.subtype)
+        out.subtype = event.subtype;
+    if (event.model)
+        out.model = event.model;
+    if (event.permissionMode)
+        out.permissionMode = event.permissionMode;
+    if (event.durationMs !== undefined)
+        out.durationMs = event.durationMs;
+    if (event.content)
+        out.content = event.content;
+    if (event.hookCount !== undefined)
+        out.hookCount = event.hookCount;
+    if (event.hookInfos)
+        out.hookInfos = event.hookInfos;
+    if (event.hookErrors)
+        out.hookErrors = event.hookErrors;
+    if (event.hasOutput !== undefined)
+        out.hasOutput = event.hasOutput;
+    if (event.preventedContinuation !== undefined)
+        out.preventedContinuation = event.preventedContinuation;
+    if (event.url)
+        out.url = event.url;
+    if (event.compactMetadata)
+        out.compactMetadata = event.compactMetadata;
+    if (event.message)
+        out.message = event.message;
+    return out;
+}
+/**
+ * Reconstruct a ResultEvent as a Claude JSONL event.
+ */
+function reconstructResult(event, sessionId, uuid, parentUuid) {
+    const out = buildEnvelope(event, sessionId, uuid, parentUuid);
+    if (event.subtype)
+        out.subtype = event.subtype;
+    if (event.result)
+        out.result = event.result;
+    if (event.message)
+        out.message = event.message;
+    return out;
+}
+/**
+ * Reconstruct a ControlRequestEvent as a Claude JSONL event.
+ */
+function reconstructControlRequest(event, sessionId, uuid, parentUuid) {
+    const out = buildEnvelope(event, sessionId, uuid, parentUuid);
+    if (event.request_id)
+        out.request_id = event.request_id;
+    if (event.request)
+        out.request = event.request;
+    return out;
+}
+/**
+ * Reconstruct a ControlResponseEvent as a Claude JSONL event.
+ */
+function reconstructControlResponse(event, sessionId, uuid, parentUuid) {
+    const out = buildEnvelope(event, sessionId, uuid, parentUuid);
+    if (event.response)
+        out.response = event.response;
+    return out;
+}
+/**
+ * Reconstruct a single SessionEvent as a Claude JSONL event object.
+ * Maps from the canonical SessionEvent type to Claude's expected format.
+ *
+ * Events that don't map to conversational messages (progress, file-history-snapshot,
+ * last-prompt, queue-operation) are skipped — Claude --resume doesn't need them.
+ */
+function toClaudeJsonlEvent(event, sessionId, uuid, parentUuid) {
+    switch (event.type) {
+        case 'user':
+            return reconstructUser(event, sessionId, uuid, parentUuid);
+        case 'assistant':
+            return reconstructAssistant(event, sessionId, uuid, parentUuid);
+        case 'system':
+            return reconstructSystem(event, sessionId, uuid, parentUuid);
+        case 'result':
+            return reconstructResult(event, sessionId, uuid, parentUuid);
+        case 'control_request':
+            return reconstructControlRequest(event, sessionId, uuid, parentUuid);
+        case 'control_response':
+            return reconstructControlResponse(event, sessionId, uuid, parentUuid);
+        // Skip non-conversational events — not needed for resume
+        case 'progress':
+        case 'file-history-snapshot':
+        case 'last-prompt':
+        case 'queue-operation':
+            return null;
+    }
+}
+// ═══════════════════════════════════════════════════════
+// Public API
+// ═══════════════════════════════════════════════════════
+/**
+ * Reconstruct SessionEvent[] as a Claude Code JSONL file for `claude --resume`.
+ * Path: ~/.claude/projects/<project-dir-hash>/<targetUuid>.jsonl
+ *
+ * Each SessionEvent is reconstructed into Claude's native JSONL format
+ * from its typed fields — not passed through as raw JSON. This enables
+ * cross-agent forking: events from any agent type can be written as
+ * valid Claude JSONL.
+ *
+ * @param events - Array of SessionEvents to write
+ * @param targetUuid - The UUID for the new session file (no "sess_" prefix)
+ * @param directory - The project working directory (for path hashing)
+ * @returns The full path to the written JSONL file
+ */
+export function writeForkedClaudeJsonl(events, targetUuid, directory) {
+    const dirHash = projectDirHash(path.resolve(directory));
+    const projectDir = path.join(os.homedir(), '.claude', 'projects', dirHash);
+    const jsonlPath = path.join(projectDir, `${targetUuid}.jsonl`);
+    // Ensure directory exists
+    fs.mkdirSync(projectDir, { recursive: true });
+    // Build UUID remap: old UUID -> new UUID (preserves parentUuid chain)
+    const uuidMap = new Map();
+    for (const event of events) {
+        if (event.uuid) {
+            uuidMap.set(event.uuid, uuidv4());
+        }
+    }
+    // First pass: determine which events will be written (not filtered out)
+    const writtenUuids = new Set();
+    for (const event of events) {
+        // Check if toClaudeJsonlEvent would produce output for this event type
+        const isConversational = ['user', 'assistant', 'system', 'result', 'control_request', 'control_response'].includes(event.type);
+        if (isConversational && event.uuid) {
+            writtenUuids.add(uuidMap.get(event.uuid));
+        }
+    }
+    const lines = [];
+    let lastUuid = null;
+    for (const event of events) {
+        const newUuid = (event.uuid && uuidMap.get(event.uuid)) || uuidv4();
+        // Resolve parentUuid: if the parent event was filtered out (e.g. progress),
+        // fall back to lastUuid to keep the conversation tree connected.
+        let newParentUuid;
+        if (event.parentUuid) {
+            const remapped = uuidMap.get(event.parentUuid) || null;
+            newParentUuid = (remapped && writtenUuids.has(remapped)) ? remapped : lastUuid;
+        }
+        else {
+            newParentUuid = lastUuid;
+        }
+        const jsonlEvent = toClaudeJsonlEvent(event, targetUuid, newUuid, newParentUuid);
+        if (jsonlEvent) {
+            lines.push(JSON.stringify(jsonlEvent));
+            lastUuid = newUuid;
+        }
+    }
+    fs.writeFileSync(jsonlPath, lines.join('\n') + '\n');
+    console.log(`[claude-jsonl-writer] Reconstructed ${lines.length} events to ${jsonlPath}`);
+    return jsonlPath;
+}
+/**
+ * Fork a slice of SessionEvents into a resumable JSONL file.
+ * Handles event slicing, range-fork synthetic init, UUID generation, and writing.
+ *
+ * @returns The resume UUID, or null if the fork point wasn't found.
+ */
+/**
+ * Fork a slice of SessionEvents into a resumable JSONL file.
+ * Handles event slicing, range-fork synthetic init, UUID generation, and writing.
+ *
+ * The returned UUID is parent-linked: its first 16 hex chars are the last 16 hex chars
+ * of the parent session ID, enabling tree-view reconstruction in session history.
+ *
+ * @returns The resume UUID, or null if the fork point wasn't found.
+ */
+export function forkEventsToResumable(events, afterEventUuid, directory, parentSessionId, fromEventUuid) {
+    if (events.length === 0)
+        return null;
+    const forkIdx = events.findIndex((e) => e.uuid === afterEventUuid);
+    if (forkIdx === -1)
+        return null;
+    let startIdx = 0;
+    if (fromEventUuid) {
+        startIdx = events.findIndex((e) => e.uuid === fromEventUuid);
+        if (startIdx === -1 || startIdx > forkIdx)
+            return null;
+        // Ensure the range starts with a user message so we can embed the context
+        // header into it. Claude Code's --resume branches from the first user
+        // message, so a separate synthetic init would make imported events a dead
+        // branch. Walk backward to find the preceding user message if needed.
+        if (events[startIdx].type !== 'user') {
+            for (let i = startIdx - 1; i >= 0; i--) {
+                if (events[i].type === 'user') {
+                    startIdx = i;
+                    break;
+                }
+            }
+        }
+    }
+    let sliced = events.slice(startIdx, forkIdx + 1);
+    // Event boundary integrity: if the last event is an assistant message with tool_use blocks,
+    // include the corresponding tool_result user events and any child events
+    const lastEvent = sliced[sliced.length - 1];
+    if (lastEvent?.type === 'assistant' && Array.isArray(lastEvent.message?.content)) {
+        const toolUseIds = lastEvent.message.content
+            .filter((b) => b.type === 'tool_use')
+            .map((b) => b.id);
+        if (toolUseIds.length > 0) {
+            for (let i = forkIdx + 1; i < events.length; i++) {
+                const ev = events[i];
+                if (ev.parent_tool_use_id && toolUseIds.includes(ev.parent_tool_use_id)) {
+                    sliced.push(ev);
+                    continue;
+                }
+                if (ev.type === 'user' && Array.isArray(ev.message?.content)) {
+                    const hasMatchingResult = ev.message.content.some((item) => item.type === 'tool_result' && toolUseIds.includes(item.tool_use_id));
+                    if (hasMatchingResult) {
+                        sliced.push(ev);
+                        continue;
+                    }
+                }
+            }
+        }
+    }
+    // For range forks, inject a context header into the first event's content
+    // so the model knows this is imported context. We do NOT prepend a separate
+    // synthetic user message because Claude Code's --resume creates a new branch
+    // from the first user message, which would make the imported events a dead
+    // sibling branch that's never included in context.
+    if (fromEventUuid && sliced.length > 0) {
+        const header = '[This session continues from a selected range of a previous conversation. The messages below are the selected context. Continue from where this conversation left off.]';
+        const first = sliced[0];
+        if (first.type === 'user' && first.message) {
+            // Embed the context header into the first user message. We do NOT
+            // prepend a separate synthetic user message because Claude Code's
+            // --resume creates a new branch from the first user message, which
+            // would make the imported events a dead sibling branch.
+            const msg = first.message;
+            const content = typeof msg.content === 'string'
+                ? `${header}\n\n${msg.content}`
+                : Array.isArray(msg.content)
+                    ? [{ type: 'text', text: header }, ...msg.content]
+                    : msg.content;
+            sliced[0] = { ...first, message: { ...msg, content } };
+        }
+    }
+    const targetUuid = buildLinkedUuid(parentSessionId, 'fork');
+    writeForkedClaudeJsonl(sliced, targetUuid, directory);
+    return targetUuid;
+}

package/dist/src/agents/lib/claude/workspace-trust.d.ts

@@ -0,0 +1 @@
+export declare function ensureWorkspaceTrust(directory: string): void;

package/dist/src/agents/lib/claude/workspace-trust.js

@@ -0,0 +1,29 @@
+/**
+ * Pre-trust a workspace directory in ~/.claude.json so that
+ * Claude CLI commands don't fail with "Workspace not trusted".
+ */
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+export function ensureWorkspaceTrust(directory) {
+    const claudeJsonPath = path.join(os.homedir(), '.claude.json');
+    try {
+        let config = {};
+        if (fs.existsSync(claudeJsonPath)) {
+            config = JSON.parse(fs.readFileSync(claudeJsonPath, 'utf-8'));
+        }
+        if (!config.projects)
+            config.projects = {};
+        const absDir = path.resolve(directory);
+        if (!config.projects[absDir])
+            config.projects[absDir] = {};
+        if (!config.projects[absDir].hasTrustDialogAccepted) {
+            config.projects[absDir].hasTrustDialogAccepted = true;
+            fs.writeFileSync(claudeJsonPath, JSON.stringify(config, null, 2));
+            console.log(`[claude] Pre-trusted workspace: ${absDir}`);
+        }
+    }
+    catch (err) {
+        console.warn(`[claude] Failed to pre-trust workspace: ${err.message}`);
+    }
+}

package/dist/src/agents/lib/codex/fs-sessions.d.ts

@@ -0,0 +1,34 @@
+import type { SessionEvent } from '../../../events/types.js';
+export interface CodexSessionMeta {
+    uuid: string;
+    directory: string;
+    title: string;
+    lastModified: string;
+    fileSize: number;
+    eventCount: number;
+    jsonlPath: string;
+}
+declare class CodexSessionScanner {
+    private cache;
+    private lastScanTime;
+    scan(): Promise<CodexSessionMeta[]>;
+    private walkSessionDirs;
+    private parseQuickMeta;
+    /**
+     * Read all events from a Codex session, converting to SessionEvent[].
+     */
+    readEvents(uuid: string): Promise<SessionEvent[]>;
+    getByUuid(uuid: string): CodexSessionMeta | undefined;
+    invalidate(): void;
+    /**
+     * Find the JSONL file path for a given session UUID.
+     */
+    findSessionFile(uuid: string): string | null;
+    private findFileByUuid;
+    /**
+     * Return JSONL file paths for sessions matching the given cwds.
+     */
+    getFilesForProject(cwds: string[]): Promise<string[]>;
+}
+export declare const codexSessionScanner: CodexSessionScanner;
+export {};

package/dist/src/agents/lib/codex/fs-sessions.js

@@ -0,0 +1,255 @@
+/**
+ * Scan ~/.codex/sessions/ for Codex session metadata.
+ *
+ * Codex stores sessions at:
+ *   ~/.codex/sessions/YYYY/MM/DD/rollout-{timestamp}-{uuid}.jsonl
+ *
+ * The UUID is extracted from the filename.
+ */
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { mapCodexJsonlLine } from './jsonl-mapper.js';
+const CODEX_SESSIONS_DIR = path.join(os.homedir(), '.codex', 'sessions');
+const CACHE_TTL = 30_000;
+/**
+ * Extract UUID from Codex session filename.
+ * "rollout-2026-03-08T14-42-42-019ccdaf-9532-7b01-a95d-120dfe13ec7c.jsonl"
+ * → "019ccdaf-9532-7b01-a95d-120dfe13ec7c"
+ */
+function extractUuidFromFilename(filename) {
+    // UUID is at the end of the filename before .jsonl
+    // Pattern: rollout-{datetime}-{uuid}.jsonl where uuid has 5 groups
+    const match = filename.match(/([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/);
+    return match ? match[1] : null;
+}
+class CodexSessionScanner {
+    cache = new Map();
+    lastScanTime = 0;
+    async scan() {
+        const now = Date.now();
+        if (now - this.lastScanTime < CACHE_TTL && this.cache.size > 0) {
+            return Array.from(this.cache.values());
+        }
+        const results = [];
+        try {
+            // Walk ~/.codex/sessions/YYYY/MM/DD/
+            this.walkSessionDirs(CODEX_SESSIONS_DIR, results);
+        }
+        catch {
+            // ~/.codex/sessions doesn't exist
+        }
+        this.cache.clear();
+        for (const meta of results) {
+            this.cache.set(meta.uuid, meta);
+        }
+        this.lastScanTime = now;
+        return results;
+    }
+    walkSessionDirs(baseDir, results) {
+        let yearDirs;
+        try {
+            yearDirs = fs.readdirSync(baseDir);
+        }
+        catch {
+            return;
+        }
+        for (const year of yearDirs) {
+            const yearPath = path.join(baseDir, year);
+            let monthDirs;
+            try {
+                monthDirs = fs.readdirSync(yearPath);
+            }
+            catch {
+                continue;
+            }
+            for (const month of monthDirs) {
+                const monthPath = path.join(yearPath, month);
+                let dayDirs;
+                try {
+                    dayDirs = fs.readdirSync(monthPath);
+                }
+                catch {
+                    continue;
+                }
+                for (const day of dayDirs) {
+                    const dayPath = path.join(monthPath, day);
+                    let files;
+                    try {
+                        files = fs.readdirSync(dayPath);
+                    }
+                    catch {
+                        continue;
+                    }
+                    for (const file of files) {
+                        if (!file.endsWith('.jsonl'))
+                            continue;
+                        const uuid = extractUuidFromFilename(file);
+                        if (!uuid)
+                            continue;
+                        const jsonlPath = path.join(dayPath, file);
+                        try {
+                            const stat = fs.statSync(jsonlPath);
+                            if (stat.size === 0)
+                                continue;
+                            // Parse first few lines for metadata
+                            const meta = this.parseQuickMeta(jsonlPath, uuid, stat);
+                            if (meta)
+                                results.push(meta);
+                        }
+                        catch { /* skip */ }
+                    }
+                }
+            }
+        }
+    }
+    parseQuickMeta(jsonlPath, uuid, stat) {
+        // Read first 32KB for quick metadata extraction
+        const maxBytes = Math.min(stat.size, 32 * 1024);
+        const buf = Buffer.alloc(maxBytes);
+        const fd = fs.openSync(jsonlPath, 'r');
+        fs.readSync(fd, buf, 0, maxBytes, 0);
+        fs.closeSync(fd);
+        const chunk = buf.toString('utf-8');
+        const lines = chunk.split('\n');
+        let directory = '';
+        let title = '';
+        let lineCount = 0;
+        for (const line of lines) {
+            if (!line.trim())
+                continue;
+            lineCount++;
+            try {
+                const parsed = JSON.parse(line);
+                // Extract cwd from session_meta
+                if (parsed.type === 'session_meta' && parsed.payload?.cwd) {
+                    directory = parsed.payload.cwd;
+                }
+                // Extract first user message as title
+                if (!title && parsed.type === 'event_msg' && parsed.payload?.type === 'user_message') {
+                    title = (parsed.payload.message || '').substring(0, 100);
+                }
+            }
+            catch { /* skip */ }
+            if (directory && title)
+                break;
+        }
+        if (!directory)
+            return null;
+        // Extrapolate event count
+        const bytesRead = chunk.length;
+        let eventCount = lineCount;
+        if (bytesRead > 0 && bytesRead < stat.size) {
+            eventCount = Math.round((stat.size / bytesRead) * lineCount);
+        }
+        return {
+            uuid,
+            directory,
+            title: title || 'Untitled',
+            lastModified: stat.mtime.toISOString(),
+            fileSize: stat.size,
+            eventCount,
+            jsonlPath,
+        };
+    }
+    /**
+     * Read all events from a Codex session, converting to SessionEvent[].
+     */
+    async readEvents(uuid) {
+        const meta = this.cache.get(uuid);
+        if (!meta)
+            return [];
+        const content = fs.readFileSync(meta.jsonlPath, 'utf-8');
+        const events = [];
+        for (const line of content.split('\n')) {
+            if (!line.trim())
+                continue;
+            try {
+                const parsed = JSON.parse(line);
+                const mapped = mapCodexJsonlLine(parsed);
+                events.push(...mapped);
+            }
+            catch { /* skip */ }
+        }
+        return events;
+    }
+    getByUuid(uuid) {
+        return this.cache.get(uuid);
+    }
+    invalidate() {
+        this.cache.clear();
+        this.lastScanTime = 0;
+    }
+    /**
+     * Find the JSONL file path for a given session UUID.
+     */
+    findSessionFile(uuid) {
+        const meta = this.cache.get(uuid);
+        if (meta)
+            return meta.jsonlPath;
+        // Walk the directory to find it
+        try {
+            return this.findFileByUuid(CODEX_SESSIONS_DIR, uuid);
+        }
+        catch {
+            return null;
+        }
+    }
+    findFileByUuid(baseDir, uuid) {
+        let yearDirs;
+        try {
+            yearDirs = fs.readdirSync(baseDir);
+        }
+        catch {
+            return null;
+        }
+        for (const year of yearDirs) {
+            const yearPath = path.join(baseDir, year);
+            let monthDirs;
+            try {
+                monthDirs = fs.readdirSync(yearPath);
+            }
+            catch {
+                continue;
+            }
+            for (const month of monthDirs) {
+                const monthPath = path.join(yearPath, month);
+                let dayDirs;
+                try {
+                    dayDirs = fs.readdirSync(monthPath);
+                }
+                catch {
+                    continue;
+                }
+                for (const day of dayDirs) {
+                    const dayPath = path.join(monthPath, day);
+                    let files;
+                    try {
+                        files = fs.readdirSync(dayPath);
+                    }
+                    catch {
+                        continue;
+                    }
+                    for (const file of files) {
+                        if (file.includes(uuid) && file.endsWith('.jsonl')) {
+                            return path.join(dayPath, file);
+                        }
+                    }
+                }
+            }
+        }
+        return null;
+    }
+    /**
+     * Return JSONL file paths for sessions matching the given cwds.
+     */
+    async getFilesForProject(cwds) {
+        await this.scan();
+        const cwdSet = new Set(cwds);
+        return Array.from(this.cache.values())
+            .filter(meta => cwdSet.has(meta.directory))
+            .sort((a, b) => new Date(b.lastModified).getTime() - new Date(a.lastModified).getTime())
+            .map(meta => meta.jsonlPath);
+    }
+}
+export const codexSessionScanner = new CodexSessionScanner();

package/dist/src/agents/lib/codex/jsonl-mapper.d.ts

@@ -0,0 +1,11 @@
+import type { SessionEvent } from '../../../events/types.js';
+interface CodexLine {
+    timestamp?: string;
+    type: string;
+    payload: any;
+}
+/**
+ * Convert a single parsed Codex JSONL line into zero or more SessionEvents.
+ */
+export declare function mapCodexJsonlLine(line: CodexLine): SessionEvent[];
+export {};