zerg-ztc 0.1.10 → 0.1.12

package/src/agent/agent.ts

@@ -1,534 +0,0 @@
-// Standard library
-import { existsSync, readFileSync } from 'fs';
-import { extname } from 'path';
-
-// Local
-import { Message, ToolCall, AgentEvent } from '../types.js';
-import { AnthropicBackend, AgentBackend, BackendRequest, BackendResponse, ContentBlock, LlmMessage, RequestContentBlock, ToolResultBlock, TokenUsage } from './backends/index.js';
-import { AllowAllPolicy, Policy } from './runtime/policy.js';
-import { NoopTracer, Tracer } from './runtime/tracing.js';
-import { defaultTools, executeTool, getToolDefinitions, getTool } from './tools/index.js';
-
-// --- Types ---
-
-export interface AgentConfig {
-  model?: string;
-  apiKey?: string;
-  apiEndpoint?: string;
-  maxTokens?: number;
-  maxIterations?: number;
-  tools?: typeof defaultTools;
-  systemPrompt?: string;
-  backend?: AgentBackend;
-  policy?: Policy;
-  tracer?: Tracer;
-  cwd?: string;  // Working directory for tool execution
-}
-
-export class AgentError extends Error {
-  constructor(message: string, public code?: string) {
-    super(message);
-    this.name = 'AgentError';
-  }
-}
-
-export type EventHandler = (event: AgentEvent) => void;
-
-// --- Agent Class ---
-
-export class Agent {
-  private config: Required<AgentConfig>;
-  private eventHandlers: Set<EventHandler> = new Set();
-  private backend: AgentBackend;
-  private policy: Policy;
-  private tracer: Tracer;
-  private streamChunkSize = 32;
-  private _cwd: string;
-
-  constructor(config: AgentConfig = {}) {
-    const apiKey = config.apiKey || process.env.ANTHROPIC_API_KEY || '';
-
-    this.config = {
-      model: config.model || 'claude-opus-4-20250514',
-      apiKey,
-      apiEndpoint: config.apiEndpoint || 'https://api.anthropic.com/v1/messages',
-      maxTokens: config.maxTokens || 4096,
-      maxIterations: config.maxIterations || 10,
-      tools: config.tools || defaultTools,
-      systemPrompt: config.systemPrompt || this.getDefaultSystemPrompt(),
-      backend: config.backend || new AnthropicBackend({ apiKey, apiEndpoint: config.apiEndpoint }),
-      policy: config.policy || new AllowAllPolicy(),
-      tracer: config.tracer || new NoopTracer(),
-      cwd: config.cwd || process.cwd()
-    };
-
-    this.backend = this.config.backend;
-    this.policy = this.config.policy;
-    this.tracer = this.config.tracer;
-    this._cwd = this.config.cwd;
-  }
-
-  hasApiKey(): boolean {
-    return !!this.config.apiKey && this.config.apiKey.length > 0;
-  }
-
-  setCwd(cwd: string): void {
-    this._cwd = cwd;
-  }
-
-  getCwd(): string {
-    return this._cwd;
-  }
-
-  private getDefaultSystemPrompt(): string {
-    return `You are ZTC (Zerg Terminal Client), an AI assistant that helps users interact with the Zerg continual AI system and manage local development tasks.
-
-You have access to tools for:
-- Reading and writing files
-- Listing directory contents
-- Running shell commands
-- Taking screenshots (full screen or specific windows by app name, PID, or window ID)
-- Listing open windows to find window IDs
-- Launching apps and capturing their windows
-- Querying the Zerg system
-
-Be concise and helpful. When using tools, explain what you're doing briefly. If a task requires multiple steps, proceed through them systematically.
-
-When a user intent maps to an available slash command, invoke the command directly (just the command) instead of explaining how to do it. Prefer executing commands over describing them.`;
-  }
-
-  // Event handling
-  on(handler: EventHandler): () => void {
-    this.eventHandlers.add(handler);
-    return () => this.eventHandlers.delete(handler);
-  }
-
-  private emit(event: AgentEvent): void {
-    for (const handler of this.eventHandlers) {
-      handler(event);
-    }
-  }
-
-  // Convert messages to API format
-  private formatMessages(messages: Message[]): LlmMessage[] {
-    return messages
-      .filter((m): m is Message & { role: 'user' | 'assistant' } => {
-        // Only include user and assistant messages
-        if (m.role !== 'user' && m.role !== 'assistant') return false;
-        // Filter out assistant messages with empty content AND no tool calls
-        if (m.role === 'assistant' && (!m.content || m.content.trim() === '') && !m.toolCalls?.length) return false;
-        return true;
-      })
-      .map(m => {
-        if (m.role === 'user') {
-          return {
-            role: m.role,
-            content: this.buildContentBlocks(m.content)
-          };
-        }
-
-        // Assistant message - may need to include tool_use blocks
-        if (m.toolCalls && m.toolCalls.length > 0) {
-          // Build content array with text and tool_use blocks
-          const contentBlocks: Array<{ type: 'text'; text: string } | { type: 'tool_use'; id: string; name: string; input: Record<string, unknown> }> = [];
-
-          // Add text content if present
-          if (m.content && m.content.trim() && m.content !== '[Using tools...]') {
-            contentBlocks.push({ type: 'text', text: m.content });
-          }
-
-          // Add tool_use blocks
-          for (const tc of m.toolCalls) {
-            contentBlocks.push({
-              type: 'tool_use',
-              id: tc.id,
-              name: tc.name,
-              input: tc.args
-            });
-          }
-
-          return {
-            role: m.role,
-            content: contentBlocks as unknown as RequestContentBlock[]
-          };
-        }
-
-        // Plain text assistant message
-        return {
-          role: m.role,
-          content: m.content
-        };
-      });
-  }
-
-  private contentLength(content: string | RequestContentBlock[]): number {
-    if (typeof content === 'string') return content.length;
-    return content.reduce((sum, block) => {
-      if (block.type === 'text') return sum + block.text.length;
-      if (block.type === 'image') return sum + block.data.length;
-      if (block.type === 'tool_result') {
-        // Estimate tool result content length
-        if (typeof block.content === 'string') return sum + block.content.length;
-        return sum + block.content.reduce((s, b) => {
-          if (b.type === 'text') return s + b.text.length;
-          if (b.type === 'image') return s + b.source.data.length;
-          return s;
-        }, 0);
-      }
-      return sum;
-    }, 0);
-  }
-
-  // Parse tool result string to check for image data
-  private parseToolResultForImages(result: string): { hasImage: boolean; imageData?: { mediaType: string; data: string }; text: string } {
-    try {
-      const parsed = JSON.parse(result);
-      if (parsed && parsed.type === 'image' && parsed.data && parsed.mediaType) {
-        return {
-          hasImage: true,
-          imageData: { mediaType: parsed.mediaType, data: parsed.data },
-          text: parsed.description || 'Screenshot captured'
-        };
-      }
-    } catch {
-      // Not JSON or not an image result
-    }
-    return { hasImage: false, text: result };
-  }
-
-  // Build tool result content blocks for the API
-  private buildToolResultBlocks(toolResults: Array<{ tool_use_id: string; content: string }>): ToolResultBlock[] {
-    return toolResults.map(result => {
-      const parsed = this.parseToolResultForImages(result.content);
-
-      if (parsed.hasImage && parsed.imageData) {
-        // Include both text and image in tool result
-        return {
-          type: 'tool_result' as const,
-          tool_use_id: result.tool_use_id,
-          content: [
-            { type: 'text' as const, text: parsed.text },
-            {
-              type: 'image' as const,
-              source: {
-                type: 'base64' as const,
-                media_type: parsed.imageData.mediaType,
-                data: parsed.imageData.data
-              }
-            }
-          ]
-        };
-      }
-
-      // Plain text result
-      return {
-        type: 'tool_result' as const,
-        tool_use_id: result.tool_use_id,
-        content: result.content
-      };
-    });
-  }
-
-  private buildContentBlocks(content: string): string | RequestContentBlock[] {
-    const trimmed = content.trimStart();
-
-    // Check if this is a tool results message
-    if (trimmed.startsWith('[') && trimmed.includes('"tool_use_id"')) {
-      try {
-        const toolResults = JSON.parse(trimmed) as Array<{ tool_use_id: string; content: string }>;
-        return this.buildToolResultBlocks(toolResults);
-      } catch {
-        return content;
-      }
-    }
-
-    const imageRegex = /\[image ([^\]]+)\]/g;
-    let match: RegExpExecArray | null;
-    let cursor = 0;
-    const blocks: RequestContentBlock[] = [];
-
-    while ((match = imageRegex.exec(content)) !== null) {
-      const start = match.index;
-      const end = match.index + match[0].length;
-      if (start > cursor) {
-        blocks.push({ type: 'text', text: content.slice(cursor, start) });
-      }
-      const path = match[1].trim();
-      const imageBlock = this.loadImageBlock(path);
-      if (imageBlock) {
-        blocks.push(imageBlock);
-      } else {
-        blocks.push({ type: 'text', text: match[0] });
-      }
-      cursor = end;
-    }
-
-    if (blocks.length === 0) return content;
-    if (cursor < content.length) {
-      blocks.push({ type: 'text', text: content.slice(cursor) });
-    }
-
-    const merged: RequestContentBlock[] = [];
-    for (const block of blocks) {
-      const last = merged[merged.length - 1];
-      if (block.type === 'text' && last?.type === 'text') {
-        last.text += block.text;
-        continue;
-      }
-      merged.push(block);
-    }
-
-    const hasImage = merged.some(block => block.type === 'image');
-    return hasImage ? merged : content;
-  }
-
-  private loadImageBlock(path: string): RequestContentBlock | null {
-    try {
-      if (!existsSync(path)) return null;
-      const ext = extname(path).toLowerCase();
-      const mediaType = this.getImageMediaType(ext);
-      if (!mediaType) return null;
-      const buffer = readFileSync(path);
-      return {
-        type: 'image',
-        mediaType,
-        data: buffer.toString('base64'),
-        path
-      };
-    } catch {
-      return null;
-    }
-  }
-
-  private getImageMediaType(ext: string): string | null {
-    switch (ext) {
-      case '.png':
-        return 'image/png';
-      case '.jpg':
-      case '.jpeg':
-        return 'image/jpeg';
-      case '.webp':
-        return 'image/webp';
-      case '.gif':
-        return 'image/gif';
-      case '.bmp':
-        return 'image/bmp';
-      case '.tif':
-      case '.tiff':
-        return 'image/tiff';
-      case '.heic':
-      case '.heif':
-        return 'image/heic';
-      default:
-        return null;
-    }
-  }
-
-  // Type guards
-  private isTextBlock(block: ContentBlock): block is { type: 'text'; text: string } {
-    return block.type === 'text';
-  }
-
-  private isToolUseBlock(block: ContentBlock): block is { type: 'tool_use'; id: string; name: string; input: Record<string, unknown> } {
-    return block.type === 'tool_use';
-  }
-
-  private buildRequest(messages: Message[]): BackendRequest {
-    return {
-      model: this.config.model,
-      maxTokens: this.config.maxTokens,
-      system: this.config.systemPrompt,
-      messages: this.formatMessages(messages),
-      tools: getToolDefinitions(this.config.tools)
-    };
-  }
-
-  private estimateUsage(request: BackendRequest, response: BackendResponse): TokenUsage {
-    const inputChars = request.system.length + request.messages.reduce((sum, msg) => sum + this.contentLength(msg.content), 0);
-    const outputChars = response.content
-      .filter(this.isTextBlock)
-      .reduce((sum, block) => sum + block.text.length, 0);
-    const inputTokens = Math.max(1, Math.ceil(inputChars / 4));
-    const outputTokens = Math.max(1, Math.ceil(outputChars / 4));
-    return {
-      inputTokens,
-      outputTokens,
-      totalTokens: inputTokens + outputTokens,
-      estimated: true
-    };
-  }
-
-  private mergeUsage(current: TokenUsage | null, next: TokenUsage): TokenUsage {
-    if (!current) return next;
-    return {
-      inputTokens: current.inputTokens + next.inputTokens,
-      outputTokens: current.outputTokens + next.outputTokens,
-      totalTokens: current.totalTokens + next.totalTokens,
-      estimated: current.estimated || next.estimated
-    };
-  }
-
-  private async emitStreamText(text: string): Promise<void> {
-    this.emit({ type: 'stream_start' });
-    for (let i = 0; i < text.length; i += this.streamChunkSize) {
-      const chunk = text.slice(i, i + this.streamChunkSize);
-      this.emit({ type: 'stream_delta', content: chunk });
-      await new Promise(resolve => setTimeout(resolve, 10));
-    }
-    this.emit({ type: 'stream_end' });
-  }
-
-  // Main execution loop
-  async run(messages: Message[]): Promise<{ content: string; toolCalls: ToolCall[]; usage?: TokenUsage }> {
-    if (!this.hasApiKey()) {
-      throw new AgentError('No API key configured. Use /config key <key> to set one.', 'NO_API_KEY');
-    }
-
-    const allToolCalls: ToolCall[] = [];
-    let iterations = 0;
-    let finalContent = '';
-    let totalUsage: TokenUsage | null = null;
-
-    while (iterations < this.config.maxIterations) {
-      iterations++;
-      this.emit({ type: 'thinking_start' });
-
-      try {
-        // Call the API
-        const request = this.buildRequest(messages);
-        this.tracer.event({ type: 'api_request', timestamp: new Date() });
-        const response = await this.callAPI(request);
-        this.tracer.event({ type: 'api_response', timestamp: new Date(), data: { stopReason: response.stopReason } });
-        this.emit({ type: 'thinking_end' });
-
-        const usage = response.usage ?? this.estimateUsage(request, response);
-        totalUsage = this.mergeUsage(totalUsage, usage);
-        this.emit({ type: 'token_usage', usage: totalUsage });
-
-        // Check for tool use
-        const toolUseBlocks = response.content.filter(this.isToolUseBlock);
-
-        if (toolUseBlocks.length === 0) {
-          // No tools, extract text and finish
-          const textBlocks = response.content.filter(this.isTextBlock);
-          finalContent = textBlocks.map(b => b.text).join('\n');
-          await this.emitStreamText(finalContent);
-          break;
-        }
-
-        // Execute tools
-        const toolResults: Array<{ tool_use_id: string; content: string }> = [];
-        
-        for (const toolBlock of toolUseBlocks) {
-          const toolCall: ToolCall = {
-            id: toolBlock.id,
-            name: toolBlock.name,
-            args: toolBlock.input,
-            status: 'running',
-            startedAt: new Date()
-          };
-          allToolCalls.push(toolCall);
-          
-          const tool = getTool(toolBlock.name, this.config.tools);
-          const policyDecision = this.policy.evaluateTool({
-            name: toolBlock.name,
-            args: toolBlock.input,
-            capabilities: tool?.capabilities || []
-          });
-
-          if (!policyDecision.allowed) {
-            const reason = policyDecision.reason || 'Policy denied tool execution';
-            toolCall.status = 'error';
-            toolCall.error = reason;
-            toolCall.completedAt = new Date();
-            toolResults.push({ tool_use_id: toolBlock.id, content: `Error: ${reason}` });
-            this.emit({ type: 'tool_error', tool: toolBlock.name, error: reason });
-            this.tracer.event({
-              type: 'policy_denied',
-              timestamp: new Date(),
-              data: { tool: toolBlock.name, reason }
-            });
-            continue;
-          }
-
-          this.tracer.event({
-            type: 'tool_start',
-            timestamp: new Date(),
-            data: { tool: toolBlock.name }
-          });
-          this.emit({ type: 'tool_start', tool: toolBlock.name, args: toolBlock.input });
-
-          try {
-            const result = await executeTool(
-              toolBlock.name,
-              toolBlock.input,
-              this.config.tools,
-              { cwd: this._cwd }
-            );
-            
-            toolCall.status = 'complete';
-            toolCall.result = result;
-            toolCall.completedAt = new Date();
-            
-            toolResults.push({ tool_use_id: toolBlock.id, content: result });
-            this.emit({ type: 'tool_end', tool: toolBlock.name, result });
-            this.tracer.event({
-              type: 'tool_end',
-              timestamp: new Date(),
-              data: { tool: toolBlock.name }
-            });
-          } catch (err) {
-            const error = (err as Error).message;
-            toolCall.status = 'error';
-            toolCall.error = error;
-            toolCall.completedAt = new Date();
-            
-            toolResults.push({ tool_use_id: toolBlock.id, content: `Error: ${error}` });
-            this.emit({ type: 'tool_error', tool: toolBlock.name, error });
-            this.tracer.event({
-              type: 'tool_error',
-              timestamp: new Date(),
-              data: { tool: toolBlock.name, error }
-            });
-          }
-        }
-
-        // Add assistant message with tool use
-        const textContent = response.content
-          .filter(this.isTextBlock)
-          .map(b => b.text)
-          .join('\n');
-        
-        messages.push({
-          id: `assistant_${Date.now()}`,
-          role: 'assistant',
-          content: textContent || '[Using tools...]',
-          timestamp: new Date(),
-          toolCalls: allToolCalls.slice(-toolUseBlocks.length)
-        });
-
-        // Add tool results as user message (API format)
-        messages.push({
-          id: `tool_${Date.now()}`,
-          role: 'user',
-          content: JSON.stringify(toolResults),
-          timestamp: new Date()
-        });
-
-      } catch (err) {
-        const error = (err as Error).message;
-        this.emit({ type: 'error', error });
-        throw err;
-      }
-    }
-
-    return { content: finalContent, toolCalls: allToolCalls, usage: totalUsage || undefined };
-  }
-
-  // API call
-  private async callAPI(request: BackendRequest): Promise<BackendResponse> {
-    return this.backend.generate(request);
-  }
-}
-
-export default Agent;

package/src/agent/backends/anthropic.ts

@@ -1,86 +0,0 @@
-import { AgentBackend, BackendRequest, BackendResponse } from './types.js';
-
-interface AnthropicBackendConfig {
-  apiKey: string;
-  apiEndpoint?: string;
-}
-
-interface AnthropicResponse {
-  content: BackendResponse['content'];
-  stop_reason: string;
-  usage?: {
-    input_tokens?: number;
-    output_tokens?: number;
-  };
-}
-
-export class AnthropicBackend implements AgentBackend {
-  private apiKey: string;
-  private apiEndpoint: string;
-
-  constructor(config: AnthropicBackendConfig) {
-    this.apiKey = config.apiKey;
-    this.apiEndpoint = config.apiEndpoint || 'https://api.anthropic.com/v1/messages';
-  }
-
-  async generate(request: BackendRequest): Promise<BackendResponse> {
-    const body = {
-      model: request.model,
-      max_tokens: request.maxTokens,
-      system: request.system,
-      messages: request.messages.map(message => ({
-        role: message.role,
-        content: typeof message.content === 'string'
-          ? message.content
-          : message.content.map(block => {
-            if (block.type === 'text') {
-              return { type: 'text', text: block.text };
-            }
-            if (block.type === 'tool_result') {
-              // Pass tool results through in Anthropic format
-              return block;
-            }
-            if (block.type === 'tool_use') {
-              // Pass tool_use blocks through for assistant messages
-              return block;
-            }
-            // Image block
-            return { type: 'image', source: { type: 'base64', media_type: block.mediaType, data: block.data } };
-          })
-      })),
-      tools: request.tools.map(t => ({
-        name: t.name,
-        description: t.description,
-        input_schema: t.parameters
-      }))
-    };
-
-    const response = await fetch(this.apiEndpoint, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'x-api-key': this.apiKey,
-        'anthropic-version': '2023-06-01'
-      },
-      body: JSON.stringify(body)
-    });
-
-    if (!response.ok) {
-      const errorText = await response.text();
-      throw new Error(`API error (${response.status}): ${errorText}`);
-    }
-
-    const data = await response.json() as AnthropicResponse;
-    const inputTokens = data.usage?.input_tokens ?? 0;
-    const outputTokens = data.usage?.output_tokens ?? 0;
-    return {
-      content: data.content,
-      stopReason: data.stop_reason,
-      usage: data.usage ? {
-        inputTokens,
-        outputTokens,
-        totalTokens: inputTokens + outputTokens
-      } : undefined
-    };
-  }
-}