@sooneocean/agw 1.4.0 → 1.5.0

package/package.json

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

package/src/daemon/routes/templates.ts

@@ -0,0 +1,60 @@
+import type { FastifyInstance } from 'fastify';
+import type { TemplateEngine, TaskTemplate, InstantiateRequest } from '../services/template-engine.js';
+import type { TaskExecutor } from '../services/task-executor.js';
+import type { LlmRouter } from '../../router/llm-router.js';
+import type { AgentManager } from '../services/agent-manager.js';
+
+export function registerTemplateRoutes(
+  app: FastifyInstance,
+  templateEngine: TemplateEngine,
+  executor: TaskExecutor,
+  router: LlmRouter,
+  agentManager: AgentManager,
+): void {
+  // List templates
+  app.get<{ Querystring: { tag?: string } }>('/templates', async (request) => {
+    return templateEngine.list(request.query.tag);
+  });
+
+  // Get template
+  app.get<{ Params: { id: string } }>('/templates/:id', async (request, reply) => {
+    const t = templateEngine.get(request.params.id);
+    if (!t) return reply.status(404).send({ error: 'Template not found' });
+    return t;
+  });
+
+  // Register custom template
+  app.post<{ Body: TaskTemplate }>('/templates', async (request, reply) => {
+    templateEngine.register(request.body);
+    return reply.status(201).send(request.body);
+  });
+
+  // Delete template
+  app.delete<{ Params: { id: string } }>('/templates/:id', async (request, reply) => {
+    const deleted = templateEngine.unregister(request.params.id);
+    if (!deleted) return reply.status(404).send({ error: 'Template not found' });
+    return { deleted: true };
+  });
+
+  // Instantiate and execute a template
+  app.post<{ Body: InstantiateRequest }>('/templates/execute', async (request, reply) => {
+    try {
+      const { prompt, agent, priority } = templateEngine.instantiate(request.body);
+      const availableAgents = agentManager.getAvailableAgents();
+
+      const task = await executor.execute(
+        {
+          prompt,
+          preferredAgent: agent ?? request.body.overrides?.agent,
+          workingDirectory: request.body.overrides?.workingDirectory,
+          priority,
+        },
+        async (p) => router.route(p, availableAgents, agent),
+      );
+
+      return reply.status(201).send(task);
+    } catch (err) {
+      return reply.status(400).send({ error: (err as Error).message });
+    }
+  });
+}

package/src/daemon/routes/webhooks.ts

@@ -0,0 +1,18 @@
+import type { FastifyInstance } from 'fastify';
+import type { WebhookManager, WebhookConfig } from '../services/webhook-manager.js';
+
+export function registerWebhookRoutes(app: FastifyInstance, webhookManager: WebhookManager): void {
+  app.get('/webhooks', async () => {
+    return webhookManager.getWebhooks();
+  });
+
+  app.post<{ Body: WebhookConfig }>('/webhooks', async (request, reply) => {
+    webhookManager.addWebhook(request.body);
+    return reply.status(201).send({ registered: true, url: request.body.url });
+  });
+
+  app.delete<{ Body: { url: string } }>('/webhooks', async (request) => {
+    webhookManager.removeWebhook(request.body.url);
+    return { removed: true };
+  });
+}

package/src/daemon/server.ts

@@ -10,22 +10,26 @@ import { AuditRepo } from '../store/audit-repo.js';
 import { CostRepo } from '../store/cost-repo.js';
 import { WorkflowRepo } from '../store/workflow-repo.js';
 import { ComboRepo } from '../store/combo-repo.js';
+import { MemoryRepo } from '../store/memory-repo.js';
 import { AgentManager } from './services/agent-manager.js';
 import { TaskExecutor } from './services/task-executor.js';
 import { WorkflowExecutor } from './services/workflow-executor.js';
 import { ComboExecutor } from './services/combo-executor.js';
 import { LlmRouter } from '../router/llm-router.js';
+import { MetricsCollector } from './services/metrics.js';
+import { CircuitBreakerRegistry } from './services/circuit-breaker.js';
+import { TemplateEngine } from './services/template-engine.js';
+import { WebhookManager } from './services/webhook-manager.js';
 import { registerAuthMiddleware } from './middleware/auth.js';
 import { registerAgentRoutes } from './routes/agents.js';
 import { registerTaskRoutes } from './routes/tasks.js';
 import { registerWorkflowRoutes } from './routes/workflows.js';
 import { registerCostRoutes } from './routes/costs.js';
 import { registerComboRoutes } from './routes/combos.js';
-import { MemoryRepo } from '../store/memory-repo.js';
 import { registerMemoryRoutes } from './routes/memory.js';
 import { registerHealthRoutes } from './routes/health.js';
-import { MetricsCollector } from './services/metrics.js';
-import { CircuitBreakerRegistry } from './services/circuit-breaker.js';
+import { registerTemplateRoutes } from './routes/templates.js';
+import { registerWebhookRoutes } from './routes/webhooks.js';
 
 interface ServerOptions {
   dbPath?: string;
@@ -58,6 +62,9 @@ export async function buildServer(options: ServerOptions = {}): Promise<FastifyI
   const comboExecutor = new ComboExecutor(comboRepo, auditRepo, executor, agentManager);
   const metrics = new MetricsCollector();
   const cbRegistry = new CircuitBreakerRegistry();
+  const templateEngine = new TemplateEngine();
+  templateEngine.seedDefaults();
+  const webhookManager = new WebhookManager();
 
   const app = Fastify({
     logger: false,
@@ -73,6 +80,8 @@ export async function buildServer(options: ServerOptions = {}): Promise<FastifyI
   registerComboRoutes(app, comboExecutor, config);
   registerMemoryRoutes(app, memoryRepo);
   registerHealthRoutes(app, metrics, agentManager, cbRegistry, taskRepo, costRepo, config);
+  registerTemplateRoutes(app, templateEngine, executor, router, agentManager);
+  registerWebhookRoutes(app, webhookManager);
 
   app.register(import('./routes/ui.js'));
 

package/src/daemon/services/condition-engine.ts

@@ -0,0 +1,75 @@
+/**
+ * Condition Engine — evaluates conditions on agent output to control combo flow.
+ *
+ * Conditions:
+ *   contains:"APPROVED"     — output contains string
+ *   !contains:"ERROR"       — output does NOT contain string
+ *   exitCode:0              — task exit code equals value
+ *   length>100              — output length greater than threshold
+ *   matches:/pattern/i      — output matches regex
+ *   always                  — always true (default)
+ */
+
+export interface Condition {
+  type: 'contains' | 'not-contains' | 'exitCode' | 'length-gt' | 'length-lt' | 'matches' | 'always';
+  value?: string | number;
+}
+
+export interface ConditionalBranch {
+  condition: Condition;
+  thenStep: number;  // step index to jump to
+  elseStep?: number; // step index if condition is false
+}
+
+export function parseCondition(expr: string): Condition {
+  if (expr === 'always') return { type: 'always' };
+
+  const containsMatch = expr.match(/^contains:"(.+)"$/);
+  if (containsMatch) return { type: 'contains', value: containsMatch[1] };
+
+  const notContainsMatch = expr.match(/^!contains:"(.+)"$/);
+  if (notContainsMatch) return { type: 'not-contains', value: notContainsMatch[1] };
+
+  const exitCodeMatch = expr.match(/^exitCode:(\d+)$/);
+  if (exitCodeMatch) return { type: 'exitCode', value: parseInt(exitCodeMatch[1], 10) };
+
+  const lengthGtMatch = expr.match(/^length>(\d+)$/);
+  if (lengthGtMatch) return { type: 'length-gt', value: parseInt(lengthGtMatch[1], 10) };
+
+  const lengthLtMatch = expr.match(/^length<(\d+)$/);
+  if (lengthLtMatch) return { type: 'length-lt', value: parseInt(lengthLtMatch[1], 10) };
+
+  const matchesMatch = expr.match(/^matches:\/(.+)\/([gimsuy]*)$/);
+  if (matchesMatch) return { type: 'matches', value: matchesMatch[1] + (matchesMatch[2] ? `/${matchesMatch[2]}` : '') };
+
+  throw new Error(`Invalid condition: ${expr}`);
+}
+
+export function evaluateCondition(condition: Condition, output: string, exitCode: number = 0): boolean {
+  switch (condition.type) {
+    case 'always':
+      return true;
+
+    case 'contains':
+      return output.includes(String(condition.value));
+
+    case 'not-contains':
+      return !output.includes(String(condition.value));
+
+    case 'exitCode':
+      return exitCode === condition.value;
+
+    case 'length-gt':
+      return output.length > (condition.value as number);
+
+    case 'length-lt':
+      return output.length < (condition.value as number);
+
+    case 'matches': {
+      const parts = String(condition.value).split('/');
+      const pattern = parts[0];
+      const flags = parts[1] ?? '';
+      return new RegExp(pattern, flags).test(output);
+    }
+  }
+}

package/src/daemon/services/template-engine.ts

@@ -0,0 +1,145 @@
+/**
+ * Task Template Engine — reusable parameterized task definitions.
+ *
+ * Templates use {{param.name}} syntax for user-supplied values.
+ * Templates can be stored, listed, and instantiated.
+ *
+ * Example:
+ *   { id: "code-review", prompt: "Review {{param.file}} for {{param.criteria}}", agent: "claude" }
+ *   Instantiate with: { templateId: "code-review", params: { file: "auth.ts", criteria: "security" } }
+ */
+
+export interface TaskTemplate {
+  id: string;
+  name: string;
+  description: string;
+  prompt: string;           // template with {{param.name}} placeholders
+  agent?: string;           // default agent
+  priority?: number;
+  params: TemplateParam[];  // parameter definitions
+  tags?: string[];
+}
+
+export interface TemplateParam {
+  name: string;
+  description: string;
+  required: boolean;
+  default?: string;
+}
+
+export interface InstantiateRequest {
+  templateId: string;
+  params: Record<string, string>;
+  overrides?: {
+    agent?: string;
+    priority?: number;
+    workingDirectory?: string;
+  };
+}
+
+export class TemplateEngine {
+  private templates = new Map<string, TaskTemplate>();
+
+  register(template: TaskTemplate): void {
+    this.templates.set(template.id, template);
+  }
+
+  unregister(id: string): boolean {
+    return this.templates.delete(id);
+  }
+
+  get(id: string): TaskTemplate | undefined {
+    return this.templates.get(id);
+  }
+
+  list(tag?: string): TaskTemplate[] {
+    const all = Array.from(this.templates.values());
+    if (tag) return all.filter(t => t.tags?.includes(tag));
+    return all;
+  }
+
+  instantiate(request: InstantiateRequest): { prompt: string; agent?: string; priority?: number } {
+    const template = this.templates.get(request.templateId);
+    if (!template) throw new Error(`Template not found: ${request.templateId}`);
+
+    // Validate required params
+    for (const param of template.params) {
+      if (param.required && !(request.params[param.name] ?? param.default)) {
+        throw new Error(`Missing required parameter: ${param.name}`);
+      }
+    }
+
+    // Interpolate {{param.name}} with provided values
+    let prompt = template.prompt;
+    for (const param of template.params) {
+      const value = request.params[param.name] ?? param.default ?? '';
+      prompt = prompt.replace(new RegExp(`\\{\\{param\\.${param.name}\\}\\}`, 'g'), value);
+    }
+
+    return {
+      prompt,
+      agent: request.overrides?.agent ?? template.agent,
+      priority: request.overrides?.priority ?? template.priority,
+    };
+  }
+
+  /** Seed built-in templates */
+  seedDefaults(): void {
+    this.register({
+      id: 'code-review',
+      name: 'Code Review',
+      description: 'Review a file for quality, security, and correctness',
+      prompt: 'Review {{param.file}} for {{param.criteria}}. Focus on actionable issues.',
+      agent: 'claude',
+      priority: 4,
+      params: [
+        { name: 'file', description: 'File path to review', required: true },
+        { name: 'criteria', description: 'Review criteria', required: false, default: 'quality, security, correctness' },
+      ],
+      tags: ['review', 'quality'],
+    });
+
+    this.register({
+      id: 'implement-feature',
+      name: 'Implement Feature',
+      description: 'Implement a new feature with tests',
+      prompt: 'Implement the following feature: {{param.description}}\n\nRequirements:\n{{param.requirements}}\n\nInclude unit tests.',
+      agent: 'codex',
+      priority: 3,
+      params: [
+        { name: 'description', description: 'Feature description', required: true },
+        { name: 'requirements', description: 'Detailed requirements', required: false, default: 'Follow existing patterns' },
+      ],
+      tags: ['implementation', 'feature'],
+    });
+
+    this.register({
+      id: 'explain-code',
+      name: 'Explain Code',
+      description: 'Explain what a piece of code does',
+      prompt: 'Explain this code in {{param.detail_level}} detail:\n\n{{param.code}}',
+      agent: 'claude',
+      priority: 2,
+      params: [
+        { name: 'code', description: 'Code to explain', required: true },
+        { name: 'detail_level', description: 'Detail level (brief/moderate/deep)', required: false, default: 'moderate' },
+      ],
+      tags: ['explanation', 'documentation'],
+    });
+
+    this.register({
+      id: 'debug-issue',
+      name: 'Debug Issue',
+      description: 'Diagnose and fix a bug',
+      prompt: 'Debug this issue: {{param.issue}}\n\nError message: {{param.error}}\n\nRelevant file: {{param.file}}',
+      agent: 'claude',
+      priority: 5,
+      params: [
+        { name: 'issue', description: 'Description of the issue', required: true },
+        { name: 'error', description: 'Error message or stack trace', required: false, default: 'N/A' },
+        { name: 'file', description: 'Relevant file path', required: false, default: 'N/A' },
+      ],
+      tags: ['debugging', 'fix'],
+    });
+  }
+}

package/src/daemon/services/webhook-manager.ts

@@ -0,0 +1,98 @@
+/**
+ * Webhook Manager — sends HTTP POST notifications on AGW events.
+ *
+ * Config example:
+ *   webhooks: [
+ *     { url: "https://slack.com/...", events: ["task.completed", "combo.completed"], secret: "hmac-key" }
+ *   ]
+ */
+
+import { createHmac } from 'node:crypto';
+
+export interface WebhookConfig {
+  url: string;
+  events: string[];      // event types to subscribe to, or ["*"] for all
+  secret?: string;       // HMAC-SHA256 signing key
+  headers?: Record<string, string>;
+  retries?: number;
+  timeoutMs?: number;
+}
+
+export interface WebhookPayload {
+  event: string;
+  timestamp: string;
+  data: Record<string, unknown>;
+}
+
+export class WebhookManager {
+  private hooks: WebhookConfig[] = [];
+
+  addWebhook(config: WebhookConfig): void {
+    this.hooks.push(config);
+  }
+
+  removeWebhook(url: string): void {
+    this.hooks = this.hooks.filter(h => h.url !== url);
+  }
+
+  getWebhooks(): WebhookConfig[] {
+    return this.hooks.map(h => ({ ...h, secret: h.secret ? '***' : undefined }));
+  }
+
+  async emit(event: string, data: Record<string, unknown>): Promise<void> {
+    const payload: WebhookPayload = {
+      event,
+      timestamp: new Date().toISOString(),
+      data,
+    };
+    const body = JSON.stringify(payload);
+
+    const matching = this.hooks.filter(h =>
+      h.events.includes('*') || h.events.includes(event)
+    );
+
+    const deliveries = matching.map(hook => this.deliver(hook, body));
+    await Promise.allSettled(deliveries);
+  }
+
+  private async deliver(hook: WebhookConfig, body: string): Promise<void> {
+    const maxRetries = hook.retries ?? 2;
+    const timeout = hook.timeoutMs ?? 10_000;
+
+    const headers: Record<string, string> = {
+      'Content-Type': 'application/json',
+      'User-Agent': 'AGW-Webhook/1.5',
+      ...hook.headers,
+    };
+
+    if (hook.secret) {
+      const signature = createHmac('sha256', hook.secret).update(body).digest('hex');
+      headers['X-AGW-Signature'] = `sha256=${signature}`;
+    }
+
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      try {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), timeout);
+
+        const res = await fetch(hook.url, {
+          method: 'POST',
+          headers,
+          body,
+          signal: controller.signal,
+        });
+
+        clearTimeout(timer);
+
+        if (res.ok) return;
+        if (res.status >= 400 && res.status < 500) return; // Don't retry client errors
+      } catch {
+        // Retry on network errors
+      }
+
+      if (attempt < maxRetries) {
+        await new Promise(r => setTimeout(r, 1000 * (attempt + 1)));
+      }
+    }
+  }
+}