@jinn-network/core 0.1.0

package/dist/trajectory/transcript-parsers/codex-session.js

@@ -0,0 +1,235 @@
+/**
+ * Codex CLI session transcript parser.
+ *
+ * Reads `~/.codex/sessions/<id>.jsonl` line-by-line, mapping per-record content
+ * to canonical TranscriptEvent shapes (Task 3.1):
+ *  - role: 'user' with string content       → user-message
+ *  - role: 'assistant' with string content  → assistant-message
+ *  - role: 'function' with function_call    → tool-call (also: assistant with
+ *    a top-level function_call field)
+ *  - role: 'tool' with content               → tool-result
+ *
+ * Codex CLI 0.129.0+ wraps each line as `{ timestamp, type, payload }` where
+ * `type` is `session_meta`, `turn_context`, `response_item`, or `event_msg`.
+ * Tool calls and messages live inside `payload` (e.g. `function_call`,
+ * `function_call_output`, `message` with `input_text` / `output_text` blocks).
+ * Older sessions use a flat per-line shape with `role` at the top level; both
+ * are detected by record shape.
+ *
+ * `parseChunk` preserves any incomplete trailing line across calls so the
+ * watcher (Task 3.9) can stream tail bytes without losing partial records.
+ *
+ * Spec: spec/2026-05-07-telemetry-collector-and-task-generator.md §4.2 path B.
+ */
+import { readFile } from 'node:fs/promises';
+export class CodexSessionParser {
+    tool = 'codex';
+    buffer = '';
+    /** Maps function_call `call_id` → tool name for function_call_output rows. */
+    callNames = new Map();
+    parseChunk(input) {
+        const text = typeof input.chunk === 'string' ? input.chunk : input.chunk.toString('utf-8');
+        this.buffer += text;
+        const lines = this.buffer.split('\n');
+        this.buffer = lines.pop() ?? '';
+        const events = [];
+        for (const line of lines) {
+            if (!line.trim())
+                continue;
+            let raw;
+            try {
+                raw = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            events.push(...this.lineToEvents(raw));
+        }
+        return events;
+    }
+    async parseFull(input) {
+        const text = await readFile(input.path, 'utf-8');
+        const normalised = text.endsWith('\n') ? text : text + '\n';
+        const previousBuffer = this.buffer;
+        const previousCallNames = new Map(this.callNames);
+        this.buffer = '';
+        this.callNames.clear();
+        try {
+            return this.parseChunk({ sessionId: input.sessionId, chunk: normalised });
+        }
+        finally {
+            this.buffer = previousBuffer;
+            this.callNames = previousCallNames;
+        }
+    }
+    lineToEvents(raw) {
+        if (!raw || typeof raw !== 'object')
+            return [];
+        if (isWrappedEnvelope(raw)) {
+            return this.wrappedEnvelopeToEvents(raw);
+        }
+        return this.recordToEvents(raw);
+    }
+    wrappedEnvelopeToEvents(envelope) {
+        const ts = envelope.timestamp;
+        if (typeof ts !== 'string')
+            return [];
+        const payload = envelope.payload;
+        if (!payload || typeof payload !== 'object')
+            return [];
+        if (envelope.type === 'response_item') {
+            return this.responseItemToEvents(ts, payload);
+        }
+        // `event_msg` rows (user_message, agent_message, mcp_tool_call_end) duplicate
+        // `response_item` message/tool rows — skip them to avoid double-counting.
+        return [];
+    }
+    responseItemToEvents(ts, payload) {
+        const itemType = payload.type;
+        if (itemType === 'function_call') {
+            const name = payload.name;
+            if (typeof name !== 'string')
+                return [];
+            const callId = payload.call_id;
+            if (typeof callId === 'string') {
+                this.callNames.set(callId, name);
+            }
+            return [
+                {
+                    kind: 'tool-call',
+                    timestamp: ts,
+                    name,
+                    args: parseArgs(payload.arguments),
+                },
+            ];
+        }
+        if (itemType === 'function_call_output') {
+            const output = payload.output;
+            const content = typeof output === 'string' ? output : stringifyContent(output);
+            if (!content)
+                return [];
+            const callId = payload.call_id;
+            const name = (typeof callId === 'string' ? this.callNames.get(callId) : undefined) ??
+                (typeof callId === 'string' ? callId : undefined);
+            if (typeof name !== 'string')
+                return [];
+            return [{ kind: 'tool-result', timestamp: ts, name, content, isError: false }];
+        }
+        if (itemType === 'message') {
+            const role = payload.role;
+            const text = extractMessageText(payload.content);
+            if (!text)
+                return [];
+            if (role === 'user') {
+                return [{ kind: 'user-message', timestamp: ts, content: text }];
+            }
+            if (role === 'assistant') {
+                return [{ kind: 'assistant-message', timestamp: ts, content: text }];
+            }
+        }
+        return [];
+    }
+    recordToEvents(record) {
+        if (!record || typeof record !== 'object')
+            return [];
+        const ts = record.ts ?? record.timestamp;
+        if (typeof ts !== 'string')
+            return [];
+        const role = record.role;
+        // function_call may sit on either a 'function' role record or alongside an
+        // 'assistant' role record. Emit a tool-call event when we find one.
+        if (record.function_call && typeof record.function_call === 'object') {
+            const fn = record.function_call;
+            if (typeof fn.name === 'string') {
+                return [
+                    {
+                        kind: 'tool-call',
+                        timestamp: ts,
+                        name: fn.name,
+                        args: parseArgs(fn.arguments),
+                    },
+                ];
+            }
+        }
+        if (role === 'user') {
+            const text = extractMessageText(record.content);
+            if (text) {
+                return [{ kind: 'user-message', timestamp: ts, content: text }];
+            }
+            return [];
+        }
+        if (role === 'assistant') {
+            const text = extractMessageText(record.content);
+            if (text) {
+                return [{ kind: 'assistant-message', timestamp: ts, content: text }];
+            }
+            return [];
+        }
+        if (role === 'tool' || role === 'function-result') {
+            const content = stringifyContent(record.content);
+            if (!content)
+                return [];
+            // Prefer `name` (tool name) when present; fall back to tool_call_id so
+            // downstream consumers always see a stable identifier. v0 gap: when
+            // only an id is available it carries less display signal than the name.
+            const name = record.name ?? record.tool_call_id;
+            if (typeof name !== 'string')
+                return [];
+            return [{ kind: 'tool-result', timestamp: ts, name, content, isError: false }];
+        }
+        return [];
+    }
+}
+function isWrappedEnvelope(raw) {
+    const rec = raw;
+    return (typeof rec.type === 'string' &&
+        rec.payload !== undefined &&
+        rec.payload !== null &&
+        typeof rec.payload === 'object' &&
+        !('role' in rec));
+}
+function extractMessageText(content) {
+    if (typeof content === 'string')
+        return content;
+    if (!Array.isArray(content))
+        return null;
+    const parts = [];
+    for (const block of content) {
+        if (!block || typeof block !== 'object')
+            continue;
+        const b = block;
+        const blockType = b.type;
+        if ((blockType === 'input_text' || blockType === 'output_text') &&
+            typeof b.text === 'string') {
+            parts.push(b.text);
+        }
+    }
+    return parts.length > 0 ? parts.join('\n') : null;
+}
+function parseArgs(raw) {
+    if (!raw)
+        return {};
+    if (typeof raw === 'object')
+        return raw;
+    if (typeof raw === 'string') {
+        try {
+            const parsed = JSON.parse(raw);
+            if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+                return parsed;
+            }
+        }
+        catch {
+            // Fall through — store the raw string under a sentinel key so the args
+            // round-trip through the canonical schema's `record(unknown)` shape.
+            return { _raw: raw };
+        }
+    }
+    return {};
+}
+function stringifyContent(content) {
+    if (typeof content === 'string')
+        return content;
+    if (content == null)
+        return '';
+    return JSON.stringify(content);
+}

package/dist/trajectory/transcript-parsers/continue-devdata.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Continue dev_data transcript parser.
+ *
+ * Continue (continue.dev) writes telemetry to `<workspace>/.continue/dev_data/`
+ * with one JSONL file per event kind and schema version:
+ *
+ *   .continue/dev_data/chat/<schema-version>.jsonl
+ *   .continue/dev_data/edit/<schema-version>.jsonl
+ *   .continue/dev_data/autocomplete/<schema-version>.jsonl
+ *
+ * For Phase 3 v0 we ingest `chat` and `edit` directories. `autocomplete` is a
+ * different signal (per-keystroke completions) and is intentionally skipped.
+ *
+ * Per-event-kind record shapes (best-effort; schema varies slightly across
+ * Continue versions):
+ *   chat:  { role: 'user' | 'assistant', timestamp, content }
+ *   edit:  { timestamp, filepath, diff } (also accepts `path` for filepath)
+ *
+ * `parseFull` is given the dev_data directory; it globs the kind-subdirs we
+ * care about, reads each JSONL file, and dispatches per kind.
+ *
+ * `parseChunk` supports streaming a single file: callers may include a `kind`
+ * field on each record (the watcher knows which file it is tailing and tags
+ * each line); when missing, the parser tries chat first, then edit. Records
+ * that match neither are skipped.
+ *
+ * Spec: spec/2026-05-07-telemetry-collector-and-task-generator.md §4.2 path B.
+ */
+import type { TranscriptEvent, TranscriptParser } from './types.js';
+export declare class ContinueDevDataParser implements TranscriptParser {
+    readonly tool: "continue";
+    private buffer;
+    parseChunk(input: {
+        sessionId: string;
+        chunk: Buffer | string;
+    }): TranscriptEvent[];
+    parseFull(input: {
+        sessionId: string;
+        path: string;
+    }): Promise<TranscriptEvent[]>;
+}

package/dist/trajectory/transcript-parsers/continue-devdata.js

@@ -0,0 +1,190 @@
+/**
+ * Continue dev_data transcript parser.
+ *
+ * Continue (continue.dev) writes telemetry to `<workspace>/.continue/dev_data/`
+ * with one JSONL file per event kind and schema version:
+ *
+ *   .continue/dev_data/chat/<schema-version>.jsonl
+ *   .continue/dev_data/edit/<schema-version>.jsonl
+ *   .continue/dev_data/autocomplete/<schema-version>.jsonl
+ *
+ * For Phase 3 v0 we ingest `chat` and `edit` directories. `autocomplete` is a
+ * different signal (per-keystroke completions) and is intentionally skipped.
+ *
+ * Per-event-kind record shapes (best-effort; schema varies slightly across
+ * Continue versions):
+ *   chat:  { role: 'user' | 'assistant', timestamp, content }
+ *   edit:  { timestamp, filepath, diff } (also accepts `path` for filepath)
+ *
+ * `parseFull` is given the dev_data directory; it globs the kind-subdirs we
+ * care about, reads each JSONL file, and dispatches per kind.
+ *
+ * `parseChunk` supports streaming a single file: callers may include a `kind`
+ * field on each record (the watcher knows which file it is tailing and tags
+ * each line); when missing, the parser tries chat first, then edit. Records
+ * that match neither are skipped.
+ *
+ * Spec: spec/2026-05-07-telemetry-collector-and-task-generator.md §4.2 path B.
+ */
+import { readFile, readdir, stat } from 'node:fs/promises';
+import * as path from 'node:path';
+const SUPPORTED_KINDS = new Set(['chat', 'edit']);
+export class ContinueDevDataParser {
+    tool = 'continue';
+    buffer = '';
+    parseChunk(input) {
+        const text = typeof input.chunk === 'string' ? input.chunk : input.chunk.toString('utf-8');
+        this.buffer += text;
+        const lines = this.buffer.split('\n');
+        this.buffer = lines.pop() ?? '';
+        const events = [];
+        for (const line of lines) {
+            if (!line.trim())
+                continue;
+            let record;
+            try {
+                record = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            const event = recordToEvent(record);
+            if (event)
+                events.push(event);
+        }
+        return events;
+    }
+    async parseFull(input) {
+        // For dev_data, the path is the dev_data directory (or a single file).
+        // If it's a directory, walk supported kind-subdirs; otherwise treat as
+        // a single JSONL file (delegate to parseChunk).
+        let stats;
+        try {
+            stats = await stat(input.path);
+        }
+        catch {
+            return [];
+        }
+        if (stats.isFile()) {
+            const text = await readFile(input.path, 'utf-8');
+            const normalised = text.endsWith('\n') ? text : text + '\n';
+            const previousBuffer = this.buffer;
+            this.buffer = '';
+            try {
+                // Tag records with the inferred kind from the parent directory so
+                // ambiguous shapes resolve correctly.
+                const inferredKind = inferKindFromPath(input.path);
+                return this.parseChunk({
+                    sessionId: input.sessionId,
+                    chunk: tagChunkWithKind(normalised, inferredKind),
+                });
+            }
+            finally {
+                this.buffer = previousBuffer;
+            }
+        }
+        if (!stats.isDirectory())
+            return [];
+        const events = [];
+        let entries;
+        try {
+            entries = await readdir(input.path);
+        }
+        catch {
+            return [];
+        }
+        for (const entry of entries) {
+            if (!SUPPORTED_KINDS.has(entry))
+                continue;
+            const subdir = path.join(input.path, entry);
+            let subEntries;
+            try {
+                subEntries = await readdir(subdir);
+            }
+            catch {
+                continue;
+            }
+            for (const sub of subEntries) {
+                if (!sub.endsWith('.jsonl'))
+                    continue;
+                const filePath = path.join(subdir, sub);
+                const text = await readFile(filePath, 'utf-8');
+                for (const line of text.split('\n')) {
+                    if (!line.trim())
+                        continue;
+                    let record;
+                    try {
+                        record = JSON.parse(line);
+                    }
+                    catch {
+                        continue;
+                    }
+                    // Tag with the dir-inferred kind so ambiguous records resolve.
+                    if (!record.kind)
+                        record.kind = entry;
+                    const event = recordToEvent(record);
+                    if (event)
+                        events.push(event);
+                }
+            }
+        }
+        return events;
+    }
+}
+function recordToEvent(record) {
+    if (!record || typeof record !== 'object')
+        return null;
+    const ts = record.timestamp ?? record.ts;
+    if (typeof ts !== 'string')
+        return null;
+    const kind = record.kind;
+    if (kind === 'chat' || (!kind && typeof record.role === 'string')) {
+        if (typeof record.content !== 'string')
+            return null;
+        if (record.role === 'user') {
+            return { kind: 'user-message', timestamp: ts, content: record.content };
+        }
+        if (record.role === 'assistant') {
+            return { kind: 'assistant-message', timestamp: ts, content: record.content };
+        }
+        return null;
+    }
+    if (kind === 'edit' || (!kind && (record.filepath || record.path) && record.diff)) {
+        const filePath = record.filepath ?? record.path;
+        if (typeof filePath !== 'string')
+            return null;
+        if (typeof record.diff !== 'string')
+            return null;
+        return { kind: 'edit', timestamp: ts, path: filePath, diff: record.diff };
+    }
+    return null;
+}
+function inferKindFromPath(filePath) {
+    const parent = path.basename(path.dirname(filePath));
+    if (SUPPORTED_KINDS.has(parent))
+        return parent;
+    return null;
+}
+function tagChunkWithKind(text, kind) {
+    if (!kind)
+        return text;
+    // Splice a `"kind":"<kind>"` field into each JSON object. Cheap approach:
+    // re-parse + re-stringify each record to set the field. Avoids string-
+    // surgery edge cases on malformed lines.
+    return (text
+        .split('\n')
+        .map((line) => {
+        if (!line.trim())
+            return line;
+        try {
+            const obj = JSON.parse(line);
+            if (typeof obj.kind !== 'string')
+                obj.kind = kind;
+            return JSON.stringify(obj);
+        }
+        catch {
+            return line;
+        }
+    })
+        .join('\n'));
+}

package/dist/trajectory/transcript-parsers/cursor-sqlite.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Cursor SQLite chat-store parser.
+ *
+ * Cursor stores its workspace chat history in a SQLite key-value DB at
+ * `<workspace>/.cursor/state.vscdb` (or `<state-dir>/User/workspaceStorage/
+ * <hash>/state.vscdb` for the global store). Chat data lives under the key
+ * `workbench.panel.aichat.view.aichat.chatdata` in the `ItemTable` row, with
+ * the value being a JSON blob structured as `{ tabs: [{ bubbles: [...] }] }`.
+ *
+ * Each bubble is one of:
+ *   - { type: 'user' | 'human', text/content }     → user-message
+ *   - { type: 'ai' | 'assistant', text/content }   → assistant-message
+ *   - { type: 'tool_call', toolName, args }        → tool-call
+ *   - { type: 'tool_result', toolName, content }   → tool-result
+ *
+ * Cursor's exact on-disk shape varies by version; this parser is best-effort
+ * and skips bubbles it doesn't recognise. Hand-crafted fixtures cover the
+ * canonical happy paths; no binary `.vscdb` files are committed (the test
+ * suite builds an SQLite DB at runtime via better-sqlite3).
+ *
+ * `parseChunk` is a no-op for SQLite — the watcher polls the DB and replays
+ * via `parseFull`. `parseFull` opens read-only, queries the chat-data row,
+ * decodes the JSON, and walks bubbles in order.
+ *
+ * Spec: spec/2026-05-07-telemetry-collector-and-task-generator.md §4.2 path B.
+ */
+import type { TranscriptEvent, TranscriptParser } from './types.js';
+export declare class CursorSqliteParser implements TranscriptParser {
+    readonly tool: "cursor";
+    parseChunk(_input: {
+        sessionId: string;
+        chunk: Buffer | string;
+    }): TranscriptEvent[];
+    parseFull(input: {
+        sessionId: string;
+        path: string;
+    }): Promise<TranscriptEvent[]>;
+}

package/dist/trajectory/transcript-parsers/cursor-sqlite.js

@@ -0,0 +1,118 @@
+/**
+ * Cursor SQLite chat-store parser.
+ *
+ * Cursor stores its workspace chat history in a SQLite key-value DB at
+ * `<workspace>/.cursor/state.vscdb` (or `<state-dir>/User/workspaceStorage/
+ * <hash>/state.vscdb` for the global store). Chat data lives under the key
+ * `workbench.panel.aichat.view.aichat.chatdata` in the `ItemTable` row, with
+ * the value being a JSON blob structured as `{ tabs: [{ bubbles: [...] }] }`.
+ *
+ * Each bubble is one of:
+ *   - { type: 'user' | 'human', text/content }     → user-message
+ *   - { type: 'ai' | 'assistant', text/content }   → assistant-message
+ *   - { type: 'tool_call', toolName, args }        → tool-call
+ *   - { type: 'tool_result', toolName, content }   → tool-result
+ *
+ * Cursor's exact on-disk shape varies by version; this parser is best-effort
+ * and skips bubbles it doesn't recognise. Hand-crafted fixtures cover the
+ * canonical happy paths; no binary `.vscdb` files are committed (the test
+ * suite builds an SQLite DB at runtime via better-sqlite3).
+ *
+ * `parseChunk` is a no-op for SQLite — the watcher polls the DB and replays
+ * via `parseFull`. `parseFull` opens read-only, queries the chat-data row,
+ * decodes the JSON, and walks bubbles in order.
+ *
+ * Spec: spec/2026-05-07-telemetry-collector-and-task-generator.md §4.2 path B.
+ */
+import Database from 'better-sqlite3';
+const CHAT_DATA_KEY = 'workbench.panel.aichat.view.aichat.chatdata';
+export class CursorSqliteParser {
+    tool = 'cursor';
+    parseChunk(_input) {
+        // SQLite is not a streaming format — the watcher polls and re-runs parseFull.
+        return [];
+    }
+    async parseFull(input) {
+        const db = new Database(input.path, { readonly: true, fileMustExist: true });
+        try {
+            const row = db
+                .prepare('SELECT value FROM ItemTable WHERE key = ?')
+                .get(CHAT_DATA_KEY);
+            if (!row || typeof row.value !== 'string')
+                return [];
+            let parsed;
+            try {
+                parsed = JSON.parse(row.value);
+            }
+            catch {
+                return [];
+            }
+            if (!parsed || !Array.isArray(parsed.tabs))
+                return [];
+            const events = [];
+            for (const tab of parsed.tabs) {
+                if (!tab || !Array.isArray(tab.bubbles))
+                    continue;
+                for (const raw of tab.bubbles) {
+                    const event = bubbleToEvent(raw);
+                    if (event)
+                        events.push(event);
+                }
+            }
+            return events;
+        }
+        finally {
+            db.close();
+        }
+    }
+}
+function bubbleToEvent(raw) {
+    if (!raw || typeof raw !== 'object')
+        return null;
+    const bubble = raw;
+    const ts = bubble.timestamp ?? bubble.ts;
+    if (typeof ts !== 'string')
+        return null;
+    const type = bubble.type;
+    if (type === 'user' || type === 'human') {
+        const content = bubble.text ?? (typeof bubble.content === 'string' ? bubble.content : null);
+        if (typeof content !== 'string')
+            return null;
+        return { kind: 'user-message', timestamp: ts, content };
+    }
+    if (type === 'ai' || type === 'assistant') {
+        const content = bubble.text ?? (typeof bubble.content === 'string' ? bubble.content : null);
+        if (typeof content !== 'string')
+            return null;
+        return { kind: 'assistant-message', timestamp: ts, content };
+    }
+    if (type === 'tool_call') {
+        const name = bubble.toolName ?? bubble.name;
+        if (typeof name !== 'string')
+            return null;
+        return {
+            kind: 'tool-call',
+            timestamp: ts,
+            name,
+            args: bubble.args && typeof bubble.args === 'object' ? bubble.args : {},
+        };
+    }
+    if (type === 'tool_result') {
+        const name = bubble.toolName ?? bubble.name;
+        if (typeof name !== 'string')
+            return null;
+        const content = typeof bubble.content === 'string'
+            ? bubble.content
+            : bubble.content == null
+                ? ''
+                : JSON.stringify(bubble.content);
+        return {
+            kind: 'tool-result',
+            timestamp: ts,
+            name,
+            content,
+            isError: bubble.isError ?? false,
+        };
+    }
+    return null;
+}

package/dist/trajectory/transcript-parsers/gemini-session.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Gemini CLI session transcript parser.
+ *
+ * Reads `~/.gemini/sessions/<id>.jsonl` (or comparable path) line-by-line,
+ * mapping per-record content to canonical TranscriptEvent shapes (Task 3.1).
+ *
+ * Gemini's content shape follows the GenerativeAI Content schema: each record
+ * has a `role` ('user' or 'model') and a `parts` array. Each part may be:
+ *   - { text: string }                  → user-message / assistant-message
+ *   - { functionCall: { name, args } }  → tool-call
+ *   - { functionResponse: { name, response } } → tool-result
+ *
+ * Multiple parts in a single record can produce multiple events, mirroring
+ * the Claude Code parser's tool_use-block handling. Text parts within the
+ * same model record are concatenated into a single assistant-message; mixing
+ * text and functionCall parts emits both, in order.
+ *
+ * `parseChunk` preserves any incomplete trailing line across calls.
+ *
+ * Spec: spec/2026-05-07-telemetry-collector-and-task-generator.md §4.2 path B.
+ */
+import type { TranscriptEvent, TranscriptParser } from './types.js';
+export declare class GeminiSessionParser implements TranscriptParser {
+    readonly tool: "gemini-cli";
+    private buffer;
+    parseChunk(input: {
+        sessionId: string;
+        chunk: Buffer | string;
+    }): TranscriptEvent[];
+    parseFull(input: {
+        sessionId: string;
+        path: string;
+    }): Promise<TranscriptEvent[]>;
+    private recordToEvents;
+}