@sooneocean/agw 1.4.0

package/src/dsl/parser.ts

@@ -0,0 +1,124 @@
+/**
+ * AGW DSL — a simple domain-specific language for agent orchestration.
+ *
+ * Syntax:
+ *   claude: "analyze {{input}}"
+ *   | codex: "implement {{prev}}"
+ *   | claude: "review {{prev}}"
+ *
+ *   [claude: "perspective A {{input}}", codex: "perspective B {{input}}"]
+ *   | claude: "synthesize {{all}}"
+ *
+ *   {codex: "implement {{input}}", claude: "review {{prev}}"} x3
+ *
+ * Operators:
+ *   |  = pipeline (sequential, output flows)
+ *   [] = parallel (map phase)
+ *   {} = review loop
+ *   xN = max iterations for review loop
+ */
+
+export interface DslStep {
+  agent: string;
+  prompt: string;
+}
+
+export interface DslProgram {
+  pattern: 'pipeline' | 'map-reduce' | 'review-loop';
+  steps: DslStep[];
+  maxIterations?: number;
+}
+
+export function parseDsl(source: string): DslProgram {
+  const trimmed = source.trim();
+
+  // Review loop: {agent1: "...", agent2: "..."} xN
+  const loopMatch = trimmed.match(/^\{(.+)\}\s*(?:x(\d+))?$/s);
+  if (loopMatch) {
+    const steps = parseStepList(loopMatch[1]);
+    if (steps.length < 2) throw new Error('Review loop requires at least 2 steps');
+    return {
+      pattern: 'review-loop',
+      steps,
+      maxIterations: loopMatch[2] ? parseInt(loopMatch[2], 10) : 3,
+    };
+  }
+
+  // Check for parallel blocks: [...] | agent: "..."
+  if (trimmed.includes('[') && trimmed.includes(']')) {
+    const parts = splitPipeline(trimmed);
+    const steps: DslStep[] = [];
+
+    for (const part of parts) {
+      const p = part.trim();
+      if (p.startsWith('[') && p.endsWith(']')) {
+        const inner = p.slice(1, -1);
+        steps.push(...parseStepList(inner));
+      } else {
+        steps.push(parseStep(p));
+      }
+    }
+
+    return { pattern: 'map-reduce', steps };
+  }
+
+  // Pipeline: agent1: "..." | agent2: "..."
+  if (trimmed.includes('|')) {
+    const parts = splitPipeline(trimmed);
+    const steps = parts.map(p => parseStep(p.trim()));
+    return { pattern: 'pipeline', steps };
+  }
+
+  // Single step
+  return { pattern: 'pipeline', steps: [parseStep(trimmed)] };
+}
+
+function parseStep(text: string): DslStep {
+  const match = text.match(/^(\w+)\s*:\s*"(.+)"$/s);
+  if (!match) throw new Error(`Invalid step syntax: ${text.slice(0, 50)}`);
+  return { agent: match[1], prompt: match[2] };
+}
+
+function parseStepList(text: string): DslStep[] {
+  // Split by comma, but respect quoted strings
+  const steps: DslStep[] = [];
+  let current = '';
+  let inQuote = false;
+
+  for (const char of text) {
+    if (char === '"') inQuote = !inQuote;
+    if (char === ',' && !inQuote) {
+      if (current.trim()) steps.push(parseStep(current.trim()));
+      current = '';
+    } else {
+      current += char;
+    }
+  }
+  if (current.trim()) steps.push(parseStep(current.trim()));
+
+  return steps;
+}
+
+function splitPipeline(text: string): string[] {
+  const parts: string[] = [];
+  let current = '';
+  let depth = 0;
+  let inQuote = false;
+
+  for (const char of text) {
+    if (char === '"') inQuote = !inQuote;
+    if (!inQuote) {
+      if (char === '[') depth++;
+      if (char === ']') depth--;
+      if (char === '|' && depth === 0) {
+        parts.push(current);
+        current = '';
+        continue;
+      }
+    }
+    current += char;
+  }
+  if (current.trim()) parts.push(current);
+
+  return parts;
+}

package/src/plugins/plugin-loader.ts

@@ -0,0 +1,72 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+
+export interface AgentPlugin {
+  type: 'agent';
+  id: string;
+  name: string;
+  command: string;
+  args: string[];
+  healthCheckCommand: string;
+  useStdin?: boolean;
+  strengths?: string[];  // keywords for routing
+}
+
+export interface ComboPlugin {
+  type: 'combo';
+  id: string;
+  name: string;
+  description: string;
+  pattern: 'pipeline' | 'map-reduce' | 'review-loop' | 'debate';
+  steps: { agent: string; prompt: string; role?: string }[];
+  maxIterations?: number;
+}
+
+export interface RouterPlugin {
+  type: 'router';
+  id: string;
+  name: string;
+  keywords: Record<string, string[]>; // agentId → keywords
+}
+
+export type Plugin = AgentPlugin | ComboPlugin | RouterPlugin;
+
+export interface PluginManifest {
+  plugins: Plugin[];
+}
+
+const PLUGIN_DIR = path.join(os.homedir(), '.agw', 'plugins');
+
+export function loadPlugins(): Plugin[] {
+  const plugins: Plugin[] = [];
+
+  if (!fs.existsSync(PLUGIN_DIR)) return plugins;
+
+  const files = fs.readdirSync(PLUGIN_DIR).filter(f => f.endsWith('.json'));
+  for (const file of files) {
+    try {
+      const raw = fs.readFileSync(path.join(PLUGIN_DIR, file), 'utf-8');
+      const manifest = JSON.parse(raw) as PluginManifest;
+      if (Array.isArray(manifest.plugins)) {
+        plugins.push(...manifest.plugins);
+      }
+    } catch {
+      // Skip malformed plugin files
+    }
+  }
+
+  return plugins;
+}
+
+export function getAgentPlugins(plugins: Plugin[]): AgentPlugin[] {
+  return plugins.filter((p): p is AgentPlugin => p.type === 'agent');
+}
+
+export function getComboPlugins(plugins: Plugin[]): ComboPlugin[] {
+  return plugins.filter((p): p is ComboPlugin => p.type === 'combo');
+}
+
+export function getRouterPlugins(plugins: Plugin[]): RouterPlugin[] {
+  return plugins.filter((p): p is RouterPlugin => p.type === 'router');
+}

package/src/router/keyword-router.ts

@@ -0,0 +1,63 @@
+import type { RouteDecision } from '../types.js';
+
+interface KeywordRule {
+  patterns: RegExp[];
+  agentId: string;
+}
+
+const RULES: KeywordRule[] = [
+  {
+    agentId: 'claude',
+    patterns: [
+      /重構|refactor/i,
+      /架構|architect/i,
+      /review|審查|code review/i,
+      /分析|analy[sz]/i,
+      /explain|解釋/i,
+      /complex|複雜/i,
+    ],
+  },
+  {
+    agentId: 'codex',
+    patterns: [
+      /rename|重命名/i,
+      /file|檔案/i,
+      /script|腳本/i,
+      /run|執行|bash|shell/i,
+      /quick|快速/i,
+      /install|安裝/i,
+    ],
+  },
+  {
+    agentId: 'gemini',
+    patterns: [
+      /research|研究/i,
+      /search|搜尋/i,
+      /summarize|摘要/i,
+      /compare|比較/i,
+      /explore|探索/i,
+    ],
+  },
+];
+
+export function keywordRoute(prompt: string, availableAgentIds: string[]): RouteDecision {
+  for (const rule of RULES) {
+    if (!availableAgentIds.includes(rule.agentId)) continue;
+    if (rule.patterns.some(p => p.test(prompt))) {
+      return {
+        agentId: rule.agentId,
+        reason: `Keyword match for ${rule.agentId}`,
+        confidence: 0.3,
+      };
+    }
+  }
+
+  // Default: pick first available, prefer claude
+  const preferred = ['claude', 'codex', 'gemini'];
+  const fallback = preferred.find(id => availableAgentIds.includes(id)) ?? availableAgentIds[0];
+  return {
+    agentId: fallback,
+    reason: 'No keyword match, using default agent',
+    confidence: 0.3,
+  };
+}

package/src/router/llm-router.ts

@@ -0,0 +1,93 @@
+import type { AgentDescriptor, RouteDecision } from '../types.js';
+import { keywordRoute } from './keyword-router.js';
+
+type CreateMessageFn = (params: {
+  model: string;
+  max_tokens: number;
+  system: string;
+  messages: Array<{ role: string; content: string }>;
+}) => Promise<{ content: Array<{ type: string; text: string }> }>;
+
+const AGENT_DESCRIPTIONS: Record<string, string> = {
+  claude: 'Large codebase understanding, structural refactoring, complex reasoning, long context',
+  codex: 'Local terminal-intensive development, fast iteration, file operations',
+  gemini: 'Open-ended research, multimodal understanding, broad tool integration',
+};
+
+export class LlmRouter {
+  constructor(
+    private apiKey: string,
+    private model: string,
+    private createMessage?: CreateMessageFn,
+  ) {}
+
+  async route(
+    prompt: string,
+    availableAgents: AgentDescriptor[],
+    preferredAgent?: string,
+  ): Promise<RouteDecision> {
+    // Override: skip LLM entirely
+    if (preferredAgent && availableAgents.some(a => a.id === preferredAgent)) {
+      return { agentId: preferredAgent, reason: 'User override', confidence: 1.0 };
+    }
+
+    const agentIds = availableAgents.map(a => a.id);
+
+    try {
+      return await this.callLlm(prompt, availableAgents, agentIds);
+    } catch {
+      return keywordRoute(prompt, agentIds);
+    }
+  }
+
+  private async callLlm(
+    prompt: string,
+    availableAgents: AgentDescriptor[],
+    agentIds: string[],
+  ): Promise<RouteDecision> {
+    const agentList = availableAgents
+      .map(a => `- ${a.id}: ${AGENT_DESCRIPTIONS[a.id] ?? 'General purpose agent'}`)
+      .join('\n');
+
+    const systemPrompt = `You are a task router. Given a task description, select the best agent from the available list.
+
+Available agents:
+${agentList}
+
+Return ONLY valid JSON: { "agentId": "...", "reason": "...", "confidence": 0.0-1.0 }`;
+
+    const createFn = this.createMessage ?? this.getDefaultCreateFn();
+
+    const response = await createFn({
+      model: this.model,
+      max_tokens: 200,
+      system: systemPrompt,
+      messages: [{ role: 'user', content: prompt }],
+    });
+
+    const text = response.content[0]?.text ?? '';
+    const jsonMatch = text.match(/\{[\s\S]*\}/);
+    if (!jsonMatch) {
+      throw new Error('No JSON in LLM response');
+    }
+
+    const parsed = JSON.parse(jsonMatch[0]) as RouteDecision;
+
+    // Post-validation
+    if (!agentIds.includes(parsed.agentId)) {
+      return keywordRoute(prompt, agentIds);
+    }
+
+    return parsed;
+  }
+
+  private getDefaultCreateFn(): CreateMessageFn {
+    // Lazy import to avoid requiring the SDK at test time
+    return async (params) => {
+      const { default: Anthropic } = await import('@anthropic-ai/sdk');
+      const client = new Anthropic({ apiKey: this.apiKey });
+      const response = await client.messages.create(params as Parameters<typeof client.messages.create>[0]);
+      return response as unknown as { content: Array<{ type: string; text: string }> };
+    };
+  }
+}

package/src/store/agent-repo.ts

@@ -0,0 +1,57 @@
+import type Database from 'better-sqlite3';
+import type { AgentDescriptor } from '../types.js';
+
+interface AgentRow {
+  id: string;
+  name: string;
+  command: string;
+  args: string;
+  health_check_command: string;
+  enabled: number;
+  available: number;
+  last_health_check: string | null;
+}
+
+function rowToAgent(row: AgentRow): AgentDescriptor {
+  return {
+    id: row.id,
+    name: row.name,
+    command: row.command,
+    args: JSON.parse(row.args),
+    healthCheckCommand: row.health_check_command,
+    enabled: row.enabled === 1,
+    available: row.available === 1,
+    lastHealthCheck: row.last_health_check ?? undefined,
+  };
+}
+
+export class AgentRepo {
+  constructor(private db: Database.Database) {}
+
+  listAll(): AgentDescriptor[] {
+    const rows = this.db.prepare('SELECT * FROM agents ORDER BY id').all() as AgentRow[];
+    return rows.map(rowToAgent);
+  }
+
+  listAvailable(): AgentDescriptor[] {
+    const rows = this.db.prepare(
+      'SELECT * FROM agents WHERE enabled = 1 AND available = 1 ORDER BY id'
+    ).all() as AgentRow[];
+    return rows.map(rowToAgent);
+  }
+
+  getById(id: string): AgentDescriptor | undefined {
+    const row = this.db.prepare('SELECT * FROM agents WHERE id = ?').get(id) as AgentRow | undefined;
+    return row ? rowToAgent(row) : undefined;
+  }
+
+  setAvailability(id: string, available: boolean): void {
+    this.db.prepare(
+      'UPDATE agents SET available = ?, last_health_check = ? WHERE id = ?'
+    ).run(available ? 1 : 0, new Date().toISOString(), id);
+  }
+
+  setEnabled(id: string, enabled: boolean): void {
+    this.db.prepare('UPDATE agents SET enabled = ? WHERE id = ?').run(enabled ? 1 : 0, id);
+  }
+}

package/src/store/audit-repo.ts

@@ -0,0 +1,25 @@
+import type Database from 'better-sqlite3';
+import type { AuditEventType, AuditEntry } from '../types.js';
+
+export class AuditRepo {
+  constructor(private db: Database.Database) {}
+
+  log(taskId: string | null, eventType: AuditEventType, payload: Record<string, unknown>): void {
+    this.db.prepare(
+      'INSERT INTO audit_log (task_id, event_type, payload, created_at) VALUES (?, ?, ?, ?)'
+    ).run(taskId, eventType, JSON.stringify(payload), new Date().toISOString());
+  }
+
+  getByTaskId(taskId: string): AuditEntry[] {
+    const rows = this.db.prepare(
+      'SELECT * FROM audit_log WHERE task_id = ? ORDER BY id ASC'
+    ).all(taskId) as Array<{ id: number; task_id: string; event_type: string; payload: string; created_at: string }>;
+    return rows.map(r => ({
+      id: r.id,
+      taskId: r.task_id,
+      eventType: r.event_type as AuditEventType,
+      payload: JSON.parse(r.payload),
+      createdAt: r.created_at,
+    }));
+  }
+}

package/src/store/combo-repo.ts

@@ -0,0 +1,99 @@
+import type Database from 'better-sqlite3';
+import type { ComboDescriptor, ComboStatus, ComboStep, ComboPattern } from '../types.js';
+
+interface ComboRow {
+  combo_id: string;
+  name: string;
+  pattern: string;
+  steps: string;
+  input: string;
+  status: string;
+  task_ids: string;
+  step_results: string;
+  final_output: string | null;
+  max_iterations: number;
+  iterations: number;
+  working_directory: string | null;
+  priority: number;
+  created_at: string;
+  completed_at: string | null;
+}
+
+function rowToCombo(row: ComboRow): ComboDescriptor {
+  return {
+    comboId: row.combo_id,
+    name: row.name,
+    pattern: row.pattern as ComboPattern,
+    steps: JSON.parse(row.steps) as ComboStep[],
+    input: row.input,
+    status: row.status as ComboStatus,
+    taskIds: JSON.parse(row.task_ids) as string[],
+    stepResults: JSON.parse(row.step_results) as Record<number, string>,
+    finalOutput: row.final_output ?? undefined,
+    maxIterations: row.max_iterations,
+    iterations: row.iterations,
+    createdAt: row.created_at,
+    completedAt: row.completed_at ?? undefined,
+  };
+}
+
+export class ComboRepo {
+  constructor(private db: Database.Database) {}
+
+  create(combo: {
+    comboId: string;
+    name: string;
+    pattern: ComboPattern;
+    steps: ComboStep[];
+    input: string;
+    status: ComboStatus;
+    maxIterations?: number;
+    workingDirectory?: string;
+    priority?: number;
+    createdAt: string;
+  }): void {
+    this.db.prepare(
+      `INSERT INTO combos (combo_id, name, pattern, steps, input, status, max_iterations, working_directory, priority, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(combo.comboId, combo.name, combo.pattern, JSON.stringify(combo.steps),
+      combo.input, combo.status, combo.maxIterations ?? 3,
+      combo.workingDirectory ?? null, combo.priority ?? 3, combo.createdAt);
+  }
+
+  getById(comboId: string): ComboDescriptor | undefined {
+    const row = this.db.prepare('SELECT * FROM combos WHERE combo_id = ?').get(comboId) as ComboRow | undefined;
+    return row ? rowToCombo(row) : undefined;
+  }
+
+  updateStatus(comboId: string, status: ComboStatus): void {
+    const completedAt = status === 'completed' || status === 'failed' ? new Date().toISOString() : null;
+    this.db.prepare('UPDATE combos SET status = ?, completed_at = ? WHERE combo_id = ?').run(status, completedAt, comboId);
+  }
+
+  addTaskId(comboId: string, taskId: string): void {
+    this.db.prepare(
+      `UPDATE combos SET task_ids = json_insert(task_ids, '$[#]', ?) WHERE combo_id = ?`
+    ).run(taskId, comboId);
+  }
+
+  setStepResult(comboId: string, stepIndex: number, output: string): void {
+    this.db.prepare(
+      `UPDATE combos SET step_results = json_set(step_results, '$.' || ?, ?) WHERE combo_id = ?`
+    ).run(String(stepIndex), output, comboId);
+  }
+
+  setFinalOutput(comboId: string, output: string): void {
+    this.db.prepare('UPDATE combos SET final_output = ? WHERE combo_id = ?').run(output, comboId);
+  }
+
+  incrementIterations(comboId: string): void {
+    this.db.prepare('UPDATE combos SET iterations = iterations + 1 WHERE combo_id = ?').run(comboId);
+  }
+
+  list(limit: number = 20, offset: number = 0): ComboDescriptor[] {
+    const rows = this.db.prepare(
+      'SELECT * FROM combos ORDER BY created_at DESC LIMIT ? OFFSET ?'
+    ).all(limit, offset) as ComboRow[];
+    return rows.map(rowToCombo);
+  }
+}

package/src/store/cost-repo.ts

@@ -0,0 +1,55 @@
+import type Database from 'better-sqlite3';
+import type { CostSummary } from '../types.js';
+
+export class CostRepo {
+  constructor(private db: Database.Database) {}
+
+  record(taskId: string, agentId: string, cost: number, tokens: number): void {
+    this.db.prepare(
+      `INSERT INTO cost_records (task_id, agent_id, cost, tokens, recorded_at) VALUES (?, ?, ?, ?, ?)`
+    ).run(taskId, agentId, cost, tokens, new Date().toISOString());
+  }
+
+  getDailyCost(): number {
+    const today = new Date().toISOString().slice(0, 10);
+    const row = this.db.prepare(
+      `SELECT COALESCE(SUM(cost), 0) as total FROM cost_records WHERE recorded_at >= ?`
+    ).get(`${today}T00:00:00.000Z`) as { total: number };
+    return row.total;
+  }
+
+  getMonthlyCost(): number {
+    const monthStart = new Date().toISOString().slice(0, 7) + '-01';
+    const row = this.db.prepare(
+      `SELECT COALESCE(SUM(cost), 0) as total FROM cost_records WHERE recorded_at >= ?`
+    ).get(`${monthStart}T00:00:00.000Z`) as { total: number };
+    return row.total;
+  }
+
+  getAllTimeCost(): number {
+    const row = this.db.prepare(
+      `SELECT COALESCE(SUM(cost), 0) as total FROM cost_records`
+    ).get() as { total: number };
+    return row.total;
+  }
+
+  getCostByAgent(): Record<string, number> {
+    const rows = this.db.prepare(
+      `SELECT agent_id, COALESCE(SUM(cost), 0) as total FROM cost_records GROUP BY agent_id`
+    ).all() as { agent_id: string; total: number }[];
+    const result: Record<string, number> = {};
+    for (const row of rows) result[row.agent_id] = row.total;
+    return result;
+  }
+
+  getSummary(dailyLimit?: number, monthlyLimit?: number): CostSummary {
+    return {
+      daily: this.getDailyCost(),
+      monthly: this.getMonthlyCost(),
+      allTime: this.getAllTimeCost(),
+      byAgent: this.getCostByAgent(),
+      dailyLimit,
+      monthlyLimit,
+    };
+  }
+}