@llm-dev-ops/agentics-cli 1.4.58 → 1.4.68

package/dist/bundled-agents/governance-dashboard-agents/package.json

@@ -1,13 +0,0 @@
-{
-  "dependencies": {
-    "claude-flow": "^2.7.41"
-  },
-  "devDependencies": {
-    "@llm-dev-ops/llm-analytics-api": "github:LLM-Dev-Ops/analytics-hub",
-    "@llm-dev-ops/llm-cost-ops-sdk": "github:LLM-Dev-Ops/cost-ops",
-    "@llm-dev-ops/llm-registry-sdk": "github:LLM-Dev-Ops/registry",
-    "@llm-dev-ops/observatory-sdk": "github:LLM-Dev-Ops/observatory",
-    "@llm-devops/policy-engine": "github:LLM-Dev-Ops/policy-engine",
-    "@llm-dev-ops/infra": "github:LLM-Dev-Ops/infra"
-  }
-}

package/dist/bundled-agents/orchestrator-agents/functions/contracts/index.js

@@ -1,590 +0,0 @@
-'use strict';
-
-// =============================================================================
-// Contract Schemas for all 7 Orchestrator Agents
-// Ported from crates/agentics-contracts/src/
-// =============================================================================
-
-// ---------------------------------------------------------------------------
-// 1. Workflow Orchestrator Agent
-// ---------------------------------------------------------------------------
-const workflowContract = {
-  agent_id: 'workflow-orchestrator',
-  agent_version: '0.1.0',
-  classification: 'WORKFLOW_EXECUTION',
-  description: 'Execute and coordinate multi-step workflows across agents in a deterministic and state-aware manner.',
-  input: {
-    type: 'object',
-    required: ['workflow_id', 'workflow_name', 'tasks'],
-    properties: {
-      envelope_id: { type: 'string', format: 'uuid' },
-      workflow_id: { type: 'string', format: 'uuid' },
-      workflow_name: { type: 'string', minLength: 1, maxLength: 256 },
-      workflow_version: { type: 'string' },
-      state: { type: 'string', enum: ['pending', 'scheduled', 'running', 'paused', 'completed', 'failed', 'cancelled', 'retry_waiting'] },
-      inputs: { type: 'object' },
-      tasks: {
-        type: 'array',
-        items: {
-          type: 'object',
-          required: ['task_id', 'name', 'task_type'],
-          properties: {
-            task_id: { type: 'string', format: 'uuid' },
-            name: { type: 'string', minLength: 1, maxLength: 256 },
-            task_type: { type: 'string', enum: ['llm_completion', 'embedding', 'vector_search', 'transform', 'action', 'agent_invocation', 'conditional', 'parallel'] },
-            state: { type: 'string', enum: ['pending', 'queued', 'running', 'completed', 'failed', 'skipped', 'cancelled', 'retry_waiting'] },
-            inputs: { type: 'object' },
-            outputs: { type: 'object' },
-            depends_on: { type: 'array', items: { type: 'string', format: 'uuid' } },
-            config: { type: 'object' },
-          },
-        },
-      },
-      config: {
-        type: 'object',
-        properties: {
-          max_concurrency: { type: 'integer', default: 4 },
-          timeout_seconds: { type: 'integer', default: 3600 },
-          retry_config: {
-            type: 'object',
-            properties: {
-              max_attempts: { type: 'integer', default: 3 },
-              initial_delay_ms: { type: 'integer', default: 1000 },
-              max_delay_ms: { type: 'integer', default: 30000 },
-              backoff_multiplier: { type: 'number', default: 2.0 },
-              jitter: { type: 'boolean', default: true },
-            },
-          },
-          continue_on_failure: { type: 'boolean', default: false },
-          strategy: { type: 'string', enum: ['sequential', 'parallel', 'dag_based', 'adaptive'] },
-        },
-      },
-    },
-  },
-  output: {
-    type: 'object',
-    properties: {
-      execution_id: { type: 'string' },
-      repo_span: { type: 'object' },
-      agent_spans: { type: 'array' },
-      valid: { type: 'boolean' },
-    },
-  },
-};
-
-// ---------------------------------------------------------------------------
-// 2. Task Scheduler Agent
-// ---------------------------------------------------------------------------
-const schedulerContract = {
-  agent_id: 'task-scheduler',
-  agent_version: '0.1.0',
-  classification: 'TASK_COORDINATION',
-  description: 'Schedule and coordinate task execution ordering, timing, and trigger-based invocation.',
-  input: {
-    type: 'object',
-    required: ['schedule_id', 'tasks'],
-    properties: {
-      schedule_id: { type: 'string', format: 'uuid' },
-      workflow_id: { type: 'string', format: 'uuid' },
-      tasks: {
-        type: 'array',
-        items: {
-          type: 'object',
-          required: ['task_id', 'name', 'schedule_type'],
-          properties: {
-            task_id: { type: 'string' },
-            name: { type: 'string' },
-            schedule_type: { type: 'string', enum: ['immediate', 'delayed', 'scheduled', 'cron', 'event_triggered', 'dependency_based'] },
-            trigger: {
-              type: 'object',
-              properties: {
-                trigger_type: { type: 'string', enum: ['workflow_complete', 'step_complete', 'webhook', 'message_queue', 'external_api'] },
-                condition: { type: 'object' },
-              },
-            },
-            priority: { type: 'integer', default: 0 },
-            delay_ms: { type: 'integer' },
-            cron_expression: { type: 'string' },
-            retry_policy: {
-              type: 'object',
-              properties: {
-                max_retries: { type: 'integer', default: 3 },
-                backoff_strategy: { type: 'string', enum: ['fixed', 'exponential', 'linear'] },
-                initial_delay_ms: { type: 'integer', default: 1000 },
-              },
-            },
-          },
-        },
-      },
-      config: {
-        type: 'object',
-        properties: {
-          max_concurrent: { type: 'integer', default: 10 },
-          timeout_ms: { type: 'integer', default: 300000 },
-        },
-      },
-    },
-  },
-  output: {
-    type: 'object',
-    properties: {
-      schedule_id: { type: 'string' },
-      status: { type: 'string', enum: ['scheduled', 'running', 'completed', 'failed'] },
-      scheduled_tasks: { type: 'array' },
-      next_execution: { type: 'string', format: 'date-time' },
-    },
-  },
-};
-
-// ---------------------------------------------------------------------------
-// 3. Dependency Resolver Agent
-// ---------------------------------------------------------------------------
-const dependenciesContract = {
-  agent_id: 'dependency-resolver',
-  agent_version: '0.1.0',
-  classification: 'TASK_COORDINATION',
-  description: 'Analyze task dependencies and determine execution order with cycle detection and critical path analysis.',
-  input: {
-    type: 'object',
-    required: ['request_id', 'workflow_id', 'tasks'],
-    properties: {
-      request_id: { type: 'string', format: 'uuid' },
-      workflow_id: { type: 'string', format: 'uuid' },
-      tasks: {
-        type: 'array',
-        items: {
-          type: 'object',
-          required: ['task_id', 'name'],
-          properties: {
-            task_id: { type: 'string' },
-            name: { type: 'string' },
-            task_type: { type: 'string' },
-            dependencies: {
-              type: 'array',
-              items: {
-                type: 'object',
-                properties: {
-                  task_id: { type: 'string' },
-                  required_status: { type: 'string', enum: ['success', 'complete', 'started', 'skipped', 'any'] },
-                  timeout_ms: { type: 'integer' },
-                },
-              },
-            },
-            estimated_duration_ms: { type: 'integer' },
-            priority: { type: 'integer', default: 0 },
-          },
-        },
-      },
-      config: {
-        type: 'object',
-        properties: {
-          max_depth: { type: 'integer', default: 100 },
-          detect_cycles: { type: 'boolean', default: true },
-          calculate_critical_path: { type: 'boolean', default: true },
-          optimize_parallelism: { type: 'boolean', default: true },
-          timeout_ms: { type: 'integer' },
-        },
-      },
-      timestamp: { type: 'string', format: 'date-time' },
-    },
-  },
-  output: {
-    type: 'object',
-    properties: {
-      request_id: { type: 'string' },
-      workflow_id: { type: 'string' },
-      status: { type: 'string', enum: ['success', 'success_with_warnings', 'failed', 'timeout', 'cancelled'] },
-      execution_order: { type: 'array', items: { type: 'string' } },
-      parallel_groups: {
-        type: 'array',
-        items: {
-          type: 'object',
-          properties: {
-            group_index: { type: 'integer' },
-            task_ids: { type: 'array', items: { type: 'string' } },
-            depends_on_groups: { type: 'array', items: { type: 'integer' } },
-          },
-        },
-      },
-      graph_summary: {
-        type: 'object',
-        properties: {
-          total_tasks: { type: 'integer' },
-          total_dependencies: { type: 'integer' },
-          max_depth: { type: 'integer' },
-          root_tasks: { type: 'integer' },
-          leaf_tasks: { type: 'integer' },
-          parallel_groups: { type: 'integer' },
-          has_cycles: { type: 'boolean' },
-        },
-      },
-      critical_path: {
-        type: 'object',
-        properties: {
-          task_ids: { type: 'array', items: { type: 'string' } },
-          total_duration_ms: { type: 'integer' },
-          task_count: { type: 'integer' },
-        },
-      },
-      issues: { type: 'array' },
-      resolved_at: { type: 'string', format: 'date-time' },
-    },
-  },
-};
-
-// ---------------------------------------------------------------------------
-// 4. Retry & Recovery Agent
-// ---------------------------------------------------------------------------
-const retryContract = {
-  agent_id: 'retry-recovery',
-  agent_version: '0.1.0',
-  classification: 'TASK_COORDINATION',
-  description: 'Determine safe retry, backoff, or recovery strategies following task or workflow failure.',
-  input: {
-    type: 'object',
-    required: ['request_id', 'failure'],
-    properties: {
-      request_id: { type: 'string', format: 'uuid' },
-      workflow_id: { type: 'string', format: 'uuid' },
-      execution_id: { type: 'string', format: 'uuid' },
-      failure: {
-        type: 'object',
-        required: ['task_id', 'error_category'],
-        properties: {
-          task_id: { type: 'string' },
-          task_name: { type: 'string' },
-          error_category: { type: 'string', enum: ['transient', 'permanent', 'timeout', 'resource_exhaustion', 'rate_limit', 'validation', 'dependency', 'infrastructure', 'unknown'] },
-          error_message: { type: 'string' },
-          error_code: { type: 'string' },
-          attempt: { type: 'integer' },
-          max_attempts: { type: 'integer' },
-          last_attempt_at: { type: 'string', format: 'date-time' },
-          context: { type: 'object' },
-        },
-      },
-      retry_policy: {
-        type: 'object',
-        properties: {
-          max_attempts: { type: 'integer', default: 3 },
-          backoff_strategy: { type: 'string', enum: ['fixed', 'exponential', 'linear', 'fibonacci', 'immediate'], default: 'exponential' },
-          initial_delay_ms: { type: 'integer', default: 1000 },
-          max_delay_ms: { type: 'integer', default: 30000 },
-          backoff_multiplier: { type: 'number', default: 2.0 },
-          jitter: { type: 'boolean', default: true },
-        },
-      },
-      timestamp: { type: 'string', format: 'date-time' },
-    },
-  },
-  output: {
-    type: 'object',
-    properties: {
-      request_id: { type: 'string' },
-      decision: { type: 'string', enum: ['retry', 'retry_with_modification', 'skip', 'fail', 'rollback', 'alternate_path', 'defer_retry'] },
-      retry_delay_ms: { type: 'integer' },
-      next_attempt: { type: 'integer' },
-      modifications: { type: 'object' },
-      recovery_path: { type: 'string' },
-      confidence: { type: 'number', minimum: 0, maximum: 1 },
-      reasoning: { type: 'string' },
-      timestamp: { type: 'string', format: 'date-time' },
-    },
-  },
-};
-
-// ---------------------------------------------------------------------------
-// 5. Parallelization Agent
-// ---------------------------------------------------------------------------
-const parallelContract = {
-  agent_id: 'parallelization-agent',
-  agent_version: '0.1.0',
-  classification: 'TASK_COORDINATION',
-  description: 'Identify tasks that can execute concurrently to improve workflow throughput.',
-  input: {
-    type: 'object',
-    required: ['request_id', 'workflow_id', 'tasks'],
-    properties: {
-      request_id: { type: 'string', format: 'uuid' },
-      workflow_id: { type: 'string', format: 'uuid' },
-      tasks: {
-        type: 'array',
-        items: {
-          type: 'object',
-          required: ['task_id', 'name'],
-          properties: {
-            task_id: { type: 'string' },
-            name: { type: 'string' },
-            task_type: { type: 'string' },
-            dependencies: { type: 'array' },
-            estimated_duration_ms: { type: 'integer' },
-            priority: { type: 'integer', default: 0 },
-          },
-        },
-      },
-      config: {
-        type: 'object',
-        properties: {
-          max_concurrency: { type: 'integer', default: 8 },
-          respect_soft_dependencies: { type: 'boolean', default: true },
-          analyze_data_dependencies: { type: 'boolean', default: true },
-          consider_resource_constraints: { type: 'boolean', default: true },
-          optimize_makespan: { type: 'boolean', default: true },
-          balance_load: { type: 'boolean', default: false },
-          timeout_ms: { type: 'integer' },
-        },
-      },
-      resource_constraints: {
-        type: 'object',
-        properties: {
-          max_total_memory_bytes: { type: 'integer' },
-          max_total_cpu: { type: 'number' },
-          max_total_gpu: { type: 'number' },
-          max_total_tokens: { type: 'integer' },
-        },
-      },
-      timestamp: { type: 'string', format: 'date-time' },
-    },
-  },
-  output: {
-    type: 'object',
-    properties: {
-      request_id: { type: 'string' },
-      workflow_id: { type: 'string' },
-      status: { type: 'string', enum: ['success', 'no_opportunities', 'success_with_warnings', 'failed', 'timeout'] },
-      execution_plan: {
-        type: 'object',
-        properties: {
-          plan_id: { type: 'string' },
-          phases: { type: 'array' },
-          total_phases: { type: 'integer' },
-          max_parallelism: { type: 'integer' },
-          strategy: { type: 'string', enum: ['sequential', 'static_parallel', 'dynamic_parallel', 'pipeline', 'hybrid'] },
-          critical_path_tasks: { type: 'array', items: { type: 'string' } },
-        },
-      },
-      summary: {
-        type: 'object',
-        properties: {
-          total_tasks: { type: 'integer' },
-          parallelizable_tasks: { type: 'integer' },
-          sequential_tasks: { type: 'integer' },
-          execution_phases: { type: 'integer' },
-          max_parallelism: { type: 'integer' },
-          avg_parallelism: { type: 'number' },
-        },
-      },
-      optimization_metrics: {
-        type: 'object',
-        properties: {
-          sequential_duration_ms: { type: 'integer' },
-          parallel_duration_ms: { type: 'integer' },
-          speedup_factor: { type: 'number' },
-          efficiency_score: { type: 'number' },
-        },
-      },
-      issues: { type: 'array' },
-      analyzed_at: { type: 'string', format: 'date-time' },
-    },
-  },
-};
-
-// ---------------------------------------------------------------------------
-// 6. State Machine Agent
-// ---------------------------------------------------------------------------
-const stateMachineContract = {
-  agent_id: 'state-machine-agent',
-  agent_version: '1.0.0',
-  classification: 'STATE_MANAGEMENT',
-  description: 'Manage workflow state transitions according to defined state machines and rules.',
-  input: {
-    type: 'object',
-    required: ['request_id', 'execution_id', 'entity_type', 'current_state', 'target_state', 'reason', 'initiated_by'],
-    properties: {
-      request_id: { type: 'string', format: 'uuid' },
-      execution_id: { type: 'string', format: 'uuid' },
-      entity_type: { type: 'string', enum: ['workflow', 'task'] },
-      current_state: { type: 'string' },
-      target_state: { type: 'string' },
-      reason: { type: 'string', minLength: 1, maxLength: 1024 },
-      initiated_by: { type: 'string' },
-      force: { type: 'boolean', default: false },
-      context: { type: 'object' },
-      timestamp: { type: 'string', format: 'date-time' },
-    },
-  },
-  output: {
-    type: 'object',
-    properties: {
-      request_id: { type: 'string' },
-      execution_id: { type: 'string' },
-      entity_type: { type: 'string' },
-      success: { type: 'boolean' },
-      previous_state: { type: 'string' },
-      new_state: { type: 'string' },
-      status: { type: 'string', enum: ['completed', 'invalid', 'blocked', 'forced', 'no_change', 'error'] },
-      validation: {
-        type: 'object',
-        properties: {
-          valid: { type: 'boolean' },
-          source_state_matches: { type: 'boolean' },
-          target_state_exists: { type: 'boolean' },
-          rule_violations: { type: 'array' },
-          warnings: { type: 'array' },
-        },
-      },
-      confidence: { type: 'number', minimum: 0, maximum: 1 },
-      timestamp: { type: 'string', format: 'date-time' },
-    },
-  },
-  state_machine: {
-    workflow: {
-      initial_state: 'pending',
-      terminal_states: ['completed', 'cancelled'],
-      transitions: {
-        pending: ['scheduled', 'running', 'cancelled'],
-        scheduled: ['running', 'cancelled'],
-        running: ['paused', 'completed', 'failed', 'cancelled', 'retry_waiting'],
-        paused: ['running', 'cancelled'],
-        retry_waiting: ['running', 'failed', 'cancelled'],
-        failed: ['retry_waiting'],
-      },
-    },
-    task: {
-      initial_state: 'pending',
-      terminal_states: ['completed', 'skipped', 'cancelled'],
-      transitions: {
-        pending: ['queued', 'running', 'skipped', 'cancelled'],
-        queued: ['running', 'cancelled'],
-        running: ['completed', 'failed', 'cancelled', 'retry_waiting'],
-        retry_waiting: ['running', 'failed', 'cancelled'],
-        failed: ['retry_waiting'],
-      },
-    },
-  },
-};
-
-// ---------------------------------------------------------------------------
-// 7. Swarm Coordinator Agent
-// ---------------------------------------------------------------------------
-const swarmContract = {
-  agent_id: 'swarm-coordinator-agent',
-  agent_version: '0.1.0',
-  classification: 'TASK_COORDINATION',
-  description: 'Coordinate fan-out / fan-in execution across multiple agents working toward a shared objective.',
-  input: {
-    type: 'object',
-    required: ['request_id', 'workflow_id', 'objective', 'workers'],
-    properties: {
-      request_id: { type: 'string', format: 'uuid' },
-      workflow_id: { type: 'string', format: 'uuid' },
-      objective: {
-        type: 'object',
-        required: ['id', 'description', 'objective_type'],
-        properties: {
-          id: { type: 'string' },
-          description: { type: 'string' },
-          objective_type: { type: 'string', enum: ['research', 'analysis', 'generation', 'execution', 'review'] },
-          inputs: { type: 'object' },
-          success_criteria: { type: 'array' },
-          priority: { type: 'integer', minimum: 0, maximum: 10 },
-        },
-      },
-      workers: {
-        type: 'array',
-        items: {
-          type: 'object',
-          required: ['worker_id', 'agent_type', 'task'],
-          properties: {
-            worker_id: { type: 'string' },
-            agent_type: { type: 'string', enum: ['workflow_orchestrator', 'dependency_resolver', 'parallelization'] },
-            task: {
-              type: 'object',
-              required: ['task_id', 'description'],
-              properties: {
-                task_id: { type: 'string' },
-                description: { type: 'string' },
-                inputs: { type: 'object' },
-                expected_outputs: { type: 'array', items: { type: 'string' } },
-                timeout_ms: { type: 'integer' },
-              },
-            },
-            depends_on: { type: 'array', items: { type: 'string' } },
-            config: {
-              type: 'object',
-              properties: {
-                max_retries: { type: 'integer', default: 3 },
-                retry_delay_ms: { type: 'integer', default: 1000 },
-                critical: { type: 'boolean', default: false },
-              },
-            },
-          },
-        },
-      },
-      config: {
-        type: 'object',
-        properties: {
-          max_concurrent_workers: { type: 'integer', default: 8 },
-          coordination_timeout_ms: { type: 'integer', default: 300000 },
-          consensus_strategy: { type: 'string', enum: ['first_wins', 'last_wins', 'majority', 'weighted_majority', 'merge_all'] },
-          continue_on_partial_failure: { type: 'boolean', default: false },
-          convergence_threshold: { type: 'number', default: 0.8, minimum: 0, maximum: 1 },
-        },
-      },
-      aggregation: {
-        type: 'object',
-        properties: {
-          mode: { type: 'string', enum: ['combine', 'select_best', 'summarize', 'collect'], default: 'combine' },
-          aggregate_fields: { type: 'array', items: { type: 'string' } },
-          merge_fields: { type: 'array', items: { type: 'string' } },
-        },
-      },
-      timestamp: { type: 'string', format: 'date-time' },
-    },
-  },
-  output: {
-    type: 'object',
-    properties: {
-      request_id: { type: 'string' },
-      workflow_id: { type: 'string' },
-      status: { type: 'string', enum: ['success', 'partial_success', 'consensus_reached', 'failed', 'timeout', 'cancelled'] },
-      aggregated_output: {
-        type: 'object',
-        properties: {
-          primary: {},
-          fields: { type: 'object' },
-          consensus: { type: 'object' },
-          confidence: { type: 'number' },
-        },
-      },
-      worker_results: { type: 'array' },
-      summary: {
-        type: 'object',
-        properties: {
-          total_workers: { type: 'integer' },
-          successful_workers: { type: 'integer' },
-          failed_workers: { type: 'integer' },
-          max_concurrency_achieved: { type: 'integer' },
-          total_duration_ms: { type: 'integer' },
-          objective_met: { type: 'boolean' },
-        },
-      },
-      issues: { type: 'array' },
-      completed_at: { type: 'string', format: 'date-time' },
-    },
-  },
-};
-
-// ---------------------------------------------------------------------------
-// Registry
-// ---------------------------------------------------------------------------
-const AGENT_CONTRACTS = {
-  workflow: workflowContract,
-  scheduler: schedulerContract,
-  dependencies: dependenciesContract,
-  retry: retryContract,
-  parallel: parallelContract,
-  'state-machine': stateMachineContract,
-  swarm: swarmContract,
-};
-
-module.exports = { AGENT_CONTRACTS };