zerg-ztc 0.1.0

package/src/agent/commands/models.ts

@@ -0,0 +1,116 @@
+import { Command } from './types.js';
+
+const LATEST_TAGS = ['latest', 'current', 'default'];
+
+function pickLatestModel(models: string[]): string | null {
+  if (!models.length) return null;
+
+  const tagged = models
+    .map(name => ({ name, lower: name.toLowerCase() }))
+    .filter(entry => LATEST_TAGS.some(tag => entry.lower.includes(tag)));
+
+  if (tagged.length > 0) {
+    const sorted = tagged.sort((a, b) => {
+      const aRank = LATEST_TAGS.findIndex(tag => a.lower.includes(tag));
+      const bRank = LATEST_TAGS.findIndex(tag => b.lower.includes(tag));
+      if (aRank !== bRank) return aRank - bRank;
+      return b.name.localeCompare(a.name);
+    });
+    return sorted[0].name;
+  }
+
+  const datePattern = /(\d{4})[.-]?(\d{2})[.-]?(\d{2})/;
+  const withDates = models
+    .map(name => {
+      const match = name.match(datePattern);
+      if (!match) return null;
+      const dateValue = Number(match[1]) * 10000 + Number(match[2]) * 100 + Number(match[3]);
+      return { name, dateValue };
+    })
+    .filter((entry): entry is { name: string; dateValue: number } => !!entry);
+
+  if (withDates.length > 0) {
+    withDates.sort((a, b) => b.dateValue - a.dateValue || b.name.localeCompare(a.name));
+    return withDates[0].name;
+  }
+
+  const versionPattern = /(\d+(?:\.\d+)+|\d+)/g;
+  const withVersions = models
+    .map(name => {
+      const match = name.match(versionPattern);
+      if (!match || match.length === 0) return null;
+      const versionValue = parseFloat(match[0]);
+      return { name, versionValue };
+    })
+    .filter((entry): entry is { name: string; versionValue: number } => !!entry);
+
+  if (withVersions.length > 0) {
+    withVersions.sort((a, b) => b.versionValue - a.versionValue || b.name.localeCompare(a.name));
+    return withVersions[0].name;
+  }
+
+  return models.slice().sort((a, b) => b.localeCompare(a))[0];
+}
+
+export const modelsCommand: Command = {
+  name: 'models',
+  description: 'List or set available models for a provider',
+  usage: '<list [provider]|latest [provider]|set <model-id>>',
+  handler: async (args, ctx) => {
+    const subCmd = (args[0] || 'list').toLowerCase();
+
+    if (subCmd === 'set') {
+      const value = args.slice(1).join(' ').trim();
+      if (!value) {
+        ctx.addMessage({
+          role: 'system',
+          content: 'Usage: /models set <model-id>'
+        });
+        return;
+      }
+      ctx.config.set('model', value);
+      await ctx.config.save();
+      ctx.reloadAgent();
+      ctx.addMessage({ role: 'system', content: `✓ Model updated: ${value}` });
+      return;
+    }
+
+    const provider = args[0] && args[0] !== 'list' && args[0] !== 'latest' ? args[0] : ctx.config.getProvider();
+    try {
+      const models = await ctx.models.list(provider);
+      if (models.length === 0) {
+        ctx.addMessage({
+          role: 'system',
+          content: `No models returned for provider: ${provider}`
+        });
+        return;
+      }
+      if (subCmd === 'latest') {
+        const latest = pickLatestModel(models);
+        if (!latest) {
+          ctx.addMessage({
+            role: 'system',
+            content: `Unable to determine latest model for ${provider}`
+          });
+          return;
+        }
+        ctx.config.set('model', latest);
+        await ctx.config.save();
+        ctx.reloadAgent();
+        ctx.addMessage({ role: 'system', content: `✓ Model updated: ${latest}` });
+      } else {
+        const lines = models.sort().map(model => `  ${model}`);
+        ctx.addMessage({
+          role: 'system',
+          content: [`Models (${provider}):`, ...lines].join('\n')
+        });
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : 'Unable to list models';
+      ctx.addMessage({
+        role: 'system',
+        content: `Models error: ${message}`
+      });
+    }
+  }
+};

package/src/agent/commands/permissions.ts

@@ -0,0 +1,64 @@
+import { Command } from './types.js';
+
+const ALL_CAPS = ['file_read', 'file_write', 'shell_exec', 'network'] as const;
+
+function normalize(value: string): string {
+  return value.trim().toLowerCase();
+}
+
+export const permissionsCommand: Command = {
+  name: 'permissions',
+  description: 'View or update tool permissions',
+  usage: '<show|set> [capability] [on|off]',
+  handler: async (args, ctx) => {
+    const subCmd = normalize(args[0] || 'show');
+    const config = ctx.config.get();
+    const current = config.toolPermissions || {};
+
+    if (subCmd === 'show') {
+      const lines = ALL_CAPS.map(cap => {
+        const value = current[cap];
+        const label = value === false ? 'off' : 'on';
+        return `  ${cap}: ${label}`;
+      });
+      ctx.addMessage({
+        role: 'system',
+        content: ['Tool permissions:', ...lines].join('\n')
+      });
+      return;
+    }
+
+    if (subCmd === 'set') {
+      const cap = normalize(args[1] || '');
+      const value = normalize(args[2] || '');
+      if (!cap || !ALL_CAPS.includes(cap as typeof ALL_CAPS[number])) {
+        ctx.addMessage({
+          role: 'system',
+          content: `Usage: /permissions set <${ALL_CAPS.join('|')}> <on|off>`
+        });
+        return;
+      }
+      if (value !== 'on' && value !== 'off') {
+        ctx.addMessage({
+          role: 'system',
+          content: 'Usage: /permissions set <capability> <on|off>'
+        });
+        return;
+      }
+      const next = { ...current, [cap]: value === 'on' };
+      ctx.config.set('toolPermissions', next);
+      await ctx.config.save();
+      ctx.reloadAgent();
+      ctx.addMessage({
+        role: 'system',
+        content: `✓ Permission updated: ${cap} ${value}`
+      });
+      return;
+    }
+
+    ctx.addMessage({
+      role: 'system',
+      content: 'Usage: /permissions <show|set> [capability] [on|off]'
+    });
+  }
+};

package/src/agent/commands/retry.ts

@@ -0,0 +1,9 @@
+import { Command } from './types.js';
+
+export const retryCommand: Command = {
+  name: 'retry',
+  description: 'Retry the last request',
+  handler: (_args, ctx) => {
+    ctx.retry();
+  }
+};

package/src/agent/commands/shell.ts

@@ -0,0 +1,68 @@
+import { Command, ShellResult } from './types.js';
+
+function formatShellResult(result: ShellResult): string {
+  const lines: string[] = [];
+  const stdout = result.stdout.trimEnd();
+  const stderr = result.stderr.trimEnd();
+
+  if (stdout) lines.push(stdout);
+  if (stderr) lines.push(stderr);
+  if (!stdout && !stderr) lines.push('(no output)');
+
+  if (result.exitCode !== 0) {
+    lines.push(`exit code: ${result.exitCode}`);
+  }
+  if (result.truncated) {
+    lines.push('(output truncated)');
+  }
+
+  return lines.join('\n');
+}
+
+export const shellCommand: Command = {
+  name: 'shell',
+  description: 'Run a local shell command (or use !command)',
+  usage: '<command>',
+  handler: async (args, ctx) => {
+    const command = args.join(' ').trim();
+    if (!command) {
+      ctx.addMessage({
+        role: 'system',
+        content: 'Usage: /shell <command>\n\nExample:\n  /shell ls -la\n  !pwd'
+      });
+      return;
+    }
+
+    ctx.addMessage({ role: 'system', content: `$ ${command}` });
+    try {
+      const result = await ctx.shell.run(command);
+      ctx.addMessage({ role: 'system', content: formatShellResult(result) });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : 'Command failed';
+      ctx.addMessage({ role: 'system', content: `shell: ${message}` });
+    }
+  }
+};
+
+export const cdCommand: Command = {
+  name: 'cd',
+  description: 'Change working directory for !/shell commands',
+  usage: '[path]',
+  handler: async (args, ctx) => {
+    const target = args.join(' ').trim();
+    if (!target) {
+      ctx.addMessage({
+        role: 'system',
+        content: `cwd: ${ctx.shell.getCwd()}`
+      });
+      return;
+    }
+    try {
+      const next = await ctx.shell.setCwd(target);
+      ctx.addMessage({ role: 'system', content: `cwd: ${next}` });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : 'Unable to change directory';
+      ctx.addMessage({ role: 'system', content: `cd: ${message}` });
+    }
+  }
+};

package/src/agent/commands/skills.ts

@@ -0,0 +1,54 @@
+import { Command } from './types.js';
+import { formatSkillList } from '../../skills/index.js';
+
+export const skillsCommand: Command = {
+  name: 'skills',
+  description: 'List or show available skills',
+  usage: '<list|show> [id]',
+  handler: async (args, ctx) => {
+    const subCmd = (args[0] || 'list').toLowerCase();
+    const registry = await ctx.skills.list();
+
+    if (subCmd === 'list') {
+      ctx.addMessage({
+        role: 'system',
+        content: formatSkillList(registry)
+      });
+      return;
+    }
+
+    if (subCmd === 'show') {
+      const id = (args[1] || '').trim();
+      if (!id) {
+        ctx.addMessage({
+          role: 'system',
+          content: 'Usage: /skills show <id>'
+        });
+        return;
+      }
+      const skill = registry.find(entry => entry.id === id);
+      if (!skill) {
+        ctx.addMessage({
+          role: 'system',
+          content: `Skill not found: ${id}`
+        });
+        return;
+      }
+      ctx.addMessage({
+        role: 'system',
+        content: [
+          `Skill: ${skill.name}`,
+          `ID: ${skill.id}`,
+          skill.description ? `Description: ${skill.description}` : '',
+          skill.instructions
+        ].filter(Boolean).join('\n')
+      });
+      return;
+    }
+
+    ctx.addMessage({
+      role: 'system',
+      content: 'Usage: /skills <list|show> [id]'
+    });
+  }
+};

package/src/agent/commands/status.ts

@@ -0,0 +1,19 @@
+import { Command } from './types.js';
+
+export const statusCommand: Command = {
+  name: 'status',
+  description: 'Show current status',
+  handler: (_, ctx) => {
+    const hasKey = ctx.config.hasApiKey();
+    const config = ctx.config.get();
+    ctx.addMessage({
+      role: 'system',
+      content: [
+        'Status:',
+        `  API Key: ${hasKey ? '✓ configured' : '✗ not set (use /config key <key>)'}`,
+        `  Model: ${config.model}`,
+        `  Ready: ${hasKey ? 'Yes' : 'No - need API key'}`
+      ].join('\n')
+    });
+  }
+};

package/src/agent/commands/types.ts

@@ -0,0 +1,78 @@
+import { AgentState, Message } from '../../types.js';
+import { ZTCConfig } from '../../config/types.js';
+import type { EmulationProfile } from '../../emulation/types.js';
+import type { Skill } from '../../skills/types.js';
+
+export interface ConfigController {
+  locationLabel?: string;
+  get: () => ZTCConfig;
+  set: <K extends keyof ZTCConfig>(key: K, value: ZTCConfig[K]) => void;
+  refresh?: () => Promise<void>;
+  hasApiKey: () => boolean;
+  getApiKey: (provider?: string) => string | undefined;
+  setApiKey: (key: string, provider?: string) => void;
+  getMaskedApiKey: () => string;
+  getProvider: () => string;
+  setProvider: (provider: string) => void;
+  getOpenAICompatibleBaseUrl: () => string | undefined;
+  setOpenAICompatibleBaseUrl: (url: string | undefined) => void;
+  getEmulationId: () => string | undefined;
+  setEmulationId: (id: string | undefined) => void;
+  save: () => void | Promise<void>;
+}
+
+export interface EmulationController {
+  list: () => EmulationProfile[];
+  get: (id: string) => EmulationProfile | undefined;
+}
+
+export interface ShellResult {
+  command: string;
+  cwd: string;
+  stdout: string;
+  stderr: string;
+  exitCode: number;
+  truncated: boolean;
+}
+
+export interface ShellController {
+  run: (command: string) => Promise<ShellResult>;
+  getCwd: () => string;
+  setCwd: (path: string) => Promise<string>;
+}
+
+export interface ClipboardController {
+  writeText: (text: string) => Promise<void>;
+}
+
+export interface ModelsController {
+  list: (provider?: string) => Promise<string[]>;
+}
+
+export interface SkillsController {
+  list: () => Promise<Skill[]>;
+}
+
+export interface CommandContext {
+  addMessage: (msg: Omit<Message, 'id' | 'timestamp'>) => void;
+  clearMessages: () => void;
+  getMessages: () => Message[];
+  setAgentState: (state: AgentState) => void;
+  reloadAgent: () => void;
+  setDebug: (debug: boolean) => void;
+  retry: () => void;
+  exit: () => void;
+  config: ConfigController;
+  emulation: EmulationController;
+  shell: ShellController;
+  clipboard: ClipboardController;
+  models: ModelsController;
+  skills: SkillsController;
+}
+
+export interface Command {
+  name: string;
+  description: string;
+  usage?: string;
+  handler: (args: string[], ctx: CommandContext) => void | Promise<void>;
+}

package/src/agent/factory.ts

@@ -0,0 +1,60 @@
+import { Agent } from './agent.js';
+import { AnthropicBackend, OpenAIBackend, OpenAICompatibleBackend, GeminiBackend, InceptionBackend } from './backends/index.js';
+import { getEmulationProfile } from '../emulation/catalog.js';
+import { ZTCConfig } from '../config/types.js';
+import { CapabilityPolicy } from './runtime/policy.js';
+
+export interface AgentFactoryOptions {
+  config: ZTCConfig;
+  provider?: string;
+  apiKey?: string;
+  openaiCompatibleBaseUrl?: string;
+  emulationId?: string;
+  apiEndpoint?: string;
+  skillPrompt?: string;
+}
+
+export function createAgentFromConfig(options: AgentFactoryOptions): Agent | null {
+  const provider = options.provider || options.config.provider || 'anthropic';
+  const apiKey = options.apiKey || options.config.apiKey || '';
+  if (!apiKey) return null;
+
+  const emulationId = options.emulationId || options.config.emulationId;
+  const emulation = emulationId ? getEmulationProfile(emulationId) : undefined;
+
+  let backend;
+  switch (provider) {
+    case 'openai':
+      backend = new OpenAIBackend({ apiKey });
+      break;
+    case 'gemini':
+      backend = new GeminiBackend({ apiKey });
+      break;
+    case 'inception':
+      backend = new InceptionBackend({ apiKey });
+      break;
+    case 'openai_compatible':
+      backend = new OpenAICompatibleBackend({
+        apiKey,
+        baseUrl: options.openaiCompatibleBaseUrl || options.config.openaiCompatibleBaseUrl || 'https://api.openai.com/v1'
+      });
+      break;
+    case 'anthropic':
+    default:
+      backend = new AnthropicBackend({ apiKey, apiEndpoint: options.apiEndpoint });
+  }
+
+  const basePrompt = emulation?.systemPrompt;
+  const skillPrompt = options.skillPrompt?.trim();
+  const systemPrompt = skillPrompt
+    ? [basePrompt, skillPrompt].filter(Boolean).join('\n\n')
+    : basePrompt;
+
+  return new Agent({
+    apiKey,
+    model: options.config.model,
+    systemPrompt,
+    backend,
+    policy: new CapabilityPolicy(options.config.toolPermissions)
+  });
+}

package/src/agent/index.ts

@@ -0,0 +1,20 @@
+// Agent module exports
+export { Agent, AgentError, type AgentConfig, type EventHandler } from './agent.js';
+export { 
+  defaultTools, 
+  getToolDefinitions, 
+  getTool, 
+  executeTool,
+  type Tool 
+} from './tools/index.js';
+export { AnthropicBackend, OpenAIBackend, OpenAICompatibleBackend, InceptionBackend, GeminiBackend } from './backends/index.js';
+export type { AgentBackend, BackendRequest, BackendResponse } from './backends/index.js';
+export { AllowAllPolicy } from './runtime/policy.js';
+export type { Policy } from './runtime/policy.js';
+export { NoopTracer } from './runtime/tracing.js';
+export type { Tracer, TraceEvent, TraceEventType } from './runtime/tracing.js';
+export { InMemoryStore } from './runtime/memory.js';
+export type { MemoryStore } from './runtime/memory.js';
+export { InMemorySessionStore } from './runtime/session.js';
+export type { SessionStore } from './runtime/session.js';
+export { ToolCapability } from './runtime/capabilities.js';

package/src/agent/runtime/capabilities.ts

@@ -0,0 +1,6 @@
+export enum ToolCapability {
+  FILE_READ = 'file_read',
+  FILE_WRITE = 'file_write',
+  SHELL_EXEC = 'shell_exec',
+  NETWORK = 'network'
+}

package/src/agent/runtime/memory.ts

@@ -0,0 +1,23 @@
+import { Message } from '../../types.js';
+
+export interface MemoryStore {
+  addMessage(message: Message): void;
+  getRecent(limit: number): Message[];
+  clear(): void;
+}
+
+export class InMemoryStore implements MemoryStore {
+  private messages: Message[] = [];
+
+  addMessage(message: Message): void {
+    this.messages.push(message);
+  }
+
+  getRecent(limit: number): Message[] {
+    return this.messages.slice(-limit);
+  }
+
+  clear(): void {
+    this.messages = [];
+  }
+}

package/src/agent/runtime/policy.ts

@@ -0,0 +1,48 @@
+import { ToolCapability } from './capabilities.js';
+
+export interface ToolPolicyRequest {
+  name: string;
+  args: Record<string, unknown>;
+  capabilities: ToolCapability[];
+}
+
+export interface ToolPolicyDecision {
+  allowed: boolean;
+  reason?: string;
+}
+
+export interface Policy {
+  evaluateTool(request: ToolPolicyRequest): ToolPolicyDecision;
+}
+
+export class AllowAllPolicy implements Policy {
+  evaluateTool(): ToolPolicyDecision {
+    return { allowed: true };
+  }
+}
+
+export class CapabilityPolicy implements Policy {
+  private permissions: Record<string, boolean>;
+
+  constructor(permissions?: Partial<Record<string, boolean>>) {
+    this.permissions = {
+      file_read: true,
+      file_write: true,
+      shell_exec: true,
+      network: true,
+      ...permissions
+    };
+  }
+
+  evaluateTool(request: ToolPolicyRequest): ToolPolicyDecision {
+    for (const capability of request.capabilities) {
+      if (this.permissions[capability] === false) {
+        return {
+          allowed: false,
+          reason: `Permission denied: ${capability}`
+        };
+      }
+    }
+    return { allowed: true };
+  }
+}

package/src/agent/runtime/session.ts

@@ -0,0 +1,18 @@
+import { Session } from '../../types.js';
+
+export interface SessionStore {
+  save(session: Session): Promise<void>;
+  load(id: string): Promise<Session | null>;
+}
+
+export class InMemorySessionStore implements SessionStore {
+  private sessions = new Map<string, Session>();
+
+  async save(session: Session): Promise<void> {
+    this.sessions.set(session.id, session);
+  }
+
+  async load(id: string): Promise<Session | null> {
+    return this.sessions.get(id) || null;
+  }
+}

package/src/agent/runtime/tracing.ts

@@ -0,0 +1,23 @@
+export type TraceEventType =
+  | 'api_request'
+  | 'api_response'
+  | 'tool_start'
+  | 'tool_end'
+  | 'tool_error'
+  | 'policy_denied';
+
+export interface TraceEvent {
+  type: TraceEventType;
+  timestamp: Date;
+  data?: Record<string, unknown>;
+}
+
+export interface Tracer {
+  event(event: TraceEvent): void;
+}
+
+export class NoopTracer implements Tracer {
+  event(): void {
+    // No-op
+  }
+}