@jinn-network/core 0.1.0

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

@@ -0,0 +1,253 @@
+import { readFile } from 'node:fs/promises';
+import { CodexSessionParser } from '../transcript-parsers/codex-session.js';
+import { makeProvenanceAttrs, truncate, truncateLeaves } from './attrs.js';
+const SOURCE_FORMAT = 'codex-exec-json';
+const PARSER_NAME = 'codex-exec-json';
+const PARSER_VERSION = '1.1.0';
+class TimestampCursor {
+    lastGoodNs = 0n;
+    next(iso) {
+        const milliseconds = new Date(iso).getTime();
+        if (Number.isFinite(milliseconds)) {
+            const nanoseconds = BigInt(milliseconds) * 1000000n;
+            this.lastGoodNs = nanoseconds;
+            return String(nanoseconds);
+        }
+        this.lastGoodNs += 1n;
+        return String(this.lastGoodNs);
+    }
+}
+function provenanceAttrs() {
+    return makeProvenanceAttrs(SOURCE_FORMAT, PARSER_NAME, PARSER_VERSION);
+}
+/**
+ * `codex exec --json` stdout uses item lifecycle records, while Codex home
+ * sessions use timestamped `response_item` envelopes. Convert the direct
+ * stream to the same events consumed below; returning no events preserves the
+ * home-session compatibility fallback.
+ */
+function parseDirectExecEvents(rawText) {
+    const events = [];
+    const pendingCommandIds = new Set();
+    let syntheticTimestampMs = 0;
+    const nextTimestamp = () => new Date(syntheticTimestampMs++).toISOString();
+    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 || (record.type !== 'item.started' && record.type !== 'item.completed')) {
+            continue;
+        }
+        if (!record.item || typeof record.item !== 'object' || Array.isArray(record.item)) {
+            continue;
+        }
+        const item = record.item;
+        if (record.type === 'item.completed' &&
+            item.type === 'agent_message' &&
+            typeof item.text === 'string' &&
+            item.text.length > 0) {
+            events.push({
+                kind: 'assistant-message',
+                timestamp: nextTimestamp(),
+                content: item.text,
+            });
+            continue;
+        }
+        if (item.type !== 'command_execution' || typeof item.command !== 'string') {
+            continue;
+        }
+        const itemId = typeof item.id === 'string' ? item.id : null;
+        const hasPendingCall = itemId !== null && pendingCommandIds.has(itemId);
+        if (record.type === 'item.started') {
+            events.push({
+                kind: 'tool-call',
+                timestamp: nextTimestamp(),
+                name: 'command_execution',
+                args: { command: item.command },
+                ...(itemId !== null ? { correlationId: itemId } : {}),
+            });
+            if (itemId !== null)
+                pendingCommandIds.add(itemId);
+            continue;
+        }
+        // A completed-only stream still carries enough evidence for a full call.
+        if (!hasPendingCall) {
+            events.push({
+                kind: 'tool-call',
+                timestamp: nextTimestamp(),
+                name: 'command_execution',
+                args: { command: item.command },
+                ...(itemId !== null ? { correlationId: itemId } : {}),
+            });
+        }
+        if (itemId !== null)
+            pendingCommandIds.delete(itemId);
+        const output = typeof item.aggregated_output === 'string' ? item.aggregated_output : '';
+        const isError = (typeof item.exit_code === 'number' && item.exit_code !== 0) ||
+            item.status === 'failed';
+        events.push({
+            kind: 'tool-result',
+            timestamp: nextTimestamp(),
+            name: 'command_execution',
+            content: output,
+            isError,
+            ...(itemId !== null ? { correlationId: itemId } : {}),
+        });
+    }
+    return events;
+}
+function findTerminalUsage(rawText) {
+    let result = null;
+    for (const line of rawText.split('\n')) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        let object;
+        try {
+            object = JSON.parse(trimmed);
+        }
+        catch {
+            continue;
+        }
+        if ((object['type'] === 'turn.completed' || object['type'] === 'turn.failed') &&
+            object['usage']) {
+            const usage = object['usage'];
+            const inputTokens = usage['input_tokens'];
+            const outputTokens = usage['output_tokens'];
+            if (typeof inputTokens === 'number' && typeof outputTokens === 'number') {
+                result = { inputTokens, outputTokens };
+            }
+        }
+    }
+    return result;
+}
+export class CodexExecJsonParser {
+    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) {
+        let events = parseDirectExecEvents(rawText);
+        if (events.length === 0) {
+            try {
+                const normalized = rawText.endsWith('\n') ? rawText : `${rawText}\n`;
+                events = new CodexSessionParser().parseChunk({
+                    sessionId: 'engine-pack',
+                    chunk: normalized,
+                });
+            }
+            catch {
+                return [];
+            }
+        }
+        const spans = [];
+        const pendingByName = new Map();
+        const pendingByCorrelationId = new Map();
+        const agentTurns = [];
+        const cursor = new TimestampCursor();
+        for (const event of events) {
+            switch (event.kind) {
+                case 'user-message':
+                case 'assistant-message': {
+                    const timestamp = cursor.next(event.timestamp);
+                    const turn = {
+                        name: `agent_turn.${event.kind === 'user-message' ? 'user' : 'assistant'}`,
+                        kind: 'INTERNAL',
+                        startTimeUnixNano: timestamp,
+                        endTimeUnixNano: timestamp,
+                        attributes: {
+                            'jinn.span.kind': 'jinn.agent_turn',
+                            'jinn.turn.role': event.kind === 'user-message' ? 'user' : 'assistant',
+                            'message.content': truncate(event.content),
+                            ...provenanceAttrs(),
+                        },
+                        events: [],
+                        status: { code: 'OK' },
+                    };
+                    spans.push(turn);
+                    agentTurns.push(turn);
+                    break;
+                }
+                case 'tool-call': {
+                    const timestamp = cursor.next(event.timestamp);
+                    const call = {
+                        name: `tool_call.${event.name}`,
+                        kind: 'INTERNAL',
+                        startTimeUnixNano: timestamp,
+                        endTimeUnixNano: timestamp,
+                        attributes: {
+                            'jinn.span.kind': 'jinn.tool_call',
+                            'tool.name': event.name,
+                            'tool.args': truncateLeaves(event.args),
+                            ...provenanceAttrs(),
+                        },
+                        events: [],
+                        status: { code: 'UNSET' },
+                    };
+                    spans.push(call);
+                    if (event.correlationId) {
+                        pendingByCorrelationId.set(event.correlationId, call);
+                    }
+                    else {
+                        const queue = pendingByName.get(event.name) ?? [];
+                        queue.push(call);
+                        pendingByName.set(event.name, queue);
+                    }
+                    break;
+                }
+                case 'tool-result': {
+                    let call;
+                    if (event.correlationId) {
+                        call = pendingByCorrelationId.get(event.correlationId);
+                        pendingByCorrelationId.delete(event.correlationId);
+                    }
+                    else {
+                        const queue = pendingByName.get(event.name);
+                        call = queue?.shift();
+                    }
+                    if (!call)
+                        break;
+                    const timestamp = cursor.next(event.timestamp);
+                    call.endTimeUnixNano = timestamp;
+                    call.events = [
+                        {
+                            timeUnixNano: timestamp,
+                            name: 'tool_result',
+                            attributes: {
+                                'tool.result': truncate(event.content),
+                                'tool.result.is_error': event.isError ?? false,
+                            },
+                        },
+                    ];
+                    call.status = event.isError ? { code: 'ERROR' } : { code: 'OK' };
+                    break;
+                }
+                default:
+                    break;
+            }
+        }
+        const usage = findTerminalUsage(rawText);
+        if (usage && agentTurns.length > 0) {
+            const last = agentTurns[agentTurns.length - 1];
+            last.attributes['gen_ai.usage.input_tokens'] = usage.inputTokens;
+            last.attributes['gen_ai.usage.output_tokens'] = usage.outputTokens;
+        }
+        return spans;
+    }
+}

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

@@ -0,0 +1,4 @@
+export * from './attrs.js';
+export * from './claude-code-stream-json.js';
+export * from './codex-exec-json.js';
+export * from './types.js';

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

@@ -0,0 +1,4 @@
+export * from './attrs.js';
+export * from './claude-code-stream-json.js';
+export * from './codex-exec-json.js';
+export * from './types.js';

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

@@ -0,0 +1,18 @@
+import type { Span } from '../schema.js';
+/** A canonical typed trajectory span before collector-assigned ids and chaining. */
+export type TranscriptSpanInput = Omit<Span, 'traceId' | 'spanId' | 'parentSpanId'> & {
+    parentSpanId?: string | null;
+};
+/**
+ * Converts a native harness transcript to canonical typed trajectory spans.
+ * File parsing always degrades to an empty list. Parsers that can safely
+ * consume in-memory snapshot bytes expose the same implementation via
+ * `parseText`.
+ */
+export interface TranscriptSpanParser {
+    readonly sourceFormat: string;
+    readonly parserName: string;
+    readonly parserVersion: string;
+    parse(transcriptPath: string): Promise<TranscriptSpanInput[]>;
+    parseText?(rawText: string): TranscriptSpanInput[];
+}

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

@@ -0,0 +1 @@
+export {};

package/dist/window.d.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod/v3';
+export declare const WindowSchema: z.ZodObject<{
+    startTs: z.ZodNumber;
+    endTs: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    startTs: number;
+    endTs: number;
+}, {
+    startTs: number;
+    endTs: number;
+}>;
+export type Window = z.infer<typeof WindowSchema>;

package/dist/window.js

@@ -0,0 +1,5 @@
+import { z } from 'zod/v3';
+export const WindowSchema = z.object({
+    startTs: z.number().int(),
+    endTs: z.number().int(),
+});

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "@jinn-network/core",
+  "version": "0.1.0",
+  "description": "Domain core for Jinn — evidence/contribution stores, scrub, trajectory parsing, and corpus reads. Independent of client/src.",
+  "type": "module",
+  "packageManager": "yarn@4.13.0",
+  "license": "MIT",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist/"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./corpus-read": {
+      "import": "./dist/corpus-read/index.js",
+      "types": "./dist/corpus-read/index.d.ts"
+    },
+    "./scrub": {
+      "import": "./dist/scrub/index.js",
+      "types": "./dist/scrub/index.d.ts"
+    },
+    "./trajectory": {
+      "import": "./dist/trajectory/index.js",
+      "types": "./dist/trajectory/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc --noEmit -p tsconfig.json",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@huggingface/transformers": "^4.2.0",
+    "@jinn-network/plugin": "0.1.0",
+    "@noble/hashes": "^2.2.0",
+    "@secretlint/core": "^13.0.2",
+    "@secretlint/secretlint-rule-preset-recommend": "^13.0.2",
+    "better-sqlite3": "^12.10.0",
+    "canonicalize": "^3.0.0",
+    "openredaction": "^1.1.2",
+    "zod": "^4.4.3"
+  },
+  "peerDependencies": {
+    "vitest": "^4.1.8"
+  },
+  "peerDependenciesMeta": {
+    "vitest": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.0",
+    "@types/node": "^26.1.0",
+    "typescript": "^5.4.0",
+    "vitest": "^4.1.8"
+  },
+  "resolutions": {
+    "@jinn-network/plugin": "portal:../plugin"
+  }
+}