@shipfox/api-logs 2.0.0

package/src/core/session/claude/rows.ts

@@ -0,0 +1,223 @@
+import type {
+  SessionViewLifecycleRow,
+  SessionViewRow,
+  SessionViewRowMeta,
+  SessionViewToolCallRow,
+  SessionViewToolResultRow,
+} from '@shipfox/api-logs-dto';
+import {asLooseObject} from '../entry-schema.js';
+import {
+  booleanField,
+  field,
+  formatNumber,
+  isMeta,
+  metaItem,
+  stringField,
+  stringifyValue,
+  toJson,
+} from '../object.js';
+import {lifecycleRow, messageRow, thinkingRow} from '../rows.js';
+
+export function systemRow(
+  timestamp: number,
+  message: Record<string, unknown>,
+): SessionViewLifecycleRow {
+  const subtype = stringField(message, 'subtype');
+  const label = subtype === 'init' || message.type === 'init' ? 'Session started' : 'Session event';
+  const detail = stringField(message, 'session_id') ?? stringField(message, 'sessionId') ?? null;
+  const meta = [
+    metaItem('cwd', stringField(message, 'cwd'), false),
+    metaItem('model', stringField(message, 'model')),
+    metaItem(
+      'permission',
+      stringField(message, 'permissionMode') ?? stringField(message, 'permission_mode'),
+    ),
+  ].filter(isMeta);
+
+  return lifecycleRow(timestamp, label, detail, 'default', false, meta);
+}
+
+export function assistantRows(
+  timestamp: number,
+  message: Record<string, unknown>,
+): readonly SessionViewRow[] {
+  const sdkMessage = asLooseObject(message.message) ?? message;
+  const rows: SessionViewRow[] = [];
+  const textParts: string[] = [];
+  const thinkingParts: string[] = [];
+
+  const pushText = () => {
+    if (textParts.length === 0) return;
+    rows.push(messageRow(timestamp, 'assistant', 'assistant', textParts.join('\n\n'), false));
+    textParts.length = 0;
+  };
+  const pushThinking = () => {
+    if (thinkingParts.length === 0) return;
+    rows.push(thinkingRow(timestamp, thinkingParts.join('\n\n')));
+    thinkingParts.length = 0;
+  };
+
+  for (const block of contentBlocks(sdkMessage)) {
+    const type = stringField(block, 'type');
+    if (type === 'tool_use' || type === 'tool-use' || type === 'toolCall') {
+      pushText();
+      pushThinking();
+      rows.push(toolCallRow(timestamp, block));
+      continue;
+    }
+
+    if (type === 'thinking' || type === 'reasoning') {
+      pushText();
+      const text = blockText(block);
+      if (text) thinkingParts.push(text);
+      continue;
+    }
+
+    pushThinking();
+    const text = blockText(block);
+    if (text) textParts.push(text);
+  }
+
+  pushText();
+  pushThinking();
+
+  if (rows.length > 0) return rows;
+
+  const text = stringField(sdkMessage, 'content') ?? stringField(message, 'result');
+  return [messageRow(timestamp, 'assistant', 'assistant', text ?? toJson(message), false)];
+}
+
+export function userRows(
+  timestamp: number,
+  message: Record<string, unknown>,
+): readonly SessionViewRow[] {
+  const sdkMessage = asLooseObject(message.message) ?? message;
+  const rows: SessionViewRow[] = [];
+  const textParts: string[] = [];
+  const pushText = () => {
+    if (textParts.length === 0) return;
+    rows.push(messageRow(timestamp, 'user', 'user', textParts.join('\n\n'), false));
+    textParts.length = 0;
+  };
+
+  for (const block of contentBlocks(sdkMessage)) {
+    const type = stringField(block, 'type');
+    if (type === 'tool_result' || type === 'tool-result') {
+      pushText();
+      rows.push(toolResultRow(timestamp, block));
+      continue;
+    }
+
+    const text = blockText(block);
+    if (text) textParts.push(text);
+  }
+
+  pushText();
+
+  if (rows.length > 0) return rows;
+
+  const content = stringField(sdkMessage, 'content');
+  return [messageRow(timestamp, 'user', 'user', content ?? toJson(message), false)];
+}
+
+export function resultRow(
+  timestamp: number,
+  message: Record<string, unknown>,
+): SessionViewLifecycleRow {
+  const isError = booleanField(message, 'is_error') || booleanField(message, 'isError');
+  const subtype = stringField(message, 'subtype');
+  const terminalFailure = isError || subtype === 'error';
+  const detail =
+    stringField(message, 'result') ??
+    stringField(message, 'error') ??
+    stringField(message, 'message') ??
+    null;
+  const meta = [
+    numberMeta(message, 'duration_ms', 'duration', 'ms'),
+    numberMeta(message, 'duration_api_ms', 'api duration', 'ms'),
+    numberMeta(message, 'num_turns', 'turns'),
+    costMeta(message),
+  ].filter(isMeta);
+
+  return lifecycleRow(
+    timestamp,
+    terminalFailure ? 'Session failed' : 'Session completed',
+    detail,
+    terminalFailure ? 'error' : 'default',
+    terminalFailure,
+    meta,
+  );
+}
+
+function contentBlocks(message: Record<string, unknown>): Record<string, unknown>[] {
+  const content = message.content;
+  if (!Array.isArray(content)) return [];
+
+  return content.flatMap((block) => {
+    const object = asLooseObject(block);
+    return object ? [object] : [];
+  });
+}
+
+function toolCallRow(timestamp: number, block: Record<string, unknown>): SessionViewToolCallRow {
+  return {
+    kind: 'tool-call',
+    timestamp,
+    id: stringField(block, 'id') ?? null,
+    name: stringField(block, 'name') ?? 'tool',
+    input: stringifyValue(field(block, 'input') ?? {}),
+  };
+}
+
+function toolResultRow(
+  timestamp: number,
+  block: Record<string, unknown>,
+): SessionViewToolResultRow {
+  return {
+    kind: 'tool-result',
+    timestamp,
+    toolCallId: stringField(block, 'tool_use_id') ?? stringField(block, 'toolUseId') ?? null,
+    toolName: stringField(block, 'name') ?? 'tool',
+    output: blockText(block) || stringifyValue(field(block, 'content') ?? ''),
+    isError: booleanField(block, 'is_error') || booleanField(block, 'isError'),
+  };
+}
+
+function blockText(block: Record<string, unknown>): string {
+  const content = field(block, 'content');
+  if (Array.isArray(content)) {
+    return content
+      .map((item) => {
+        const object = asLooseObject(item);
+        return object ? blockText(object) : typeof item === 'string' ? item : '';
+      })
+      .filter(Boolean)
+      .join('\n\n');
+  }
+
+  return (
+    stringField(block, 'text') ??
+    stringField(block, 'thinking') ??
+    (typeof content === 'string' ? content : '') ??
+    ''
+  );
+}
+
+function numberMeta(
+  value: unknown,
+  key: string,
+  label: string,
+  unit?: string,
+): SessionViewRowMeta | null {
+  const raw = field(value, key);
+  if (typeof raw !== 'number' || !Number.isFinite(raw)) return null;
+
+  return metaItem(label, unit ? `${formatNumber(raw)} ${unit}` : formatNumber(raw));
+}
+
+function costMeta(message: Record<string, unknown>): SessionViewRowMeta | null {
+  const value = field(message, 'total_cost_usd') ?? field(message, 'totalCostUsd');
+  if (typeof value !== 'number' || !Number.isFinite(value)) return null;
+
+  return metaItem('cost', `$${value.toFixed(value < 0.01 ? 4 : 2)}`);
+}

package/src/core/session/claude-parser.test.ts

@@ -0,0 +1,199 @@
+import {parseClaudeSessionRecord} from './claude-parser.js';
+
+const record = (data: unknown, ts = 1) => ({
+  ts,
+  data: typeof data === 'string' ? data : JSON.stringify(data),
+});
+
+describe('parseClaudeSessionRecord', () => {
+  it('returns a raw row for malformed JSON', () => {
+    const rows = parseClaudeSessionRecord(record('{not json'));
+
+    expect(rows).toEqual([
+      {kind: 'raw', timestamp: 1, label: 'Malformed session entry', raw: '{not json'},
+    ]);
+  });
+
+  it('returns a raw row for an unknown message type', () => {
+    const rows = parseClaudeSessionRecord(record({type: 'future_event', value: 1}));
+
+    expect(rows).toEqual([
+      {
+        kind: 'raw',
+        timestamp: 1,
+        label: 'Unknown Claude message: future_event',
+        raw: '{"type":"future_event","value":1}',
+      },
+    ]);
+  });
+
+  it('maps the init message to a lifecycle row', () => {
+    const rows = parseClaudeSessionRecord(
+      record({
+        type: 'system',
+        subtype: 'init',
+        session_id: 'session-1',
+        cwd: '/workspace',
+        model: 'claude-opus-4-8',
+      }),
+    );
+
+    expect(rows).toEqual([
+      {
+        kind: 'lifecycle',
+        timestamp: 1,
+        label: 'Session started',
+        detail: 'session-1',
+        meta: [
+          {label: 'cwd', value: '/workspace', inline: false},
+          {label: 'model', value: 'claude-opus-4-8'},
+        ],
+        tone: 'default',
+        terminalFailure: false,
+      },
+    ]);
+  });
+
+  it('expands assistant text, thinking, and tool-use blocks in order', () => {
+    const rows = parseClaudeSessionRecord(
+      record({
+        type: 'assistant',
+        message: {
+          role: 'assistant',
+          content: [
+            {type: 'text', text: 'I will inspect the repo.'},
+            {type: 'thinking', thinking: 'Need the failing file first.'},
+            {type: 'tool_use', id: 'tool-1', name: 'Read', input: {file_path: 'src/a.ts'}},
+          ],
+        },
+      }),
+    );
+
+    expect(rows).toEqual([
+      {
+        kind: 'message',
+        timestamp: 1,
+        role: 'assistant',
+        label: 'assistant',
+        meta: [],
+        text: 'I will inspect the repo.',
+        terminalFailure: false,
+      },
+      {kind: 'thinking', timestamp: 1, text: 'Need the failing file first.'},
+      {
+        kind: 'tool-call',
+        timestamp: 1,
+        id: 'tool-1',
+        name: 'Read',
+        input: '{\n  "file_path": "src/a.ts"\n}',
+      },
+    ]);
+  });
+
+  it('maps user tool results to tool-result rows', () => {
+    const rows = parseClaudeSessionRecord(
+      record({
+        type: 'user',
+        message: {
+          role: 'user',
+          content: [
+            {
+              type: 'tool_result',
+              tool_use_id: 'tool-1',
+              content: [{type: 'text', text: 'file contents'}],
+              is_error: true,
+            },
+          ],
+        },
+      }),
+    );
+
+    expect(rows).toEqual([
+      {
+        kind: 'tool-result',
+        timestamp: 1,
+        toolCallId: 'tool-1',
+        toolName: 'tool',
+        output: 'file contents',
+        isError: true,
+      },
+    ]);
+  });
+
+  it('preserves mixed user text and tool-result block order', () => {
+    const rows = parseClaudeSessionRecord(
+      record({
+        type: 'user',
+        message: {
+          role: 'user',
+          content: [
+            {type: 'text', text: 'before'},
+            {
+              type: 'tool_result',
+              tool_use_id: 'tool-1',
+              content: [{type: 'text', text: 'tool output'}],
+            },
+            {type: 'text', text: 'after'},
+          ],
+        },
+      }),
+    );
+
+    expect(rows).toEqual([
+      {
+        kind: 'message',
+        timestamp: 1,
+        role: 'user',
+        label: 'user',
+        meta: [],
+        text: 'before',
+        terminalFailure: false,
+      },
+      {
+        kind: 'tool-result',
+        timestamp: 1,
+        toolCallId: 'tool-1',
+        toolName: 'tool',
+        output: 'tool output',
+        isError: false,
+      },
+      {
+        kind: 'message',
+        timestamp: 1,
+        role: 'user',
+        label: 'user',
+        meta: [],
+        text: 'after',
+        terminalFailure: false,
+      },
+    ]);
+  });
+
+  it('maps result messages to terminal lifecycle rows', () => {
+    const rows = parseClaudeSessionRecord(
+      record({
+        type: 'result',
+        subtype: 'error',
+        is_error: true,
+        result: 'Timed out',
+        duration_ms: 1200,
+        total_cost_usd: 0.0042,
+      }),
+    );
+
+    expect(rows).toEqual([
+      {
+        kind: 'lifecycle',
+        timestamp: 1,
+        label: 'Session failed',
+        detail: 'Timed out',
+        meta: [
+          {label: 'duration', value: '1,200 ms'},
+          {label: 'cost', value: '$0.0042'},
+        ],
+        tone: 'error',
+        terminalFailure: true,
+      },
+    ]);
+  });
+});

package/src/core/session/claude-parser.ts

@@ -0,0 +1,38 @@
+import type {SessionViewRow} from '@shipfox/api-logs-dto';
+import {z} from 'zod';
+import {assistantRows, resultRow, systemRow, userRows} from './claude/rows.js';
+import {rawRecordRow} from './rows.js';
+import type {AgentSessionRecord} from './session-record.js';
+
+const claudeMessageSchema = z
+  .object({
+    type: z.string().min(1),
+  })
+  .catchall(z.unknown());
+
+export function parseClaudeSessionRecord(record: AgentSessionRecord): readonly SessionViewRow[] {
+  let json: unknown;
+  try {
+    json = JSON.parse(record.data);
+  } catch {
+    return [rawRecordRow(record, 'Malformed session entry')];
+  }
+
+  const parsed = claudeMessageSchema.safeParse(json);
+  if (!parsed.success) return [rawRecordRow(record, 'Unsupported Claude message')];
+
+  const message = parsed.data;
+  switch (message.type) {
+    case 'system':
+    case 'init':
+      return [systemRow(record.ts, message)];
+    case 'assistant':
+      return assistantRows(record.ts, message);
+    case 'user':
+      return userRows(record.ts, message);
+    case 'result':
+      return [resultRow(record.ts, message)];
+    default:
+      return [rawRecordRow(record, `Unknown Claude message: ${message.type}`)];
+  }
+}

package/src/core/session/entry-schema.ts

@@ -0,0 +1,82 @@
+import {z} from 'zod';
+
+const looseObjectSchema = z.object({}).catchall(z.unknown());
+
+export const sessionEntrySchema = z
+  .object({
+    type: z.string().min(1),
+  })
+  .catchall(z.unknown());
+
+export const agentMessageSchema = z
+  .object({
+    type: z.string().optional(),
+    role: z.string().optional(),
+    content: z.unknown().optional(),
+    model: z.string().optional(),
+    provider: z.string().optional(),
+    stopReason: z.string().optional(),
+    errorMessage: z.string().optional(),
+    toolCallId: z.string().optional(),
+    toolName: z.string().optional(),
+    isError: z.boolean().optional(),
+  })
+  .catchall(z.unknown());
+
+export const sessionMessageEntrySchema = z
+  .object({
+    type: z.literal('message'),
+    message: agentMessageSchema,
+  })
+  .catchall(z.unknown());
+
+export const contentBlockSchema = z
+  .object({
+    type: z.string().optional(),
+  })
+  .catchall(z.unknown());
+
+export type SessionEntry = z.infer<typeof sessionEntrySchema>;
+export type AgentMessage = z.infer<typeof agentMessageSchema>;
+export type ContentBlock = z.infer<typeof contentBlockSchema>;
+
+export interface ParsedSessionEntry {
+  ok: true;
+  entry: SessionEntry;
+}
+
+export interface MalformedSessionEntry {
+  ok: false;
+  raw: string;
+  reason: 'invalid-json' | 'invalid-entry';
+}
+
+export type SessionEntryParseResult = ParsedSessionEntry | MalformedSessionEntry;
+
+export function parseSessionEntry(data: string): SessionEntryParseResult {
+  let json: unknown;
+  try {
+    json = JSON.parse(data);
+  } catch {
+    return {ok: false, raw: data, reason: 'invalid-json'};
+  }
+
+  const parsed = sessionEntrySchema.safeParse(json);
+  if (!parsed.success) return {ok: false, raw: data, reason: 'invalid-entry'};
+
+  return {ok: true, entry: parsed.data};
+}
+
+export function asLooseObject(value: unknown): Record<string, unknown> | null {
+  const parsed = looseObjectSchema.safeParse(value);
+  return parsed.success ? parsed.data : null;
+}
+
+export function asContentBlocks(value: unknown): ContentBlock[] {
+  if (!Array.isArray(value)) return [];
+
+  return value.flatMap((item) => {
+    const parsed = contentBlockSchema.safeParse(item);
+    return parsed.success ? [parsed.data] : [];
+  });
+}

package/src/core/session/object.ts

@@ -0,0 +1,57 @@
+import type {SessionViewRowMeta} from '@shipfox/api-logs-dto';
+import {asLooseObject} from './entry-schema.js';
+
+const SESSION_META_NUMBER_LOCALE = 'en-US';
+
+export function field(value: unknown, key: string): unknown {
+  const object = asLooseObject(value);
+  return object?.[key];
+}
+
+export function stringField(value: unknown, key: string): string | undefined {
+  const fieldValue = field(value, key);
+  return typeof fieldValue === 'string' && fieldValue.length > 0 ? fieldValue : undefined;
+}
+
+export function numberField(value: unknown, key: string): number | undefined {
+  const fieldValue = field(value, key);
+  return typeof fieldValue === 'number' && Number.isFinite(fieldValue) ? fieldValue : undefined;
+}
+
+export function booleanField(value: unknown, key: string): boolean {
+  return field(value, key) === true;
+}
+
+export function stringifyValue(value: unknown): string {
+  if (typeof value === 'string') return value;
+  return toJson(value);
+}
+
+export function toJson(value: unknown): string {
+  const json = JSON.stringify(value, null, 2);
+  return json === undefined ? String(value) : json;
+}
+
+export function formatNumber(value: number): string {
+  return new Intl.NumberFormat(SESSION_META_NUMBER_LOCALE, {
+    maximumFractionDigits: 1,
+    notation: value >= 10000 ? 'compact' : 'standard',
+  }).format(value);
+}
+
+export function formatCount(value: number, unit: string): string {
+  return `${formatNumber(value)} ${unit}${value === 1 ? '' : 's'}`;
+}
+
+export function metaItem(
+  label: string,
+  value: string | null | undefined,
+  inline = true,
+): SessionViewRowMeta | null {
+  if (value == null || value.length === 0) return null;
+  return inline ? {label, value} : {label, value, inline};
+}
+
+export function isMeta(value: SessionViewRowMeta | null | undefined): value is SessionViewRowMeta {
+  return value != null;
+}

package/src/core/session/parse-session.ts

@@ -0,0 +1,23 @@
+import type {Harness} from '@shipfox/api-agent-dto';
+import type {SessionViewRow} from '@shipfox/api-logs-dto';
+import {parseClaudeSessionRecord} from './claude-parser.js';
+import {parsePiSessionRecord} from './pi-parser.js';
+import type {AgentSessionRecord} from './session-record.js';
+
+export function parseSessionRecord(
+  record: AgentSessionRecord,
+  harness: Harness,
+): readonly SessionViewRow[] {
+  try {
+    return harness === 'claude' ? parseClaudeSessionRecord(record) : parsePiSessionRecord(record);
+  } catch {
+    return [
+      {
+        kind: 'raw',
+        timestamp: record.ts,
+        label: 'Unsupported session entry',
+        raw: record.data,
+      },
+    ];
+  }
+}