@build-astron-co/nimbus 0.2.0

package/src/engine/index.ts

@@ -0,0 +1,76 @@
+/**
+ * Engine — barrel exports
+ *
+ * Re-exports all classes, interfaces, and key types from every engine module.
+ * Consumers can import from '@nimbus/engine' (or 'src/engine') without
+ * needing to know which sub-module a symbol lives in.
+ */
+
+// ==========================================
+// Planner
+// ==========================================
+export { Planner } from './planner';
+export type { AgentTask, AgentPlan, PlanStep, PlanDependency, Risk } from './planner';
+
+// ==========================================
+// Orchestrator (also re-exports shared types)
+// ==========================================
+export { AgentOrchestrator } from './orchestrator';
+export type {
+  ExecutionResult,
+  ExecutionArtifact,
+  ExecutionLog,
+  VerificationResult,
+  VerificationCheck,
+  AgentEvent,
+} from './orchestrator';
+
+// ==========================================
+// Executor
+// ==========================================
+export { Executor } from './executor';
+
+// ==========================================
+// Verifier
+// ==========================================
+export { Verifier } from './verifier';
+
+// ==========================================
+// Safety Manager
+// ==========================================
+export { SafetyManager } from './safety';
+export type { SafetyCheck, SafetyCheckResult } from './safety';
+
+// ==========================================
+// Drift Detector
+// ==========================================
+export { DriftDetector } from './drift-detector';
+export type {
+  DriftDetectionOptions,
+  DriftReport,
+  DriftSummary,
+  ResourceDrift,
+  DriftItem,
+  DriftType,
+  DriftSeverity,
+  DriftProvider,
+} from './drift-detector';
+
+// ==========================================
+// Cost Estimator
+// ==========================================
+export { CostEstimator } from './cost-estimator';
+export type {
+  CostEstimationInput,
+  CostEstimate,
+  ComponentCostBreakdown,
+  KnownComponent,
+  EnvironmentTier,
+  CloudProvider,
+} from './cost-estimator';
+
+// ==========================================
+// Diagram Generator
+// ==========================================
+export { DiagramGenerator } from './diagram-generator';
+export type { DiagramComponent, DiagramConnection, DiagramOptions } from './diagram-generator';

package/src/engine/orchestrator.ts

@@ -0,0 +1,636 @@
+import { logger } from '../utils';
+import { Planner, type AgentTask, type AgentPlan } from './planner';
+import { Executor } from './executor';
+import { Verifier } from './verifier';
+import { SafetyManager } from './safety';
+
+// ==========================================
+// Re-export shared types for use by executor and other modules
+// ==========================================
+
+export type { AgentTask, AgentPlan, PlanStep, PlanDependency, Risk } from './planner';
+
+export interface ExecutionResult {
+  id: string;
+  plan_id: string;
+  step_id: string;
+  status: 'success' | 'failure' | 'partial';
+  started_at: Date;
+  completed_at: Date;
+  duration: number;
+  outputs?: Record<string, unknown>;
+  artifacts?: ExecutionArtifact[];
+  logs?: ExecutionLog[];
+  error?: {
+    code: string;
+    message: string;
+    details?: Record<string, unknown>;
+    stack_trace?: string;
+  };
+}
+
+export interface ExecutionArtifact {
+  id: string;
+  type: 'terraform' | 'kubernetes' | 'script' | 'config' | 'documentation';
+  name: string;
+  path: string;
+  size: number;
+  checksum: string;
+  created_at: Date;
+}
+
+export interface ExecutionLog {
+  timestamp: Date;
+  level: 'debug' | 'info' | 'warn' | 'error';
+  message: string;
+  context?: Record<string, unknown>;
+}
+
+export interface VerificationResult {
+  id: string;
+  execution_id: string;
+  status: 'passed' | 'failed' | 'warning';
+  started_at: Date;
+  completed_at: Date;
+  checks: VerificationCheck[];
+  summary: {
+    total_checks: number;
+    passed: number;
+    failed: number;
+    warnings: number;
+  };
+}
+
+export interface VerificationCheck {
+  id: string;
+  type: 'security' | 'compliance' | 'functionality' | 'performance' | 'cost';
+  name: string;
+  description: string;
+  status: 'passed' | 'failed' | 'warning' | 'skipped';
+  expected?: unknown;
+  actual?: unknown;
+  error?: string;
+  remediation?: string;
+}
+
+export interface AgentEvent {
+  id: string;
+  task_id: string;
+  type:
+    | 'task_created'
+    | 'plan_generated'
+    | 'plan_approved'
+    | 'execution_started'
+    | 'step_completed'
+    | 'verification_completed'
+    | 'task_completed'
+    | 'task_failed'
+    | 'task_cancelled';
+  timestamp: Date;
+  data?: Record<string, unknown>;
+  user_id?: string;
+}
+
+// ==========================================
+// Orchestrator
+// ==========================================
+
+export class AgentOrchestrator {
+  private planner: Planner;
+  private executor: Executor;
+  private verifier: Verifier;
+  private safetyManager: SafetyManager;
+
+  private tasks: Map<string, AgentTask>;
+  private plans: Map<string, AgentPlan>;
+  private events: AgentEvent[];
+
+  constructor() {
+    this.planner = new Planner();
+    this.executor = new Executor();
+    this.verifier = new Verifier();
+    this.safetyManager = new SafetyManager();
+
+    this.tasks = new Map();
+    this.plans = new Map();
+    this.events = [];
+
+    logger.info('Agent Orchestrator initialized');
+  }
+
+  /**
+   * Create a new task
+   */
+  async createTask(taskInput: {
+    type: 'generate' | 'deploy' | 'verify' | 'rollback' | 'analyze';
+    user_id: string;
+    priority?: 'low' | 'medium' | 'high' | 'critical';
+    context: {
+      provider: 'aws' | 'gcp' | 'azure';
+      environment: string;
+      region?: string;
+      components: string[];
+      requirements?: Record<string, unknown>;
+    };
+    metadata?: Record<string, unknown>;
+  }): Promise<AgentTask> {
+    const task: AgentTask = {
+      id: this.generateTaskId(),
+      type: taskInput.type,
+      status: 'pending',
+      priority: taskInput.priority || 'medium',
+      user_id: taskInput.user_id,
+      created_at: new Date(),
+      updated_at: new Date(),
+      context: taskInput.context,
+      execution: {},
+      metadata: taskInput.metadata,
+    };
+
+    this.tasks.set(task.id, task);
+    this.emitEvent({
+      id: this.generateEventId(),
+      task_id: task.id,
+      type: 'task_created',
+      timestamp: new Date(),
+      user_id: task.user_id,
+      data: { task },
+    });
+
+    logger.info(`Created task ${task.id}: ${task.type} for ${task.context.components.join(', ')}`);
+
+    return task;
+  }
+
+  /**
+   * Execute a task (full workflow)
+   */
+  async executeTask(taskId: string): Promise<{
+    task: AgentTask;
+    plan: AgentPlan;
+    executionResults: ExecutionResult[];
+    verificationResult: VerificationResult;
+  }> {
+    const task = this.tasks.get(taskId);
+    if (!task) {
+      throw new Error(`Task not found: ${taskId}`);
+    }
+
+    logger.info(`Starting task execution: ${taskId}`);
+
+    try {
+      // Step 1: Generate plan
+      task.status = 'planning';
+      task.updated_at = new Date();
+
+      const plan = await this.planner.generatePlan(task);
+      this.plans.set(plan.id, plan);
+      task.execution.plan_id = plan.id;
+
+      this.emitEvent({
+        id: this.generateEventId(),
+        task_id: task.id,
+        type: 'plan_generated',
+        timestamp: new Date(),
+        data: { plan_id: plan.id, steps: plan.steps.length },
+      });
+
+      logger.info(`Generated plan ${plan.id} with ${plan.steps.length} steps`);
+
+      // Step 2: Run pre-execution safety checks
+      const safetyChecks = await this.safetyManager.runPreExecutionChecks(task, plan);
+
+      if (!safetyChecks.passed) {
+        task.status = 'failed';
+        task.result = {
+          success: false,
+          errors: safetyChecks.blockers.map(b => b.message),
+        };
+        task.updated_at = new Date();
+
+        logger.error(`Safety checks failed for task ${taskId}`, safetyChecks.blockers);
+        throw new Error('Pre-execution safety checks failed');
+      }
+
+      // Step 3: Approve plan if required
+      if (plan.requires_approval && !plan.approved_by) {
+        task.status = 'pending';
+        task.updated_at = new Date();
+
+        logger.info(`Task ${taskId} requires approval before execution`);
+        // In production, this would notify user and wait for approval
+        // For now, auto-approve non-critical tasks
+        if (plan.risk_level !== 'critical') {
+          plan.approved_by = 'system';
+          plan.approved_at = new Date();
+          plan.status = 'approved';
+
+          this.emitEvent({
+            id: this.generateEventId(),
+            task_id: task.id,
+            type: 'plan_approved',
+            timestamp: new Date(),
+            data: { plan_id: plan.id, approved_by: 'system' },
+          });
+        } else {
+          throw new Error('Critical plan requires manual approval');
+        }
+      }
+
+      // Step 4: Execute plan
+      task.status = 'executing';
+      task.updated_at = new Date();
+
+      this.emitEvent({
+        id: this.generateEventId(),
+        task_id: task.id,
+        type: 'execution_started',
+        timestamp: new Date(),
+        data: { plan_id: plan.id },
+      });
+
+      logger.info(`Executing plan ${plan.id}`);
+
+      const executionResults = await this.executor.executePlan(plan);
+      task.execution.execution_id = executionResults[0]?.id;
+
+      // Check if execution succeeded
+      const executionFailed = executionResults.some(r => r.status === 'failure');
+
+      if (executionFailed) {
+        task.status = 'failed';
+        task.result = {
+          success: false,
+          errors: executionResults.filter(r => r.error).map(r => r.error!.message),
+        };
+        task.updated_at = new Date();
+
+        logger.error(`Execution failed for task ${taskId}`);
+        throw new Error('Execution failed');
+      }
+
+      // Emit step completed events
+      for (const result of executionResults) {
+        this.emitEvent({
+          id: this.generateEventId(),
+          task_id: task.id,
+          type: 'step_completed',
+          timestamp: new Date(),
+          data: {
+            step_id: result.step_id,
+            status: result.status,
+            duration: result.duration,
+          },
+        });
+      }
+
+      // Step 5: Verify execution
+      task.status = 'verifying';
+      task.updated_at = new Date();
+
+      logger.info(`Verifying execution results`);
+
+      const verificationResult = await this.verifier.verifyExecution(executionResults, {
+        ...task.context,
+        environment: task.context.environment,
+      });
+      task.execution.verification_id = verificationResult.id;
+
+      this.emitEvent({
+        id: this.generateEventId(),
+        task_id: task.id,
+        type: 'verification_completed',
+        timestamp: new Date(),
+        data: {
+          verification_id: verificationResult.id,
+          status: verificationResult.status,
+          checks_passed: verificationResult.summary.passed,
+          checks_failed: verificationResult.summary.failed,
+        },
+      });
+
+      // Step 6: Run post-execution safety checks
+      await this.safetyManager.runPostExecutionChecks({
+        task,
+        plan,
+        execution_results: executionResults,
+        verification_result: verificationResult,
+      });
+
+      // Step 7: Complete task
+      task.status = 'completed';
+      task.completed_at = new Date();
+      task.updated_at = new Date();
+      task.result = {
+        success: true,
+        outputs: executionResults.reduce((acc, r) => ({ ...acc, ...r.outputs }), {}),
+        artifacts: executionResults.flatMap(r => r.artifacts?.map(a => a.name) || []),
+      };
+
+      plan.status = 'completed';
+
+      this.emitEvent({
+        id: this.generateEventId(),
+        task_id: task.id,
+        type: 'task_completed',
+        timestamp: new Date(),
+        data: {
+          duration: task.completed_at.getTime() - task.created_at.getTime(),
+          verification_status: verificationResult.status,
+        },
+      });
+
+      logger.info(`Task ${taskId} completed successfully`);
+
+      return {
+        task,
+        plan,
+        executionResults,
+        verificationResult,
+      };
+    } catch (error) {
+      task.status = 'failed';
+      task.updated_at = new Date();
+      task.result = {
+        success: false,
+        errors: [(error as Error).message],
+      };
+
+      this.emitEvent({
+        id: this.generateEventId(),
+        task_id: task.id,
+        type: 'task_failed',
+        timestamp: new Date(),
+        data: {
+          error: (error as Error).message,
+        },
+      });
+
+      logger.error(`Task ${taskId} failed`, error);
+      throw error;
+    }
+  }
+
+  /**
+   * Resume a task from its last checkpoint
+   */
+  async resumeTask(taskId: string): Promise<{
+    task: AgentTask;
+    executionResults: ExecutionResult[];
+  }> {
+    const task = this.tasks.get(taskId);
+    if (!task) {
+      throw new Error(`Task not found: ${taskId}`);
+    }
+
+    if (!task.execution.plan_id) {
+      throw new Error(`Task ${taskId} has no associated plan. Cannot resume.`);
+    }
+
+    const plan = this.plans.get(task.execution.plan_id);
+    if (!plan) {
+      throw new Error(`Plan ${task.execution.plan_id} not found. Cannot resume.`);
+    }
+
+    logger.info(`Resuming task ${taskId} with plan ${plan.id}`);
+
+    // Update task status
+    task.status = 'executing';
+    task.updated_at = new Date();
+
+    this.emitEvent({
+      id: this.generateEventId(),
+      task_id: task.id,
+      type: 'execution_started',
+      timestamp: new Date(),
+      data: { plan_id: plan.id, resumed: true },
+    });
+
+    // Re-execute the plan; the executor will pick up from the checkpoint
+    const executionResults = await this.executor.executePlan(plan);
+
+    // Check if execution succeeded
+    const executionFailed = executionResults.some(r => r.status === 'failure');
+
+    if (executionFailed) {
+      task.status = 'failed';
+      task.result = {
+        success: false,
+        errors: executionResults.filter(r => r.error).map(r => r.error!.message),
+      };
+      task.updated_at = new Date();
+
+      this.emitEvent({
+        id: this.generateEventId(),
+        task_id: task.id,
+        type: 'task_failed',
+        timestamp: new Date(),
+        data: { error: 'Resumed execution failed' },
+      });
+
+      throw new Error('Resumed execution failed');
+    }
+
+    // Mark task as completed
+    task.status = 'completed';
+    task.completed_at = new Date();
+    task.updated_at = new Date();
+    task.result = {
+      success: true,
+      outputs: executionResults.reduce((acc, r) => ({ ...acc, ...r.outputs }), {}),
+      artifacts: executionResults.flatMap(r => r.artifacts?.map(a => a.name) || []),
+    };
+
+    this.emitEvent({
+      id: this.generateEventId(),
+      task_id: task.id,
+      type: 'task_completed',
+      timestamp: new Date(),
+      data: {
+        duration: task.completed_at.getTime() - task.created_at.getTime(),
+        resumed: true,
+      },
+    });
+
+    logger.info(`Resumed task ${taskId} completed successfully`);
+
+    return {
+      task,
+      executionResults,
+    };
+  }
+
+  /**
+   * Get task by ID
+   */
+  getTask(taskId: string): AgentTask | undefined {
+    return this.tasks.get(taskId);
+  }
+
+  /**
+   * Get plan by ID
+   */
+  getPlan(planId: string): AgentPlan | undefined {
+    return this.plans.get(planId);
+  }
+
+  /**
+   * List all tasks
+   */
+  listTasks(filters?: {
+    user_id?: string;
+    status?: AgentTask['status'];
+    type?: AgentTask['type'];
+  }): AgentTask[] {
+    let tasks = Array.from(this.tasks.values());
+
+    if (filters?.user_id) {
+      tasks = tasks.filter(t => t.user_id === filters.user_id);
+    }
+
+    if (filters?.status) {
+      tasks = tasks.filter(t => t.status === filters.status);
+    }
+
+    if (filters?.type) {
+      tasks = tasks.filter(t => t.type === filters.type);
+    }
+
+    return tasks.sort((a, b) => b.created_at.getTime() - a.created_at.getTime());
+  }
+
+  /**
+   * Cancel a task
+   */
+  async cancelTask(taskId: string): Promise<void> {
+    const task = this.tasks.get(taskId);
+    if (!task) {
+      throw new Error(`Task not found: ${taskId}`);
+    }
+
+    if (task.status === 'completed' || task.status === 'failed') {
+      throw new Error(`Cannot cancel task in ${task.status} status`);
+    }
+
+    task.status = 'cancelled';
+    task.updated_at = new Date();
+
+    this.emitEvent({
+      id: this.generateEventId(),
+      task_id: task.id,
+      type: 'task_cancelled',
+      timestamp: new Date(),
+    });
+
+    logger.info(`Task ${taskId} cancelled`);
+  }
+
+  /**
+   * Get task events
+   */
+  getTaskEvents(taskId: string): AgentEvent[] {
+    return this.events.filter(e => e.task_id === taskId);
+  }
+
+  /**
+   * Get all events
+   */
+  getAllEvents(): AgentEvent[] {
+    return [...this.events].sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime());
+  }
+
+  /**
+   * Get task statistics
+   */
+  getStatistics(): {
+    total_tasks: number;
+    by_status: Record<string, number>;
+    by_type: Record<string, number>;
+    average_duration: number;
+    success_rate: number;
+  } {
+    const tasks = Array.from(this.tasks.values());
+
+    const byStatus: Record<string, number> = {};
+    const byType: Record<string, number> = {};
+    let totalDuration = 0;
+    let completedTasks = 0;
+    let successfulTasks = 0;
+
+    for (const task of tasks) {
+      byStatus[task.status] = (byStatus[task.status] || 0) + 1;
+      byType[task.type] = (byType[task.type] || 0) + 1;
+
+      if (task.completed_at) {
+        completedTasks++;
+        totalDuration += task.completed_at.getTime() - task.created_at.getTime();
+
+        if (task.result?.success) {
+          successfulTasks++;
+        }
+      }
+    }
+
+    return {
+      total_tasks: tasks.length,
+      by_status: byStatus,
+      by_type: byType,
+      average_duration: completedTasks > 0 ? totalDuration / completedTasks : 0,
+      success_rate: completedTasks > 0 ? (successfulTasks / completedTasks) * 100 : 0,
+    };
+  }
+
+  /**
+   * Emit event
+   */
+  private emitEvent(event: AgentEvent): void {
+    this.events.push(event);
+
+    // Keep only last 1000 events
+    if (this.events.length > 1000) {
+      this.events = this.events.slice(-1000);
+    }
+  }
+
+  /**
+   * Generate task ID
+   */
+  private generateTaskId(): string {
+    return `task_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+  }
+
+  /**
+   * Generate event ID
+   */
+  private generateEventId(): string {
+    return `event_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+  }
+
+  /**
+   * Get planner instance (for direct access)
+   */
+  getPlanner(): Planner {
+    return this.planner;
+  }
+
+  /**
+   * Get executor instance (for direct access)
+   */
+  getExecutor(): Executor {
+    return this.executor;
+  }
+
+  /**
+   * Get verifier instance (for direct access)
+   */
+  getVerifier(): Verifier {
+    return this.verifier;
+  }
+
+  /**
+   * Get safety manager instance (for direct access)
+   */
+  getSafetyManager(): SafetyManager {
+    return this.safetyManager;
+  }
+}