@volter/supercode-interchange 0.1.1 → 0.1.3

package/session-time.mjs

@@ -0,0 +1,46 @@
+const min = -(1n << 63n), max = (1n << 63n) - 1n;
+const floorDiv = (value, divisor) => value < 0n ? (value - divisor + 1n) / divisor : value / divisor;
+
+/** The native f64-to-i64 cast saturates, including infinities and NaN. */
+function milliseconds(seconds, rounded) {
+  let value = seconds * 1000;
+  if (Number.isNaN(value)) return 0n;
+  if (rounded && Number.isFinite(value)) {
+    const whole = Math.trunc(value);
+    value = Math.abs(value - whole) >= 0.5 ? whole + Math.sign(value) : whole;
+  }
+  if (value >= Number(max)) return max;
+  if (value <= Number(min)) return min;
+  return BigInt(Math.trunc(value));
+}
+
+function civil(seconds, sub) {
+  const days = floorDiv(seconds, 86400n), sod = seconds - days * 86400n;
+  const z = days + 719468n, era = floorDiv(z, 146097n), doe = z - era * 146097n;
+  const yoe = (doe - doe / 1460n + doe / 36524n - doe / 146096n) / 365n;
+  let year = yoe + era * 400n;
+  const doy = doe - (365n * yoe + yoe / 4n - yoe / 100n), mp = (5n * doy + 2n) / 153n;
+  const day = doy - (153n * mp + 2n) / 5n + 1n, month = mp < 10n ? mp + 3n : mp - 9n;
+  if (month <= 2n) year++;
+  const yearText = year < 0n ? `-${String(-year).padStart(3, '0')}` : String(year).padStart(4, '0');
+  const pad = (value, width = 2) => String(value).padStart(width, '0');
+  return `${yearText}-${pad(month)}-${pad(day)}T${pad(sod / 3600n)}:${pad(sod % 3600n / 60n)}:${pad(sod % 60n)}.${pad(sub, 3)}Z`;
+}
+
+/** Binding lifecycle epochs round milliseconds and retain pre-epoch dates. */
+export function bindingEpoch(seconds) {
+  const ms = milliseconds(seconds, true), secs = floorDiv(ms, 1000n);
+  return civil(secs, ms - secs * 1000n);
+}
+
+/** Message sidecar epochs truncate milliseconds and clamp negative seconds,
+ * retaining the native helper's Euclidean sub-second remainder. */
+export function messageEpoch(seconds) {
+  return messageMilliseconds(milliseconds(seconds, false));
+}
+
+/** Exact signed native millisecond clock, without a floating-point round trip. */
+export function messageMilliseconds(ms) {
+  const secs = floorDiv(ms, 1000n);
+  return civil(secs < 0n ? 0n : secs, ms - secs * 1000n);
+}

package/session-views.mjs

@@ -0,0 +1,171 @@
+// Read projections preserve the internal transcript and its source records.
+import { isDeepStrictEqual } from 'node:util';
+import { messageJson } from './message.mjs';
+import { cloneNativeJson, nativeObjectKeys, parseNativeJson } from './native-json.mjs';
+import { nativeTrim, truncateScalars } from './text.mjs';
+
+function truncate(text, count) {
+  const prefix = truncateScalars(text, count);
+  return prefix.length < text.length ? `${prefix}\n…` : text;
+}
+
+function boundStrings(value, count) {
+  if (typeof value === 'string') return truncate(value, count);
+  if (value != null && typeof value === 'object') {
+    for (const key of nativeObjectKeys(value)) value[key] = boundStrings(value[key], count);
+  }
+  return value;
+}
+
+/** Mutates this display view only, matching bound_session_view. Raw/source
+ * records and total imported count are untouched; subagents are not bounded. */
+export function boundSessionView(session, messageLimit = null, maxMessageChars = null) {
+  if (messageLimit != null && session.messages.length > messageLimit) session.messages.splice(0, session.messages.length - messageLimit);
+  if (maxMessageChars == null) return;
+  for (const message of session.messages) {
+    if (message.content != null) message.content = truncate(message.content, maxMessageChars);
+    if (message.content_parts != null) boundStrings(message.content_parts, maxMessageChars);
+    for (const call of message.tool_calls ?? []) call.function.arguments = truncate(call.function.arguments, maxMessageChars);
+    for (const key of Object.keys(message.metadata)) message.metadata[key] = truncate(message.metadata[key], maxMessageChars);
+  }
+}
+
+export function messageHasContent(message) {
+  return (message.content != null && nativeTrim(message.content) !== '') || (message.content_parts?.length ?? 0) > 0;
+}
+
+export function messageText(message) {
+  if (message.content != null) return message.content;
+  return (message.content_parts ?? []).filter((part) => typeof part?.text === 'string').map((part) => part.text).join('\n');
+}
+
+export function normalizedItemCount(messages) {
+  let count = 0;
+  for (const message of messages) {
+    if (['assistant', 'user', 'tool'].includes(message.role) && messageHasContent(message)) count++;
+    count += message.tool_calls?.length ?? 0;
+  }
+  return count;
+}
+
+export function projectedMessageWindow(total, options) {
+  if (options.message_tail != null) return [Math.max(0, total - options.message_tail), total];
+  const offset = Math.min(options.message_offset ?? 0, total);
+  return [offset, options.message_limit == null ? total : Math.min(offset + options.message_limit, total)];
+}
+
+export function projectInlineMedia(message, options) {
+  const result = cloneNativeJson(message);
+  if (!Array.isArray(result.content)) return result;
+  for (let at = 0; at < result.content.length; at++) {
+    const part = result.content[at];
+    const url = part?.image_url?.url;
+    if (typeof url !== 'string' || !url.startsWith('data:')) continue;
+    const rest = url.slice(5), separator = rest.indexOf(';base64,');
+    if (separator < 0) continue;
+    const mediaType = rest.slice(0, separator), encoded = rest.slice(separator + 8);
+    const encodedBytes = Buffer.byteLength(encoded), padding = Number(encoded.endsWith('=')) + Number(encoded.endsWith('=='));
+    const decodedBytes = Math.max(0, Math.floor(encodedBytes * 3 / 4) - padding);
+    if (options.inline_media !== 'metadata' && (options.max_inline_media_bytes == null || decodedBytes <= options.max_inline_media_bytes)) continue;
+    result.content[at] = { type: 'media_reference', media_type: mediaType, encoding: 'base64', encoded_bytes: encodedBytes, decoded_bytes: decodedBytes, omitted: true };
+  }
+  return result;
+}
+
+export function projectedSessionSummary(session, options) {
+  let first = null, last = null, firstAssistant = null, lastAssistant = null, final = null;
+  for (const message of session.messages) {
+    if (message.role !== 'system') final = message;
+    if (!['assistant', 'user'].includes(message.role) || !messageHasContent(message)) continue;
+    first ??= message; last = message;
+    if (message.role === 'assistant') { firstAssistant ??= message; lastAssistant = message; }
+  }
+  const project = (message) => message == null ? null : projectInlineMedia(messageJson(message), options);
+  return {
+    end_of_turn: final != null && final.role === 'assistant' && messageHasContent(final) && (final.tool_calls?.length ?? 0) === 0 && final.metadata.phase !== 'commentary',
+    first_assistant_message: project(firstAssistant), first_message: project(first),
+    last_assistant_message: project(lastAssistant), last_assistant_text: lastAssistant == null ? '' : messageText(lastAssistant), last_message: project(last),
+  };
+}
+
+const string = (value) => typeof value === 'string' ? value : null;
+const has = (value, key) => value != null && typeof value === 'object' && !Array.isArray(value) && Object.hasOwn(value, key);
+const payloadFor = (record) => has(record, 'payload') ? record.payload : record;
+function parsedRecord(line) { try { return parseNativeJson(line); } catch { return null; } }
+
+/** Only recorded facts. Current configuration and the reader's executable
+ * never fill unknown historical fields. */
+export function recordedSessionProfile(session) {
+  const { meta } = session;
+  let model = session.messages.findLast((message) => has(message.metadata, 'model'))?.metadata.model ?? meta.model;
+  let cwd = meta.cwd, version = null, approval = null, sandbox = null;
+  for (const header of meta.codex_headers) {
+    const payload = payloadFor(header);
+    version = string(payload?.cli_version) ?? version;
+    model = string(payload?.model) ?? model;
+    cwd = string(payload?.cwd) ?? cwd;
+    if (has(payload, 'approval_policy')) approval = cloneNativeJson(payload.approval_policy);
+    if (has(payload, 'sandbox_policy')) sandbox = cloneNativeJson(payload.sandbox_policy);
+  }
+  if (meta.source === 'claude_code') {
+    for (let at = session.raw.length - 1; at >= 0; at--) {
+      const recorded = string(parsedRecord(session.raw[at])?.version);
+      if (recorded != null) { version = recorded; break; }
+    }
+  }
+  return {
+    worker: { harness: meta.source === 'claude_code' ? 'claude-code' : meta.source, model, cwd, binary: { version } },
+    permissions: { native: { approval, sandbox } }, source: 'native-session',
+  };
+}
+
+export function recordedSessionProfileHistory(session) {
+  if (!['codex', 'claude_code'].includes(session.meta.source)) return [];
+  const profile = {
+    worker: { harness: session.meta.source === 'codex' ? 'codex' : 'claude-code', model: null, cwd: null, binary: { version: null } },
+    permissions: { native: { approval: null, sandbox: null } }, source: 'native-session',
+  };
+  const records = session.meta.source === 'codex' ? session.meta.codex_headers : session.raw;
+  const history = [];
+  for (let index = 0; index < records.length; index++) {
+    const record = session.meta.source === 'codex' ? records[index] : parsedRecord(records[index]);
+    if (record == null) continue;
+    const before = cloneNativeJson(profile), payload = payloadFor(record);
+    for (const key of ['cwd', 'model']) {
+      if (typeof payload?.[key] === 'string') profile.worker[key] = payload[key];
+    }
+    const version = string(has(payload, 'cli_version') ? payload.cli_version : record?.version);
+    if (version != null) profile.worker.binary.version = version;
+    if (typeof record?.message?.model === 'string') profile.worker.model = record.message.model;
+    for (const [key, target] of [['approval_policy', 'approval'], ['sandbox_policy', 'sandbox']]) {
+      if (has(payload, key)) profile.permissions.native[target] = cloneNativeJson(payload[key]);
+    }
+    if (!isDeepStrictEqual(before, profile)) history.push({ native_key: `profile-record:${index}`, at: string(record?.timestamp), profile: cloneNativeJson(profile) });
+  }
+  return history;
+}
+
+export function projectedSessionJson(session, options) {
+  const { meta } = session, [offset, end] = projectedMessageWindow(session.messages.length, options);
+  const childOptions = { ...options, message_limit: null, message_offset: null, message_tail: null };
+  return {
+    source: meta.source, session_id: meta.session_id, ended_at: meta.ended_at, end_reason: meta.end_reason, model: meta.model,
+    resolved_profile: recordedSessionProfile(session), resolved_profile_history: recordedSessionProfileHistory(session),
+    cwd: meta.cwd, system_prompt: meta.system_prompt, agent_id: meta.agent_id, parent_tool_use_id: meta.parent_tool_use_id,
+    lineage: cloneNativeJson(meta.lineage), messages: session.messages.slice(offset, end).map((message) => projectInlineMedia(messageJson(message), options)),
+    subagents: options.include_subagents === false ? [] : session.subagents.map((child) => projectedSessionJson(child, childOptions)),
+    raw_record_count: session.raw.length, parse_error_lines: session.parse_error_lines,
+  };
+}
+
+export function projectedSessionResult(session, options) {
+  const total = session.messages.length, [offset, end] = projectedMessageWindow(total, options);
+  return {
+    session: projectedSessionJson(session, options), summary: projectedSessionSummary(session, options),
+    window: {
+      has_more: offset > 0 || end < total, has_newer: end < total, has_older: offset > 0,
+      newer_items: normalizedItemCount(session.messages.slice(end)), offset,
+      older_items: normalizedItemCount(session.messages.slice(0, offset)), returned: end - offset, total_messages: total,
+    },
+  };
+}