zerg-ztc 0.1.10 → 0.1.12

package/src/agent/backends/gemini.ts

@@ -1,119 +0,0 @@
-import { AgentBackend, BackendRequest, BackendResponse, ContentBlock } from './types.js';
-
-interface GeminiConfig {
-  apiKey: string;
-  apiEndpoint?: string;
-}
-
-interface GeminiCandidate {
-  content?: {
-    parts?: Array<{
-      text?: string;
-      functionCall?: {
-        name?: string;
-        args?: Record<string, unknown>;
-      };
-    }>;
-  };
-  finishReason?: string;
-}
-
-interface GeminiResponse {
-  candidates?: GeminiCandidate[];
-  usageMetadata?: {
-    promptTokenCount?: number;
-    candidatesTokenCount?: number;
-    totalTokenCount?: number;
-  };
-}
-
-export class GeminiBackend implements AgentBackend {
-  private apiKey: string;
-  private apiEndpoint: string;
-
-  constructor(config: GeminiConfig) {
-    this.apiKey = config.apiKey;
-    this.apiEndpoint = config.apiEndpoint || 'https://generativelanguage.googleapis.com/v1beta/models';
-  }
-
-  async generate(request: BackendRequest): Promise<BackendResponse> {
-    const url = `${this.apiEndpoint}/${encodeURIComponent(request.model)}:generateContent?key=${this.apiKey}`;
-    const mapParts = (content: BackendRequest['messages'][number]['content']) => {
-      if (typeof content === 'string') {
-        return [{ text: content }];
-      }
-      return content.map(block => {
-        if (block.type === 'text') {
-          return { text: block.text };
-        }
-        if (block.type === 'tool_result') {
-          // Gemini handles function responses differently - convert to text for now
-          const resultText = typeof block.content === 'string'
-            ? block.content
-            : block.content.map(b => b.type === 'text' ? b.text : '[image]').join('\n');
-          return { text: `Function result: ${resultText}` };
-        }
-        if (block.type === 'tool_use') {
-          // Convert tool_use to function call format for Gemini
-          return { functionCall: { name: block.name, args: block.input } };
-        }
-        // Image block
-        return { inlineData: { mimeType: block.mediaType, data: block.data } };
-      });
-    };
-    const body = {
-      systemInstruction: { parts: [{ text: request.system }] },
-      contents: request.messages.map(m => ({
-        role: m.role === 'assistant' ? 'model' : 'user',
-        parts: mapParts(m.content)
-      })),
-      tools: [{
-        functionDeclarations: request.tools.map(t => ({
-          name: t.name,
-          description: t.description,
-          parameters: t.parameters
-        }))
-      }]
-    };
-
-    const response = await fetch(url, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      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 GeminiResponse;
-    const candidate = data.candidates?.[0];
-    const blocks: ContentBlock[] = [];
-    const parts = candidate?.content?.parts || [];
-
-    for (const part of parts) {
-      if (part.text) {
-        blocks.push({ type: 'text', text: part.text });
-      }
-      if (part.functionCall?.name) {
-        blocks.push({
-          type: 'tool_use',
-          id: `${part.functionCall.name}_${Date.now()}`,
-          name: part.functionCall.name,
-          input: part.functionCall.args || {}
-        });
-      }
-    }
-
-    const inputTokens = data.usageMetadata?.promptTokenCount ?? 0;
-    const outputTokens = data.usageMetadata?.candidatesTokenCount ?? 0;
-    const totalTokens = data.usageMetadata?.totalTokenCount ?? (inputTokens + outputTokens);
-
-    return {
-      content: blocks,
-      stopReason: candidate?.finishReason || 'unknown',
-      usage: data.usageMetadata ? { inputTokens, outputTokens, totalTokens } : undefined
-    };
-  }
-}

package/src/agent/backends/inception.ts

@@ -1,23 +0,0 @@
-import { OpenAICompatibleBackend } from './openai_compatible.js';
-import { AgentBackend, BackendRequest, BackendResponse } from './types.js';
-
-interface InceptionConfig {
-  apiKey: string;
-  apiEndpoint?: string;
-}
-
-export class InceptionBackend implements AgentBackend {
-  private backend: OpenAICompatibleBackend;
-
-  constructor(config: InceptionConfig) {
-    this.backend = new OpenAICompatibleBackend({
-      apiKey: config.apiKey,
-      baseUrl: config.apiEndpoint || 'https://api.inceptionlabs.ai/v1',
-      apiPath: '/chat/completions'
-    });
-  }
-
-  async generate(request: BackendRequest): Promise<BackendResponse> {
-    return this.backend.generate(request);
-  }
-}

package/src/agent/backends/index.ts

@@ -1,17 +0,0 @@
-export { AnthropicBackend } from './anthropic.js';
-export { OpenAIBackend } from './openai.js';
-export { OpenAICompatibleBackend } from './openai_compatible.js';
-export { InceptionBackend } from './inception.js';
-export { GeminiBackend } from './gemini.js';
-export type {
-  AgentBackend,
-  BackendRequest,
-  BackendResponse,
-  ContentBlock,
-  TextBlock,
-  ToolUseBlock,
-  LlmMessage,
-  RequestContentBlock,
-  ToolResultBlock,
-  TokenUsage
-} from './types.js';

package/src/agent/backends/openai.ts

@@ -1,23 +0,0 @@
-import { OpenAICompatibleBackend } from './openai_compatible.js';
-import { AgentBackend, BackendRequest, BackendResponse } from './types.js';
-
-interface OpenAIConfig {
-  apiKey: string;
-  apiEndpoint?: string;
-}
-
-export class OpenAIBackend implements AgentBackend {
-  private backend: OpenAICompatibleBackend;
-
-  constructor(config: OpenAIConfig) {
-    this.backend = new OpenAICompatibleBackend({
-      apiKey: config.apiKey,
-      baseUrl: config.apiEndpoint || 'https://api.openai.com/v1',
-      apiPath: '/chat/completions'
-    });
-  }
-
-  async generate(request: BackendRequest): Promise<BackendResponse> {
-    return this.backend.generate(request);
-  }
-}

package/src/agent/backends/openai_compatible.ts

@@ -1,143 +0,0 @@
-import { AgentBackend, BackendRequest, BackendResponse, ContentBlock } from './types.js';
-
-interface OpenAICompatibleConfig {
-  apiKey: string;
-  baseUrl: string;
-  apiPath?: string;
-  headers?: Record<string, string>;
-}
-
-interface OpenAICompatibleResponse {
-  choices?: Array<{
-    message?: {
-      content?: string | null;
-      tool_calls?: Array<{
-        id?: string;
-        function?: {
-          name?: string;
-          arguments?: string;
-        };
-      }>;
-    };
-    finish_reason?: string;
-  }>;
-  usage?: {
-    prompt_tokens?: number;
-    completion_tokens?: number;
-    total_tokens?: number;
-  };
-}
-
-export class OpenAICompatibleBackend implements AgentBackend {
-  private apiKey: string;
-  private baseUrl: string;
-  private apiPath: string;
-  private headers: Record<string, string>;
-
-  constructor(config: OpenAICompatibleConfig) {
-    this.apiKey = config.apiKey;
-    this.baseUrl = config.baseUrl.replace(/\/+$/, '');
-    this.apiPath = config.apiPath || '/chat/completions';
-    this.headers = config.headers || {};
-  }
-
-  async generate(request: BackendRequest): Promise<BackendResponse> {
-    const url = `${this.baseUrl}${this.apiPath}`;
-    const mapContent = (content: BackendRequest['messages'][number]['content']) => {
-      if (typeof content === 'string') return content;
-      return content.map(block => {
-        if (block.type === 'text') {
-          return { type: 'text', text: block.text };
-        }
-        if (block.type === 'tool_result') {
-          // OpenAI format: convert tool result to text
-          const resultText = typeof block.content === 'string'
-            ? block.content
-            : block.content.map(b => b.type === 'text' ? b.text : '[image]').join('\n');
-          return { type: 'text', text: `Tool result (${block.tool_use_id}): ${resultText}` };
-        }
-        if (block.type === 'tool_use') {
-          // OpenAI handles tool calls differently - convert to text representation
-          return { type: 'text', text: `[Tool call: ${block.name}(${JSON.stringify(block.input)})]` };
-        }
-        // Image block
-        return {
-          type: 'image_url',
-          image_url: { url: `data:${block.mediaType};base64,${block.data}` }
-        };
-      });
-    };
-    const body = {
-      model: request.model,
-      max_tokens: request.maxTokens,
-      messages: [
-        { role: 'system', content: request.system },
-        ...request.messages.map(message => ({
-          role: message.role,
-          content: mapContent(message.content)
-        }))
-      ],
-      tools: request.tools.map(t => ({
-        type: 'function',
-        function: {
-          name: t.name,
-          description: t.description,
-          parameters: t.parameters
-        }
-      }))
-    };
-
-    const response = await fetch(url, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        Authorization: `Bearer ${this.apiKey}`,
-        ...this.headers
-      },
-      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 OpenAICompatibleResponse;
-    const choice = data.choices?.[0];
-    const message = choice?.message;
-    const blocks: ContentBlock[] = [];
-
-    if (message?.content) {
-      blocks.push({ type: 'text', text: message.content });
-    }
-
-    if (message?.tool_calls) {
-      for (const call of message.tool_calls) {
-        const name = call.function?.name || 'unknown_tool';
-        const rawArgs = call.function?.arguments || '{}';
-        let args: Record<string, unknown> = {};
-        try {
-          args = JSON.parse(rawArgs);
-        } catch {
-          args = { _raw: rawArgs };
-        }
-        blocks.push({
-          type: 'tool_use',
-          id: call.id || `${name}_${Date.now()}`,
-          name,
-          input: args
-        });
-      }
-    }
-
-    const inputTokens = data.usage?.prompt_tokens ?? 0;
-    const outputTokens = data.usage?.completion_tokens ?? 0;
-    const totalTokens = data.usage?.total_tokens ?? (inputTokens + outputTokens);
-
-    return {
-      content: blocks,
-      stopReason: choice?.finish_reason || 'unknown',
-      usage: data.usage ? { inputTokens, outputTokens, totalTokens } : undefined
-    };
-  }
-}

package/src/agent/backends/types.ts

@@ -1,83 +0,0 @@
-import { ToolDefinition } from '../../types.js';
-
-export interface RequestTextBlock {
-  type: 'text';
-  text: string;
-}
-
-export interface RequestImageBlock {
-  type: 'image';
-  mediaType: string;
-  data: string;
-  path?: string;
-}
-
-export interface ToolResultImageSource {
-  type: 'base64';
-  media_type: string;
-  data: string;
-}
-
-export interface ToolResultImageBlock {
-  type: 'image';
-  source: ToolResultImageSource;
-}
-
-export interface ToolResultBlock {
-  type: 'tool_result';
-  tool_use_id: string;
-  content: string | Array<RequestTextBlock | ToolResultImageBlock>;
-}
-
-export interface ToolUseRequestBlock {
-  type: 'tool_use';
-  id: string;
-  name: string;
-  input: Record<string, unknown>;
-}
-
-export type RequestContentBlock = RequestTextBlock | RequestImageBlock | ToolResultBlock | ToolUseRequestBlock;
-
-export interface LlmMessage {
-  role: 'user' | 'assistant';
-  content: string | RequestContentBlock[];
-}
-
-export interface TextBlock {
-  type: 'text';
-  text: string;
-}
-
-export interface ToolUseBlock {
-  type: 'tool_use';
-  id: string;
-  name: string;
-  input: Record<string, unknown>;
-}
-
-export type ContentBlock = TextBlock | ToolUseBlock;
-
-export interface BackendRequest {
-  model: string;
-  maxTokens: number;
-  system: string;
-  messages: LlmMessage[];
-  tools: ToolDefinition[];
-}
-
-export interface BackendResponse {
-  content: ContentBlock[];
-  stopReason: string;
-  usage?: TokenUsage;
-}
-
-export interface TokenUsage {
-  inputTokens: number;
-  outputTokens: number;
-  totalTokens: number;
-  estimated?: boolean;
-}
-
-export interface AgentBackend {
-  generate(request: BackendRequest): Promise<BackendResponse>;
-}

package/src/agent/commands/clipboard.ts

@@ -1,77 +0,0 @@
-import { Command } from './types.js';
-
-type Role = 'user' | 'assistant' | 'system';
-
-function formatMessages(messages: { role: string; content: string }[]): string {
-  return messages
-    .map(msg => `[${msg.role}] ${msg.content}`)
-    .join('\n\n')
-    .trim();
-}
-
-function lastByRole(messages: { role: string; content: string }[], role: Role): { role: string; content: string } | undefined {
-  for (let i = messages.length - 1; i >= 0; i -= 1) {
-    if (messages[i].role === role) return messages[i];
-  }
-  return undefined;
-}
-
-export const clipboardCommand: Command = {
-  name: 'clipboard',
-  description: 'Copy conversation text to the clipboard',
-  usage: '<all|last|assistant|user|system> [role]',
-  handler: async (args, ctx) => {
-    const messages = ctx.getMessages();
-    if (messages.length === 0) {
-      ctx.addMessage({ role: 'system', content: 'Clipboard: no messages to copy.' });
-      return;
-    }
-
-    const target = (args[0] || 'last').toLowerCase();
-    const roleArg = (args[1] || '').toLowerCase();
-    const role = (roleArg === 'assistant' || roleArg === 'user' || roleArg === 'system')
-      ? roleArg as Role
-      : undefined;
-
-    let text = '';
-    let label = target;
-
-    if (target === 'all') {
-      text = formatMessages(messages);
-    } else if (target === 'last') {
-      const msg = role ? lastByRole(messages, role) : messages[messages.length - 1];
-      if (!msg) {
-        ctx.addMessage({ role: 'system', content: `Clipboard: no ${role} messages found.` });
-        return;
-      }
-      text = formatMessages([msg]);
-      label = role ? `last ${role}` : 'last';
-    } else if (target === 'assistant' || target === 'user' || target === 'system') {
-      const msg = lastByRole(messages, target as Role);
-      if (!msg) {
-        ctx.addMessage({ role: 'system', content: `Clipboard: no ${target} messages found.` });
-        return;
-      }
-      text = formatMessages([msg]);
-    } else {
-      ctx.addMessage({
-        role: 'system',
-        content: 'Usage: /clipboard <all|last|assistant|user|system> [role]\n\nExamples:\n  /clipboard all\n  /clipboard last\n  /clipboard last assistant\n  /clipboard assistant'
-      });
-      return;
-    }
-
-    if (!text) {
-      ctx.addMessage({ role: 'system', content: 'Clipboard: nothing to copy.' });
-      return;
-    }
-
-    try {
-      await ctx.clipboard.writeText(text);
-      ctx.addMessage({ role: 'system', content: `✓ Copied ${text.length} chars (${label})` });
-    } catch (err) {
-      const message = err instanceof Error ? err.message : 'Failed to copy';
-      ctx.addMessage({ role: 'system', content: `Clipboard error: ${message}` });
-    }
-  }
-};

package/src/agent/commands/config.ts

@@ -1,204 +0,0 @@
-import { Command } from './types.js';
-import { DEFAULT_SPINNER_VERBS, formatSpinnerVerbs, parseSpinnerVerbs } from '../../utils/spinner_verbs.js';
-
-export const configCommand: Command = {
-  name: 'config',
-  description: 'Manage configuration',
-  usage: '<show|key|provider|endpoint|model|spinner> [value]',
-  handler: async (args, ctx) => {
-    const [subCmd, ...rest] = args;
-    const value = rest.join(' ');
-
-    switch (subCmd) {
-      case 'show':
-        if (ctx.config.refresh) {
-          await ctx.config.refresh();
-        }
-        const config = ctx.config.get();
-        ctx.addMessage({
-          role: 'system',
-          content: [
-            'Current configuration:',
-            `  API Key: ${ctx.config.getMaskedApiKey()}`,
-            `  Provider: ${ctx.config.getProvider()}`,
-            `  Model: ${config.model}`,
-            `  Max Tokens: ${config.maxTokens}`,
-            `  Zerg Endpoint: ${config.zergEndpoint || '(not set)'}`,
-            `  Emulation: ${ctx.config.getEmulationId() || '(none)'}`,
-            `  Spinner verbs: ${formatSpinnerVerbs(config.spinnerVerbs || DEFAULT_SPINNER_VERBS)}`,
-            '',
-            `Config storage: ${ctx.config.locationLabel || '~/.ztc/config.json'}`
-          ].join('\n')
-        });
-        break;
-
-      case 'key':
-        if (!value) {
-          ctx.addMessage({
-            role: 'system',
-            content: `Current API key: ${ctx.config.getMaskedApiKey()}\n\nUsage: /config key <your-api-key>`
-          });
-          return;
-        }
-
-        let provider = ctx.config.getProvider();
-        let apiKey = value;
-        if (args[0] && ['anthropic', 'openai', 'gemini', 'inception', 'openai_compatible'].includes(args[0])) {
-          provider = args[0];
-          apiKey = args.slice(1).join(' ');
-        }
-        if (!apiKey) {
-          ctx.addMessage({
-            role: 'system',
-            content: 'Usage: /config key <provider> <api-key>'
-          });
-          return;
-        }
-
-        if (provider === 'anthropic' && !apiKey.startsWith('sk-ant-')) {
-          ctx.addMessage({
-            role: 'system',
-            content: '⚠️  Warning: API key doesn\'t look like an Anthropic key (should start with sk-ant-). Setting anyway...'
-          });
-        }
-
-        ctx.config.setApiKey(apiKey, provider);
-        ctx.config.save();
-        ctx.reloadAgent();
-        ctx.addMessage({
-          role: 'system',
-          content: `✓ API key updated (${provider}): ${ctx.config.getMaskedApiKey()}\n  Saved to ${ctx.config.locationLabel || '~/.ztc/config.json'}`
-        });
-        break;
-
-      case 'provider':
-        if (!value) {
-          ctx.addMessage({
-            role: 'system',
-            content: `Current provider: ${ctx.config.getProvider()}\n\nUsage: /config provider <anthropic|openai|gemini|inception|openai_compatible>`
-          });
-          return;
-        }
-        ctx.config.setProvider(value);
-        ctx.config.save();
-        ctx.reloadAgent();
-        ctx.addMessage({
-          role: 'system',
-          content: `✓ Provider updated: ${value}`
-        });
-        break;
-
-      case 'endpoint':
-        if (!value) {
-          ctx.addMessage({
-            role: 'system',
-            content: `Current OpenAI-compatible base URL: ${ctx.config.getOpenAICompatibleBaseUrl() || '(not set)'}\n\nUsage: /config endpoint <url>`
-          });
-          return;
-        }
-        ctx.config.setOpenAICompatibleBaseUrl(value);
-        ctx.config.save();
-        ctx.reloadAgent();
-        ctx.addMessage({
-          role: 'system',
-          content: `✓ OpenAI-compatible base URL updated: ${value}`
-        });
-        break;
-
-      case 'model':
-        if (!value) {
-          ctx.addMessage({
-            role: 'system',
-            content: `Current model: ${ctx.config.get().model}\n\nUsage: /config model <model-name>\n\nAvailable models:\n  claude-opus-4-20250514\n  claude-sonnet-4-20250514\n  claude-haiku-3-20240307`
-          });
-          return;
-        }
-        ctx.config.set('model', value);
-        ctx.config.save();
-        ctx.reloadAgent();
-        ctx.addMessage({
-          role: 'system',
-          content: `✓ Model updated: ${value}`
-        });
-        break;
-
-      case 'spinner': {
-        const [action, ...restParts] = rest;
-        const actionValue = restParts.join(' ');
-        const current = ctx.config.get().spinnerVerbs || DEFAULT_SPINNER_VERBS;
-
-        if (!action || action === 'show') {
-          ctx.addMessage({
-            role: 'system',
-            content: `Spinner verbs:\n  ${formatSpinnerVerbs(current)}\n\nUsage:\n  /config spinner show\n  /config spinner set <verb1, verb2, ...>\n  /config spinner add <verb>\n  /config spinner remove <verb>\n  /config spinner reset\n  /config spinner off`
-          });
-          return;
-        }
-
-        if (action === 'reset') {
-          ctx.config.set('spinnerVerbs', DEFAULT_SPINNER_VERBS);
-          ctx.config.save();
-          ctx.addMessage({ role: 'system', content: '✓ Spinner verbs reset to defaults.' });
-          return;
-        }
-
-        if (action === 'off') {
-          ctx.config.set('spinnerVerbs', []);
-          ctx.config.save();
-          ctx.addMessage({ role: 'system', content: '✓ Spinner verbs disabled.' });
-          return;
-        }
-
-        if (action === 'set') {
-          const verbs = parseSpinnerVerbs(actionValue);
-          if (verbs.length === 0) {
-            ctx.addMessage({ role: 'system', content: 'Usage: /config spinner set <verb1, verb2, ...>' });
-            return;
-          }
-          ctx.config.set('spinnerVerbs', verbs);
-          ctx.config.save();
-          ctx.addMessage({ role: 'system', content: `✓ Spinner verbs updated: ${formatSpinnerVerbs(verbs)}` });
-          return;
-        }
-
-        if (action === 'add') {
-          const verbs = parseSpinnerVerbs(actionValue);
-          if (verbs.length === 0) {
-            ctx.addMessage({ role: 'system', content: 'Usage: /config spinner add <verb>' });
-            return;
-          }
-          const next = [...current, ...verbs];
-          ctx.config.set('spinnerVerbs', next);
-          ctx.config.save();
-          ctx.addMessage({ role: 'system', content: `✓ Added spinner verbs: ${formatSpinnerVerbs(verbs)}` });
-          return;
-        }
-
-        if (action === 'remove') {
-          const verbs = parseSpinnerVerbs(actionValue).map(v => v.toLowerCase());
-          if (verbs.length === 0) {
-            ctx.addMessage({ role: 'system', content: 'Usage: /config spinner remove <verb>' });
-            return;
-          }
-          const next = current.filter(v => !verbs.includes(v.toLowerCase()));
-          ctx.config.set('spinnerVerbs', next);
-          ctx.config.save();
-          ctx.addMessage({ role: 'system', content: `✓ Removed spinner verbs: ${formatSpinnerVerbs(verbs)}` });
-          return;
-        }
-
-        ctx.addMessage({
-          role: 'system',
-          content: 'Usage: /config spinner <show|set|add|remove|reset|off> [value]'
-        });
-        break;
-      }
-
-      default:
-        ctx.addMessage({
-          role: 'system',
-          content: 'Usage: /config <show|key|provider|endpoint|model|spinner> [value]\n\nExamples:\n  /config show                           Show current config\n  /config key sk-ant-...                  Set API key (current provider)\n  /config key openai sk-...               Set API key for provider\n  /config provider openai                 Set provider\n  /config endpoint https://api.example.com/v1  Set OpenAI-compatible base URL\n  /config model claude-opus-4-20250514    Set model\n  /config spinner set Reticulating splines, Organizing thoughts'
-        });
-    }
-  }
-};