zerg-ztc 0.1.0

package/src/config.ts

@@ -0,0 +1,178 @@
+import { homedir } from 'os';
+import { join } from 'path';
+import { readFile, writeFile, mkdir } from 'fs/promises';
+
+import { ZTCConfig } from './config/types.js';
+
+// --- Configuration Store ---
+
+const DEFAULT_CONFIG: ZTCConfig = {
+  apiKey: process.env.ANTHROPIC_API_KEY,
+  apiKeys: undefined,
+  provider: 'anthropic',
+  openaiCompatibleBaseUrl: undefined,
+  model: 'claude-opus-4-20250514',
+  maxTokens: 4096,
+  zergEndpoint: undefined,
+  emulationId: undefined,
+  toolPermissions: {
+    file_read: true,
+    file_write: true,
+    shell_exec: true,
+    network: true
+  }
+};
+
+const CONFIG_DIR = join(homedir(), '.ztc');
+const CONFIG_FILE = join(CONFIG_DIR, 'config.json');
+
+class ConfigStore {
+  private config: ZTCConfig = { ...DEFAULT_CONFIG };
+  private loaded = false;
+
+  private applyEnvOverrides(): void {
+    if (process.env.ANTHROPIC_API_KEY) {
+      this.config.apiKey = process.env.ANTHROPIC_API_KEY;
+    }
+  }
+
+  async load(force = false): Promise<ZTCConfig> {
+    if (this.loaded && !force) return this.config;
+
+    try {
+      const data = await readFile(CONFIG_FILE, 'utf-8');
+      const saved = JSON.parse(data) as Partial<ZTCConfig>;
+      this.config = { ...DEFAULT_CONFIG, ...saved };
+      if (this.config.model === 'claude-opus-4-5-20250514') {
+        this.config.model = 'claude-opus-4-20250514';
+      }
+      if (!this.config.toolPermissions) {
+        this.config.toolPermissions = { ...DEFAULT_CONFIG.toolPermissions };
+      }
+      this.applyEnvOverrides();
+    } catch {
+      // File doesn't exist or is invalid, use defaults
+      this.config = { ...DEFAULT_CONFIG };
+    }
+
+    this.loaded = true;
+    return this.config;
+  }
+
+  async refresh(): Promise<void> {
+    await this.load(true);
+  }
+
+  async save(): Promise<void> {
+    try {
+      await mkdir(CONFIG_DIR, { recursive: true });
+      
+      // Don't persist API key if it came from env
+      const toSave: Partial<ZTCConfig> = { ...this.config };
+      if (process.env.ANTHROPIC_API_KEY === this.config.apiKey) {
+        delete toSave.apiKey;
+      }
+      
+      await writeFile(CONFIG_FILE, JSON.stringify(toSave, null, 2), 'utf-8');
+    } catch (err) {
+      console.error('Failed to save config:', err);
+    }
+  }
+
+  get(): ZTCConfig {
+    return this.config;
+  }
+
+  set<K extends keyof ZTCConfig>(key: K, value: ZTCConfig[K]): void {
+    this.config[key] = value;
+  }
+
+  setAll(next: Partial<ZTCConfig>): void {
+    this.config = { ...DEFAULT_CONFIG, ...this.config, ...next };
+    if (this.config.model === 'claude-opus-4-5-20250514') {
+      this.config.model = 'claude-opus-4-20250514';
+    }
+    if (!this.config.toolPermissions) {
+      this.config.toolPermissions = { ...DEFAULT_CONFIG.toolPermissions };
+    }
+    this.applyEnvOverrides();
+    this.loaded = true;
+  }
+
+  hasApiKey(): boolean {
+    const key = this.getApiKey();
+    return !!key && key.length > 0;
+  }
+
+  getApiKey(provider?: string): string | undefined {
+    const chosen = provider || this.getProvider();
+    const envKey = this.getEnvKey(chosen);
+    if (envKey) return envKey;
+    if (this.config.apiKeys && this.config.apiKeys[chosen]) return this.config.apiKeys[chosen];
+    return this.config.apiKey;
+  }
+
+  setApiKey(key: string, provider?: string): void {
+    const chosen = provider || this.getProvider();
+    if (!this.config.apiKeys) {
+      this.config.apiKeys = {};
+    }
+    this.config.apiKeys[chosen] = key;
+    if (chosen === 'anthropic') {
+      this.config.apiKey = key;
+    }
+  }
+
+  getEmulationId(): string | undefined {
+    return this.config.emulationId;
+  }
+
+  setEmulationId(id: string | undefined): void {
+    this.config.emulationId = id;
+  }
+
+  getMaskedApiKey(): string {
+    const key = this.getApiKey();
+    if (!key) return '(not set)';
+    if (key.length < 12) return '****';
+    return `${key.slice(0, 7)}...${key.slice(-4)}`;
+  }
+
+  getProvider(): string {
+    return this.config.provider || 'anthropic';
+  }
+
+  setProvider(provider: string): void {
+    this.config.provider = provider;
+  }
+
+  getOpenAICompatibleBaseUrl(): string | undefined {
+    return this.config.openaiCompatibleBaseUrl;
+  }
+
+  setOpenAICompatibleBaseUrl(url: string | undefined): void {
+    this.config.openaiCompatibleBaseUrl = url;
+  }
+
+  private getEnvKey(provider: string): string | undefined {
+    const map: Record<string, string | undefined> = {
+      anthropic: process.env.ANTHROPIC_API_KEY,
+      openai: process.env.OPENAI_API_KEY,
+      gemini: process.env.GOOGLE_API_KEY || process.env.GEMINI_API_KEY,
+      inception: process.env.INCEPTION_API_KEY,
+      openai_compatible: process.env.OPENAI_COMPAT_API_KEY
+    };
+    return map[provider];
+  }
+
+  getConfigPath(): string {
+    return CONFIG_FILE;
+  }
+
+  get locationLabel(): string {
+    return CONFIG_FILE;
+  }
+}
+
+export const configStore = new ConfigStore();
+export default configStore;

package/src/debug/logger.ts

@@ -0,0 +1,14 @@
+import { appendFileSync } from 'fs';
+
+const enabled = process.env.ZTC_DEBUG_RENDER === '1';
+const logPath = process.env.ZTC_DEBUG_RENDER_LOG || '/tmp/ztc_render.log';
+
+export function debugLog(message: string): void {
+  if (!enabled) return;
+  const line = `[${new Date().toISOString()}] ${message}\n`;
+  try {
+    appendFileSync(logPath, line, 'utf-8');
+  } catch {
+    // Ignore logging failures
+  }
+}

package/src/emulation/README.md

@@ -0,0 +1,24 @@
+## Emulation Layer
+
+This module loads third-party tool prompts (e.g., Claude Code, Codex CLI) and exposes them as selectable emulation profiles.
+
+### Data Source
+The content is extracted from the `x1xhlol/system-prompts-and-models-of-ai-tools` repository and stored locally in:
+`~/.ztc/emulations/x1xhlol/`
+
+You can override the base path with `ZTC_EMULATION_DIR` (useful for tests or custom fixtures).
+
+### Fixture Setup
+For tests, point `ZTC_EMULATION_DIR` at `tests/fixtures/emulations/x1xhlol` to use the bundled fixture data.
+
+To populate your local emulation cache:
+- `npm run emulation:init`
+
+### Usage
+- `/emulation list` to see available profiles
+- `/emulation set <id>` to activate
+- `/emulation show` to see the current profile
+
+### Notes
+- The emulation layer currently wires the **system prompt** into the agent.
+- Tool schemas are loaded and stored for future use, but not yet mapped to runtime tools.

package/src/emulation/catalog.ts

@@ -0,0 +1,82 @@
+import { readFileSync, existsSync } from 'fs';
+import { resolve, join } from 'path';
+import { fileURLToPath } from 'url';
+import { homedir } from 'os';
+import { EmulationProfile } from './types.js';
+
+interface EmulationSource {
+  id: string;
+  name: string;
+  description: string;
+  promptPath: string;
+  toolsPath?: string;
+}
+
+const sources: EmulationSource[] = [
+  {
+    id: 'claude-code',
+    name: 'Claude Code',
+    description: 'Anthropic Claude Code CLI emulation',
+    promptPath: 'Anthropic/Claude Code/Prompt.txt',
+    toolsPath: 'Anthropic/Claude Code/Tools.json'
+  },
+  {
+    id: 'codex-cli-system',
+    name: 'Codex CLI (System Prompt 2025-08-20)',
+    description: 'OpenAI Codex CLI system prompt emulation',
+    promptPath: 'Open Source prompts/Codex CLI/openai-codex-cli-system-prompt-20250820.txt'
+  },
+  {
+    id: 'codex-cli',
+    name: 'Codex CLI (Prompt)',
+    description: 'OpenAI Codex CLI prompt emulation',
+    promptPath: 'Open Source prompts/Codex CLI/Prompt.txt'
+  }
+];
+
+function resolveBaseDir(): string {
+  const override = process.env.ZTC_EMULATION_DIR;
+  if (override && override.trim().length > 0) {
+    return resolve(override);
+  }
+  const candidates = [
+    join(homedir(), '.ztc', 'emulations', 'x1xhlol'),
+    resolve(process.cwd(), 'emulations/x1xhlol'),
+    resolve(process.cwd(), 'ztc/emulations/x1xhlol'),
+    resolve(fileURLToPath(new URL('../../emulations/x1xhlol', import.meta.url)))
+  ];
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  return candidates[0];
+}
+
+export function loadEmulationProfiles(): EmulationProfile[] {
+  const baseDir = resolveBaseDir();
+
+  return sources.flatMap(source => {
+    const promptFile = resolve(baseDir, source.promptPath);
+    if (!existsSync(promptFile)) {
+      return [];
+    }
+    const prompt = readFileSync(promptFile, 'utf-8');
+    const toolsFile = source.toolsPath ? resolve(baseDir, source.toolsPath) : undefined;
+    const tools = toolsFile && existsSync(toolsFile)
+      ? JSON.parse(readFileSync(toolsFile, 'utf-8'))
+      : undefined;
+
+    return [{
+      id: source.id,
+      name: source.name,
+      description: source.description,
+      systemPrompt: prompt,
+      tools
+    }];
+  });
+}
+
+export function getEmulationProfile(id: string): EmulationProfile | undefined {
+  return loadEmulationProfiles().find(profile => profile.id === id);
+}

package/src/emulation/trace_style.ts

@@ -0,0 +1,8 @@
+export type TraceStyle = 'claude_code' | 'codex' | 'plain';
+
+export function getTraceStyle(emulationId?: string): TraceStyle {
+  if (!emulationId) return 'plain';
+  if (emulationId === 'claude-code') return 'claude_code';
+  if (emulationId.startsWith('codex')) return 'codex';
+  return 'plain';
+}

package/src/emulation/types.ts

@@ -0,0 +1,7 @@
+export interface EmulationProfile {
+  id: string;
+  name: string;
+  description: string;
+  systemPrompt: string;
+  tools?: Record<string, unknown>;
+}

package/src/skills/index.ts

@@ -0,0 +1,36 @@
+import { Skill } from './types.js';
+
+export function buildSkillPrompt(skills: Skill[]): string {
+  if (skills.length === 0) return '';
+  const blocks = skills.map(skill => {
+    const header = `Skill: ${skill.name}`;
+    const description = skill.description ? `Description: ${skill.description}` : '';
+    const instructions = skill.instructions.trim();
+    return [header, description, instructions].filter(Boolean).join('\n');
+  });
+  return ['# Skills', ...blocks].join('\n\n');
+}
+
+export function autoActivateSkills(message: string, skills: Skill[]): Skill[] {
+  const haystack = message.toLowerCase();
+  return skills.filter(skill => {
+    const name = skill.name.toLowerCase();
+    const id = skill.id.toLowerCase();
+    if (haystack.includes(name) || haystack.includes(id)) return true;
+    if (skill.keywords) {
+      return skill.keywords.some(keyword => haystack.includes(keyword.toLowerCase()));
+    }
+    return false;
+  });
+}
+
+export function formatSkillList(skills: Skill[]): string {
+  if (skills.length === 0) return 'No skills found.';
+  const lines = skills
+    .sort((a, b) => a.name.localeCompare(b.name))
+    .map(skill => {
+      const source = skill.sourceRoot.includes('.claude') ? 'claude' : 'ztc';
+      return `  ${skill.id} - ${skill.name}${skill.description ? `: ${skill.description}` : ''} (${source})`;
+    });
+  return ['Available skills:', ...lines].join('\n');
+}

package/src/skills/loader.ts

@@ -0,0 +1,135 @@
+import { homedir } from 'os';
+import { join, resolve, basename } from 'path';
+import { readdir, readFile, stat } from 'fs/promises';
+
+import { Skill } from './types.js';
+
+const MAX_DEPTH = 4;
+
+function defaultRoots(): string[] {
+  const home = homedir();
+  return [
+    join(home, '.ztc', 'skills'),
+    join(home, '.claude', 'skills'),
+    join(process.cwd(), '.ztc', 'skills'),
+    join(process.cwd(), '.claude', 'skills')
+  ];
+}
+
+async function walk(dir: string, depth = 0): Promise<string[]> {
+  if (depth > MAX_DEPTH) return [];
+  try {
+    const entries = await readdir(dir, { withFileTypes: true });
+    const results: string[] = [];
+    for (const entry of entries) {
+      if (entry.name.startsWith('.')) continue;
+      const full = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        results.push(...await walk(full, depth + 1));
+      } else if (entry.isFile() && entry.name.toLowerCase() === 'skill.md') {
+        results.push(full);
+      }
+    }
+    return results;
+  } catch {
+    return [];
+  }
+}
+
+function parseFrontmatter(content: string): { meta: Record<string, unknown>; body: string } {
+  if (!content.startsWith('---')) {
+    return { meta: {}, body: content };
+  }
+  const end = content.indexOf('\n---', 3);
+  if (end === -1) return { meta: {}, body: content };
+
+  const metaBlock = content.slice(3, end).trim();
+  const body = content.slice(end + 4).trim();
+  const meta: Record<string, unknown> = {};
+  let currentKey: string | null = null;
+
+  for (const line of metaBlock.split('\n')) {
+    if (!line.trim()) continue;
+    if (line.startsWith('  -') || line.startsWith('- ')) {
+      if (!currentKey) continue;
+      const value = line.replace(/^(\s*-)\s*/, '').trim();
+      const list = Array.isArray(meta[currentKey]) ? meta[currentKey] as string[] : [];
+      list.push(value);
+      meta[currentKey] = list;
+      continue;
+    }
+    const idx = line.indexOf(':');
+    if (idx === -1) continue;
+    const key = line.slice(0, idx).trim();
+    let value = line.slice(idx + 1).trim();
+    if (value.startsWith('[') && value.endsWith(']')) {
+      value = value.slice(1, -1);
+      meta[key] = value.split(',').map(item => item.trim()).filter(Boolean);
+    } else if (value) {
+      meta[key] = value;
+    } else {
+      meta[key] = [];
+      currentKey = key;
+      continue;
+    }
+    currentKey = key;
+  }
+
+  return { meta, body };
+}
+
+function normalizeList(value?: unknown): string[] | undefined {
+  if (!value) return undefined;
+  if (Array.isArray(value)) {
+    return value.map(item => String(item)).filter(Boolean);
+  }
+  if (typeof value === 'string') {
+    return value.split(',').map(item => item.trim()).filter(Boolean);
+  }
+  return undefined;
+}
+
+function deriveSkillId(path: string, meta: Record<string, unknown>): string {
+  const explicit = meta.id ? String(meta.id) : '';
+  if (explicit) return explicit;
+  const name = meta.name ? String(meta.name) : '';
+  if (name) return name.toLowerCase().replace(/\s+/g, '-');
+  return basename(resolve(path, '..')) || 'skill';
+}
+
+export async function loadSkills(roots: string[] = defaultRoots()): Promise<Skill[]> {
+  const files = new Set<string>();
+  for (const root of roots) {
+    const paths = await walk(root);
+    for (const path of paths) files.add(path);
+  }
+
+  const skills: Skill[] = [];
+  for (const filePath of files) {
+    try {
+      const content = await readFile(filePath, 'utf-8');
+      const { meta, body } = parseFrontmatter(content);
+      const id = deriveSkillId(filePath, meta);
+      const name = meta.name ? String(meta.name) : id;
+      const description = meta.description ? String(meta.description) : undefined;
+      const allowedTools = normalizeList(meta['allowed-tools'] || meta.allowed_tools || meta.allowedTools);
+      const keywords = normalizeList(meta.keywords);
+      const root = roots.find(r => filePath.startsWith(resolve(r))) || resolve(filePath, '..');
+      await stat(filePath);
+      skills.push({
+        id,
+        name,
+        description,
+        instructions: body.trim(),
+        allowedTools,
+        keywords,
+        sourcePath: filePath,
+        sourceRoot: root
+      });
+    } catch {
+      // skip unreadable skills
+    }
+  }
+
+  return skills;
+}

package/src/skills/registry.ts

@@ -0,0 +1,6 @@
+import { loadSkills } from './loader.js';
+import { Skill } from './types.js';
+
+export async function getSkillRegistry(): Promise<Skill[]> {
+  return loadSkills();
+}

package/src/skills/types.ts

@@ -0,0 +1,10 @@
+export interface Skill {
+  id: string;
+  name: string;
+  description?: string;
+  instructions: string;
+  allowedTools?: string[];
+  keywords?: string[];
+  sourcePath: string;
+  sourceRoot: string;
+}

package/src/types.ts

@@ -0,0 +1,83 @@
+// ==========================================
+// ZTC Type Definitions
+// ==========================================
+
+export type MessageRole = 'user' | 'assistant' | 'tool' | 'system';
+
+export type ToolStatus = 'pending' | 'running' | 'complete' | 'error';
+
+export type AgentStatus = 'idle' | 'thinking' | 'tool_use' | 'streaming' | 'error';
+
+export interface ToolCall {
+  id: string;
+  name: string;
+  args: Record<string, unknown>;
+  status: ToolStatus;
+  result?: string;
+  error?: string;
+  startedAt?: Date;
+  completedAt?: Date;
+}
+
+export interface Message {
+  id: string;
+  role: MessageRole;
+  content: string;
+  timestamp: Date;
+  toolCalls?: ToolCall[];
+  isStreaming?: boolean;
+  metadata?: Record<string, unknown>;
+}
+
+export interface AgentState {
+  status: AgentStatus;
+  currentTool?: string;
+  tokensUsed?: number;
+  contextTokens?: number;
+  tokensEstimated?: boolean;
+  authError?: boolean;
+  error?: string;
+  startedAt?: Date;
+}
+
+export interface Session {
+  id: string;
+  createdAt: Date;
+  messages: Message[];
+  metadata?: Record<string, unknown>;
+}
+
+export interface ZTCConfig {
+  zergEndpoint?: string;
+  maxTokens?: number;
+  timeout?: number;
+  tools?: string[];
+}
+
+// Tool definition for the agent
+export interface ToolDefinition {
+  name: string;
+  description: string;
+  parameters: {
+    type: 'object';
+    properties: Record<string, {
+      type: string;
+      description: string;
+      enum?: string[];
+    }>;
+    required?: string[];
+  };
+}
+
+// Events emitted during agent execution
+export type AgentEvent = 
+  | { type: 'thinking_start' }
+  | { type: 'thinking_end' }
+  | { type: 'tool_start'; tool: string; args: Record<string, unknown> }
+  | { type: 'tool_end'; tool: string; result: string }
+  | { type: 'tool_error'; tool: string; error: string }
+  | { type: 'stream_start' }
+  | { type: 'stream_delta'; content: string }
+  | { type: 'stream_end' }
+  | { type: 'token_usage'; usage: { inputTokens: number; outputTokens: number; totalTokens: number; estimated?: boolean } }
+  | { type: 'error'; error: string };

package/src/ui/README.md

@@ -0,0 +1,44 @@
+## UI Architecture (Renderer-Agnostic)
+
+This directory defines a shared, renderer-agnostic UI tree for ZTC and thin adapters for Ink (CLI), Web (React DOM), and Vue.
+
+### Goals
+- Single source of truth for layout and UI structure.
+- Pixel-aligned monospace rendering in the browser.
+- Optional Yoga integration for layout parity with Ink.
+
+### Structure
+- `core/`: layout tree types + helpers
+- `ink/`: Ink renderer adapter
+- `web/`: React DOM renderer adapter
+- `vue/`: Vue adapter (no Vue dependency; pass `h()` from your app)
+
+### Core Tree
+The UI is expressed as a `LayoutNode` tree:
+- `box` nodes with flex and spacing styles
+- `text` nodes with basic text styles
+
+This keeps the model portable across Ink/DOM/Vue.
+
+### Renderers
+- **Ink** uses `Box`/`Text` directly.
+- **Web** renders to `div`/`span` with strict monospace styles to match terminal layout.
+- **Vue** uses a tiny helper `renderToVue(h, node)` that returns VNodes.
+
+### Nuxt/Vue Integration
+Because `vue/` does not import Vue directly, you can pass Nuxt's `h`:
+
+```ts
+import { renderToVue } from '~/ui/vue';
+
+export default {
+  render() {
+    return renderToVue(this.$createElement, nodeTree);
+  }
+};
+```
+
+### Next Steps
+- Add Yoga-backed layout engine in `core/` for exact Ink parity.
+- Move existing Ink UI components to build `LayoutNode` trees.
+- Create a web mirror route that renders the same tree for debugging.

package/src/ui/core/factory.ts

@@ -0,0 +1,9 @@
+import { BoxNode, LayoutNode, TextNode } from './types.js';
+
+export function box(children: LayoutNode[] = [], style?: BoxNode['style']): BoxNode {
+  return { type: 'box', children, style };
+}
+
+export function text(content: string, style?: TextNode['style']): TextNode {
+  return { type: 'text', text: content, style };
+}

package/src/ui/core/index.ts

@@ -0,0 +1,4 @@
+export type { LayoutNode, BoxNode, TextNode, Style, TextStyle } from './types.js';
+export { box, text } from './factory.js';
+export { toCssStyle } from './style.js';
+export { computeLayout, type LayoutFrame } from './layout_yoga.js';

package/src/ui/core/input.ts

@@ -0,0 +1,38 @@
+export interface InputKey {
+  return?: boolean;
+  shift?: boolean;
+  upArrow?: boolean;
+  downArrow?: boolean;
+  leftArrow?: boolean;
+  rightArrow?: boolean;
+  ctrl?: boolean;
+  meta?: boolean;
+  backspace?: boolean;
+  delete?: boolean;
+}
+
+export interface InputEvent {
+  input: string;
+  key: InputKey;
+}
+
+export interface InputBus {
+  subscribe(handler: (event: InputEvent) => void): () => void;
+  emit(event: InputEvent): void;
+}
+
+export function createInputBus(): InputBus {
+  const handlers = new Set<(event: InputEvent) => void>();
+
+  return {
+    subscribe(handler) {
+      handlers.add(handler);
+      return () => handlers.delete(handler);
+    },
+    emit(event) {
+      for (const handler of handlers) {
+        handler(event);
+      }
+    }
+  };
+}