anorion 0.1.0

package/src/agents/pipeline.ts

@@ -0,0 +1,231 @@
+// Agent Pipelines — chain agents together for multi-step workflows
+// Pipeline: Agent A output → Agent B input → Agent C input → final result
+
+import { nanoid } from 'nanoid';
+import { sendMessage } from '../agents/runtime';
+import { agentRegistry } from '../agents/registry';
+import { logger } from '../shared/logger';
+import { eventBus } from '../shared/events';
+
+export interface PipelineStep {
+  /** Agent ID or name */
+  agent: string;
+  /** Optional system prompt override for this step */
+  systemPrompt?: string;
+  /** Optional model override */
+  model?: string;
+  /** Max iterations for this step */
+  maxIterations?: number;
+  /** Transform the output before passing to next step */
+  transform?: 'raw' | 'json-extract' | 'first-line' | 'last-line';
+  /** Prepend to the input */
+  prefix?: string;
+  /** Append to the input */
+  suffix?: string;
+  /** Timeout in ms (default: 120000) */
+  timeoutMs?: number;
+}
+
+export interface PipelineDefinition {
+  name: string;
+  description?: string;
+  steps: PipelineStep[];
+  /** Whether to pass all previous step results or just the last one */
+  chainMode: 'last-output' | 'all-outputs';
+  /** What to do if a step fails */
+  onFailure: 'stop' | 'skip' | 'retry';
+  /** Max retries per step */
+  maxRetries: number;
+}
+
+export interface PipelineResult {
+  pipelineId: string;
+  name: string;
+  steps: Array<{
+    agent: string;
+    input: string;
+    output: string;
+    durationMs: number;
+    tokensUsed?: number;
+    success: boolean;
+    error?: string;
+  }>;
+  finalOutput: string;
+  totalDurationMs: number;
+  success: boolean;
+}
+
+const pipelines = new Map<string, PipelineDefinition>();
+
+/** Register a pipeline */
+export function registerPipeline(definition: PipelineDefinition): void {
+  pipelines.set(definition.name, definition);
+  logger.info({ pipeline: definition.name, steps: definition.steps.length }, 'Pipeline registered');
+}
+
+/** Register pipelines from a YAML file */
+export function loadPipelinesFromFile(filePath: string): void {
+  const { readFileSync, existsSync } = require('fs');
+  const { parse: parseYaml } = require('yaml');
+
+  if (!existsSync(filePath)) return;
+  const raw = readFileSync(filePath, 'utf-8');
+  const defs = parseYaml(raw);
+
+  if (Array.isArray(defs)) {
+    for (const def of defs) registerPipeline(def);
+  } else if (defs.pipelines) {
+    for (const def of defs.pipelines) registerPipeline(def);
+  }
+}
+
+/** Execute a pipeline */
+export async function executePipeline(
+  name: string,
+  input: string,
+  sessionId?: string,
+): Promise<PipelineResult> {
+  const definition = pipelines.get(name);
+  if (!definition) throw new Error(`Pipeline not found: ${name}`);
+
+  const result: PipelineResult = {
+    pipelineId: nanoid(10),
+    name,
+    steps: [],
+    finalOutput: '',
+    totalDurationMs: 0,
+    success: false,
+  };
+
+  const startTime = Date.now();
+  let currentInput = input;
+  const allOutputs: string[] = [];
+
+  for (let i = 0; i < definition.steps.length; i++) {
+    const step = definition.steps[i];
+    const stepStart = Date.now();
+
+    // Resolve agent
+    const agent = agentRegistry.get(step.agent) || agentRegistry.getByName(step.agent);
+    if (!agent) {
+      const error = `Agent not found: ${step.agent}`;
+      result.steps.push({
+        agent: step.agent,
+        input: currentInput,
+        output: '',
+        durationMs: Date.now() - stepStart,
+        success: false,
+        error,
+      });
+
+      if (definition.onFailure === 'stop') break;
+      continue;
+    }
+
+    // Build input for this step
+    let stepInput = currentInput;
+    if (step.prefix) stepInput = step.prefix + stepInput;
+    if (step.suffix) stepInput = stepInput + step.suffix;
+
+    if (definition.chainMode === 'all-outputs' && allOutputs.length > 0) {
+      stepInput = `[Previous step results]\n${allOutputs.join('\n---\n')}\n\n[Current task]\n${stepInput}`;
+    }
+
+    // Execute with retries
+    let stepResult: Awaited<ReturnType<typeof sendMessage>> | null = null;
+    let lastError: string | undefined;
+
+    for (let attempt = 0; attempt <= definition.maxRetries; attempt++) {
+      try {
+        stepResult = await sendMessage({
+          agentId: agent.id,
+          sessionId,
+          text: stepInput,
+        });
+        break;
+      } catch (err) {
+        lastError = (err as Error).message;
+        logger.warn({ pipeline: name, step: i, attempt, error: lastError }, 'Pipeline step failed');
+        if (definition.onFailure === 'skip') break;
+      }
+    }
+
+    const durationMs = Date.now() - stepStart;
+
+    if (stepResult) {
+      let output = stepResult.content;
+
+      // Apply transform
+      switch (step.transform) {
+        case 'json-extract':
+          try {
+            const parsed = JSON.parse(output);
+            output = typeof parsed === 'string' ? parsed : JSON.stringify(parsed, null, 2);
+          } catch { /* keep raw */ }
+          break;
+        case 'first-line':
+          output = output.split('\n')[0];
+          break;
+        case 'last-line':
+          output = output.split('\n').filter(Boolean).pop() || output;
+          break;
+      }
+
+      allOutputs.push(output);
+      currentInput = output;
+
+      result.steps.push({
+        agent: agent.name,
+        input: stepInput.slice(0, 500), // truncate for storage
+        output: output.slice(0, 5000),
+        durationMs,
+        tokensUsed: stepResult.usage?.totalTokens,
+        success: true,
+      });
+    } else {
+      result.steps.push({
+        agent: agent.name,
+        input: stepInput.slice(0, 500),
+        output: '',
+        durationMs,
+        success: false,
+        error: lastError,
+      });
+
+      if (definition.onFailure === 'stop') break;
+    }
+  }
+
+  result.finalOutput = currentInput;
+  result.totalDurationMs = Date.now() - startTime;
+  result.success = result.steps.every((s) => s.success);
+
+  logger.info({
+    pipeline: name,
+    pipelineId: result.pipelineId,
+    steps: result.steps.length,
+    success: result.success,
+    durationMs: result.totalDurationMs,
+  }, 'Pipeline completed');
+
+  return result;
+}
+
+/** List all registered pipelines */
+export function listPipelines(): Array<{ name: string; description?: string; stepCount: number }> {
+  return [...pipelines.values()].map((p) => ({
+    name: p.name,
+    description: p.description,
+    stepCount: p.steps.length,
+  }));
+}
+
+/** Get a pipeline definition */
+export function getPipeline(name: string): PipelineDefinition | undefined {
+  return pipelines.get(name);
+}
+
+/** Remove a pipeline */
+export function removePipeline(name: string): boolean {
+  return pipelines.delete(name);
+}

package/src/agents/registry.ts

@@ -0,0 +1,153 @@
+import type { AgentConfig, Agent } from '../shared/types';
+import type { Db } from '../shared/db';
+import type { PreparedStatements } from '../shared/db/prepared';
+import { readFileSync, readdirSync, existsSync } from 'fs';
+import { resolve } from 'path';
+import { parse as parseYaml } from 'yaml';
+import { logger } from '../shared/logger';
+
+class AgentRegistry {
+  private agents = new Map<string, Agent>();
+  private db: Db | null = null;
+  private prepared: PreparedStatements | null = null;
+
+  setDb(db: Db, prepared: PreparedStatements): void {
+    this.db = db;
+    this.prepared = prepared;
+  }
+
+  async loadFromDirectory(dir: string): Promise<void> {
+    const absDir = resolve(process.cwd(), dir);
+    if (!existsSync(absDir)) {
+      logger.warn({ dir: absDir }, 'Agent directory not found');
+      return;
+    }
+
+    const files = readdirSync(absDir).filter((f) => f.endsWith('.yaml') || f.endsWith('.yml'));
+    for (const file of files) {
+      try {
+        const raw = readFileSync(resolve(absDir, file), 'utf-8');
+        const parsed = parseYaml(raw) as Partial<AgentConfig>;
+        if (!parsed.name) continue;
+        // Deterministic ID from agent name for stability across restarts
+        const nameHash = Bun.hash(parsed.name).toString(16).padStart(8, '0').slice(0, 8);
+        await this.create({
+          id: parsed.id || ('agent-' + nameHash),
+          name: parsed.name,
+          model: parsed.model || 'openai/gpt-4o',
+          systemPrompt: parsed.systemPrompt || 'You are a helpful assistant.',
+          tools: parsed.tools || [],
+          maxIterations: parsed.maxIterations || 10,
+          timeoutMs: parsed.timeoutMs || 120000,
+          tags: parsed.tags,
+          metadata: parsed.metadata,
+        });
+      } catch (err) {
+        logger.error({ file, error: (err as Error).message }, 'Failed to load agent YAML');
+      }
+    }
+  }
+
+  async create(config: AgentConfig): Promise<Agent> {
+    const now = new Date().toISOString();
+    const agent: Agent = {
+      ...config,
+      id: config.id || crypto.randomUUID().slice(0, 10),
+      state: 'idle',
+      createdAt: now,
+      updatedAt: now,
+    };
+
+    this.agents.set(agent.id, agent);
+
+    if (this.prepared) {
+      this.prepared.agentInsert.run({
+        $id: agent.id,
+        $name: agent.name,
+        $model: agent.model,
+        $fallbackModel: agent.fallbackModel ?? null,
+        $systemPrompt: agent.systemPrompt,
+        $tools: JSON.stringify(agent.tools),
+        $maxIterations: agent.maxIterations ?? null,
+        $timeoutMs: agent.timeoutMs ?? null,
+        $state: agent.state,
+        $tags: JSON.stringify(agent.tags || []),
+        $metadata: JSON.stringify(agent.metadata || {}),
+        $createdAt: agent.createdAt,
+        $updatedAt: agent.updatedAt,
+      });
+    }
+
+    logger.info({ agent: agent.name, id: agent.id }, 'Agent created');
+    return agent;
+  }
+
+  get(id: string): Agent | undefined {
+    return this.agents.get(id);
+  }
+
+  getByName(name: string): Agent | undefined {
+    return [...this.agents.values()].find((a) => a.name === name);
+  }
+
+  list(): Agent[] {
+    return [...this.agents.values()];
+  }
+
+  async update(id: string, updates: Partial<AgentConfig>): Promise<Agent | undefined> {
+    const existing = this.agents.get(id);
+    if (!existing) return undefined;
+
+    const updated: Agent = {
+      ...existing,
+      ...updates,
+      id: existing.id, // prevent id change
+      state: existing.state,
+      updatedAt: new Date().toISOString(),
+    };
+
+    this.agents.set(id, updated);
+
+    if (this.prepared) {
+      this.prepared.agentUpdate.run({
+        $id: id,
+        $name: updated.name,
+        $model: updated.model,
+        $fallbackModel: updated.fallbackModel ?? null,
+        $systemPrompt: updated.systemPrompt,
+        $tools: JSON.stringify(updated.tools),
+        $maxIterations: updated.maxIterations ?? null,
+        $timeoutMs: updated.timeoutMs ?? null,
+        $tags: JSON.stringify(updated.tags || []),
+        $metadata: JSON.stringify(updated.metadata || {}),
+        $updatedAt: updated.updatedAt,
+      });
+    }
+
+    logger.info({ agent: updated.name, id }, 'Agent updated');
+    return updated;
+  }
+
+  async delete(id: string): Promise<boolean> {
+    const existing = this.agents.get(id);
+    if (!existing) return false;
+
+    this.agents.delete(id);
+
+    if (this.prepared) {
+      this.prepared.agentDelete.run({ $id: id });
+    }
+
+    logger.info({ agent: existing.name, id }, 'Agent deleted');
+    return true;
+  }
+
+  setState(id: string, state: Agent['state']): void {
+    const agent = this.agents.get(id);
+    if (agent) {
+      agent.state = state;
+    }
+  }
+}
+
+export const agentRegistry = new AgentRegistry();