@sooneocean/agw 1.6.0 → 1.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sooneocean/agw",
-  "version": "1.6.0",
+  "version": "1.7.0",
   "description": "Agent Gateway — multi-agent task router for Claude, Codex, Gemini with combos, DAG, DSL",
   "type": "module",
   "bin": {

package/src/cli/commands/dashboard.ts

@@ -0,0 +1,67 @@
+import type { Command } from 'commander';
+import { HttpClient } from '../http-client.js';
+
+export function registerDashboardCommand(program: Command): void {
+  program
+    .command('dashboard')
+    .alias('dash')
+    .description('Live terminal dashboard — refresh every 3 seconds')
+    .option('--once', 'Print once and exit')
+    .action(async (options: { once?: boolean }) => {
+      const client = new HttpClient();
+
+      const render = async () => {
+        try {
+          const [metrics, agents, costs] = await Promise.all([
+            client.get<any>('/metrics').catch(() => null),
+            client.get<any[]>('/agents').catch(() => []),
+            client.get<any>('/costs').catch(() => null),
+          ]);
+
+          console.clear();
+          console.log('\x1b[36m╔══════════════════════════════════════════════╗\x1b[0m');
+          console.log('\x1b[36m║\x1b[0m        \x1b[1mAGW Dashboard\x1b[0m                         \x1b[36m║\x1b[0m');
+          console.log('\x1b[36m╚══════════════════════════════════════════════╝\x1b[0m');
+
+          if (metrics) {
+            const up = Math.floor(metrics.uptime / 1000);
+            const h = Math.floor(up / 3600);
+            const m = Math.floor((up % 3600) / 60);
+            const s = up % 60;
+            console.log(`\n  Uptime: ${h}h ${m}m ${s}s    Memory: ${metrics.memory?.heapMB ?? '?'}MB`);
+            console.log(`\n  \x1b[1mTasks\x1b[0m`);
+            console.log(`    Total: ${metrics.tasks.total}  ✓ ${metrics.tasks.completed}  ✗ ${metrics.tasks.failed}  ⟳ ${metrics.tasks.running}  ⏳ ${metrics.tasks.pending ?? 0}`);
+            if (metrics.performance.avgDurationMs > 0) {
+              console.log(`    Avg: ${(metrics.performance.avgDurationMs / 1000).toFixed(1)}s  P95: ${(metrics.performance.p95DurationMs / 1000).toFixed(1)}s`);
+            }
+          } else {
+            console.log('\n  \x1b[31mDaemon not running\x1b[0m');
+          }
+
+          console.log(`\n  \x1b[1mAgents\x1b[0m`);
+          for (const a of agents) {
+            const icon = a.available ? '\x1b[32m●\x1b[0m' : '\x1b[31m●\x1b[0m';
+            console.log(`    ${icon} ${a.name.padEnd(12)} ${a.available ? 'Ready' : 'Down'}`);
+          }
+
+          if (costs) {
+            console.log(`\n  \x1b[1mCosts\x1b[0m`);
+            console.log(`    Daily:  $${costs.daily.toFixed(2)}${costs.dailyLimit ? ` / $${costs.dailyLimit.toFixed(2)}` : ''}`);
+            console.log(`    Monthly: $${costs.monthly.toFixed(2)}${costs.monthlyLimit ? ` / $${costs.monthlyLimit.toFixed(2)}` : ''}`);
+          }
+
+          if (!options.once) {
+            console.log(`\n  \x1b[2mRefreshing every 3s... (Ctrl+C to quit)\x1b[0m`);
+          }
+        } catch {
+          console.log('\x1b[31m  Cannot connect to daemon\x1b[0m');
+        }
+      };
+
+      await render();
+      if (options.once) return;
+
+      const interval = setInterval(render, 3000);
+      process.on('SIGINT', () => { clearInterval(interval); process.exit(0); });
+    });
+}

package/src/cli/index.ts

@@ -7,13 +7,14 @@ import { registerDaemonCommand } from './commands/daemon.js';
 import { registerCostsCommand } from './commands/costs.js';
 import { registerWorkflowCommand } from './commands/workflow.js';
 import { registerComboCommand } from './commands/combo.js';
+import { registerDashboardCommand } from './commands/dashboard.js';
 
 export function createCli(): Command {
   const program = new Command();
   program
     .name('agw')
     .description('Agent Gateway — route tasks to the best AI agent')
-    .version('0.3.0');
+    .version('1.7.0');
 
   registerRunCommand(program);
   registerStatusCommand(program);
@@ -23,6 +24,7 @@ export function createCli(): Command {
   registerCostsCommand(program);
   registerWorkflowCommand(program);
   registerComboCommand(program);
+  registerDashboardCommand(program);
 
   return program;
 }

package/src/daemon/routes/batch.ts

@@ -0,0 +1,45 @@
+import type { FastifyInstance } from 'fastify';
+import type { TaskExecutor } from '../services/task-executor.js';
+import type { LlmRouter } from '../../router/llm-router.js';
+import type { AgentManager } from '../services/agent-manager.js';
+import { BatchExecutor } from '../services/batch.js';
+import type { BatchItem } from '../services/batch.js';
+
+export function registerBatchRoutes(
+  app: FastifyInstance,
+  executor: TaskExecutor,
+  router: LlmRouter,
+  agentManager: AgentManager,
+): void {
+  const batchExecutor = new BatchExecutor();
+
+  app.post<{ Body: { items: BatchItem[]; concurrency?: number } }>('/batch', async (request, reply) => {
+    const { items, concurrency } = request.body;
+    if (!items || !Array.isArray(items) || items.length === 0) {
+      return reply.status(400).send({ error: 'items array is required' });
+    }
+    if (items.length > 50) {
+      return reply.status(400).send({ error: 'Maximum 50 items per batch' });
+    }
+
+    const result = await batchExecutor.execute(
+      items,
+      async (prompt, agent, priority) => {
+        const availableAgents = agentManager.getAvailableAgents();
+        const task = await executor.execute(
+          { prompt, preferredAgent: agent, priority },
+          async (p) => router.route(p, availableAgents, agent),
+        );
+        return {
+          taskId: task.taskId,
+          status: task.status,
+          stdout: task.result?.stdout,
+          error: task.status === 'failed' ? task.result?.stderr : undefined,
+        };
+      },
+      concurrency ?? 5,
+    );
+
+    return reply.status(200).send(result);
+  });
+}

package/src/daemon/routes/capabilities.ts

@@ -0,0 +1,17 @@
+import type { FastifyInstance } from 'fastify';
+import type { CapabilityDiscovery } from '../services/capability-discovery.js';
+
+export function registerCapabilityRoutes(app: FastifyInstance, discovery: CapabilityDiscovery): void {
+  app.get('/capabilities', async () => discovery.getAll());
+
+  app.get<{ Params: { agentId: string } }>('/capabilities/:agentId', async (request, reply) => {
+    const cap = discovery.get(request.params.agentId);
+    if (!cap) return reply.status(404).send({ error: 'Agent not found' });
+    return cap;
+  });
+
+  app.post<{ Body: { prompt: string; availableAgents?: string[] } }>('/capabilities/match', async (request) => {
+    const agents = request.body.availableAgents ?? ['claude', 'codex', 'gemini'];
+    return discovery.findBestMatch(request.body.prompt, agents) ?? { agentId: agents[0], score: 0, reason: 'Fallback' };
+  });
+}

package/src/daemon/routes/snapshots.ts

@@ -0,0 +1,23 @@
+import type { FastifyInstance } from 'fastify';
+import type { SnapshotManager } from '../services/snapshot.js';
+
+export function registerSnapshotRoutes(app: FastifyInstance, snapshotManager: SnapshotManager): void {
+  app.get('/snapshots', async () => snapshotManager.list());
+
+  app.post<{ Body: { label?: string } }>('/snapshots', async (request, reply) => {
+    const info = snapshotManager.create(request.body?.label);
+    return reply.status(201).send(info);
+  });
+
+  app.post<{ Params: { id: string } }>('/snapshots/:id/restore', async (request, reply) => {
+    const ok = snapshotManager.restore(request.params.id);
+    if (!ok) return reply.status(404).send({ error: 'Snapshot not found' });
+    return { restored: true, note: 'Restart daemon to use restored data' };
+  });
+
+  app.delete<{ Params: { id: string } }>('/snapshots/:id', async (request, reply) => {
+    const ok = snapshotManager.delete(request.params.id);
+    if (!ok) return reply.status(404).send({ error: 'Snapshot not found' });
+    return { deleted: true };
+  });
+}

package/src/daemon/server.ts

@@ -35,6 +35,11 @@ import { ReplayManager } from './services/replay.js';
 import { registerSchedulerRoutes } from './routes/scheduler.js';
 import { registerReplayRoutes } from './routes/replay.js';
 import { registerExportImportRoutes } from './routes/export-import.js';
+import { CapabilityDiscovery } from './services/capability-discovery.js';
+import { SnapshotManager } from './services/snapshot.js';
+import { registerCapabilityRoutes } from './routes/capabilities.js';
+import { registerBatchRoutes } from './routes/batch.js';
+import { registerSnapshotRoutes } from './routes/snapshots.js';
 
 interface ServerOptions {
   dbPath?: string;
@@ -72,6 +77,8 @@ export async function buildServer(options: ServerOptions = {}): Promise<FastifyI
   const webhookManager = new WebhookManager();
   const scheduler = new Scheduler();
   const replayManager = new ReplayManager(taskRepo, comboRepo, executor, comboExecutor, router, agentManager);
+  const capDiscovery = new CapabilityDiscovery();
+  const snapshotManager = new SnapshotManager(dbPath);
 
   const app = Fastify({
     logger: false,
@@ -92,6 +99,9 @@ export async function buildServer(options: ServerOptions = {}): Promise<FastifyI
   registerSchedulerRoutes(app, scheduler);
   registerReplayRoutes(app, replayManager);
   registerExportImportRoutes(app, templateEngine, webhookManager, scheduler, memoryRepo);
+  registerCapabilityRoutes(app, capDiscovery);
+  registerBatchRoutes(app, executor, router, agentManager);
+  registerSnapshotRoutes(app, snapshotManager);
 
   app.register(import('./routes/ui.js'));
 

package/src/daemon/services/batch.ts

@@ -0,0 +1,69 @@
+/**
+ * Batch Execution — submit multiple tasks at once, get unified results.
+ */
+
+import { nanoid } from 'nanoid';
+
+export interface BatchItem {
+  prompt: string;
+  agent?: string;
+  priority?: number;
+}
+
+export interface BatchResult {
+  batchId: string;
+  total: number;
+  completed: number;
+  failed: number;
+  results: { index: number; taskId: string; status: string; output?: string; error?: string }[];
+  totalDurationMs: number;
+}
+
+type ExecuteFn = (prompt: string, agent?: string, priority?: number) => Promise<{ taskId: string; status: string; stdout?: string; error?: string }>;
+
+export class BatchExecutor {
+  async execute(items: BatchItem[], executeFn: ExecuteFn, concurrency: number = 5): Promise<BatchResult> {
+    const batchId = nanoid(8);
+    const start = Date.now();
+    const results: BatchResult['results'] = [];
+
+    // Process in chunks for concurrency control
+    for (let i = 0; i < items.length; i += concurrency) {
+      const chunk = items.slice(i, i + concurrency);
+      const chunkResults = await Promise.allSettled(
+        chunk.map(async (item, offset) => {
+          const result = await executeFn(item.prompt, item.agent, item.priority);
+          return {
+            index: i + offset,
+            taskId: result.taskId,
+            status: result.status,
+            output: result.stdout,
+            error: result.error,
+          };
+        })
+      );
+
+      for (const r of chunkResults) {
+        if (r.status === 'fulfilled') {
+          results.push(r.value);
+        } else {
+          results.push({
+            index: results.length,
+            taskId: '',
+            status: 'failed',
+            error: r.reason?.message ?? 'Unknown error',
+          });
+        }
+      }
+    }
+
+    return {
+      batchId,
+      total: items.length,
+      completed: results.filter(r => r.status === 'completed').length,
+      failed: results.filter(r => r.status === 'failed').length,
+      results,
+      totalDurationMs: Date.now() - start,
+    };
+  }
+}

package/src/daemon/services/capability-discovery.ts

@@ -0,0 +1,130 @@
+/**
+ * Capability Discovery — probes agents to determine what they can do.
+ * Each agent is asked to self-describe its capabilities.
+ * Results are cached and used for smarter routing.
+ */
+
+export interface AgentCapability {
+  agentId: string;
+  strengths: string[];
+  weaknesses: string[];
+  maxContextLength?: number;
+  supportsStreaming: boolean;
+  supportsImages: boolean;
+  languages: string[];
+  specializations: string[];
+  discoveredAt: string;
+}
+
+const KNOWN_CAPABILITIES: Record<string, AgentCapability> = {
+  claude: {
+    agentId: 'claude',
+    strengths: ['complex reasoning', 'code review', 'architecture', 'refactoring', 'explanation', 'security analysis', 'long context'],
+    weaknesses: ['real-time data', 'running arbitrary shell commands autonomously'],
+    maxContextLength: 1_000_000,
+    supportsStreaming: true,
+    supportsImages: true,
+    languages: ['typescript', 'python', 'rust', 'go', 'java', 'c++', 'sql', 'bash'],
+    specializations: ['code-review', 'architecture', 'debugging', 'documentation', 'security-audit'],
+    discoveredAt: new Date().toISOString(),
+  },
+  codex: {
+    agentId: 'codex',
+    strengths: ['code generation', 'file operations', 'shell commands', 'quick edits', 'scripting', 'automation'],
+    weaknesses: ['long context reasoning', 'multi-file architecture decisions'],
+    maxContextLength: 200_000,
+    supportsStreaming: true,
+    supportsImages: false,
+    languages: ['typescript', 'python', 'rust', 'go', 'bash', 'sql'],
+    specializations: ['implementation', 'scripting', 'file-ops', 'testing', 'automation'],
+    discoveredAt: new Date().toISOString(),
+  },
+  gemini: {
+    agentId: 'gemini',
+    strengths: ['research', 'web search', 'multimodal', 'summarization', 'comparison', 'broad knowledge'],
+    weaknesses: ['precise code editing', 'complex refactoring'],
+    maxContextLength: 1_000_000,
+    supportsStreaming: true,
+    supportsImages: true,
+    languages: ['typescript', 'python', 'java', 'go', 'kotlin'],
+    specializations: ['research', 'summarization', 'comparison', 'multimodal-analysis'],
+    discoveredAt: new Date().toISOString(),
+  },
+};
+
+export class CapabilityDiscovery {
+  private capabilities = new Map<string, AgentCapability>();
+
+  constructor() {
+    // Seed known capabilities
+    for (const [id, cap] of Object.entries(KNOWN_CAPABILITIES)) {
+      this.capabilities.set(id, cap);
+    }
+  }
+
+  get(agentId: string): AgentCapability | undefined {
+    return this.capabilities.get(agentId);
+  }
+
+  getAll(): AgentCapability[] {
+    return Array.from(this.capabilities.values());
+  }
+
+  /** Find the best agent for a given task description */
+  findBestMatch(taskDescription: string, availableAgentIds: string[]): { agentId: string; score: number; reason: string } | undefined {
+    const lower = taskDescription.toLowerCase();
+    let bestMatch: { agentId: string; score: number; reason: string } | undefined;
+
+    for (const agentId of availableAgentIds) {
+      const cap = this.capabilities.get(agentId);
+      if (!cap) continue;
+
+      let score = 0;
+      const matchedStrengths: string[] = [];
+
+      for (const strength of cap.strengths) {
+        const words = strength.toLowerCase().split(/\s+/);
+        for (const word of words) {
+          if (word.length > 3 && lower.includes(word)) {
+            score += 2;
+            matchedStrengths.push(strength);
+            break;
+          }
+        }
+      }
+
+      for (const spec of cap.specializations) {
+        if (lower.includes(spec.replace('-', ' ')) || lower.includes(spec)) {
+          score += 3;
+          matchedStrengths.push(`specialization: ${spec}`);
+        }
+      }
+
+      // Penalty for weaknesses
+      for (const weakness of cap.weaknesses) {
+        const words = weakness.toLowerCase().split(/\s+/);
+        for (const word of words) {
+          if (word.length > 4 && lower.includes(word)) {
+            score -= 1;
+          }
+        }
+      }
+
+      if (!bestMatch || score > bestMatch.score) {
+        bestMatch = {
+          agentId,
+          score,
+          reason: matchedStrengths.length > 0
+            ? `Matched: ${matchedStrengths.slice(0, 3).join(', ')}`
+            : 'Default selection',
+        };
+      }
+    }
+
+    return bestMatch;
+  }
+
+  register(cap: AgentCapability): void {
+    this.capabilities.set(cap.agentId, cap);
+  }
+}

package/src/daemon/services/snapshot.ts

@@ -0,0 +1,82 @@
+/**
+ * Snapshot — full system state backup and restore.
+ * Copies the entire SQLite database file.
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+
+const SNAPSHOT_DIR = path.join(os.homedir(), '.agw', 'snapshots');
+
+export interface SnapshotInfo {
+  id: string;
+  filename: string;
+  createdAt: string;
+  sizeBytes: number;
+}
+
+export class SnapshotManager {
+  private dbPath: string;
+
+  constructor(dbPath: string) {
+    this.dbPath = dbPath;
+    if (!fs.existsSync(SNAPSHOT_DIR)) {
+      fs.mkdirSync(SNAPSHOT_DIR, { recursive: true });
+    }
+  }
+
+  create(label?: string): SnapshotInfo {
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const id = label ? `${label}-${timestamp}` : timestamp;
+    const filename = `snapshot-${id}.db`;
+    const destPath = path.join(SNAPSHOT_DIR, filename);
+
+    fs.copyFileSync(this.dbPath, destPath);
+
+    const stat = fs.statSync(destPath);
+    return {
+      id,
+      filename,
+      createdAt: new Date().toISOString(),
+      sizeBytes: stat.size,
+    };
+  }
+
+  restore(id: string): boolean {
+    const filename = `snapshot-${id}.db`;
+    const srcPath = path.join(SNAPSHOT_DIR, filename);
+    if (!fs.existsSync(srcPath)) return false;
+
+    // Backup current before overwriting
+    const backupPath = `${this.dbPath}.pre-restore`;
+    fs.copyFileSync(this.dbPath, backupPath);
+    fs.copyFileSync(srcPath, this.dbPath);
+    return true;
+  }
+
+  list(): SnapshotInfo[] {
+    if (!fs.existsSync(SNAPSHOT_DIR)) return [];
+    return fs.readdirSync(SNAPSHOT_DIR)
+      .filter(f => f.startsWith('snapshot-') && f.endsWith('.db'))
+      .map(f => {
+        const stat = fs.statSync(path.join(SNAPSHOT_DIR, f));
+        const id = f.replace(/^snapshot-/, '').replace(/\.db$/, '');
+        return {
+          id,
+          filename: f,
+          createdAt: stat.mtime.toISOString(),
+          sizeBytes: stat.size,
+        };
+      })
+      .sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+  }
+
+  delete(id: string): boolean {
+    const filename = `snapshot-${id}.db`;
+    const filePath = path.join(SNAPSHOT_DIR, filename);
+    if (!fs.existsSync(filePath)) return false;
+    fs.unlinkSync(filePath);
+    return true;
+  }
+}

package/src/daemon/services/task-chain.ts

@@ -0,0 +1,93 @@
+/**
+ * Task Chain — linked tasks with automatic rollback on failure.
+ * Each step can define a rollback action that runs if a later step fails.
+ */
+
+import { nanoid } from 'nanoid';
+import { EventEmitter } from 'node:events';
+
+export interface ChainStep {
+  prompt: string;
+  agent?: string;
+  rollbackPrompt?: string;  // prompt to execute if this step needs rollback
+}
+
+export interface ChainResult {
+  chainId: string;
+  status: 'completed' | 'failed' | 'rolled-back';
+  completedSteps: number;
+  failedAtStep?: number;
+  rolledBackSteps: number;
+  stepResults: { stepIndex: number; output: string; exitCode: number }[];
+}
+
+type ExecuteFn = (prompt: string, agent?: string) => Promise<{ stdout: string; exitCode: number }>;
+
+export class TaskChain extends EventEmitter {
+  async execute(steps: ChainStep[], executeFn: ExecuteFn): Promise<ChainResult> {
+    const chainId = nanoid(12);
+    const stepResults: ChainResult['stepResults'] = [];
+    let failedAtStep: number | undefined;
+
+    this.emit('chain:start', chainId, steps.length);
+
+    // Execute forward
+    for (let i = 0; i < steps.length; i++) {
+      this.emit('chain:step', chainId, i, 'executing');
+      try {
+        const result = await executeFn(steps[i].prompt, steps[i].agent);
+        stepResults.push({ stepIndex: i, output: result.stdout, exitCode: result.exitCode });
+
+        if (result.exitCode !== 0) {
+          failedAtStep = i;
+          this.emit('chain:step', chainId, i, 'failed');
+          break;
+        }
+        this.emit('chain:step', chainId, i, 'completed');
+      } catch (err) {
+        stepResults.push({ stepIndex: i, output: (err as Error).message, exitCode: 1 });
+        failedAtStep = i;
+        this.emit('chain:step', chainId, i, 'failed');
+        break;
+      }
+    }
+
+    // If all succeeded
+    if (failedAtStep === undefined) {
+      this.emit('chain:done', chainId, 'completed');
+      return {
+        chainId,
+        status: 'completed',
+        completedSteps: steps.length,
+        rolledBackSteps: 0,
+        stepResults,
+      };
+    }
+
+    // Rollback: execute rollback prompts in reverse order for completed steps
+    let rolledBack = 0;
+    for (let i = failedAtStep - 1; i >= 0; i--) {
+      if (!steps[i].rollbackPrompt) continue;
+      this.emit('chain:rollback', chainId, i);
+      try {
+        await executeFn(steps[i].rollbackPrompt!, steps[i].agent);
+        rolledBack++;
+      } catch {
+        // Rollback failure is logged but doesn't stop the rollback process
+        this.emit('chain:rollback-failed', chainId, i);
+      }
+    }
+
+    const status = rolledBack > 0 ? 'rolled-back' : 'failed';
+    this.emit('chain:done', chainId, status);
+
+    return {
+      chainId,
+      status,
+      completedSteps: failedAtStep,
+      failedAtStep,
+      rolledBackSteps: rolledBack,
+      stepResults,
+    };
+  }
+}