claude-flow 2.0.0-alpha.78 → 2.0.0-alpha.79

package/src/maestro/maestro-types.ts

@@ -0,0 +1,386 @@
+export interface MaestroSpec {
+  name: string;
+  description: string;
+  version: string;
+  goals: string[];
+  workflow: WorkflowPhase[];
+}
+
+export interface WorkflowPhase {
+  step: string;
+  agent: string; // Name of the sub-agent
+  input?: string;
+  input_from?: string; // Reference to previous step's output
+  input_transform?: string;
+  output_format: string;
+  next_step_on_success?: string;
+  parallel_tasks?: Array<{ task: string; agent: string; input: string }>;
+  environment?: string;
+  on_failure?: string;
+}
+
+export interface TaskItem {
+  id: string;
+  description: string;
+  status: 'pending' | 'in-progress' | 'completed' | 'failed';
+  assignedAgent?: string;
+  dependencies?: string[];
+  priority: number;
+  metadata?: Record<string, any>;
+}
+
+export interface AgentProfile {
+  id: string;
+  name: string;
+  type: string;
+  capabilities: string[];
+  maxConcurrentTasks: number;
+  priority: number;
+}
+
+export interface SteeringContext {
+  domain: string;
+  guidelines: string;
+  constraints: string[];
+  examples?: string[];
+}
+
+export type WorkflowPhase = 
+  | 'Requirements Clarification'
+  | 'Research & Design'
+  | 'Implementation Planning'
+  | 'Task Execution'
+  | 'Completed';
+
+export interface MaestroWorkflowState {
+  featureName: string;
+  currentPhase: WorkflowPhase;
+  currentTaskIndex: number;
+  status: 'idle' | 'running' | 'paused' | 'completed' | 'failed';
+  lastActivity: Date;
+  history: Array<{ phase: WorkflowPhase; status: 'completed' | 'failed' | 'in-progress' | 'approved'; timestamp: Date; output?: any; error?: string }>;
+  // Add more state as needed, e.g., for human-in-the-loop gates
+}
+
+// ===== KIRO ENHANCEMENT TYPES =====
+
+export interface KiroEnhancedSpec extends MaestroSpec {
+  livingDocumentation: LivingDocumentationConfig;
+  agentHooks: AgentHookConfig[];
+  consensusRequirements: ConsensusRequirements;
+  patternLearning: PatternLearningConfig;
+  enhancedMetadata: SpecMetadata;
+}
+
+export interface LivingDocumentationConfig {
+  enabled: boolean;
+  syncMode: 'bidirectional' | 'spec-to-code' | 'code-to-spec';
+  autoUpdateThreshold: number; // 0-1, how much change triggers auto-update
+  conflictResolution: 'manual' | 'spec-wins' | 'code-wins' | 'merge';
+  versionTracking: boolean;
+  changeDetectionGranularity: 'file' | 'function' | 'line';
+  realTimeSync: boolean;
+  watchPatterns: string[]; // File patterns to watch
+  excludePatterns: string[]; // File patterns to exclude
+}
+
+export interface AgentHookConfig {
+  type: 'file-change' | 'code-quality' | 'documentation' | 'testing' | 'deployment';
+  trigger: HookTrigger;
+  actions: HookAction[];
+  conditions: HookCondition[];
+  priority: number;
+  enabled: boolean;
+  agentTypes: string[]; // Which agent types should handle this hook
+  metadata: Record<string, any>;
+}
+
+export interface HookTrigger {
+  event: 'file-modified' | 'file-created' | 'file-deleted' | 'git-commit' | 'test-failed' | 'build-failed';
+  patterns: string[]; // File patterns or other patterns
+  debounceMs: number; // Debounce multiple triggers
+  batchingEnabled: boolean;
+  conditions?: string[]; // Additional trigger conditions
+}
+
+export interface HookAction {
+  type: 'spawn-agent' | 'update-spec' | 'run-tests' | 'generate-docs' | 'quality-check';
+  agentType: string;
+  parameters: Record<string, any>;
+  timeout: number;
+  retryCount: number;
+  background: boolean;
+}
+
+export interface HookCondition {
+  type: 'file-size' | 'file-age' | 'git-status' | 'test-status' | 'custom';
+  operator: 'eq' | 'ne' | 'gt' | 'lt' | 'contains' | 'matches';
+  value: any;
+  negate?: boolean;
+}
+
+export interface ConsensusRequirements {
+  enabled: boolean;
+  algorithm: 'simple-majority' | 'weighted-vote' | 'byzantine-fault-tolerant' | 'raft';
+  minimumAgents: number;
+  quorumPercentage: number; // 0-1, what percentage needed for consensus
+  timeoutMs: number;
+  retryCount: number;
+  validatorAgentTypes: string[];
+  consensusScope: 'design-phase' | 'implementation-phase' | 'all-phases';
+  conflictResolution: 'revote' | 'escalate' | 'fallback-to-human';
+}
+
+export interface PatternLearningConfig {
+  enabled: boolean;
+  learningMode: 'passive' | 'active' | 'hybrid';
+  dataCollection: {
+    specHistory: boolean;
+    designDecisions: boolean;
+    implementationOutcomes: boolean;
+    userFeedback: boolean;
+  };
+  modelType: 'rule-based' | 'ml-based' | 'hybrid';
+  adaptationThreshold: number; // How much data before adapting
+  confidenceThreshold: number; // Minimum confidence for suggestions
+}
+
+export interface SpecMetadata {
+  createdAt: Date;
+  lastModified: Date;
+  version: string;
+  contributors: string[];
+  reviewers: string[];
+  approvalStatus: 'draft' | 'under-review' | 'approved' | 'deprecated';
+  tags: string[];
+  relatedSpecs: string[];
+  implementationStatus: {
+    phase: string;
+    progress: number; // 0-1
+    quality: number; // 0-1
+    testCoverage: number; // 0-1
+  };
+  metrics: {
+    cycleTime: number; // ms from spec to implementation
+    defectRate: number;
+    changeFrequency: number;
+    stakeholderSatisfaction: number; // 0-1
+  };
+}
+
+// ===== ENHANCED WORKFLOW TYPES =====
+
+export interface EnhancedWorkflowPhase extends WorkflowPhase {
+  hooks: AgentHookConfig[];
+  consensusRequired: boolean;
+  livingDocSync: boolean;
+  patternLearningEnabled: boolean;
+  qualityGates: QualityGate[];
+  parallelExecution: boolean;
+  backgroundMonitoring: boolean;
+}
+
+export interface QualityGate {
+  id: string;
+  name: string;
+  type: 'automated' | 'manual' | 'hybrid';
+  criteria: QualityCriteria[];
+  threshold: number; // 0-1
+  blocking: boolean; // Does failure block progression?
+  agentTypes: string[]; // Which agents can validate this gate
+}
+
+export interface QualityCriteria {
+  metric: string;
+  operator: 'eq' | 'ne' | 'gt' | 'lt' | 'gte' | 'lte';
+  value: number;
+  weight: number; // 0-1, importance of this criteria
+  source: 'automated-test' | 'code-analysis' | 'human-review' | 'consensus';
+}
+
+// ===== LIVING DOCUMENTATION TYPES =====
+
+export interface LivingDocumentationState {
+  specVersion: string;
+  codeVersion: string;
+  lastSyncTimestamp: Date;
+  syncStatus: 'in-sync' | 'diverged' | 'syncing' | 'conflict';
+  changesSinceLastSync: DocumentationChange[];
+  conflicts: SyncConflict[];
+  automatedSyncEnabled: boolean;
+}
+
+export interface DocumentationChange {
+  id: string;
+  type: 'spec-change' | 'code-change';
+  file: string;
+  section?: string;
+  oldValue: string;
+  newValue: string;
+  timestamp: Date;
+  author: string;
+  confidence: number; // 0-1, how confident we are about this change
+}
+
+export interface SyncConflict {
+  id: string;
+  type: 'content-conflict' | 'structural-conflict' | 'semantic-conflict';
+  specSection: string;
+  codeSection: string;
+  description: string;
+  resolutionStrategy: 'manual' | 'spec-wins' | 'code-wins' | 'merge';
+  priority: 'low' | 'medium' | 'high';
+  createdAt: Date;
+}
+
+// ===== CONSENSUS SYSTEM TYPES =====
+
+export interface ConsensusSession {
+  id: string;
+  topic: string;
+  participants: ConsensusParticipant[];
+  status: 'pending' | 'active' | 'completed' | 'failed' | 'timeout';
+  startedAt: Date;
+  completedAt?: Date;
+  result?: ConsensusResult;
+  rounds: ConsensusRound[];
+  metadata: Record<string, any>;
+}
+
+export interface ConsensusParticipant {
+  agentId: string;
+  agentType: string;
+  weight: number; // Voting weight based on expertise
+  reliability: number; // 0-1, historical reliability
+  expertise: Record<string, number>; // Domain expertise scores
+  availability: boolean;
+}
+
+export interface ConsensusRound {
+  round: number;
+  votes: ConsensusVote[];
+  result: 'consensus' | 'no-consensus' | 'timeout';
+  timestamp: Date;
+  convergenceMetric: number; // How close to consensus
+}
+
+export interface ConsensusVote {
+  agentId: string;
+  option: string;
+  confidence: number; // 0-1
+  reasoning: string;
+  timestamp: Date;
+  metadata?: Record<string, any>;
+}
+
+export interface ConsensusResult {
+  decision: string;
+  confidence: number; // 0-1
+  unanimity: boolean;
+  participationRate: number; // 0-1
+  qualityScore: number; // 0-1
+  dissents: ConsensusDissent[];
+  metadata: Record<string, any>;
+}
+
+export interface ConsensusDissent {
+  agentId: string;
+  reason: string;
+  alternativeProposal?: string;
+  severity: 'low' | 'medium' | 'high';
+}
+
+// ===== AGENT HOOK SYSTEM TYPES =====
+
+export interface AgentHookEvent {
+  id: string;
+  type: string;
+  source: string;
+  timestamp: Date;
+  data: Record<string, any>;
+  processed: boolean;
+  processingResults?: HookProcessingResult[];
+}
+
+export interface HookProcessingResult {
+  hookId: string;
+  agentId: string;
+  status: 'success' | 'failed' | 'timeout';
+  result?: any;
+  error?: string;
+  processingTime: number; // ms
+  timestamp: Date;
+}
+
+// ===== PATTERN LEARNING TYPES =====
+
+export interface PatternLearningData {
+  specificationPatterns: SpecPattern[];
+  designPatterns: DesignPattern[];
+  implementationPatterns: ImplementationPattern[];
+  outcomePatterns: OutcomePattern[];
+}
+
+export interface SpecPattern {
+  id: string;
+  domain: string;
+  pattern: string;
+  frequency: number;
+  successRate: number;
+  contexts: string[];
+  examples: string[];
+}
+
+export interface DesignPattern {
+  id: string;
+  architecture: string;
+  components: string[];
+  relationships: string[];
+  applicability: string[];
+  pros: string[];
+  cons: string[];
+  usage_frequency: number;
+}
+
+export interface ImplementationPattern {
+  id: string;
+  language: string;
+  framework: string;
+  pattern_code: string;
+  complexity: 'low' | 'medium' | 'high';
+  maintainability: number; // 0-1
+  performance: number; // 0-1
+}
+
+export interface OutcomePattern {
+  id: string;
+  inputs: Record<string, any>;
+  outputs: Record<string, any>;
+  quality: number; // 0-1
+  timeline: number; // actual time taken
+  stakeholder_satisfaction: number; // 0-1
+  lessons_learned: string[];
+}
+
+// ===== ENHANCED ORCHESTRATOR STATE =====
+
+export interface KiroEnhancedWorkflowState extends MaestroWorkflowState {
+  livingDocState: LivingDocumentationState;
+  activeHooks: string[]; // Active hook IDs
+  consensusSessions: ConsensusSession[];
+  patternLearningData: PatternLearningData;
+  qualityMetrics: QualityMetrics;
+  backgroundAgents: string[]; // Background monitoring agents
+  enhancedMetadata: Record<string, any>;
+}
+
+export interface QualityMetrics {
+  codeQuality: number; // 0-1
+  documentationQuality: number; // 0-1
+  testCoverage: number; // 0-1
+  specCompleteness: number; // 0-1
+  implementationFidelity: number; // 0-1, how well code matches spec
+  consensusReliability: number; // 0-1
+  cycletime: number; // ms
+  defectDensity: number; // defects per KLOC
+}