zerg-ztc 0.1.0

package/src/agent/tools/file.ts

@@ -0,0 +1,173 @@
+import { readFile, writeFile, readdir, stat } from 'fs/promises';
+import { dirname, resolve } from 'path';
+import { Tool } from './types.js';
+import { ToolCapability } from '../runtime/capabilities.js';
+import { buildSimpleDiff } from '../../utils/diff.js';
+
+// --- File Tools ---
+
+export const readFileTool: Tool = {
+  capabilities: [ToolCapability.FILE_READ],
+  definition: {
+    name: 'read_file',
+    description: 'Read the contents of a file at the specified path',
+    parameters: {
+      type: 'object',
+      properties: {
+        path: { 
+          type: 'string', 
+          description: 'Absolute or relative file path to read' 
+        },
+        encoding: {
+          type: 'string',
+          description: 'File encoding (default: utf-8)',
+          enum: ['utf-8', 'ascii', 'base64', 'hex']
+        }
+      },
+      required: ['path']
+    }
+  },
+  execute: async (args) => {
+    const path = resolve(String(args.path));
+    const encoding = (args.encoding as BufferEncoding) || 'utf-8';
+    
+    try {
+      const content = await readFile(path, { encoding });
+      const stats = await stat(path);
+      return JSON.stringify({
+        path,
+        size: stats.size,
+        content: content.slice(0, 50000), // Limit content size
+        truncated: content.length > 50000
+      });
+    } catch (err) {
+      throw new Error(`Failed to read file: ${(err as Error).message}`);
+    }
+  }
+};
+
+export const writeFileTool: Tool = {
+  capabilities: [ToolCapability.FILE_WRITE],
+  definition: {
+    name: 'write_file',
+    description: 'Write content to a file, creating directories if needed',
+    parameters: {
+      type: 'object',
+      properties: {
+        path: { 
+          type: 'string', 
+          description: 'File path to write to' 
+        },
+        content: { 
+          type: 'string', 
+          description: 'Content to write to the file' 
+        },
+        append: {
+          type: 'string',
+          description: 'If "true", append to file instead of overwriting'
+        }
+      },
+      required: ['path', 'content']
+    }
+  },
+  execute: async (args) => {
+    const path = resolve(String(args.path));
+    const content = String(args.content);
+    const append = args.append === 'true';
+    
+    try {
+      // Ensure directory exists
+      const { mkdir, appendFile } = await import('fs/promises');
+      await mkdir(dirname(path), { recursive: true });
+      
+      let beforeContent = '';
+      try {
+        beforeContent = await readFile(path, { encoding: 'utf-8' });
+      } catch {
+        beforeContent = '';
+      }
+
+      if (append) {
+        await appendFile(path, content, 'utf-8');
+      } else {
+        await writeFile(path, content, 'utf-8');
+      }
+      
+      const stats = await stat(path);
+      const afterContent = await readFile(path, { encoding: 'utf-8' });
+      const diff = buildSimpleDiff(beforeContent, afterContent);
+      return JSON.stringify({
+        path,
+        size: stats.size,
+        action: append ? 'appended' : 'written',
+        diff,
+        before: beforeContent.slice(0, 5000),
+        after: afterContent.slice(0, 5000),
+        truncated: beforeContent.length > 5000 || afterContent.length > 5000
+      });
+    } catch (err) {
+      throw new Error(`Failed to write file: ${(err as Error).message}`);
+    }
+  }
+};
+
+export const listDirectoryTool: Tool = {
+  capabilities: [ToolCapability.FILE_READ],
+  definition: {
+    name: 'list_directory',
+    description: 'List contents of a directory',
+    parameters: {
+      type: 'object',
+      properties: {
+        path: { 
+          type: 'string', 
+          description: 'Directory path to list' 
+        },
+        recursive: {
+          type: 'string',
+          description: 'If "true", list recursively (max 3 levels)'
+        }
+      },
+      required: ['path']
+    }
+  },
+  execute: async (args) => {
+    const path = resolve(String(args.path));
+    const recursive = args.recursive === 'true';
+    
+    async function listDir(dir: string, depth = 0): Promise<object[]> {
+      if (depth > 3) return [];
+      
+      const entries = await readdir(dir, { withFileTypes: true });
+      const results: object[] = [];
+      
+      for (const entry of entries.slice(0, 100)) { // Limit entries
+        const entryPath = resolve(dir, entry.name);
+        const info: Record<string, unknown> = {
+          name: entry.name,
+          type: entry.isDirectory() ? 'directory' : 'file'
+        };
+        
+        if (entry.isFile()) {
+          const s = await stat(entryPath);
+          info.size = s.size;
+        }
+        
+        if (recursive && entry.isDirectory() && !entry.name.startsWith('.')) {
+          info.children = await listDir(entryPath, depth + 1);
+        }
+        
+        results.push(info);
+      }
+      
+      return results;
+    }
+    
+    try {
+      const entries = await listDir(path);
+      return JSON.stringify({ path, entries });
+    } catch (err) {
+      throw new Error(`Failed to list directory: ${(err as Error).message}`);
+    }
+  }
+};

package/src/agent/tools/index.ts

@@ -0,0 +1,46 @@
+import { Tool } from './types.js';
+import { ToolDefinition } from '../../types.js';
+import { readFileTool, writeFileTool, listDirectoryTool } from './file.js';
+import { runCommandTool } from './shell.js';
+import { zergQueryTool } from './zerg.js';
+import { searchTool } from './search.js';
+import { listSkillsTool } from './skills.js';
+
+// --- Tool Registry ---
+
+export const defaultTools: Tool[] = [
+  readFileTool,
+  writeFileTool,
+  listDirectoryTool,
+  searchTool,
+  listSkillsTool,
+  runCommandTool,
+  zergQueryTool
+];
+
+export function getToolDefinitions(tools: Tool[] = defaultTools): ToolDefinition[] {
+  return tools.map(t => t.definition);
+}
+
+export function getTool(name: string, tools: Tool[] = defaultTools): Tool | undefined {
+  return tools.find(t => t.definition.name === name);
+}
+
+export async function executeTool(
+  name: string, 
+  args: Record<string, unknown>,
+  tools: Tool[] = defaultTools
+): Promise<string> {
+  const tool = getTool(name, tools);
+  if (!tool) {
+    throw new Error(`Unknown tool: ${name}`);
+  }
+  return tool.execute(args);
+}
+
+export { readFileTool, writeFileTool, listDirectoryTool } from './file.js';
+export { searchTool } from './search.js';
+export { listSkillsTool } from './skills.js';
+export { runCommandTool } from './shell.js';
+export { zergQueryTool } from './zerg.js';
+export type { Tool } from './types.js';

package/src/agent/tools/search.ts

@@ -0,0 +1,137 @@
+import { spawn } from 'child_process';
+import { resolve } from 'path';
+import { Tool } from './types.js';
+import { ToolCapability } from '../runtime/capabilities.js';
+
+interface RunResult {
+  stdout: string;
+  stderr: string;
+  code: number;
+}
+
+function runCommand(command: string, args: string[], cwd: string): Promise<RunResult> {
+  return new Promise((resolveResult, reject) => {
+    const child = spawn(command, args, { cwd });
+    let stdout = '';
+    let stderr = '';
+    child.stdout.on('data', chunk => { stdout += chunk.toString(); });
+    child.stderr.on('data', chunk => { stderr += chunk.toString(); });
+    child.on('error', reject);
+    child.on('close', (code) => {
+      resolveResult({ stdout, stderr, code: code ?? 1 });
+    });
+  });
+}
+
+// --- Search Tool ---
+
+export const searchTool: Tool = {
+  capabilities: [ToolCapability.FILE_READ],
+  definition: {
+    name: 'search',
+    description: 'Search for a pattern in files (ripgrep preferred)',
+    parameters: {
+      type: 'object',
+      properties: {
+        pattern: {
+          type: 'string',
+          description: 'Regex pattern to search for'
+        },
+        path: {
+          type: 'string',
+          description: 'Path to search within (default: .)'
+        },
+        glob: {
+          type: 'string',
+          description: 'Optional glob filter (e.g., "*.ts")'
+        },
+        output_mode: {
+          type: 'string',
+          description: 'Output mode: content or files',
+          enum: ['content', 'files']
+        },
+        max_results: {
+          type: 'string',
+          description: 'Maximum number of results (default: 20)'
+        }
+      },
+      required: ['pattern']
+    }
+  },
+  execute: async (args) => {
+    const pattern = String(args.pattern || '');
+    const path = resolve(String(args.path || '.'));
+    const glob = args.glob ? String(args.glob) : undefined;
+    const outputMode = args.output_mode === 'files' ? 'files' : 'content';
+    const maxResults = Math.max(1, Math.min(200, parseInt(String(args.max_results || '20'), 10)));
+
+    if (!pattern) {
+      throw new Error('Search pattern is required');
+    }
+
+    const rgArgs: string[] = [];
+    if (outputMode === 'files') {
+      rgArgs.push('-l', '--max-count', String(maxResults));
+    } else {
+      rgArgs.push('--line-number', '--column', '--with-filename', '--no-heading', '--max-count', String(maxResults));
+    }
+    if (glob) {
+      rgArgs.push('-g', glob);
+    }
+    rgArgs.push(pattern, path);
+
+    let result: RunResult | null = null;
+    try {
+      result = await runCommand('rg', rgArgs, process.cwd());
+    } catch {
+      result = null;
+    }
+
+    if (!result || (result.code !== 0 && result.code !== 1)) {
+      const grepArgs = ['-R', '-n', pattern, path];
+      const fallback = await runCommand('grep', grepArgs, process.cwd());
+      if (fallback.code !== 0 && fallback.code !== 1) {
+        throw new Error(fallback.stderr || 'Search failed');
+      }
+      result = fallback;
+    }
+
+    const stdout = result.stdout.trim();
+    if (!stdout) {
+      return JSON.stringify({ pattern, path, matches: [], count: 0, truncated: false });
+    }
+
+    if (outputMode === 'files') {
+      const files = stdout.split('\n').slice(0, maxResults);
+      return JSON.stringify({
+        pattern,
+        path,
+        files,
+        count: files.length,
+        truncated: files.length >= maxResults
+      });
+    }
+
+    const lines = stdout.split('\n');
+    const matches = [];
+    for (const line of lines) {
+      const match = line.match(/^(.+?):(\d+):(\d+):(.*)$/);
+      if (!match) continue;
+      matches.push({
+        path: match[1],
+        line: Number(match[2]),
+        column: Number(match[3]),
+        text: match[4]
+      });
+      if (matches.length >= maxResults) break;
+    }
+
+    return JSON.stringify({
+      pattern,
+      path,
+      matches,
+      count: matches.length,
+      truncated: matches.length >= maxResults
+    });
+  }
+};

package/src/agent/tools/shell.ts

@@ -0,0 +1,65 @@
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { resolve } from 'path';
+import { Tool } from './types.js';
+import { ToolCapability } from '../runtime/capabilities.js';
+
+const execAsync = promisify(exec);
+
+// --- Shell Tool ---
+
+export const runCommandTool: Tool = {
+  capabilities: [ToolCapability.SHELL_EXEC],
+  definition: {
+    name: 'run_command',
+    description: 'Execute a shell command and return output',
+    parameters: {
+      type: 'object',
+      properties: {
+        command: { 
+          type: 'string', 
+          description: 'Shell command to execute' 
+        },
+        cwd: {
+          type: 'string',
+          description: 'Working directory for the command'
+        },
+        timeout: {
+          type: 'string',
+          description: 'Timeout in milliseconds (default: 30000)'
+        }
+      },
+      required: ['command']
+    }
+  },
+  execute: async (args) => {
+    const command = String(args.command);
+    const cwd = args.cwd ? resolve(String(args.cwd)) : process.cwd();
+    const timeout = parseInt(String(args.timeout || '30000'), 10);
+    
+    // Basic safety checks
+    const dangerous = ['rm -rf /', 'mkfs', ':(){:|:&};:'];
+    if (dangerous.some(d => command.includes(d))) {
+      throw new Error('Command rejected for safety reasons');
+    }
+    
+    try {
+      const { stdout, stderr } = await execAsync(command, { 
+        cwd, 
+        timeout,
+        maxBuffer: 1024 * 1024 // 1MB
+      });
+      
+      return JSON.stringify({
+        command,
+        cwd,
+        stdout: stdout.slice(0, 10000),
+        stderr: stderr.slice(0, 10000),
+        truncated: stdout.length > 10000 || stderr.length > 10000
+      });
+    } catch (err) {
+      const e = err as Error & { stdout?: string; stderr?: string; code?: number };
+      throw new Error(`Command failed: ${e.message}\nstderr: ${e.stderr || ''}`);
+    }
+  }
+};

package/src/agent/tools/skills.ts

@@ -0,0 +1,28 @@
+import { Tool } from './types.js';
+import { ToolCapability } from '../runtime/capabilities.js';
+import { loadSkills } from '../../skills/loader.js';
+
+export const listSkillsTool: Tool = {
+  capabilities: [ToolCapability.FILE_READ],
+  definition: {
+    name: 'list_skills',
+    description: 'List available skills',
+    parameters: {
+      type: 'object',
+      properties: {},
+      required: []
+    }
+  },
+  execute: async () => {
+    const skills = await loadSkills();
+    return JSON.stringify({
+      count: skills.length,
+      skills: skills.map(skill => ({
+        id: skill.id,
+        name: skill.name,
+        description: skill.description,
+        sourceRoot: skill.sourceRoot
+      }))
+    });
+  }
+};

package/src/agent/tools/types.ts

@@ -0,0 +1,10 @@
+import { ToolDefinition } from '../../types.js';
+import { ToolCapability } from '../runtime/capabilities.js';
+
+// --- Tool Interface ---
+
+export interface Tool {
+  definition: ToolDefinition;
+  capabilities?: ToolCapability[];
+  execute: (args: Record<string, unknown>) => Promise<string>;
+}

package/src/agent/tools/zerg.ts

@@ -0,0 +1,50 @@
+import { Tool } from './types.js';
+import { ToolCapability } from '../runtime/capabilities.js';
+
+// --- Zerg Integration Tool ---
+
+export const zergQueryTool: Tool = {
+  capabilities: [ToolCapability.NETWORK],
+  definition: {
+    name: 'zerg_query',
+    description: 'Send a query to the Zerg continual AI system',
+    parameters: {
+      type: 'object',
+      properties: {
+        query: { 
+          type: 'string', 
+          description: 'Query or instruction for Zerg' 
+        },
+        context: {
+          type: 'string',
+          description: 'Additional context for the query'
+        },
+        project: {
+          type: 'string',
+          description: 'Project identifier within Zerg'
+        },
+        wait: {
+          type: 'string',
+          description: 'If "true", wait for completion; otherwise return task ID'
+        }
+      },
+      required: ['query']
+    }
+  },
+  execute: async (args) => {
+    // Placeholder - implement actual Zerg API integration
+    const query = String(args.query);
+    const context = args.context ? String(args.context) : undefined;
+    const project = args.project ? String(args.project) : 'default';
+    
+    // TODO: Replace with actual Zerg API call
+    return JSON.stringify({
+      status: 'placeholder',
+      message: 'Zerg integration not yet implemented',
+      query,
+      context,
+      project,
+      taskId: `zerg_${Date.now()}`
+    });
+  }
+};

package/src/cli.tsx

@@ -0,0 +1,80 @@
+#!/usr/bin/env node
+import React from 'react';
+import { render } from 'ink';
+import { resolve } from 'path';
+import { statSync } from 'fs';
+import { App } from './App.js';
+
+// --- CLI Entry Point ---
+
+// Parse command line args
+const args = process.argv.slice(2);
+
+if (args.includes('--help') || args.includes('-h')) {
+  console.log(`
+ZTC - Zerg Terminal Client v0.1.0
+
+Usage: ztc [options]
+
+Options:
+  -h, --help      Show this help message
+  -v, --version   Show version number
+  --cwd <path>    Start in a specific working directory
+
+Environment Variables:
+  ANTHROPIC_API_KEY   API key for Claude (optional, can be set in-app)
+
+In-App Commands:
+  /help              Show available commands
+  /config key <key>  Set API key
+  /config show       Show current configuration
+  /clear             Clear message history
+  /status            Show current status
+  /exit              Exit ZTC
+
+Keyboard Shortcuts:
+  Ctrl+C    Exit
+  Ctrl+L    Clear screen
+  Up/Down   Navigate command history
+  Ctrl+U    Clear input line
+  Ctrl+W    Delete word
+  Ctrl+A    Move to start of line
+  Ctrl+E    Move to end of line
+`);
+  process.exit(0);
+}
+
+if (args.includes('--version') || args.includes('-v')) {
+  console.log('ztc v0.1.0');
+  process.exit(0);
+}
+
+const cwdIndex = args.indexOf('--cwd');
+if (cwdIndex >= 0) {
+  const target = args[cwdIndex + 1];
+  if (!target) {
+    console.error('Error: --cwd requires a path');
+    process.exit(1);
+  }
+  const resolved = resolve(target);
+  try {
+    const info = statSync(resolved);
+    if (!info.isDirectory()) {
+      throw new Error('Not a directory');
+    }
+    process.chdir(resolved);
+  } catch {
+    console.error(`Error: invalid --cwd path (${resolved})`);
+    process.exit(1);
+  }
+}
+
+// Render the app
+// Note: FullScreen component handles alternate screen buffer
+const { waitUntilExit } = render(<App />);
+
+// Handle clean exit
+waitUntilExit().then(() => {
+  console.log('Goodbye from ZTC! 👋');
+  process.exit(0);
+});

package/src/components/FullScreen.tsx

@@ -0,0 +1,73 @@
+import React, { useEffect, PropsWithChildren } from 'react';
+import { Box } from 'ink';
+
+/**
+ * FullScreen component that uses the alternate screen buffer.
+ * 
+ * This prevents flickering by:
+ * 1. Switching to the alternate screen buffer (like vim, htop, less do)
+ * 2. Tracking terminal resize events
+ * 3. Restoring the original terminal state on exit
+ * 
+ * ANSI escape codes:
+ * - \x1b[?1049h - Enter alternate screen buffer
+ * - \x1b[?1049l - Exit alternate screen buffer
+ * - \x1b[?25l  - Hide cursor
+ * - \x1b[?25h  - Show cursor
+ */
+
+interface FullScreenProps extends PropsWithChildren {
+  debug?: boolean;
+}
+
+const initialSize = {
+  columns: process.stdout.columns || 80,
+  rows: process.stdout.rows || 24,
+};
+
+export const FullScreen: React.FC<FullScreenProps> = ({ children, debug = false }) => {
+  const isTty = Boolean(process.stdout.isTTY);
+  const useAltScreen = isTty && process.env.ZTC_ALT_SCREEN === '1';
+
+  useEffect(() => {
+    if (!useAltScreen) {
+      return;
+    }
+
+    // Enter alternate screen buffer
+    process.stdout.write('\x1b[?1049h');
+    // Hide cursor (we'll draw our own)
+    process.stdout.write('\x1b[?25l');
+    // Clear the alternate screen
+    process.stdout.write('\x1b[2J');
+    // Move cursor to top-left
+    process.stdout.write('\x1b[H');
+
+    // Cleanup: restore terminal state
+    return () => {
+      // Show cursor
+      process.stdout.write('\x1b[?25h');
+      // Exit alternate screen buffer (restores original content)
+      process.stdout.write('\x1b[?1049l');
+    };
+  }, [useAltScreen]);
+
+  return (
+    <Box 
+      flexDirection="column"
+      borderStyle={debug ? 'single' : undefined}
+      borderColor={debug ? 'red' : undefined}
+    >
+      {children}
+    </Box>
+  );
+};
+
+/**
+ * Hook to get current screen size with resize tracking
+ */
+export function useScreenSize() {
+  return initialSize;
+}
+
+export default FullScreen;

package/src/components/Header.tsx

@@ -0,0 +1,27 @@
+import React from 'react';
+import { InkNode } from '../ui/ink/index.js';
+import { buildHeaderView } from '../ui/views/header.js';
+
+interface HeaderProps {
+  title?: string;
+  version?: string;
+  showHelp?: boolean;
+  debug?: boolean;
+}
+
+export const Header: React.FC<HeaderProps> = ({ 
+  title = 'Zerg Terminal Client',
+  version = '0.1.0',
+  showHelp = true,
+  debug = false
+}) => {
+  const dateLabel = new Date().toLocaleDateString('en-US', {
+    month: 'short',
+    day: '2-digit',
+    year: 'numeric'
+  });
+  const node = buildHeaderView({ title, version, dateLabel, showHelp, debug });
+  return <InkNode node={node} />;
+};
+
+export default Header;