zerg-ztc 0.1.10 → 0.1.12

package/src/skills/loader.ts

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

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

package/src/skills/types.ts

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

package/src/types.ts

@@ -1,84 +0,0 @@
-// ==========================================
-// 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 type InputMode = 'queue' | 'interrupt';
-
-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

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

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

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

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