zerg-ztc 0.1.11 → 0.1.12

package/src/agent/commands/types.ts

@@ -1,88 +0,0 @@
-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 DictationController {
-  startRecording: () => void;
-  stopRecording: () => Promise<string>;  // Returns transcribed text
-  isRecording: () => boolean;
-}
-
-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;
-  dictation?: DictationController;
-  getInputMode: () => 'queue' | 'interrupt';
-  setInputMode: (mode: 'queue' | 'interrupt') => void;
-  setInputText?: (text: string) => void;  // Set input field text
-}
-
-export interface Command {
-  name: string;
-  description: string;
-  usage?: string;
-  handler: (args: string[], ctx: CommandContext) => void | Promise<void>;
-}

package/src/agent/commands/update.ts

@@ -1,32 +0,0 @@
-import { Command } from './types.js';
-import { getVersion } from '../../utils/version.js';
-import { checkForUpdate } from '../../utils/update.js';
-
-export const updateCommand: Command = {
-  name: 'update',
-  description: 'Check for updates and install the latest version',
-  handler: async (_args, ctx) => {
-    try {
-      ctx.addMessage({ role: 'system', content: 'Checking for updates...' });
-      const current = getVersion();
-      const info = await checkForUpdate(current);
-      if (!info.hasUpdate) {
-        ctx.addMessage({ role: 'system', content: `ZTC is up to date (v${current}).` });
-        return;
-      }
-      ctx.addMessage({ role: 'system', content: `Updating to v${info.latest}...` });
-      const result = await ctx.shell.run('npm install -g zerg-ztc@latest');
-      if (result.exitCode === 0) {
-        ctx.addMessage({ role: 'system', content: `✓ Updated to v${info.latest}. Restart ZTC to use the new version.` });
-      } else {
-        ctx.addMessage({
-          role: 'system',
-          content: `Update failed (exit ${result.exitCode}).\n${result.stderr || result.stdout || ''}`.trim()
-        });
-      }
-    } catch (err) {
-      const message = err instanceof Error ? err.message : 'Update failed';
-      ctx.addMessage({ role: 'system', content: `Update failed: ${message}` });
-    }
-  }
-};

package/src/agent/factory.ts

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

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

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

package/src/agent/runtime/memory.ts

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

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

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

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

package/src/agent/tools/file.ts

@@ -1,178 +0,0 @@
-import { readFile, writeFile, readdir, stat } from 'fs/promises';
-import { dirname, resolve } from 'path';
-import { Tool, ToolContext } from './types.js';
-import { ToolCapability } from '../runtime/capabilities.js';
-import { buildSimpleDiff } from '../../utils/diff.js';
-
-function resolvePath(path: string, context?: ToolContext): string {
-  const base = context?.cwd || process.cwd();
-  return resolve(base, path);
-}
-
-// --- 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, context) => {
-    const path = resolvePath(String(args.path), context);
-    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, context) => {
-    const path = resolvePath(String(args.path), context);
-    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, context) => {
-    const path = resolvePath(String(args.path), context);
-    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

@@ -1,52 +0,0 @@
-import { Tool, ToolContext } 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';
-import { screenshotTool, listWindowsTool, runAndMonitorTool } from './screenshot.js';
-
-// --- Tool Registry ---
-
-export const defaultTools: Tool[] = [
-  readFileTool,
-  writeFileTool,
-  listDirectoryTool,
-  searchTool,
-  listSkillsTool,
-  runCommandTool,
-  zergQueryTool,
-  screenshotTool,
-  listWindowsTool,
-  runAndMonitorTool
-];
-
-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,
-  context?: ToolContext
-): Promise<string> {
-  const tool = getTool(name, tools);
-  if (!tool) {
-    throw new Error(`Unknown tool: ${name}`);
-  }
-  return tool.execute(args, context);
-}
-
-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 { screenshotTool, listWindowsTool, runAndMonitorTool } from './screenshot.js';
-export type { Tool } from './types.js';