job-forge 2.14.36 → 2.14.38

package/scripts/trace.mjs

@@ -1,36 +1,37 @@
 #!/usr/bin/env node
 
 import { spawnSync } from 'child_process';
-import { existsSync } from 'fs';
 import { createRequire } from 'module';
 import { dirname, join, resolve } from 'path';
-import { fileURLToPath } from 'url';
 import {
-  defaultOpenCodeDbPath,
-  findSessionById,
-  openCodeSessionLocator,
-  parseSinceCutoff,
-} from '@razroo/iso-trace';
+  clean,
+  discoverProjectSessions,
+  findObservedSession,
+  loadObservedSession,
+  pad,
+  safeJson,
+  shorten,
+  statsForSessions,
+} from '../lib/jobforge-observability.mjs';
 
-const __dirname = dirname(fileURLToPath(import.meta.url));
 const require = createRequire(import.meta.url);
 const PROJECT_DIR = process.env.JOB_FORGE_PROJECT || process.cwd();
 
-const USAGE = `job-forge trace — local OpenCode transcript observability
+const USAGE = `job-forge trace — local transcript observability across supported harnesses
 
 Usage:
-  job-forge trace:list [--since 7d] [--cwd <dir>] [--json]
-  job-forge trace:stats [<id-or-prefix>...] [--since 7d] [--cwd <dir>] [--json]
-  job-forge trace:show <id-or-prefix> [--events <kinds>] [--grep <regex>]
+  job-forge trace:list [--since 7d] [--cwd <dir>] [--harness <name>] [--json]
+  job-forge trace:stats [<id-or-prefix>...] [--since 7d] [--cwd <dir>] [--harness <name>] [--json]
+  job-forge trace:show <id-or-prefix> [--cwd <dir>] [--harness <name>] [--events <kinds>] [--grep <regex>]
   job-forge trace <iso-trace args...>
 
-Common aliases default to OpenCode sessions for the current JobForge project.
+Common aliases default to sessions for the current JobForge project.
 Use "job-forge trace sources" or "job-forge trace where" for raw iso-trace passthrough.`;
 
 const [cmd = 'help', ...args] = process.argv.slice(2);
 
 function parseFilters(rawArgs) {
-  const opts = { since: '7d', cwd: PROJECT_DIR, json: false };
+  const opts = { since: '7d', cwd: PROJECT_DIR, harness: '', json: false };
   const positional = [];
 
   for (let i = 0; i < rawArgs.length; i++) {
@@ -43,6 +44,10 @@ function parseFilters(rawArgs) {
       opts.cwd = rawArgs[++i];
     } else if (arg.startsWith('--cwd=')) {
       opts.cwd = arg.slice('--cwd='.length);
+    } else if (arg === '--harness') {
+      opts.harness = rawArgs[++i];
+    } else if (arg.startsWith('--harness=')) {
+      opts.harness = arg.slice('--harness='.length);
     } else if (arg === '--json') {
       opts.json = true;
     } else if (arg === '--help' || arg === '-h') {
@@ -59,12 +64,20 @@ function parseFilters(rawArgs) {
 }
 
 function parseShowArgs(rawArgs) {
-  const opts = {};
+  const opts = { cwd: PROJECT_DIR, harness: '' };
   const positional = [];
 
   for (let i = 0; i < rawArgs.length; i++) {
     const arg = rawArgs[i];
-    if (arg === '--events') {
+    if (arg === '--cwd') {
+      opts.cwd = rawArgs[++i];
+    } else if (arg.startsWith('--cwd=')) {
+      opts.cwd = arg.slice('--cwd='.length);
+    } else if (arg === '--harness') {
+      opts.harness = rawArgs[++i];
+    } else if (arg.startsWith('--harness=')) {
+      opts.harness = arg.slice('--harness='.length);
+    } else if (arg === '--events') {
       const raw = rawArgs[++i] || '';
       opts.events = new Set(raw.split(',').map((s) => s.trim()).filter(Boolean));
     } else if (arg.startsWith('--events=')) {
@@ -83,6 +96,7 @@ function parseShowArgs(rawArgs) {
     }
   }
 
+  opts.cwd = resolve(opts.cwd || PROJECT_DIR);
   return { opts, positional };
 }
 
@@ -95,96 +109,23 @@ function compileRegex(pattern, context) {
   }
 }
 
-async function discoverOpenCodeRefs(opts) {
-  const dbPath = defaultOpenCodeDbPath();
-  if (!existsSync(dbPath)) return [];
-
-  const where = [
-    's.time_archived is null',
-    `s.directory = ${sqlString(resolve(opts.cwd || PROJECT_DIR))}`,
-  ];
-  const sinceMs = parseSinceCutoff(opts.since);
-  if (sinceMs !== undefined) {
-    where.push(`s.time_created >= ${Number(sinceMs)}`);
-  }
-
-  const rows = queryOpenCodeDb(dbPath, [
-    'select',
-    '  s.id,',
-    '  s.directory,',
-    '  s.time_created,',
-    '  s.time_updated,',
-    '  (select count(*) from message m where m.session_id = s.id) as turn_count,',
-    '  (',
-    '    (select coalesce(sum(length(data)), 0) from message m where m.session_id = s.id) +',
-    '    (select coalesce(sum(length(data)), 0) from part p where p.session_id = s.id)',
-    '  ) as size_bytes',
-    'from session s',
-    `where ${where.join(' and ')}`,
-    'order by s.time_updated desc',
-  ].join(' '));
-
-  return rows.map((row) => ({
-    id: row.id,
-    source: {
-      harness: 'opencode',
-      format: 'opencode/sqlite-v1',
-      path: openCodeSessionLocator(row.id, dbPath),
-    },
-    cwd: row.directory,
-    startedAt: msToIso(row.time_created),
-    endedAt: msToIso(row.time_updated),
-    turnCount: row.turn_count ?? 0,
-    sizeBytes: row.size_bytes ?? 0,
-  }));
-}
-
-function queryOpenCodeDb(dbPath, sql) {
-  const result = spawnSync('sqlite3', ['-json', dbPath, sql], {
-    encoding: 'utf8',
-    maxBuffer: 16 * 1024 * 1024,
-  });
-  if ((result.status ?? 0) !== 0) {
-    const detail = result.stderr?.trim() || result.stdout?.trim() || `exit ${result.status ?? 1}`;
-    throw new Error(`job-forge trace: sqlite3 query failed: ${detail}`);
-  }
-  return JSON.parse(result.stdout || '[]');
-}
-
-function sqlString(value) {
-  return `'${String(value).replaceAll("'", "''")}'`;
-}
-
-function msToIso(ms) {
-  return new Date(Number(ms)).toISOString();
-}
-
 function sizeLabel(bytes) {
   if (bytes < 1024) return `${bytes} B`;
   if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
   return `${(bytes / 1024 / 1024).toFixed(1)} MB`;
 }
 
-function shorten(value, max) {
-  const text = String(value ?? '');
-  if (text.length <= max) return text;
-  return `${text.slice(0, max - 1)}...`;
-}
-
-function pad(value, width) {
-  const text = String(value ?? '');
-  return text.length >= width ? text : text + ' '.repeat(width - text.length);
-}
-
 function printSessionTable(refs) {
   const rows = refs.map((ref) => [
     ref.id,
+    ref.source.harness,
     ref.startedAt.replace('T', ' ').replace(/\.\d+Z$/, 'Z'),
-    shorten(ref.cwd, 42),
+    shorten(ref.title || '', 24),
+    shorten(ref.cwd, 40),
     String(ref.turnCount),
     sizeLabel(ref.sizeBytes),
   ]);
-  const header = ['id', 'started', 'cwd', 'turns', 'size'];
+  const header = ['id', 'harness', 'started', 'title', 'cwd', 'turns', 'size'];
   const widths = header.map((h, i) => Math.max(h.length, ...rows.map((row) => row[i].length)));
 
   console.log(header.map((h, i) => pad(h, widths[i])).join('  '));
@@ -211,151 +152,51 @@ function printStats(result) {
   }
 }
 
-function computeOpenCodeStats(refs) {
-  const result = {
-    sessions: refs.length,
-    turns: 0,
-    durationMs: 0,
-    tokens: { input: 0, output: 0, cacheRead: 0, cacheCreated: 0 },
-    toolCalls: {},
-    fileOps: {},
-  };
-
-  for (const ref of refs) {
-    const rows = loadOpenCodeRows(ref.id);
-    result.turns += rows.messages.length;
-    result.durationMs += Math.max(0, Date.parse(ref.endedAt || ref.startedAt) - Date.parse(ref.startedAt));
-
-    for (const row of rows.messages) {
-      const data = parseJson(row.data);
-      const tokens = data.tokens;
-      if (!tokens || typeof tokens !== 'object') continue;
-      result.tokens.input += Number(tokens.input || 0);
-      result.tokens.output += Number(tokens.output || 0);
-      result.tokens.cacheRead += Number(tokens.cache?.read || 0);
-      result.tokens.cacheCreated += Number(tokens.cache?.write || 0);
-    }
-
-    for (const row of rows.parts) {
-      const data = parseJson(row.data);
-      if (data.type !== 'tool') continue;
-      const toolName = data.tool || 'unknown';
-      result.toolCalls[toolName] = (result.toolCalls[toolName] || 0) + 1;
-      const op = fileOpForTool(toolName);
-      if (op) result.fileOps[op] = (result.fileOps[op] || 0) + 1;
-    }
-  }
-
-  return result;
-}
-
-function printOpenCodeSession(ref, opts) {
-  const rows = loadOpenCodeRows(ref.id);
+function printSession(ref, session, opts) {
   console.log(`id:        ${ref.id}`);
-  console.log(`source:    ${ref.source.harness} (${ref.source.format})`);
+  console.log(`harness:   ${ref.source.harness}`);
+  console.log(`source:    ${ref.source.format}`);
   console.log(`path:      ${ref.source.path}`);
   console.log(`cwd:       ${ref.cwd}`);
+  if (ref.title) console.log(`title:     ${ref.title}`);
+  if (session.model) console.log(`model:     ${session.model}`);
   console.log(`started:   ${ref.startedAt}`);
   if (ref.endedAt) console.log(`ended:     ${ref.endedAt}`);
-  console.log(`turns:     ${rows.messages.length}`);
+  console.log(`turns:     ${session.turns.length}`);
   console.log('');
 
-  const events = openCodeEvents(rows);
-  for (const event of events) {
-    if (opts.events && !opts.events.has(event.kind)) continue;
-    const line = formatOpenCodeEvent(event);
-    if (opts.grep && !opts.grep.test(line)) continue;
-    console.log(line);
+  for (const turn of session.turns) {
+    for (const event of turn.events) {
+      if (opts.events && !opts.events.has(event.kind)) continue;
+      const line = `${turn.at} ${event.kind}: ${formatEvent(event)}`;
+      if (opts.grep && !opts.grep.test(line)) continue;
+      console.log(line);
+    }
   }
 }
 
-function loadOpenCodeRows(sessionId) {
-  const dbPath = defaultOpenCodeDbPath();
-  const id = sqlString(sessionId);
-  return {
-    messages: queryOpenCodeDb(dbPath, `select id, time_created, data from message where session_id = ${id} order by time_created, id`),
-    parts: queryOpenCodeDb(dbPath, `select id, message_id, time_created, data from part where session_id = ${id} order by time_created, id`),
-  };
-}
-
-function openCodeEvents(rows) {
-  const events = [];
-
-  for (const row of rows.messages) {
-    const data = parseJson(row.data);
-    const at = msToIso(row.time_created);
-    const model = data.modelID && data.providerID ? `${data.providerID}/${data.modelID}` : undefined;
-    const error = data.error?.data?.message || data.error?.message;
-    events.push({
-      kind: error ? 'error' : 'turn',
-      at,
-      text: error
-        ? `${data.role || 'assistant'} ${data.agent || ''} ${model || ''}: ${error}`
-        : `${data.role || 'unknown'} ${data.agent || ''} ${model || ''} finish=${data.finish || 'unknown'}`,
-    });
-    if (data.tokens) {
-      events.push({
-        kind: 'token_usage',
-        at,
-        text: `input=${data.tokens.input || 0} output=${data.tokens.output || 0} cache_read=${data.tokens.cache?.read || 0} cache_created=${data.tokens.cache?.write || 0}${model ? ` model=${model}` : ''}`,
-      });
-    }
+function formatEvent(event) {
+  if (event.kind === 'message') {
+    return `${event.role}: ${oneLine(event.text, 360)}`;
   }
-
-  for (const row of rows.parts) {
-    const data = parseJson(row.data);
-    const at = msToIso(row.time_created);
-    if (data.type === 'text') {
-      events.push({ kind: 'message', at, text: data.text || '' });
-    } else if (data.type === 'reasoning') {
-      events.push({ kind: 'reasoning', at, text: data.text || '' });
-    } else if (data.type === 'tool') {
-      const status = data.state?.status ? ` status=${data.state.status}` : '';
-      const input = data.state?.input ? ` ${JSON.stringify(data.state.input)}` : '';
-      const output = data.state?.output ? ` => ${data.state.output}` : '';
-      events.push({ kind: 'tool_call', at, text: `${data.tool || 'unknown'}${status}${input}${output}` });
-      const op = fileOpForTool(data.tool);
-      if (op) events.push({ kind: 'file_op', at, text: `${op} ${filePathFromTool(data) || ''}`.trim() });
-    } else if (data.__parseError) {
-      events.push({ kind: 'error', at, text: `unparseable part JSON: ${data.__parseError}` });
-    } else {
-      events.push({ kind: data.type || 'part', at, text: JSON.stringify(data) });
-    }
+  if (event.kind === 'tool_call') {
+    return `${event.name || 'unknown'} ${oneLine(safeJson(event.input), 360)}`;
   }
-
-  return events.sort((a, b) => a.at.localeCompare(b.at));
-}
-
-function formatOpenCodeEvent(event) {
-  return `${event.at} ${event.kind}: ${oneLine(event.text, 360)}`;
-}
-
-function parseJson(raw) {
-  try {
-    return JSON.parse(raw || '{}');
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    return { __parseError: message, __raw: raw };
+  if (event.kind === 'tool_result') {
+    const suffix = event.error ? ` error=${oneLine(event.error, 160)}` : '';
+    return `${event.toolUseId || '(unknown)'}${suffix}${event.output ? ` => ${oneLine(event.output, 240)}` : ''}`;
   }
-}
-
-function fileOpForTool(toolName) {
-  if (toolName === 'read') return 'read';
-  if (toolName === 'write') return 'write';
-  if (toolName === 'edit') return 'edit';
-  if (toolName === 'glob') return 'list';
-  if (toolName === 'grep') return 'search';
-  return undefined;
-}
-
-function filePathFromTool(part) {
-  const input = part.state?.input;
-  if (!input || typeof input !== 'object') return undefined;
-  return input.filePath || input.path || input.pattern;
+  if (event.kind === 'file_op') {
+    return `${event.op} ${event.path} (${event.tool})`;
+  }
+  if (event.kind === 'token_usage') {
+    return `input=${event.input} output=${event.output} cache_read=${event.cacheRead} cache_created=${event.cacheCreated}${event.model ? ` model=${event.model}` : ''}`;
+  }
+  return oneLine(safeJson(event), 360);
 }
 
 function oneLine(value, max) {
-  return shorten(String(value ?? '').replace(/\s+/g, ' ').trim(), max);
+  return shorten(clean(value), max);
 }
 
 function resolveIsoTraceCli() {
@@ -373,6 +214,18 @@ function passthroughIsoTrace(rawArgs) {
   return result.status ?? 1;
 }
 
+function tryLoadSession(ref) {
+  try {
+    return { ref, session: loadObservedSession(ref), error: null };
+  } catch (error) {
+    return {
+      ref,
+      session: null,
+      error: error instanceof Error ? error.message : String(error),
+    };
+  }
+}
+
 async function main() {
   if (cmd === 'help' || cmd === '--help' || cmd === '-h') {
     console.log(USAGE);
@@ -389,13 +242,13 @@ async function main() {
       console.error(`job-forge trace:list: ${opts.error}`);
       return 2;
     }
-    const refs = await discoverOpenCodeRefs(opts);
+    const refs = await discoverProjectSessions(opts);
     if (opts.json) {
       console.log(JSON.stringify(refs, null, 2));
       return 0;
     }
     if (refs.length === 0) {
-      console.error('job-forge trace:list: no OpenCode sessions found for this project');
+      console.error('job-forge trace:list: no sessions found for this project');
       return 2;
     }
     printSessionTable(refs);
@@ -412,18 +265,30 @@ async function main() {
       console.error(`job-forge trace:stats: ${opts.error}`);
       return 2;
     }
-    const refs = await discoverOpenCodeRefs(opts);
+    const refs = await discoverProjectSessions(opts);
     const selected = positional.length === 0
       ? refs
       : positional.map((id) => {
-          const ref = findSessionById(refs, id);
-          if (!ref) throw new Error(`job-forge trace:stats: no OpenCode session matches "${id}"`);
+          const ref = findObservedSession(refs, id);
+          if (!ref) throw new Error(`job-forge trace:stats: no session matches "${id}"`);
           return ref;
         });
-    const result = computeOpenCodeStats(selected);
+    const loaded = selected.map(tryLoadSession);
+    const failures = loaded.filter((item) => item.error);
+    if (positional.length > 0 && failures.length > 0) {
+      throw new Error(`job-forge trace:stats: could not load session "${failures[0].ref.id}": ${failures[0].error}`);
+    }
+    const sessions = loaded.filter((item) => item.session).map((item) => item.session);
+    if (sessions.length === 0) {
+      throw new Error('job-forge trace:stats: no readable sessions found for this selection');
+    }
+    const result = statsForSessions(sessions);
     if (opts.json) {
       console.log(JSON.stringify(result, null, 2));
     } else {
+      if (failures.length > 0) {
+        console.error(`job-forge trace:stats: skipped ${failures.length} unreadable session(s)`);
+      }
       printStats(result);
     }
     return 0;
@@ -447,13 +312,19 @@ async function main() {
       console.error('job-forge trace:show: missing <id-or-prefix>');
       return 2;
     }
-    const refs = await discoverOpenCodeRefs({ cwd: PROJECT_DIR, since: undefined });
-    const ref = findSessionById(refs, positional[0]);
+    const refs = await discoverProjectSessions({ cwd: opts.cwd, harness: opts.harness, since: undefined });
+    const ref = findObservedSession(refs, positional[0]);
     if (!ref) {
-      console.error(`job-forge trace:show: no OpenCode session matches "${positional[0]}"`);
+      console.error(`job-forge trace:show: no session matches "${positional[0]}"`);
+      return 2;
+    }
+    const loaded = tryLoadSession(ref);
+    if (!loaded.session) {
+      console.error(`job-forge trace:show: could not load session "${ref.id}": ${loaded.error}`);
       return 2;
     }
-    printOpenCodeSession(ref, opts);
+    const session = loaded.session;
+    printSession(ref, session, opts);
     return 0;
   }