@jinn-network/core 0.1.0

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

@@ -0,0 +1,137 @@
+/**
+ * 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 { readFile } from 'node:fs/promises';
+export class GeminiSessionParser {
+    tool = 'gemini-cli';
+    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;
+            }
+            events.push(...this.recordToEvents(record));
+        }
+        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;
+        this.buffer = '';
+        try {
+            return this.parseChunk({ sessionId: input.sessionId, chunk: normalised });
+        }
+        finally {
+            this.buffer = previousBuffer;
+        }
+    }
+    recordToEvents(record) {
+        if (!record || typeof record !== 'object')
+            return [];
+        const ts = record.timestamp ?? record.ts;
+        if (typeof ts !== 'string')
+            return [];
+        if (!Array.isArray(record.parts))
+            return [];
+        const role = record.role;
+        const out = [];
+        for (const part of record.parts) {
+            if (!part || typeof part !== 'object')
+                continue;
+            if (isTextPart(part)) {
+                if (role === 'user') {
+                    out.push({ kind: 'user-message', timestamp: ts, content: part.text });
+                }
+                else if (role === 'model' || role === 'assistant') {
+                    out.push({ kind: 'assistant-message', timestamp: ts, content: part.text });
+                }
+                continue;
+            }
+            if (isFunctionCallPart(part)) {
+                out.push({
+                    kind: 'tool-call',
+                    timestamp: ts,
+                    name: part.functionCall.name,
+                    args: part.functionCall.args ?? {},
+                });
+                continue;
+            }
+            if (isFunctionResponsePart(part)) {
+                const response = part.functionResponse.response;
+                const content = stringifyResponse(response);
+                out.push({
+                    kind: 'tool-result',
+                    timestamp: ts,
+                    name: part.functionResponse.name,
+                    content,
+                    isError: false,
+                });
+                continue;
+            }
+        }
+        return out;
+    }
+}
+function isTextPart(part) {
+    return (typeof part === 'object' &&
+        part !== null &&
+        typeof part.text === 'string');
+}
+function isFunctionCallPart(part) {
+    if (typeof part !== 'object' || part === null)
+        return false;
+    const fc = part.functionCall;
+    return Boolean(fc) && typeof fc.name === 'string';
+}
+function isFunctionResponsePart(part) {
+    if (typeof part !== 'object' || part === null)
+        return false;
+    const fr = part.functionResponse;
+    return Boolean(fr) && typeof fr.name === 'string';
+}
+function stringifyResponse(response) {
+    if (response == null)
+        return '';
+    if (typeof response === 'string')
+        return response;
+    // Gemini wraps tool output as { response: { content: '...' } } commonly;
+    // unwrap a single-string `content` field for readability, otherwise
+    // round-trip the JSON.
+    if (typeof response === 'object' &&
+        !Array.isArray(response) &&
+        'content' in response &&
+        typeof response.content === 'string') {
+        return response.content;
+    }
+    return JSON.stringify(response);
+}

package/dist/trajectory/transcript-parsers/index.d.ts

@@ -0,0 +1,7 @@
+export * from './aider-history.js';
+export * from './claude-code-jsonl.js';
+export * from './codex-session.js';
+export * from './continue-devdata.js';
+export * from './cursor-sqlite.js';
+export * from './gemini-session.js';
+export * from './types.js';

package/dist/trajectory/transcript-parsers/index.js

@@ -0,0 +1,7 @@
+export * from './aider-history.js';
+export * from './claude-code-jsonl.js';
+export * from './codex-session.js';
+export * from './continue-devdata.js';
+export * from './cursor-sqlite.js';
+export * from './gemini-session.js';
+export * from './types.js';

package/dist/trajectory/transcript-parsers/types.d.ts

@@ -0,0 +1,101 @@
+import { z } from 'zod/v3';
+export declare const TranscriptEventSchema: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+    kind: z.ZodLiteral<"user-message">;
+    timestamp: z.ZodString;
+    content: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    kind: "user-message";
+    content: string;
+    timestamp: string;
+}, {
+    kind: "user-message";
+    content: string;
+    timestamp: string;
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"assistant-message">;
+    timestamp: z.ZodString;
+    content: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    kind: "assistant-message";
+    content: string;
+    timestamp: string;
+}, {
+    kind: "assistant-message";
+    content: string;
+    timestamp: string;
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"tool-call">;
+    timestamp: z.ZodString;
+    name: z.ZodString;
+    args: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    kind: "tool-call";
+    timestamp: string;
+    args: Record<string, unknown>;
+}, {
+    name: string;
+    kind: "tool-call";
+    timestamp: string;
+    args: Record<string, unknown>;
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"tool-result">;
+    timestamp: z.ZodString;
+    name: z.ZodString;
+    content: z.ZodString;
+    isError: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    kind: "tool-result";
+    content: string;
+    timestamp: string;
+    isError?: boolean | undefined;
+}, {
+    name: string;
+    kind: "tool-result";
+    content: string;
+    timestamp: string;
+    isError?: boolean | undefined;
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"edit">;
+    timestamp: z.ZodString;
+    path: z.ZodString;
+    diff: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    kind: "edit";
+    timestamp: string;
+    diff: string;
+}, {
+    path: string;
+    kind: "edit";
+    timestamp: string;
+    diff: string;
+}>]>;
+export type TranscriptEvent = z.infer<typeof TranscriptEventSchema>;
+/**
+ * Per-tool transcript parser. Each implementation reads the native disk format
+ * for one tool (Claude Code JSONL, Cursor SQLite, Aider history, etc.) and
+ * normalises into the canonical TranscriptEvent shape so the synthetic-span
+ * builder (Task 3.2) can produce uniform OTel spans regardless of source.
+ */
+export interface TranscriptParser {
+    /** Tool identity. Used by the synthetic-span builder to brand `service.name`. */
+    readonly tool: 'claude-code' | 'codex' | 'gemini-cli' | 'cursor' | 'aider' | 'continue';
+    /**
+     * Incremental parser. Called when the watcher observes new bytes appended
+     * to the transcript file. Returns events drained since the last call.
+     */
+    parseChunk(input: {
+        sessionId: string;
+        chunk: Buffer | string;
+    }): TranscriptEvent[];
+    /**
+     * One-shot parser for a complete transcript file. Used by the
+     * `jinn capture import` CLI and as the path-D safety-net ingest at session end.
+     */
+    parseFull(input: {
+        sessionId: string;
+        path: string;
+    }): Promise<TranscriptEvent[]>;
+}

package/dist/trajectory/transcript-parsers/types.js

@@ -0,0 +1,32 @@
+import { z } from 'zod/v3';
+export const TranscriptEventSchema = z.discriminatedUnion('kind', [
+    z.object({
+        kind: z.literal('user-message'),
+        timestamp: z.string().datetime(),
+        content: z.string(),
+    }),
+    z.object({
+        kind: z.literal('assistant-message'),
+        timestamp: z.string().datetime(),
+        content: z.string(),
+    }),
+    z.object({
+        kind: z.literal('tool-call'),
+        timestamp: z.string().datetime(),
+        name: z.string(),
+        args: z.record(z.unknown()),
+    }),
+    z.object({
+        kind: z.literal('tool-result'),
+        timestamp: z.string().datetime(),
+        name: z.string(),
+        content: z.string(),
+        isError: z.boolean().optional(),
+    }),
+    z.object({
+        kind: z.literal('edit'),
+        timestamp: z.string().datetime(),
+        path: z.string(),
+        diff: z.string(),
+    }),
+]);

package/dist/trajectory/transcript-to-spans/attrs.d.ts

@@ -0,0 +1,4 @@
+export declare function truncate(value: string): string;
+export declare function truncateLeaves(value: unknown): unknown;
+export declare function stringifyResultContent(content: unknown): string;
+export declare function makeProvenanceAttrs(sourceFormat: string, parserName: string, parserVersion: string): Record<string, unknown>;

package/dist/trajectory/transcript-to-spans/attrs.js

@@ -0,0 +1,30 @@
+const MAX_ATTR_LENGTH = 8000;
+export function truncate(value) {
+    return value.length > MAX_ATTR_LENGTH ? value.slice(0, MAX_ATTR_LENGTH) : value;
+}
+export function truncateLeaves(value) {
+    if (typeof value === 'string')
+        return truncate(value);
+    if (Array.isArray(value))
+        return value.map(truncateLeaves);
+    if (value && typeof value === 'object') {
+        const result = {};
+        for (const [key, child] of Object.entries(value)) {
+            result[key] = truncateLeaves(child);
+        }
+        return result;
+    }
+    return value;
+}
+export function stringifyResultContent(content) {
+    if (typeof content === 'string')
+        return content;
+    return JSON.stringify(content) ?? String(content);
+}
+export function makeProvenanceAttrs(sourceFormat, parserName, parserVersion) {
+    return {
+        'jinn.transcript.sourceFormat': sourceFormat,
+        'jinn.transcript.parser': parserName,
+        'jinn.transcript.parserVersion': parserVersion,
+    };
+}

package/dist/trajectory/transcript-to-spans/claude-code-stream-json.d.ts

@@ -0,0 +1,8 @@
+import type { TranscriptSpanInput, TranscriptSpanParser } from './types.js';
+export declare class ClaudeCodeStreamJsonParser implements TranscriptSpanParser {
+    readonly sourceFormat = "claude-code-stream-json";
+    readonly parserName = "claude-code-stream-json";
+    readonly parserVersion = "1.0.0";
+    parse(transcriptPath: string): Promise<TranscriptSpanInput[]>;
+    parseText(rawText: string): TranscriptSpanInput[];
+}

package/dist/trajectory/transcript-to-spans/claude-code-stream-json.js

@@ -0,0 +1,162 @@
+import { readFile } from 'node:fs/promises';
+import { makeProvenanceAttrs, stringifyResultContent, truncate, truncateLeaves, } from './attrs.js';
+const SOURCE_FORMAT = 'claude-code-stream-json';
+const PARSER_NAME = 'claude-code-stream-json';
+const PARSER_VERSION = '1.0.0';
+function provenanceAttrs() {
+    return makeProvenanceAttrs(SOURCE_FORMAT, PARSER_NAME, PARSER_VERSION);
+}
+export class ClaudeCodeStreamJsonParser {
+    sourceFormat = SOURCE_FORMAT;
+    parserName = PARSER_NAME;
+    parserVersion = PARSER_VERSION;
+    async parse(transcriptPath) {
+        let rawText;
+        try {
+            rawText = await readFile(transcriptPath, 'utf-8');
+        }
+        catch {
+            return [];
+        }
+        return this.parseText(rawText);
+    }
+    parseText(rawText) {
+        const spans = [];
+        const pendingByToolUseId = new Map();
+        const agentTurns = [];
+        let nextNs = BigInt(Date.now()) * 1000000n;
+        const nextTimestamp = () => {
+            const timestamp = nextNs;
+            nextNs += 1n;
+            return String(timestamp);
+        };
+        for (const line of rawText.split('\n')) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            let record;
+            try {
+                record = JSON.parse(trimmed);
+            }
+            catch {
+                continue;
+            }
+            if (!record || typeof record.type !== 'string' || record.type === 'system')
+                continue;
+            if (record.type === 'result') {
+                const inputTokens = record.usage?.input_tokens;
+                const outputTokens = record.usage?.output_tokens;
+                if (typeof inputTokens === 'number' &&
+                    typeof outputTokens === 'number' &&
+                    agentTurns.length > 0) {
+                    const last = agentTurns[agentTurns.length - 1];
+                    last.attributes['gen_ai.usage.input_tokens'] = inputTokens;
+                    last.attributes['gen_ai.usage.output_tokens'] = outputTokens;
+                }
+                continue;
+            }
+            if (record.type === 'user') {
+                const content = record.message?.content;
+                if (typeof content === 'string') {
+                    const timestamp = nextTimestamp();
+                    const turn = {
+                        name: 'agent_turn.user',
+                        kind: 'INTERNAL',
+                        startTimeUnixNano: timestamp,
+                        endTimeUnixNano: timestamp,
+                        attributes: {
+                            'jinn.span.kind': 'jinn.agent_turn',
+                            'jinn.turn.role': 'user',
+                            'message.content': truncate(content),
+                            ...provenanceAttrs(),
+                        },
+                        events: [],
+                        status: { code: 'OK' },
+                    };
+                    spans.push(turn);
+                    agentTurns.push(turn);
+                    continue;
+                }
+                if (Array.isArray(content)) {
+                    for (const block of content) {
+                        if (!block ||
+                            typeof block !== 'object' ||
+                            block.type !== 'tool_result') {
+                            continue;
+                        }
+                        const toolResult = block;
+                        const call = pendingByToolUseId.get(toolResult.tool_use_id);
+                        if (!call)
+                            continue;
+                        pendingByToolUseId.delete(toolResult.tool_use_id);
+                        const timestamp = nextTimestamp();
+                        call.endTimeUnixNano = timestamp;
+                        call.events = [
+                            {
+                                timeUnixNano: timestamp,
+                                name: 'tool_result',
+                                attributes: {
+                                    'tool.result': truncate(stringifyResultContent(toolResult.content)),
+                                    'tool.result.is_error': toolResult.is_error ?? false,
+                                },
+                            },
+                        ];
+                        call.status = toolResult.is_error ? { code: 'ERROR' } : { code: 'OK' };
+                    }
+                }
+                continue;
+            }
+            if (record.type !== 'assistant' || !Array.isArray(record.message?.content))
+                continue;
+            for (const block of record.message.content) {
+                if (!block || typeof block !== 'object')
+                    continue;
+                const blockType = block.type;
+                if (blockType === 'thinking')
+                    continue;
+                if (blockType === 'text') {
+                    const text = block;
+                    const timestamp = nextTimestamp();
+                    const turn = {
+                        name: 'agent_turn.assistant',
+                        kind: 'INTERNAL',
+                        startTimeUnixNano: timestamp,
+                        endTimeUnixNano: timestamp,
+                        attributes: {
+                            'jinn.span.kind': 'jinn.agent_turn',
+                            'jinn.turn.role': 'assistant',
+                            'message.content': truncate(text.text),
+                            ...provenanceAttrs(),
+                        },
+                        events: [],
+                        status: { code: 'OK' },
+                    };
+                    spans.push(turn);
+                    agentTurns.push(turn);
+                    continue;
+                }
+                if (blockType === 'tool_use') {
+                    const toolUse = block;
+                    const timestamp = nextTimestamp();
+                    const call = {
+                        name: `tool_call.${toolUse.name}`,
+                        kind: 'INTERNAL',
+                        startTimeUnixNano: timestamp,
+                        endTimeUnixNano: timestamp,
+                        attributes: {
+                            'jinn.span.kind': 'jinn.tool_call',
+                            'tool.name': toolUse.name,
+                            'tool.args': truncateLeaves(toolUse.input),
+                            ...provenanceAttrs(),
+                        },
+                        events: [],
+                        status: { code: 'UNSET' },
+                    };
+                    spans.push(call);
+                    pendingByToolUseId.set(toolUse.id, call);
+                }
+            }
+        }
+        return spans;
+    }
+}

package/dist/trajectory/transcript-to-spans/codex-exec-json.d.ts

@@ -0,0 +1,8 @@
+import type { TranscriptSpanInput, TranscriptSpanParser } from './types.js';
+export declare class CodexExecJsonParser implements TranscriptSpanParser {
+    readonly sourceFormat = "codex-exec-json";
+    readonly parserName = "codex-exec-json";
+    readonly parserVersion = "1.1.0";
+    parse(transcriptPath: string): Promise<TranscriptSpanInput[]>;
+    parseText(rawText: string): TranscriptSpanInput[];
+}