mcp-codex-worker 1.0.18 → 1.0.20

package/src/timeline-writer.ts

@@ -0,0 +1,274 @@
+// ---------------------------------------------------------------------------
+// Timeline Writer — pure formatter for timeline.log
+//
+// Receives a raw event (same shape as events.jsonl entries) and returns
+// a formatted one-liner or null (skip). No state — deduplication is
+// handled by the caller via lastTokenCount.
+// ---------------------------------------------------------------------------
+
+export interface TimelineConfig {
+  maxCommandLength: number;
+  maxMessageLength: number;
+  maxPathLength: number;
+  maxReasoningLength: number;
+  maxPlanStepLength: number;
+  maxLineLength: number;
+  maxStderrLength: number;
+  maxErrorLength: number;
+}
+
+export const DEFAULT_TIMELINE_CONFIG: TimelineConfig = {
+  maxCommandLength: 120,
+  maxMessageLength: 200,
+  maxPathLength: 80,
+  maxReasoningLength: 150,
+  maxPlanStepLength: 80,
+  maxLineLength: 500,
+  maxStderrLength: 200,
+  maxErrorLength: 200,
+};
+
+export interface TimelineEvent {
+  t: string;
+  method: string;
+  params?: unknown;
+  code?: number | null;
+  signal?: string | null;
+  data?: string;
+  synthetic?: boolean;
+}
+
+export interface TimelineResult {
+  line: string | null;
+  newTokenCount?: number;
+}
+
+// ---------------------------------------------------------------------------
+// Main entry point
+// ---------------------------------------------------------------------------
+
+export function formatTimelineLine(
+  event: TimelineEvent,
+  config: TimelineConfig = DEFAULT_TIMELINE_CONFIG,
+  lastTokenCount?: number,
+): TimelineResult {
+  const ts = localTime(event.t);
+  const p = asObj(event.params);
+
+  switch (event.method) {
+    case 'thread/status/changed': {
+      const status = asStr(asObj(p?.status)?.type);
+      if (status === 'active') return line(ts, 'STARTED', '', config);
+      if (status === 'idle') return line(ts, 'IDLE', '', config);
+      if (status === 'waitingOnUserInput') return line(ts, 'ASK', 'waiting for orchestrator', config);
+      return SKIP;
+    }
+
+    case 'turn/started': {
+      const turnId = asStr(asObj(p?.turn)?.id) ?? '';
+      return line(ts, 'TURN', truncate(turnId, 40), config);
+    }
+
+    case 'turn/completed': {
+      const turn = asObj(p?.turn);
+      const status = asStr(turn?.status) ?? 'unknown';
+      const errMsg = asStr(asObj(turn?.error)?.message);
+      const detail = errMsg ? `${status}: ${truncate(errMsg, 100)}` : status;
+      return line(ts, 'DONE', detail, config);
+    }
+
+    case 'turn/plan/updated': {
+      const steps = Array.isArray(p?.plan) ? (p.plan as Array<{ step?: string; status?: string }>) : [];
+      return line(ts, 'PLAN', formatPlan(steps, config), config);
+    }
+
+    case 'item/completed':
+      return formatItemCompleted(ts, asObj(p?.item), config);
+
+    case 'thread/tokenUsage/updated': {
+      const usage = asObj(asObj(p?.tokenUsage)?.total);
+      const window = typeof (asObj(p?.tokenUsage) as Record<string, unknown> | undefined)?.modelContextWindow === 'number'
+        ? (asObj(p?.tokenUsage) as Record<string, unknown>).modelContextWindow as number
+        : undefined;
+      if (!usage || !window) return SKIP;
+      const total = typeof usage.totalTokens === 'number' ? usage.totalTokens : 0;
+      if (total === (lastTokenCount ?? -1)) return SKIP; // deduplicate
+      const pct = (Math.round(total / window * 1000) / 10).toFixed(1);
+      return { line: capLine(`${ts} ${pad('TOKENS')} ${total} / ${window} (${pct}%)`, config), newTokenCount: total };
+    }
+
+    case 'item/commandExecution/requestApproval': {
+      const cmd = cleanCommand(asStr(p?.command) ?? '');
+      return line(ts, 'APPROVE', `cmd: ${truncate(cmd, 100)}`, config);
+    }
+
+    case 'item/fileChange/requestApproval': {
+      const changes = Array.isArray(p?.changes) ? (p.changes as Array<{ path?: string }>) : [];
+      const paths = changes.map(c => truncatePath(asStr(c?.path) ?? '', 40)).join(', ');
+      return line(ts, 'APPROVE', `files: ${paths} (${changes.length} files)`, config);
+    }
+
+    case '_process_exit':
+      return line(ts, 'EXIT', `code=${event.code ?? '?'} signal=${String(event.signal ?? 'null')}`, config);
+
+    case '_stderr': {
+      const data = stripAnsi(event.data ?? '').replace(/\n/g, ' ').trim();
+      if (!data) return SKIP;
+      return line(ts, 'STDERR', truncate(data, config.maxStderrLength), config);
+    }
+
+    case 'error': {
+      const errObj = asObj(p?.error);
+      const message = asStr(errObj?.message) ?? asStr(p?.message) ?? 'unknown';
+      const info = asStr(errObj?.codexErrorInfo) ?? asStr(p?.codexErrorInfo) ?? '';
+      const detail = info ? `${info} — ${truncate(message, config.maxErrorLength)}` : truncate(message, config.maxErrorLength);
+      return line(ts, 'ERROR', detail, config);
+    }
+
+    default:
+      return SKIP;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Item completed sub-formatter
+// ---------------------------------------------------------------------------
+
+function formatItemCompleted(
+  ts: string,
+  item: Record<string, unknown> | undefined,
+  config: TimelineConfig,
+): TimelineResult {
+  if (!item) return SKIP;
+  const itemType = asStr(item.type);
+
+  switch (itemType) {
+    case 'commandExecution': {
+      const cmd = cleanCommand(asStr(item.command) ?? '');
+      const dur = typeof item.durationMs === 'number' ? `${(item.durationMs / 1000).toFixed(1)}s` : '?';
+      const exit = item.exitCode ?? '?';
+      return line(ts, 'CMD', `${truncate(cmd, config.maxCommandLength)} → exit=${exit} (${dur})`, config);
+    }
+
+    case 'fileChange': {
+      const changes = Array.isArray(item.changes) ? (item.changes as Array<Record<string, unknown>>) : [];
+      if (changes.length === 0) return SKIP;
+      const lines = changes.map(c => {
+        const path = truncatePath(asStr(c.path) ?? 'unknown', config.maxPathLength);
+        const kind = asStr(c.kind) ?? 'modified';
+        return capLine(`${ts} ${pad('FILE')} ${path} (${kind})`, config);
+      });
+      return { line: lines.join('\n') };
+    }
+
+    case 'agentMessage': {
+      const text = (asStr(item.text) ?? '').replace(/\n/g, ' ').trim();
+      if (!text) return SKIP;
+      const max = config.maxMessageLength;
+      const display = text.length > max
+        ? `${text.slice(0, max)} [+${text.length - max} chars]`
+        : text;
+      return line(ts, 'MSG', display, config);
+    }
+
+    case 'reasoning': {
+      const summaries = Array.isArray(item.summary) ? item.summary as unknown[] : [];
+      if (summaries.length === 0) return SKIP;
+      const first = typeof summaries[0] === 'string'
+        ? summaries[0]
+        : asStr((summaries[0] as Record<string, unknown> | undefined)?.text) ?? '';
+      const cleaned = first.replace(/\*\*/g, '').replace(/\n/g, ' ').trim();
+      if (!cleaned) return SKIP;
+      return line(ts, 'THINK', truncate(cleaned, config.maxReasoningLength), config);
+    }
+
+    case 'mcpToolCall': {
+      const server = asStr(item.server) ?? '?';
+      const tool = asStr(item.tool) ?? '?';
+      const status = asStr(item.status) ?? '?';
+      return line(ts, 'MCP', `${server}/${tool} → ${status}`, config);
+    }
+
+    default:
+      return SKIP;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Plan formatter
+// ---------------------------------------------------------------------------
+
+function formatPlan(steps: Array<{ step?: string; status?: string }>, config: TimelineConfig): string {
+  if (steps.length === 0) return '(empty plan)';
+
+  const icon = (s?: string): string => {
+    switch (s) {
+      case 'completed': return '✓';
+      case 'inProgress': return '→';
+      default: return ' ';
+    }
+  };
+
+  const formatted = steps.map(s => `[${icon(s.status)}] ${truncate(s.step ?? '', config.maxPlanStepLength)}`);
+  const joined = formatted.join(' · ');
+
+  if (joined.length <= 450) return joined;
+  const first3 = formatted.slice(0, 3).join(' · ');
+  return `${first3} … +${steps.length - 3} more`;
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+const SKIP: TimelineResult = { line: null };
+
+function pad(tag: string): string {
+  return tag.padEnd(7);
+}
+
+function line(ts: string, tag: string, detail: string, config: TimelineConfig): TimelineResult {
+  return { line: capLine(`${ts} ${pad(tag)} ${detail}`.trimEnd(), config) };
+}
+
+function capLine(l: string, config: TimelineConfig): string {
+  if (l.length <= config.maxLineLength) return l;
+  return l.slice(0, config.maxLineLength - 3) + '...';
+}
+
+function localTime(iso: string): string {
+  const d = new Date(iso);
+  return [d.getHours(), d.getMinutes(), d.getSeconds()]
+    .map(n => String(n).padStart(2, '0'))
+    .join(':');
+}
+
+export function truncate(s: string, max: number): string {
+  if (s.length <= max) return s;
+  return s.slice(0, max - 1) + '…';
+}
+
+function truncatePath(p: string, max: number): string {
+  if (!p || p.length <= max) return p ?? '';
+  return '…' + p.slice(p.length - max + 1);
+}
+
+export function cleanCommand(raw: string): string {
+  const match = raw.match(/^\/bin\/(?:z?sh|bash)\s+-[a-z]*c\s+['"]?([\s\S]+?)['"]?$/);
+  let cmd = match ? match[1]! : raw;
+  if (cmd.startsWith('rtk ')) cmd = cmd.slice(4);
+  return cmd;
+}
+
+function stripAnsi(s: string): string {
+  return s.replace(/\x1b\[[0-9;]*m/g, '');
+}
+
+function asObj(v: unknown): Record<string, unknown> | undefined {
+  if (!v || typeof v !== 'object' || Array.isArray(v)) return undefined;
+  return v as Record<string, unknown>;
+}
+
+function asStr(v: unknown): string | undefined {
+  return typeof v === 'string' ? v : undefined;
+}