zerg-ztc 0.1.11 → 0.1.12

package/src/utils/diff.ts

@@ -1,52 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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

@@ -1,98 +0,0 @@
-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/path_complete.ts

@@ -1,173 +0,0 @@
-import { readdir } from 'fs/promises';
-import { resolve, dirname, basename } from 'path';
-import { homedir } from 'os';
-
-/**
- * Get path completions for tab autocomplete
- */
-export async function getPathCompletions(
-  partial: string,
-  cwd: string
-): Promise<string[]> {
-  // Expand tilde
-  let expandedPartial = partial;
-  if (partial.startsWith('~/')) {
-    expandedPartial = resolve(homedir(), partial.slice(2));
-  } else if (partial === '~') {
-    expandedPartial = homedir();
-  }
-
-  // Resolve the path relative to cwd
-  const fullPath = resolve(cwd, expandedPartial);
-
-  // Determine the directory to list and the prefix to match
-  let dirToList: string;
-  let prefix: string;
-
-  try {
-    const { stat } = await import('fs/promises');
-    const stats = await stat(fullPath);
-    if (stats.isDirectory()) {
-      // If it's a directory, list its contents
-      dirToList = fullPath;
-      prefix = '';
-    } else {
-      // It's a file, no completions
-      return [];
-    }
-  } catch {
-    // Path doesn't exist, so complete the last component
-    dirToList = dirname(fullPath);
-    prefix = basename(fullPath).toLowerCase();
-  }
-
-  try {
-    const entries = await readdir(dirToList, { withFileTypes: true });
-    const matches = entries
-      .filter(entry => entry.name.toLowerCase().startsWith(prefix))
-      .map(entry => {
-        const name = entry.name;
-        const suffix = entry.isDirectory() ? '/' : '';
-        return name + suffix;
-      })
-      .sort();
-
-    return matches;
-  } catch {
-    return [];
-  }
-}
-
-/**
- * Complete a partial path, returning the completed path or null if no unique completion
- */
-export async function completePath(
-  partial: string,
-  cwd: string
-): Promise<{ completed: string; isDirectory: boolean; alternatives: string[] } | null> {
-  // Handle empty partial - list cwd contents
-  if (!partial || partial.trim() === '') {
-    try {
-      const entries = await readdir(cwd, { withFileTypes: true });
-      const matches = entries.filter(e => !e.name.startsWith('.')).sort();
-      if (matches.length === 0) return null;
-      if (matches.length === 1) {
-        const entry = matches[0];
-        const suffix = entry.isDirectory() ? '/' : '';
-        return { completed: entry.name + suffix, isDirectory: entry.isDirectory(), alternatives: [] };
-      }
-      const alternatives = matches.map(e => e.name + (e.isDirectory() ? '/' : ''));
-      return { completed: '', isDirectory: false, alternatives };
-    } catch {
-      return null;
-    }
-  }
-
-  // Expand tilde for internal processing
-  let expandedPartial = partial;
-  let tildePrefix = '';
-  if (partial.startsWith('~/')) {
-    expandedPartial = resolve(homedir(), partial.slice(2));
-    tildePrefix = '~/';
-  } else if (partial === '~') {
-    return { completed: '~/', isDirectory: true, alternatives: [] };
-  }
-
-  const fullPath = resolve(cwd, expandedPartial);
-  let dirToList: string;
-  let prefix: string;
-  let basePath: string;
-
-  try {
-    const { stat } = await import('fs/promises');
-    const stats = await stat(fullPath);
-    if (stats.isDirectory()) {
-      // Already a complete directory, append / if not present
-      if (!partial.endsWith('/')) {
-        return { completed: partial + '/', isDirectory: true, alternatives: [] };
-      }
-      // List directory contents for alternatives
-      dirToList = fullPath;
-      prefix = '';
-      basePath = partial;
-    } else {
-      // Complete file path
-      return { completed: partial, isDirectory: false, alternatives: [] };
-    }
-  } catch {
-    // Path doesn't exist, complete the last component
-    dirToList = dirname(fullPath);
-    prefix = basename(fullPath).toLowerCase();
-
-    // Calculate basePath - the directory portion to preserve
-    if (tildePrefix) {
-      const afterTilde = expandedPartial.slice(homedir().length + 1);
-      const dirPart = dirname(afterTilde);
-      basePath = dirPart === '.' ? tildePrefix : tildePrefix + dirPart + '/';
-    } else {
-      const dirPart = dirname(partial);
-      // Don't add ./ prefix for simple filenames
-      basePath = (dirPart === '.' || dirPart === '') ? '' : dirPart + '/';
-    }
-  }
-
-  try {
-    const entries = await readdir(dirToList, { withFileTypes: true });
-    const matches = entries
-      .filter(entry => entry.name.toLowerCase().startsWith(prefix))
-      .sort();
-
-    if (matches.length === 0) {
-      return null;
-    }
-
-    if (matches.length === 1) {
-      const entry = matches[0];
-      const suffix = entry.isDirectory() ? '/' : '';
-      const completed = basePath + entry.name + suffix;
-      return { completed, isDirectory: entry.isDirectory(), alternatives: [] };
-    }
-
-    // Find common prefix among all matches
-    const names = matches.map(e => e.name);
-    let commonPrefix = names[0];
-    for (const name of names.slice(1)) {
-      let i = 0;
-      while (i < commonPrefix.length && i < name.length && commonPrefix[i] === name[i]) {
-        i++;
-      }
-      commonPrefix = commonPrefix.slice(0, i);
-    }
-
-    const alternatives = matches.map(e => e.name + (e.isDirectory() ? '/' : ''));
-    const completed = basePath + commonPrefix;
-
-    return {
-      completed: completed.length > partial.length ? completed : partial,
-      isDirectory: false,
-      alternatives
-    };
-  } catch {
-    return null;
-  }
-}

package/src/utils/path_format.ts

@@ -1,99 +0,0 @@
-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/shell.ts

@@ -1,72 +0,0 @@
-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();
-  let path = target?.trim() || '';
-
-  // Expand tilde to home directory
-  if (path.startsWith('~/')) {
-    path = resolve(process.env.HOME || '', path.slice(2));
-  } else if (path === '~') {
-    path = process.env.HOME || '';
-  }
-
-  const next = path.length > 0 ? resolve(base, path) : base;
-  const info = await stat(next);
-  if (!info.isDirectory()) {
-    throw new Error('Not a directory');
-  }
-  return next;
-}

package/src/utils/spinner_frames.ts

@@ -1 +0,0 @@
-export const SPINNER_FRAMES = ['-', '\\', '|', '/'];

package/src/utils/spinner_verbs.ts

@@ -1,23 +0,0 @@
-export const DEFAULT_SPINNER_VERBS = [
-  'Thinking',
-  'Reticulating splines',
-  'Allocating time slices',
-  'Negotiating with entropy',
-  'Consulting the archives',
-  'Organizing thoughts',
-  'Compiling context',
-  'Assembling response',
-  'Tracing dependencies',
-  'Resolving intent'
-];
-
-export function parseSpinnerVerbs(input: string): string[] {
-  return input
-    .split(/[,|;\n]+/g)
-    .map(part => part.trim())
-    .filter(Boolean);
-}
-
-export function formatSpinnerVerbs(verbs: string[]): string {
-  return verbs.length === 0 ? '(none)' : verbs.join(', ');
-}