zerg-ztc 0.1.10 → 0.1.11

package/src/utils/path_format.ts

@@ -0,0 +1,99 @@
+import { homedir } from 'os';
+import { basename, dirname } from 'path';
+
+/**
+ * Shorten a path for display:
+ * - Replace home directory with ~
+ * - Truncate middle of long paths
+ * - Show basename prominently
+ */
+export function shortenPath(path: string, maxLength = 60): string {
+  if (!path) return '';
+
+  // Replace home directory with ~
+  const home = homedir();
+  let shortened = path;
+  if (path.startsWith(home)) {
+    shortened = '~' + path.slice(home.length);
+  }
+
+  // If short enough, return as-is
+  if (shortened.length <= maxLength) {
+    return shortened;
+  }
+
+  // Truncate middle, keeping start and end
+  const base = basename(shortened);
+  const dir = dirname(shortened);
+
+  // Always show at least the basename
+  if (base.length >= maxLength - 4) {
+    return '…' + base.slice(-(maxLength - 1));
+  }
+
+  // Show as much of the directory as we can
+  const availableForDir = maxLength - base.length - 2; // 2 for /…
+  if (availableForDir < 10) {
+    return '…/' + base;
+  }
+
+  // Split dir and keep start + end
+  const startLen = Math.floor(availableForDir * 0.4);
+  const endLen = availableForDir - startLen - 1; // 1 for …
+
+  const dirStart = dir.slice(0, startLen);
+  const dirEnd = dir.slice(-endLen);
+
+  return `${dirStart}…${dirEnd}/${base}`;
+}
+
+/**
+ * Format a path for trace display - very compact
+ */
+export function formatTracePath(path: string): string {
+  if (!path) return '""';
+
+  const home = homedir();
+  let formatted = path;
+
+  // Replace home with ~
+  if (path.startsWith(home)) {
+    formatted = '~' + path.slice(home.length);
+  }
+
+  // For very long paths, just show basename with hint
+  if (formatted.length > 50) {
+    const base = basename(formatted);
+    const dir = dirname(formatted);
+    // Show abbreviated dir + full basename
+    if (dir.length > 30) {
+      const dirParts = dir.split('/').filter(Boolean);
+      if (dirParts.length > 3) {
+        const abbreviated = dirParts.slice(0, 2).join('/') + '/…/' + dirParts.slice(-1).join('/');
+        return abbreviated + '/' + base;
+      }
+    }
+  }
+
+  return formatted;
+}
+
+/**
+ * Format bytes in human readable form
+ */
+export function formatBytes(bytes: number): string {
+  if (bytes < 1024) return `${bytes} bytes`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / 1024 / 1024).toFixed(1)} MB`;
+}
+
+/**
+ * Format duration in human readable form
+ */
+export function formatDuration(ms: number): string {
+  if (ms < 1000) return `${ms}ms`;
+  if (ms < 60000) return `${(ms / 1000).toFixed(1)}s`;
+  const mins = Math.floor(ms / 60000);
+  const secs = Math.round((ms % 60000) / 1000);
+  return `${mins}m${secs}s`;
+}

package/src/utils/table.ts

@@ -0,0 +1,171 @@
+/**
+ * Box-drawing table utilities
+ * Uses Unicode box-drawing characters for clean terminal tables
+ */
+
+// Box-drawing characters
+const BOX = {
+  topLeft: '┌',
+  topRight: '┐',
+  bottomLeft: '└',
+  bottomRight: '┘',
+  horizontal: '─',
+  vertical: '│',
+  leftT: '├',
+  rightT: '┤',
+  topT: '┬',
+  bottomT: '┴',
+  cross: '┼'
+};
+
+// Light box (for subtler tables)
+const BOX_LIGHT = {
+  topLeft: '╭',
+  topRight: '╮',
+  bottomLeft: '╰',
+  bottomRight: '╯',
+  horizontal: '─',
+  vertical: '│',
+  leftT: '├',
+  rightT: '┤',
+  topT: '┬',
+  bottomT: '┴',
+  cross: '┼'
+};
+
+export interface TableColumn {
+  header: string;
+  key: string;
+  width?: number;
+  align?: 'left' | 'right' | 'center';
+}
+
+export interface TableOptions {
+  rounded?: boolean;
+  headerSeparator?: boolean;
+  compact?: boolean;
+}
+
+function padString(str: string, width: number, align: 'left' | 'right' | 'center' = 'left'): string {
+  const visibleLength = str.replace(/\x1b\[[0-9;]*m/g, '').length;
+  const padding = Math.max(0, width - visibleLength);
+
+  if (align === 'right') {
+    return ' '.repeat(padding) + str;
+  }
+  if (align === 'center') {
+    const left = Math.floor(padding / 2);
+    const right = padding - left;
+    return ' '.repeat(left) + str + ' '.repeat(right);
+  }
+  return str + ' '.repeat(padding);
+}
+
+function getColumnWidths(columns: TableColumn[], rows: Record<string, unknown>[]): number[] {
+  return columns.map(col => {
+    const headerWidth = col.header.length;
+    const dataWidth = rows.reduce((max, row) => {
+      const value = String(row[col.key] || '');
+      const visibleLength = value.replace(/\x1b\[[0-9;]*m/g, '').length;
+      return Math.max(max, visibleLength);
+    }, 0);
+    return col.width || Math.max(headerWidth, dataWidth);
+  });
+}
+
+/**
+ * Format data as a box-drawing table
+ */
+export function formatTable(
+  columns: TableColumn[],
+  rows: Record<string, unknown>[],
+  options: TableOptions = {}
+): string {
+  const { rounded = false, headerSeparator = true, compact = false } = options;
+  const box = rounded ? BOX_LIGHT : BOX;
+  const widths = getColumnWidths(columns, rows);
+  const lines: string[] = [];
+
+  // Top border
+  const topBorder = box.topLeft +
+    widths.map(w => box.horizontal.repeat(w + 2)).join(box.topT) +
+    box.topRight;
+  lines.push(topBorder);
+
+  // Header row
+  const headerRow = box.vertical +
+    columns.map((col, i) => ' ' + padString(col.header, widths[i], 'center') + ' ').join(box.vertical) +
+    box.vertical;
+  lines.push(headerRow);
+
+  // Header separator
+  if (headerSeparator) {
+    const separator = box.leftT +
+      widths.map(w => box.horizontal.repeat(w + 2)).join(box.cross) +
+      box.rightT;
+    lines.push(separator);
+  }
+
+  // Data rows
+  for (const row of rows) {
+    const dataRow = box.vertical +
+      columns.map((col, i) => {
+        const value = String(row[col.key] || '');
+        return ' ' + padString(value, widths[i], col.align) + ' ';
+      }).join(box.vertical) +
+      box.vertical;
+    lines.push(dataRow);
+
+    // Row separator (if not compact)
+    if (!compact && rows.indexOf(row) < rows.length - 1) {
+      const rowSep = box.leftT +
+        widths.map(w => box.horizontal.repeat(w + 2)).join(box.cross) +
+        box.rightT;
+      lines.push(rowSep);
+    }
+  }
+
+  // Bottom border
+  const bottomBorder = box.bottomLeft +
+    widths.map(w => box.horizontal.repeat(w + 2)).join(box.bottomT) +
+    box.bottomRight;
+  lines.push(bottomBorder);
+
+  return lines.join('\n');
+}
+
+/**
+ * Simple two-column table (key-value style)
+ */
+export function formatKeyValueTable(
+  data: Array<{ label: string; value: string }>,
+  options: TableOptions = {}
+): string {
+  const columns: TableColumn[] = [
+    { header: 'Key', key: 'label', align: 'left' },
+    { header: 'Value', key: 'value', align: 'left' }
+  ];
+  const rows = data.map(d => ({ label: d.label, value: d.value }));
+  return formatTable(columns, rows, { ...options, headerSeparator: false });
+}
+
+/**
+ * Format a schedule/calendar table
+ */
+export function formatScheduleTable(
+  events: Array<{ time: string; event: string }>,
+  options: TableOptions = {}
+): string {
+  const columns: TableColumn[] = [
+    { header: 'Time', key: 'time', align: 'left', width: 7 },
+    { header: 'Event', key: 'event', align: 'left' }
+  ];
+  return formatTable(columns, events, { rounded: true, compact: true, ...options });
+}
+
+/**
+ * Simple horizontal line/divider
+ */
+export function formatDivider(width = 80, char = '─'): string {
+  return char.repeat(width);
+}

package/src/utils/tool_trace.ts

@@ -1,45 +1,65 @@
-import { getTraceStyle, TraceStyle } from '../emulation/trace_style.js';
+import { getTraceStyle } from '../emulation/trace_style.js';
+import { formatTracePath, formatBytes, formatDuration } from './path_format.js';
 
 const toolLabels: Record<string, string> = {
   run_command: 'Bash',
   read_file: 'Read',
   write_file: 'Update',
   list_directory: 'List',
-  search: 'Search'
+  search: 'Search',
+  screenshot: 'Screenshot',
+  list_windows: 'ListWindows',
+  run_and_capture: 'RunCapture'
 };
 
-function formatValue(value: unknown): string {
-  if (typeof value === 'string') {
-    const escaped = value.replace(/\n/g, '\\n');
-    return `"${escaped}"`;
-  }
-  if (typeof value === 'number' || typeof value === 'boolean') {
-    return String(value);
-  }
-  return JSON.stringify(value);
-}
-
 function formatArgs(tool: string, args: Record<string, unknown>): string {
+  // Compact arg formatting - just show the key values
   if (tool === 'run_command') {
     const command = args.command ? String(args.command) : '';
-    const cwd = args.cwd ? `, cwd: ${formatValue(args.cwd)}` : '';
-    const timeout = args.timeout ? `, timeout: ${formatValue(args.timeout)}` : '';
-    return `(${command}${cwd}${timeout})`;
+    // Truncate long commands
+    const truncated = command.length > 60 ? command.slice(0, 57) + '...' : command;
+    return `(${truncated})`;
   }
+
   if (tool === 'search') {
-    const pattern = args.pattern ? `pattern: ${formatValue(args.pattern)}` : '';
-    const path = args.path ? `path: ${formatValue(args.path)}` : '';
-    const output = args.output_mode ? `output_mode: ${formatValue(args.output_mode)}` : '';
-    const parts = [pattern, path, output].filter(Boolean);
-    return parts.length ? `(${parts.join(', ')})` : '';
+    const pattern = args.pattern ? String(args.pattern) : '';
+    const path = args.path ? formatTracePath(String(args.path)) : '';
+    if (path) {
+      return `(${pattern}, ${path})`;
+    }
+    return `(${pattern})`;
   }
+
   if (tool === 'read_file' || tool === 'write_file' || tool === 'list_directory') {
-    const path = args.path ? formatValue(args.path) : '""';
+    const path = args.path ? formatTracePath(String(args.path)) : '';
     return `(${path})`;
   }
 
-  const entries = Object.entries(args).map(([key, value]) => `${key}: ${formatValue(value)}`);
-  return entries.length ? `(${entries.join(', ')})` : '';
+  if (tool === 'screenshot') {
+    if (args.app) return `(app: "${args.app}")`;
+    if (args.pid) return `(pid: ${args.pid})`;
+    if (args.windowId) return `(windowId: ${args.windowId})`;
+    return '';
+  }
+
+  if (tool === 'list_windows') {
+    if (args.filter) return `(filter: "${args.filter}")`;
+    return '';
+  }
+
+  // Generic: show first few args compactly
+  const entries = Object.entries(args).slice(0, 3);
+  if (entries.length === 0) return '';
+
+  const parts = entries.map(([key, value]) => {
+    if (typeof value === 'string') {
+      const v = value.length > 30 ? value.slice(0, 27) + '...' : value;
+      return `${key}: "${v}"`;
+    }
+    return `${key}: ${value}`;
+  });
+
+  return `(${parts.join(', ')})`;
 }
 
 function parseResult(raw: string): Record<string, unknown> | null {
@@ -52,37 +72,96 @@ function parseResult(raw: string): Record<string, unknown> | null {
   return null;
 }
 
+interface ParsedDiff {
+  addedLines: number;
+  removedLines: number;
+  hunks: Array<{
+    header: string;
+    lines: Array<{ type: 'add' | 'remove' | 'context'; lineNum?: number; text: string }>;
+  }>;
+}
+
+function parseDiff(diff: string): ParsedDiff | null {
+  if (!diff || !diff.includes('@@')) return null;
+
+  const lines = diff.split('\n');
+  let addedLines = 0;
+  let removedLines = 0;
+  const hunks: ParsedDiff['hunks'] = [];
+  let currentHunk: ParsedDiff['hunks'][0] | null = null;
+
+  for (const line of lines) {
+    if (line.startsWith('@@')) {
+      if (currentHunk) hunks.push(currentHunk);
+      currentHunk = { header: line, lines: [] };
+      continue;
+    }
+
+    if (!currentHunk) continue;
+
+    if (line.startsWith('+') && !line.startsWith('+++')) {
+      addedLines++;
+      currentHunk.lines.push({ type: 'add', text: line.slice(1) });
+    } else if (line.startsWith('-') && !line.startsWith('---')) {
+      removedLines++;
+      currentHunk.lines.push({ type: 'remove', text: line.slice(1) });
+    } else if (line.startsWith(' ')) {
+      currentHunk.lines.push({ type: 'context', text: line.slice(1) });
+    }
+  }
+
+  if (currentHunk) hunks.push(currentHunk);
+
+  return { addedLines, removedLines, hunks };
+}
+
 function formatOutcome(tool: string, result: string, durationMs?: number): string {
   const parsed = parseResult(result);
-  const duration = typeof durationMs === 'number' ? ` in ${(durationMs / 1000).toFixed(1)}s` : '';
+  const duration = typeof durationMs === 'number' ? ` in ${formatDuration(durationMs)}` : '';
 
   if (parsed && tool === 'search') {
     const count = typeof parsed.count === 'number' ? parsed.count : 0;
     const label = count === 1 ? 'match' : 'matches';
     return `Found ${count} ${label}${duration}`;
   }
+
   if (parsed && tool === 'run_command') {
     const stdout = String(parsed.stdout || '');
     const stderr = String(parsed.stderr || '');
     const lines = (stdout || stderr).trim().split('\n').filter(Boolean).length;
     const label = lines === 1 ? 'line' : 'lines';
-    return lines > 0 ? `Output ${lines} ${label}${duration}` : `Command finished${duration}`;
+    return lines > 0 ? `Output ${lines} ${label}${duration}` : `Done${duration}`;
   }
+
   if (parsed && tool === 'read_file') {
-    const path = String(parsed.path || '');
-    const size = parsed.size ? `${parsed.size} bytes` : 'unknown size';
+    const path = formatTracePath(String(parsed.path || ''));
+    const size = typeof parsed.size === 'number' ? formatBytes(parsed.size) : '';
     const truncated = parsed.truncated ? ' (truncated)' : '';
-    return `Read ${path} (${size})${duration}${truncated}`;
+    return `${path} (${size})${duration}${truncated}`;
   }
+
   if (parsed && tool === 'write_file') {
-    const path = String(parsed.path || '');
-    const action = String(parsed.action || 'written');
-    return `Updated ${path} (${action})${duration}`;
+    const path = formatTracePath(String(parsed.path || ''));
+    const diff = parseDiff(String(parsed.diff || ''));
+    if (diff) {
+      const parts: string[] = [];
+      if (diff.addedLines > 0) parts.push(`+${diff.addedLines}`);
+      if (diff.removedLines > 0) parts.push(`-${diff.removedLines}`);
+      const summary = parts.length > 0 ? ` (${parts.join(', ')} lines)` : '';
+      return `${path}${summary}${duration}`;
+    }
+    return `${path}${duration}`;
   }
+
   if (parsed && tool === 'list_directory') {
-    const path = String(parsed.path || '');
+    const path = formatTracePath(String(parsed.path || ''));
     const entries = Array.isArray(parsed.entries) ? parsed.entries.length : 0;
-    return `Listed ${path} (${entries} items)${duration}`;
+    return `${path} (${entries} items)${duration}`;
+  }
+
+  if (parsed && tool === 'screenshot') {
+    const desc = String(parsed.description || 'Screenshot captured');
+    return `${desc}${duration}`;
   }
 
   return `Done${duration}`;
@@ -107,7 +186,7 @@ function buildOutputLines(tool: string, result: string): { lines: string[]; trun
     const lines = matches.map((entry: unknown) => {
       if (!entry || typeof entry !== 'object') return '';
       const row = entry as Record<string, unknown>;
-      const file = String(row.path || '');
+      const file = formatTracePath(String(row.path || ''));
       const line = row.line ? `:${row.line}` : '';
       const text = String(row.text || '');
       return `${file}${line} ${text}`.trim();
@@ -122,9 +201,24 @@ function buildOutputLines(tool: string, result: string): { lines: string[]; trun
   }
 
   if (tool === 'write_file') {
-    const diff = typeof parsed.diff === 'string' ? parsed.diff : '';
-    const lines = diff ? diff.split('\n') : [];
-    return { lines, truncated: Boolean(parsed.truncated) };
+    // Return formatted diff lines
+    const diff = parseDiff(String(parsed.diff || ''));
+    if (diff && diff.hunks.length > 0) {
+      const lines: string[] = [];
+      for (const hunk of diff.hunks) {
+        for (const line of hunk.lines) {
+          if (line.type === 'add') {
+            lines.push(`+ ${line.text}`);
+          } else if (line.type === 'remove') {
+            lines.push(`- ${line.text}`);
+          } else {
+            lines.push(`  ${line.text}`);
+          }
+        }
+      }
+      return { lines, truncated: Boolean(parsed.truncated) };
+    }
+    return { lines: [], truncated: false };
   }
 
   return { lines: [], truncated: false };
@@ -134,6 +228,7 @@ export function formatToolStart(tool: string, args: Record<string, unknown>, emu
   const style = getTraceStyle(emulationId);
   const label = toolLabels[tool] || tool;
   const argsText = formatArgs(tool, args);
+
   if (style === 'claude_code') {
     return `⏺ ${label}${argsText}`;
   }
@@ -150,8 +245,9 @@ export function formatToolStart(tool: string, args: Record<string, unknown>, emu
 export function formatToolEnd(tool: string, result: string, durationMs?: number, emulationId?: string): string {
   const style = getTraceStyle(emulationId);
   const summary = formatOutcome(tool, result, durationMs);
+
   if (style === 'claude_code') {
-    return `⎿ ${summary}`;
+    return `⎿  ${summary}`;
   }
   if (style === 'codex') {
     if (tool === 'run_command') {
@@ -167,13 +263,28 @@ export function formatToolEnd(tool: string, result: string, durationMs?: number,
 
 export function formatToolError(tool: string, error: string, emulationId?: string): string {
   const style = getTraceStyle(emulationId);
+  const label = toolLabels[tool] || tool;
+
+  // Provide helpful error messages
+  let displayError = error;
+  if (error.includes('Screen Recording permission')) {
+    displayError = 'Screen Recording permission required (System Settings > Privacy & Security)';
+  }
+
   if (style === 'claude_code') {
-    return `⎿ ${tool} failed: ${error}`;
+    return `⎿  ${label} failed: ${displayError}`;
   }
   if (style === 'codex') {
-    return `  ${tool} failed: ${error}`;
+    return `  ${label} failed: ${displayError}`;
   }
-  return `< ${tool} failed: ${error}`;
+  return `< ${label} failed: ${displayError}`;
+}
+
+export interface ToolOutputMessage {
+  preview: string;
+  full: string;
+  truncated: boolean;
+  diffLines?: Array<{ type: 'add' | 'remove' | 'context'; text: string }>;
 }
 
 export function buildToolOutputMessage(
@@ -181,9 +292,25 @@ export function buildToolOutputMessage(
   result: string,
   durationMs?: number,
   emulationId?: string
-): { preview: string; full: string; truncated: boolean } {
+): ToolOutputMessage {
   const { lines, truncated } = buildOutputLines(tool, result);
-  if (lines.length === 0) {
+  const parsed = parseResult(result);
+
+  // For write_file, extract diff info
+  let diffLines: ToolOutputMessage['diffLines'];
+  if (tool === 'write_file' && parsed) {
+    const diff = parseDiff(String(parsed.diff || ''));
+    if (diff && diff.hunks.length > 0) {
+      diffLines = [];
+      for (const hunk of diff.hunks) {
+        for (const line of hunk.lines) {
+          diffLines.push({ type: line.type, text: line.text });
+        }
+      }
+    }
+  }
+
+  if (lines.length === 0 && !diffLines) {
     const summary = formatToolEnd(tool, result, durationMs, emulationId);
     return { preview: summary, full: summary, truncated: false };
   }
@@ -194,23 +321,26 @@ export function buildToolOutputMessage(
   const expandHint = truncated || remaining > 0 ? ' (ctrl+o to expand)' : '';
 
   const summary = formatToolEnd(tool, result, durationMs, emulationId);
-  const previewBlock = [
-    summary,
-    ...previewLines.map(line => `  ${line}`)
-  ];
+  const indent = '    ';
+
+  const previewBlock = [summary];
+  for (const line of previewLines) {
+    previewBlock.push(`${indent}${line}`);
+  }
   if (expandHint) {
     const extraLabel = remaining > 0 ? `… +${remaining} lines` : '…';
-    previewBlock.push(`  ${extraLabel}${expandHint}`);
+    previewBlock.push(`${indent}${extraLabel}${expandHint}`);
   }
 
-  const fullBlock = [
-    summary,
-    ...lines.map(line => `  ${line}`)
-  ];
+  const fullBlock = [summary];
+  for (const line of lines) {
+    fullBlock.push(`${indent}${line}`);
+  }
 
   return {
     preview: previewBlock.join('\n'),
     full: fullBlock.join('\n'),
-    truncated: Boolean(expandHint)
+    truncated: Boolean(expandHint),
+    diffLines
   };
 }