zerg-ztc 0.1.10 → 0.1.12

package/src/ui/web/frame_render.tsx

@@ -1,148 +0,0 @@
-import React, { useMemo } from 'react';
-import { LayoutNode, LayoutFrame, computeLayout } from '../core/index.js';
-
-type BadgeInfo = {
-  type: 'paste' | 'file' | 'image';
-  preview: string;
-  full: string;
-  path?: string;
-};
-
-interface FrameRendererProps {
-  node: LayoutNode;
-  cols: number;
-  rows: number;
-  cellWidth: number;
-  cellHeight: number;
-  debugBorders?: boolean;
-  onBadgeHover?: (badge: BadgeInfo, x: number, y: number) => void;
-  onBadgeLeave?: () => void;
-  onBadgeClick?: (badge: BadgeInfo, x: number, y: number) => void;
-  onBadgeDblClick?: (badge: BadgeInfo, x: number, y: number) => void;
-}
-
-function colorMap(color?: string): string {
-  const map: Record<string, string> = {
-    gray: '#9a9a9a',
-    magenta: '#c084fc',
-    yellow: '#facc15',
-    green: '#34d399',
-    red: '#f87171',
-    cyan: '#67e8f9',
-    blue: '#60a5fa',
-    white: '#e5e7eb'
-  };
-  return map[color || ''] || color || '#e6e6e6';
-}
-
-function renderFrame(
-  frame: LayoutFrame,
-  keyPrefix: string,
-  cellWidth: number,
-  cellHeight: number,
-  debugBorders: boolean,
-  onBadgeHover?: (badge: BadgeInfo, x: number, y: number) => void,
-  onBadgeLeave?: () => void,
-  onBadgeClick?: (badge: BadgeInfo, x: number, y: number) => void,
-  onBadgeDblClick?: (badge: BadgeInfo, x: number, y: number) => void,
-  offsetX = 0,
-  offsetY = 0,
-  out: React.ReactElement[] = []
-): React.ReactElement[] {
-  const x = offsetX + frame.x;
-  const y = offsetY + frame.y;
-  const keyBase = `${keyPrefix}-${x}-${y}`;
-
-  if (frame.node.type === 'text') {
-    const style = frame.node.style || {};
-    if (debugBorders) {
-      out.push(
-        <div
-          key={`${keyBase}-debug`}
-          style={{
-            position: 'absolute',
-            left: x * cellWidth,
-            top: y * cellHeight,
-            width: frame.width * cellWidth,
-            height: frame.height * cellHeight,
-            borderStyle: 'dashed',
-            borderWidth: 1,
-            borderColor: '#3a3a3a',
-            pointerEvents: 'none'
-          }}
-        />
-      );
-    }
-    const badge = style.badge;
-    out.push(
-      <span
-        key={`${keyBase}-text`}
-        style={{
-          position: 'absolute',
-          left: x * cellWidth,
-          top: y * cellHeight,
-          color: style.inverse ? '#111' : colorMap(style.color),
-          fontWeight: style.bold ? 600 : undefined,
-          opacity: style.dimColor ? 0.6 : undefined,
-          background: style.inverse ? '#e6e6e6' : undefined,
-          colorScheme: 'only light',
-          cursor: badge ? 'pointer' : undefined
-        }}
-        title={badge?.preview || undefined}
-        onMouseEnter={badge ? (evt) => onBadgeHover?.(badge, evt.clientX, evt.clientY) : undefined}
-        onMouseLeave={badge ? () => onBadgeLeave?.() : undefined}
-        onClick={badge ? (evt) => onBadgeClick?.(badge, evt.clientX, evt.clientY) : undefined}
-        onDoubleClick={badge ? (evt) => onBadgeDblClick?.(badge, evt.clientX, evt.clientY) : undefined}
-      >
-        {frame.node.text}
-      </span>
-    );
-    return out;
-  }
-
-  if (frame.node.type === 'box' && (frame.node.style?.borderStyle || debugBorders)) {
-    out.push(
-      <div
-        key={`${keyBase}-border`}
-        style={{
-          position: 'absolute',
-          left: x * cellWidth,
-          top: y * cellHeight,
-          width: frame.width * cellWidth,
-          height: frame.height * cellHeight,
-          borderStyle: frame.node.style?.borderStyle ? 'solid' : 'dashed',
-          borderWidth: 1,
-          borderColor: colorMap(frame.node.style?.borderColor || '#3a3a3a'),
-          pointerEvents: 'none'
-        }}
-      />
-    );
-  }
-
-  frame.children.forEach((child, idx) => {
-    renderFrame(child, `${keyBase}-${idx}`, cellWidth, cellHeight, debugBorders, onBadgeHover, onBadgeLeave, onBadgeClick, onBadgeDblClick, x, y, out);
-  });
-
-  return out;
-}
-
-export const WebFrameRenderer: React.FC<FrameRendererProps> = ({
-  node,
-  cols,
-  rows,
-  cellWidth,
-  cellHeight,
-  debugBorders = false,
-  onBadgeHover,
-  onBadgeLeave,
-  onBadgeClick,
-  onBadgeDblClick
-}) => {
-  const frame = useMemo(() => computeLayout(node, cols, rows), [node, cols, rows]);
-  const elements = useMemo(
-    () => renderFrame(frame, 'root', cellWidth, cellHeight, debugBorders, onBadgeHover, onBadgeLeave, onBadgeClick, onBadgeDblClick),
-    [frame, cellWidth, cellHeight, debugBorders, onBadgeHover, onBadgeLeave, onBadgeClick, onBadgeDblClick]
-  );
-
-  return <>{elements}</>;
-};

package/src/ui/web/index.tsx

@@ -1 +0,0 @@
-export { WebNode } from './render.js';

package/src/ui/web/render.tsx

@@ -1,41 +0,0 @@
-import React from 'react';
-import { LayoutNode, TextNode } from '../core/types.js';
-import { toCssStyle } from '../core/style.js';
-
-const monoStyle: React.CSSProperties = {
-  fontFamily: 'ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace',
-  fontSize: 14,
-  lineHeight: '16px',
-  whiteSpace: 'pre'
-};
-
-function renderText(node: TextNode): React.ReactElement {
-  const style: React.CSSProperties = {
-    ...monoStyle,
-    color: node.style?.color,
-    fontWeight: node.style?.bold ? 600 : undefined,
-    opacity: node.style?.dimColor ? 0.6 : undefined,
-    background: node.style?.inverse ? '#111' : undefined,
-    colorScheme: 'only light'
-  };
-  return <span style={style}>{node.text}</span>;
-}
-
-export function WebNode({ node }: { node: LayoutNode }): React.ReactElement {
-  if (node.type === 'text') {
-    return renderText(node);
-  }
-
-  const style = {
-    ...monoStyle,
-    ...toCssStyle(node.style)
-  } as React.CSSProperties;
-
-  return (
-    <div style={style}>
-      {node.children.map((child, index) => (
-        <WebNode key={`${child.type}-${index}`} node={child} />
-      ))}
-    </div>
-  );
-}

package/src/utils/clipboard.ts

@@ -1,39 +0,0 @@
-import { spawn } from 'child_process';
-
-function runPipe(command: string, args: string[], input: string): Promise<void> {
-  return new Promise((resolve, reject) => {
-    const child = spawn(command, args, { stdio: ['pipe', 'ignore', 'pipe'] });
-    let err = '';
-    child.stderr.on('data', chunk => {
-      err += chunk.toString();
-    });
-    child.on('error', reject);
-    child.on('close', (code) => {
-      if (code === 0) resolve();
-      else reject(new Error(err || `Clipboard command failed (${command})`));
-    });
-    child.stdin.write(input);
-    child.stdin.end();
-  });
-}
-
-export async function writeClipboard(text: string): Promise<void> {
-  const platform = process.platform;
-  if (platform === 'darwin') {
-    await runPipe('pbcopy', [], text);
-    return;
-  }
-  if (platform === 'win32') {
-    await runPipe('clip', [], text);
-    return;
-  }
-
-  try {
-    await runPipe('wl-copy', [], text);
-    return;
-  } catch {
-    // fall through
-  }
-
-  await runPipe('xclip', ['-selection', 'clipboard'], text);
-}

package/src/utils/clipboard_image.ts

@@ -1,40 +0,0 @@
-import { execFile } from 'child_process';
-import { promisify } from 'util';
-import { mkdir } from 'fs/promises';
-import { homedir } from 'os';
-import { join } from 'path';
-import { randomUUID } from 'crypto';
-
-const execFileAsync = promisify(execFile);
-
-async function hasCommand(command: string): Promise<boolean> {
-  try {
-    await execFileAsync('which', [command]);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-export async function saveClipboardImage(): Promise<string | null> {
-  if (process.platform !== 'darwin') {
-    return null;
-  }
-
-  const hasPngPaste = await hasCommand('pngpaste');
-  if (!hasPngPaste) {
-    return null;
-  }
-
-  const targetDir = join(homedir(), '.ztc', 'clipboard');
-  await mkdir(targetDir, { recursive: true });
-  const filename = `clipboard-${Date.now()}-${randomUUID().slice(0, 8)}.png`;
-  const targetPath = join(targetDir, filename);
-
-  try {
-    await execFileAsync('pngpaste', [targetPath]);
-    return targetPath;
-  } catch {
-    return null;
-  }
-}

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;
-  }
-}