zerg-ztc 0.1.0

package/src/agent/backends/openai_compatible.ts

@@ -0,0 +1,131 @@
+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 };
+        }
+        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

@@ -0,0 +1,59 @@
+import { ToolDefinition } from '../../types.js';
+
+export interface RequestTextBlock {
+  type: 'text';
+  text: string;
+}
+
+export interface RequestImageBlock {
+  type: 'image';
+  mediaType: string;
+  data: string;
+  path?: string;
+}
+
+export type RequestContentBlock = RequestTextBlock | RequestImageBlock;
+
+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

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

@@ -0,0 +1,130 @@
+import { Command } from './types.js';
+
+export const configCommand: Command = {
+  name: 'config',
+  description: 'Manage configuration',
+  usage: '<show|key|provider|endpoint|model> [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)'}`,
+            '',
+            `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;
+
+      default:
+        ctx.addMessage({
+          role: 'system',
+          content: 'Usage: /config <show|key|provider|endpoint|model> [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'
+        });
+    }
+  }
+};

package/src/agent/commands/debug.ts

@@ -0,0 +1,23 @@
+import { Command } from './types.js';
+
+export const debugCommand: Command = {
+  name: 'debug',
+  description: 'Toggle debug mode (show layout borders)',
+  handler: (args, ctx) => {
+    const on = args[0] === 'on' || args[0] === '1' || args[0] === 'true';
+    const off = args[0] === 'off' || args[0] === '0' || args[0] === 'false';
+    
+    if (on) {
+      ctx.setDebug(true);
+      ctx.addMessage({ role: 'system', content: '✓ Debug mode enabled' });
+    } else if (off) {
+      ctx.setDebug(false);
+      ctx.addMessage({ role: 'system', content: '✓ Debug mode disabled' });
+    } else {
+      ctx.addMessage({
+        role: 'system',
+        content: 'Usage: /debug <on|off>\n\nEnables layout borders for debugging.'
+      });
+    }
+  }
+};

package/src/agent/commands/emulation.ts

@@ -0,0 +1,80 @@
+import { Command } from './types.js';
+
+export const emulationCommand: Command = {
+  name: 'emulation',
+  description: 'List or select a prompt emulation',
+  usage: '<list|show|set> [id]',
+  handler: (args, ctx) => {
+    const [subCmd, ...rest] = args;
+    const value = rest.join(' ').trim();
+
+    switch (subCmd) {
+      case 'list': {
+        const profiles = ctx.emulation.list();
+        const lines = profiles.map(p => `  ${p.id} - ${p.name}`);
+        ctx.addMessage({
+          role: 'system',
+          content: ['Available emulations:', ...lines].join('\n')
+        });
+        break;
+      }
+      case 'show': {
+        const id = value || ctx.config.getEmulationId();
+        if (!id) {
+          ctx.addMessage({
+            role: 'system',
+            content: 'No emulation selected. Use /emulation list or /emulation set <id>.'
+          });
+          return;
+        }
+        const profile = ctx.emulation.get(id);
+        if (!profile) {
+          ctx.addMessage({
+            role: 'system',
+            content: `Unknown emulation: ${id}`
+          });
+          return;
+        }
+        ctx.addMessage({
+          role: 'system',
+          content: [
+            `Emulation: ${profile.name}`,
+            `ID: ${profile.id}`,
+            profile.description
+          ].join('\n')
+        });
+        break;
+      }
+      case 'set': {
+        if (!value) {
+          ctx.addMessage({
+            role: 'system',
+            content: 'Usage: /emulation set <id>'
+          });
+          return;
+        }
+        const profile = ctx.emulation.get(value);
+        if (!profile) {
+          ctx.addMessage({
+            role: 'system',
+            content: `Unknown emulation: ${value}`
+          });
+          return;
+        }
+        ctx.config.setEmulationId(profile.id);
+        ctx.config.save();
+        ctx.reloadAgent();
+        ctx.addMessage({
+          role: 'system',
+          content: `✓ Emulation set: ${profile.name}`
+        });
+        break;
+      }
+      default:
+        ctx.addMessage({
+          role: 'system',
+          content: 'Usage: /emulation <list|show|set> [id]'
+        });
+    }
+  }
+};

package/src/agent/commands/execution.ts

@@ -0,0 +1,9 @@
+import { Command } from './types.js';
+
+export const exitCommand: Command = {
+  name: 'exit',
+  description: 'Exit ZTC',
+  handler: (_, ctx) => {
+    ctx.exit();
+  }
+};

package/src/agent/commands/help.ts

@@ -0,0 +1,20 @@
+import { Command } from './types.js';
+
+export function makeHelpCommand(getCommands: () => Command[]): Command {
+  return {
+    name: 'help',
+    description: 'Show available commands',
+    handler: (_, ctx) => {
+      const helpText = getCommands()
+        .map(c => {
+          const usage = c.usage ? ` ${c.usage}` : '';
+          return `  /${c.name}${usage}\n    ${c.description}`;
+        })
+        .join('\n\n');
+      ctx.addMessage({
+        role: 'system',
+        content: `Available commands:\n\n${helpText}`
+      });
+    }
+  };
+}

package/src/agent/commands/history.ts

@@ -0,0 +1,13 @@
+import { Command } from './types.js';
+
+export const clearCommand: Command = {
+  name: 'clear',
+  description: 'Clear message history',
+  handler: (_, ctx) => {
+    ctx.clearMessages();
+    ctx.addMessage({
+      role: 'system',
+      content: 'Message history cleared.'
+    });
+  }
+};

package/src/agent/commands/index.ts

@@ -0,0 +1,40 @@
+import { makeHelpCommand } from './help.js';
+import { configCommand } from './config.js';
+import { debugCommand } from './debug.js';
+import { clearCommand } from './history.js';
+import { statusCommand } from './status.js';
+import { exitCommand } from './execution.js';
+import { emulationCommand } from './emulation.js';
+import { shellCommand, cdCommand } from './shell.js';
+import { clipboardCommand } from './clipboard.js';
+import { modelsCommand } from './models.js';
+import { modelCommand } from './model.js';
+import { permissionsCommand } from './permissions.js';
+import { skillsCommand } from './skills.js';
+import { retryCommand } from './retry.js';
+import { Command } from './types.js';
+
+const commandList: Command[] = [];
+
+const helpCommand = makeHelpCommand(() => commandList);
+
+commandList.push(
+  helpCommand,
+  configCommand,
+  debugCommand,
+  clearCommand,
+  statusCommand,
+  emulationCommand,
+  shellCommand,
+  cdCommand,
+  clipboardCommand,
+  modelsCommand,
+  modelCommand,
+  permissionsCommand,
+  skillsCommand,
+  retryCommand,
+  exitCommand
+);
+
+export const commands = commandList;
+export type { Command, CommandContext } from './types.js';

package/src/agent/commands/model.ts

@@ -0,0 +1,11 @@
+import { Command } from './types.js';
+import { configCommand } from './config.js';
+
+export const modelCommand: Command = {
+  name: 'model',
+  description: 'Alias for /config model',
+  usage: '<model-id>',
+  handler: (args, ctx) => {
+    return configCommand.handler(['model', ...args], ctx);
+  }
+};