zerg-ztc 0.1.0

package/src/utils/diff.ts

@@ -0,0 +1,52 @@
+interface DiffLine {
+  type: 'context' | 'add' | 'remove';
+  text: string;
+}
+
+export function buildSimpleDiff(before: string, after: string, maxLines = 120, context = 2): string {
+  const beforeLines = before.split('\n');
+  const afterLines = after.split('\n');
+  const maxLen = Math.max(beforeLines.length, afterLines.length);
+
+  const changes = new Set<number>();
+  for (let i = 0; i < maxLen; i += 1) {
+    const b = beforeLines[i];
+    const a = afterLines[i];
+    if (b !== a) {
+      changes.add(i);
+    }
+  }
+
+  const include = new Set<number>();
+  for (const idx of changes) {
+    for (let i = Math.max(0, idx - context); i <= idx + context; i += 1) {
+      include.add(i);
+    }
+  }
+
+  const lines: DiffLine[] = [];
+  for (let i = 0; i < maxLen; i += 1) {
+    if (!include.has(i)) continue;
+    const b = beforeLines[i];
+    const a = afterLines[i];
+    if (b === a) {
+      lines.push({ type: 'context', text: b || '' });
+    } else {
+      if (b !== undefined) lines.push({ type: 'remove', text: b || '' });
+      if (a !== undefined) lines.push({ type: 'add', text: a || '' });
+    }
+  }
+
+  const clipped = lines.slice(0, maxLines);
+  if (lines.length > maxLines) {
+    clipped.push({ type: 'context', text: '... diff truncated ...' });
+  }
+
+  return clipped
+    .map(line => {
+      if (line.type === 'add') return `+ ${line.text}`;
+      if (line.type === 'remove') return `- ${line.text}`;
+      return `  ${line.text}`;
+    })
+    .join('\n');
+}

package/src/utils/image_preview.ts

@@ -0,0 +1,36 @@
+import { execFile } from 'child_process';
+import { promisify } from 'util';
+
+const execFileAsync = promisify(execFile);
+const cache = new Map<string, string[]>();
+
+async function hasCommand(command: string): Promise<boolean> {
+  try {
+    await execFileAsync('which', [command]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function renderImagePreview(path: string, width = 40, height = 20): Promise<string[] | null> {
+  const key = `${path}:${width}x${height}`;
+  const cached = cache.get(key);
+  if (cached) return cached;
+  if (!(await hasCommand('chafa'))) {
+    return null;
+  }
+  try {
+    const { stdout } = await execFileAsync('chafa', [
+      '--colors=none',
+      '--symbols=block',
+      `--size=${width}x${height}`,
+      path
+    ]);
+    const lines = stdout.split('\n').filter(line => line.length > 0);
+    cache.set(key, lines);
+    return lines;
+  } catch {
+    return null;
+  }
+}

package/src/utils/models.ts

@@ -0,0 +1,98 @@
+interface ListModelsOptions {
+  provider: string;
+  apiKey?: string;
+  baseUrl?: string;
+}
+
+async function parseList(response: Response): Promise<string[]> {
+  const data = await response.json() as Record<string, unknown>;
+  const array =
+    (Array.isArray(data.data) && data.data) ||
+    (Array.isArray(data.models) && data.models) ||
+    (Array.isArray(data.items) && data.items) ||
+    [];
+
+  const models = array
+    .map(item => {
+      if (typeof item === 'string') return item;
+      if (item && typeof item === 'object') {
+        const obj = item as Record<string, unknown>;
+        if (typeof obj.id === 'string') return obj.id;
+        if (typeof obj.name === 'string') return obj.name;
+      }
+      return null;
+    })
+    .filter((value): value is string => typeof value === 'string');
+
+  return models;
+}
+
+export async function listModels(options: ListModelsOptions): Promise<string[]> {
+  const provider = options.provider;
+  const apiKey = options.apiKey || '';
+
+  if (!apiKey) {
+    throw new Error(`No API key configured for ${provider}`);
+  }
+
+  if (provider === 'anthropic') {
+    const res = await fetch('https://api.anthropic.com/v1/models', {
+      headers: {
+        'x-api-key': apiKey,
+        'anthropic-version': '2023-06-01'
+      }
+    });
+    if (!res.ok) {
+      throw new Error(`Anthropic error (${res.status})`);
+    }
+    return parseList(res);
+  }
+
+  if (provider === 'openai') {
+    const res = await fetch('https://api.openai.com/v1/models', {
+      headers: {
+        Authorization: `Bearer ${apiKey}`
+      }
+    });
+    if (!res.ok) {
+      throw new Error(`OpenAI error (${res.status})`);
+    }
+    return parseList(res);
+  }
+
+  if (provider === 'openai_compatible') {
+    const baseUrl = options.baseUrl || 'https://api.openai.com/v1';
+    const res = await fetch(`${baseUrl.replace(/\/$/, '')}/models`, {
+      headers: {
+        Authorization: `Bearer ${apiKey}`
+      }
+    });
+    if (!res.ok) {
+      throw new Error(`OpenAI-compatible error (${res.status})`);
+    }
+    return parseList(res);
+  }
+
+  if (provider === 'gemini') {
+    const res = await fetch(`https://generativelanguage.googleapis.com/v1beta/models?key=${apiKey}`);
+    if (!res.ok) {
+      throw new Error(`Gemini error (${res.status})`);
+    }
+    return parseList(res);
+  }
+
+  if (provider === 'inception') {
+    const baseUrl = options.baseUrl || 'https://api.inception.ai/v1';
+    const res = await fetch(`${baseUrl.replace(/\/$/, '')}/models`, {
+      headers: {
+        Authorization: `Bearer ${apiKey}`
+      }
+    });
+    if (!res.ok) {
+      throw new Error(`Inception error (${res.status})`);
+    }
+    return parseList(res);
+  }
+
+  throw new Error(`Unknown provider: ${provider}`);
+}

package/src/utils/shell.ts

@@ -0,0 +1,63 @@
+import { exec, ExecException } from 'child_process';
+import { promisify } from 'util';
+import { resolve } from 'path';
+import { stat } from 'fs/promises';
+
+import type { ShellResult } from '../agent/commands/types.js';
+
+const execAsync = promisify(exec);
+
+const MAX_BUFFER = 1024 * 1024;
+const MAX_OUTPUT = 10000;
+const DEFAULT_TIMEOUT_MS = 30000;
+const DANGEROUS = ['rm -rf /', 'mkfs', ':(){:|:&};:'];
+
+export async function runShellCommand(command: string, cwd: string): Promise<ShellResult> {
+  if (DANGEROUS.some(entry => command.includes(entry))) {
+    throw new Error('Command rejected for safety reasons');
+  }
+
+  const resolvedCwd = resolve(cwd);
+
+  try {
+    const { stdout, stderr } = await execAsync(command, {
+      cwd: resolvedCwd,
+      timeout: DEFAULT_TIMEOUT_MS,
+      maxBuffer: MAX_BUFFER
+    });
+    const clippedStdout = stdout.slice(0, MAX_OUTPUT);
+    const clippedStderr = stderr.slice(0, MAX_OUTPUT);
+    return {
+      command,
+      cwd: resolvedCwd,
+      stdout: clippedStdout,
+      stderr: clippedStderr,
+      exitCode: 0,
+      truncated: stdout.length > MAX_OUTPUT || stderr.length > MAX_OUTPUT
+    };
+  } catch (err) {
+    const error = err as ExecException & { stdout?: string; stderr?: string; code?: number };
+    const stdout = String(error.stdout || '');
+    const stderr = String(error.stderr || error.message || '');
+    const clippedStdout = stdout.slice(0, MAX_OUTPUT);
+    const clippedStderr = stderr.slice(0, MAX_OUTPUT);
+    return {
+      command,
+      cwd: resolvedCwd,
+      stdout: clippedStdout,
+      stderr: clippedStderr,
+      exitCode: typeof error.code === 'number' ? error.code : 1,
+      truncated: stdout.length > MAX_OUTPUT || stderr.length > MAX_OUTPUT
+    };
+  }
+}
+
+export async function resolveWorkingDir(current: string, target?: string): Promise<string> {
+  const base = current || process.cwd();
+  const next = target && target.trim().length > 0 ? resolve(base, target) : base;
+  const info = await stat(next);
+  if (!info.isDirectory()) {
+    throw new Error('Not a directory');
+  }
+  return next;
+}

package/src/utils/tool_summary.ts

@@ -0,0 +1,56 @@
+type ParsedResult = Record<string, unknown>;
+
+function parseResult(raw: string): ParsedResult | null {
+  try {
+    const data = JSON.parse(raw) as ParsedResult;
+    if (data && typeof data === 'object') return data;
+  } catch {
+    return null;
+  }
+  return null;
+}
+
+export function summarizeToolResult(tool: string, raw: string): string {
+  const parsed = parseResult(raw);
+  if (!parsed) {
+    const trimmed = raw.trim();
+    return trimmed.length > 140 ? `${trimmed.slice(0, 140)}...` : trimmed || 'Done';
+  }
+
+  if (tool === 'read_file') {
+    const path = String(parsed.path || '');
+    const size = parsed.size ? ` (${parsed.size} bytes)` : '';
+    return `Read ${path}${size}`;
+  }
+  if (tool === 'write_file') {
+    const path = String(parsed.path || '');
+    const action = String(parsed.action || 'written');
+    return `Wrote ${path} (${action})`;
+  }
+  if (tool === 'list_directory') {
+    const path = String(parsed.path || '');
+    const entries = Array.isArray(parsed.entries) ? parsed.entries.length : 0;
+    return `Listed ${path} (${entries} items)`;
+  }
+  if (tool === 'run_command') {
+    const cwd = String(parsed.cwd || '');
+    const cmd = String(parsed.command || '');
+    return `Ran ${cmd}${cwd ? ` (cwd ${cwd})` : ''}`;
+  }
+  if (tool === 'search') {
+    const count = parsed.count ? String(parsed.count) : '0';
+    const path = String(parsed.path || '');
+    return `Found ${count} matches${path ? ` in ${path}` : ''}`;
+  }
+
+  const fallback = raw.trim();
+  return fallback.length > 140 ? `${fallback.slice(0, 140)}...` : fallback || 'Done';
+}
+
+export function summarizeToolArgs(args: Record<string, unknown>): string {
+  const entries = Object.entries(args)
+    .map(([key, value]) => `${key}=${String(value)}`)
+    .slice(0, 3);
+  if (entries.length === 0) return '';
+  return `(${entries.join(', ')}${Object.keys(args).length > 3 ? ', ...' : ''})`;
+}

package/src/utils/tool_trace.ts

@@ -0,0 +1,206 @@
+import { getTraceStyle, TraceStyle } from '../emulation/trace_style.js';
+
+const toolLabels: Record<string, string> = {
+  run_command: 'Bash',
+  read_file: 'Read',
+  write_file: 'Update',
+  list_directory: 'List',
+  search: 'Search'
+};
+
+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 {
+  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})`;
+  }
+  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(', ')})` : '';
+  }
+  if (tool === 'read_file' || tool === 'write_file' || tool === 'list_directory') {
+    const path = args.path ? formatValue(args.path) : '""';
+    return `(${path})`;
+  }
+
+  const entries = Object.entries(args).map(([key, value]) => `${key}: ${formatValue(value)}`);
+  return entries.length ? `(${entries.join(', ')})` : '';
+}
+
+function parseResult(raw: string): Record<string, unknown> | null {
+  try {
+    const data = JSON.parse(raw) as Record<string, unknown>;
+    if (data && typeof data === 'object') return data;
+  } catch {
+    return null;
+  }
+  return null;
+}
+
+function formatOutcome(tool: string, result: string, durationMs?: number): string {
+  const parsed = parseResult(result);
+  const duration = typeof durationMs === 'number' ? ` in ${(durationMs / 1000).toFixed(1)}s` : '';
+
+  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}`;
+  }
+  if (parsed && tool === 'read_file') {
+    const path = String(parsed.path || '');
+    const size = parsed.size ? `${parsed.size} bytes` : 'unknown size';
+    const truncated = parsed.truncated ? ' (truncated)' : '';
+    return `Read ${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}`;
+  }
+  if (parsed && tool === 'list_directory') {
+    const path = String(parsed.path || '');
+    const entries = Array.isArray(parsed.entries) ? parsed.entries.length : 0;
+    return `Listed ${path} (${entries} items)${duration}`;
+  }
+
+  return `Done${duration}`;
+}
+
+function buildOutputLines(tool: string, result: string): { lines: string[]; truncated: boolean } {
+  const parsed = parseResult(result);
+  if (!parsed) {
+    return { lines: [], truncated: false };
+  }
+
+  if (tool === 'run_command') {
+    const stdout = String(parsed.stdout || '');
+    const stderr = String(parsed.stderr || '');
+    const combined = [stdout, stderr].filter(Boolean).join('\n');
+    const lines = combined.split('\n').filter(Boolean);
+    return { lines, truncated: Boolean(parsed.truncated) };
+  }
+
+  if (tool === 'search') {
+    const matches = Array.isArray(parsed.matches) ? parsed.matches : [];
+    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 line = row.line ? `:${row.line}` : '';
+      const text = String(row.text || '');
+      return `${file}${line} ${text}`.trim();
+    }).filter(Boolean);
+    return { lines, truncated: Boolean(parsed.truncated) };
+  }
+
+  if (tool === 'read_file') {
+    const content = String(parsed.content || '');
+    const lines = content.split('\n');
+    return { lines, truncated: Boolean(parsed.truncated) };
+  }
+
+  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 { lines: [], truncated: false };
+}
+
+export function formatToolStart(tool: string, args: Record<string, unknown>, emulationId?: string): string {
+  const style = getTraceStyle(emulationId);
+  const label = toolLabels[tool] || tool;
+  const argsText = formatArgs(tool, args);
+  if (style === 'claude_code') {
+    return `⏺ ${label}${argsText}`;
+  }
+  if (style === 'codex') {
+    return `• ${label}${argsText}`;
+  }
+  return `> ${label}${argsText}`;
+}
+
+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}`;
+  }
+  if (style === 'codex') {
+    return `  ${summary}`;
+  }
+  return `< ${summary}`;
+}
+
+export function formatToolError(tool: string, error: string, emulationId?: string): string {
+  const style = getTraceStyle(emulationId);
+  if (style === 'claude_code') {
+    return `⎿ ${tool} failed: ${error}`;
+  }
+  if (style === 'codex') {
+    return `  ${tool} failed: ${error}`;
+  }
+  return `< ${tool} failed: ${error}`;
+}
+
+export function buildToolOutputMessage(
+  tool: string,
+  result: string,
+  durationMs?: number,
+  emulationId?: string
+): { preview: string; full: string; truncated: boolean } {
+  const { lines, truncated } = buildOutputLines(tool, result);
+  if (lines.length === 0) {
+    const summary = formatToolEnd(tool, result, durationMs, emulationId);
+    return { preview: summary, full: summary, truncated: false };
+  }
+
+  const maxLines = 8;
+  const previewLines = lines.slice(0, maxLines);
+  const remaining = lines.length - previewLines.length;
+  const expandHint = truncated || remaining > 0 ? ' (ctrl+o to expand)' : '';
+
+  const summary = formatToolEnd(tool, result, durationMs, emulationId);
+  const previewBlock = [
+    summary,
+    ...previewLines.map(line => `  ${line}`)
+  ];
+  if (expandHint) {
+    const extraLabel = remaining > 0 ? `… +${remaining} lines` : '…';
+    previewBlock.push(`  ${extraLabel}${expandHint}`);
+  }
+
+  const fullBlock = [
+    summary,
+    ...lines.map(line => `  ${line}`)
+  ];
+
+  return {
+    preview: previewBlock.join('\n'),
+    full: fullBlock.join('\n'),
+    truncated: Boolean(expandHint)
+  };
+}

package/tsconfig.json

@@ -0,0 +1,22 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "lib": ["ES2022"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "jsx": "react-jsx",
+    "jsxImportSource": "react"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}