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

package/src/cli/swarm-standalone.js

@@ -7,7 +7,7 @@ import { spawn } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 import { dirname, join } from 'node:path';
 import { existsSync } from 'node:fs';
-import { Deno, cwd, exit } from './node-compat.js';
+import { cwd, exit } from './node-compat.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -51,7 +51,7 @@ EXAMPLES:
 
 Run 'claude-flow swarm --help' for full options
 `);
-  Deno.exit(1);
+  process.exit(1);
 }
 
 // Try to find the swarm implementation
@@ -102,7 +102,7 @@ if (!swarmPath) {
     console.log(`  • Fault Tolerance: ${flags['fault-tolerance'] || 'retry'}`);
     console.log(`  • Communication: ${flags.communication || 'event-driven'}`);
     console.log('⚠️  DRY RUN - Advanced Swarm Configuration');
-    Deno.exit(0);
+    process.exit(0);
   }
 
   // Try to use Claude wrapper approach
@@ -124,7 +124,7 @@ if (!swarmPath) {
       console.log('3. Memory sharing between agents');
       console.log('4. Progress monitoring and reporting');
       console.log('5. Result aggregation and quality checks');
-      Deno.exit(0);
+      process.exit(0);
     }
 
     // Claude is available, use it to run swarm
@@ -211,7 +211,7 @@ Use all available tools including file operations, web search, and code executio
     console.log('5. Result aggregation and quality checks');
   }
 
-  Deno.exit(0);
+  process.exit(0);
 } else {
   // Run the swarm demo directly
   const swarmArgs = [objective];

package/src/cli/utils.js

@@ -1,6 +1,10 @@
 // utils.js - Shared CLI utility functions
 
-import { Deno, existsSync } from './node-compat.js';
+import { existsSync } from './node-compat.js';
+import { promises as fs } from 'fs';
+import { spawn } from 'child_process';
+import { promisify } from 'util';
+import { chmod } from 'fs/promises';
 
 // Color formatting functions
 export function printSuccess(message) {
@@ -19,6 +23,11 @@ export function printInfo(message) {
   console.log(`ℹ️  ${message}`);
 }
 
+// Process exit function
+export function exit(code = 0) {
+  process.exit(code);
+}
+
 // Command validation helpers
 export function validateArgs(args, minLength, usage) {
   if (args.length < minLength) {
@@ -31,7 +40,7 @@ export function validateArgs(args, minLength, usage) {
 // File system helpers
 export async function ensureDirectory(path) {
   try {
-    await Deno.mkdir(path, { recursive: true });
+    await fs.mkdir(path, { recursive: true });
     return true;
   } catch (err) {
     if (err.code !== 'EEXIST') {
@@ -43,7 +52,7 @@ export async function ensureDirectory(path) {
 
 export async function fileExists(path) {
   try {
-    await Deno.stat(path);
+    await fs.stat(path);
     return true;
   } catch {
     return false;
@@ -53,7 +62,7 @@ export async function fileExists(path) {
 // JSON helpers
 export async function readJsonFile(path, defaultValue = {}) {
   try {
-    const content = await Deno.readTextFile(path);
+    const content = await fs.readFile(path, 'utf8');
     return JSON.parse(content);
   } catch {
     return defaultValue;
@@ -61,7 +70,7 @@ export async function readJsonFile(path, defaultValue = {}) {
 }
 
 export async function writeJsonFile(path, data) {
-  await Deno.writeTextFile(path, JSON.stringify(data, null, 2));
+  await fs.writeFile(path, JSON.stringify(data, null, 2), 'utf8');
 }
 
 // String helpers
@@ -121,64 +130,43 @@ export function parseFlags(args) {
 // Process execution helpers
 export async function runCommand(command, args = [], options = {}) {
   try {
-    // Check if we're in Node.js or Deno environment
-    if (typeof process !== 'undefined' && process.versions && process.versions.node) {
-      // Node.js environment
-      const { spawn } = await import('child_process');
-      const { promisify } = await import('util');
-
-      return new Promise((resolve) => {
-        const child = spawn(command, args, {
-          stdio: ['pipe', 'pipe', 'pipe'],
-          shell: true,
-          ...options,
-        });
+    // Node.js environment
+    return new Promise((resolve) => {
+      const child = spawn(command, args, {
+        stdio: ['pipe', 'pipe', 'pipe'],
+        shell: true,
+        ...options,
+      });
 
-        let stdout = '';
-        let stderr = '';
+      let stdout = '';
+      let stderr = '';
 
-        child.stdout?.on('data', (data) => {
-          stdout += data.toString();
-        });
+      child.stdout?.on('data', (data) => {
+        stdout += data.toString();
+      });
 
-        child.stderr?.on('data', (data) => {
-          stderr += data.toString();
-        });
+      child.stderr?.on('data', (data) => {
+        stderr += data.toString();
+      });
 
-        child.on('close', (code) => {
-          resolve({
-            success: code === 0,
-            code: code || 0,
-            stdout: stdout,
-            stderr: stderr,
-          });
+      child.on('close', (code) => {
+        resolve({
+          success: code === 0,
+          code: code || 0,
+          stdout: stdout,
+          stderr: stderr,
         });
+      });
 
-        child.on('error', (err) => {
-          resolve({
-            success: false,
-            code: -1,
-            stdout: '',
-            stderr: err.message,
-          });
+      child.on('error', (err) => {
+        resolve({
+          success: false,
+          code: -1,
+          stdout: '',
+          stderr: err.message,
         });
       });
-    } else {
-      // Deno environment
-      const cmd = new Deno.Command(command, {
-        args,
-        ...options,
-      });
-
-      const result = await cmd.output();
-
-      return {
-        success: result.code === 0,
-        code: result.code,
-        stdout: new TextDecoder().decode(result.stdout),
-        stderr: new TextDecoder().decode(result.stderr),
-      };
-    }
+    });
   } catch (err) {
     return {
       success: false,
@@ -209,7 +197,7 @@ export async function loadConfig(path = 'claude-flow.config.json') {
   };
 
   try {
-    const content = await Deno.readTextFile(path);
+    const content = await fs.readFile(path, 'utf8');
     return { ...defaultConfig, ...JSON.parse(content) };
   } catch {
     return defaultConfig;
@@ -238,11 +226,11 @@ export function chunk(array, size) {
 
 // Environment helpers
 export function getEnvVar(name, defaultValue = null) {
-  return Deno.env.get(name) ?? defaultValue;
+  return process.env[name] ?? defaultValue;
 }
 
 export function setEnvVar(name, value) {
-  Deno.env.set(name, value);
+  process.env[name] = value;
 }
 
 // Validation helpers
@@ -324,14 +312,14 @@ export async function callRuvSwarmMCP(tool, params = {}) {
 
     // Write messages to temp file
     const messages = JSON.stringify(initMessage) + '\n' + JSON.stringify(toolMessage);
-    await Deno.writeTextFile(tempFile, messages);
+    await fs.writeFile(tempFile, messages, 'utf8');
 
     // Create a script that feeds the file to the REAL ruv-swarm MCP server
     const script = `#!/bin/bash
 timeout 30s npx ruv-swarm mcp start --stdio < "${tempFile}" 2>/dev/null | tail -1
 `;
-    await Deno.writeTextFile(tempScript, script);
-    await Deno.chmod(tempScript, 0o755);
+    await fs.writeFile(tempScript, script, 'utf8');
+    await chmod(tempScript, 0o755);
 
     const result = await runCommand('bash', [tempScript], {
       stdout: 'piped',
@@ -340,8 +328,8 @@ timeout 30s npx ruv-swarm mcp start --stdio < "${tempFile}" 2>/dev/null | tail -
 
     // Clean up temp files
     try {
-      await Deno.remove(tempFile);
-      await Deno.remove(tempScript);
+      await fs.unlink(tempFile);
+      await fs.unlink(tempScript);
     } catch {
       // Ignore cleanup errors
     }
@@ -501,14 +489,14 @@ export async function callRuvSwarmDirectNeural(params = {}) {
     try {
       // Read the latest training file
       const neuralDir = '.ruv-swarm/neural';
-      const files = await Deno.readDir(neuralDir);
+      const files = await fs.readdir(neuralDir, { withFileTypes: true });
       let latestFile = null;
       let latestTime = 0;
 
       for await (const file of files) {
         if (file.name.startsWith(`training-${modelName}-`) && file.name.endsWith('.json')) {
           const filePath = `${neuralDir}/${file.name}`;
-          const stat = await Deno.stat(filePath);
+          const stat = await fs.stat(filePath);
           if (stat.mtime > latestTime) {
             latestTime = stat.mtime;
             latestFile = filePath;
@@ -517,7 +505,7 @@ export async function callRuvSwarmDirectNeural(params = {}) {
       }
 
       if (latestFile) {
-        const content = await Deno.readTextFile(latestFile);
+        const content = await fs.readFile(latestFile, 'utf8');
         const realResult = JSON.parse(content);
 
         return {

package/src/hive-mind/core/HiveMind.ts

@@ -168,6 +168,15 @@ export class HiveMind extends EventEmitter {
         { type: 'coordinator', count: 1 },
         { type: 'specialist', count: 4 },
       ],
+      // Maestro specs-driven topology
+      'specs-driven': [
+        { type: 'requirements_analyst', count: 1 },
+        { type: 'design_architect', count: 2 },
+        { type: 'task_planner', count: 1 },
+        { type: 'implementation_coder', count: 2 },
+        { type: 'quality_reviewer', count: 1 },
+        { type: 'steering_documenter', count: 1 },
+      ],
     };
 
     const config = topologyConfigs[this.config.topology];
@@ -460,6 +469,13 @@ export class HiveMind extends EventEmitter {
       documenter: ['documentation_generation', 'api_docs', 'user_guides'],
       monitor: ['system_monitoring', 'health_checks', 'alerting'],
       specialist: ['domain_expertise', 'custom_capabilities', 'problem_solving'],
+      // Maestro specs-driven agent capabilities
+      requirements_analyst: ['requirements_analysis', 'user_story_creation', 'acceptance_criteria'],
+      design_architect: ['system_design', 'architecture', 'technical_writing', 'specs_driven_design'],
+      task_planner: ['task_management', 'workflow_orchestration', 'project_management'],
+      implementation_coder: ['code_generation', 'implementation', 'debugging', 'refactoring'],
+      quality_reviewer: ['code_review', 'quality_assurance', 'testing', 'standards_enforcement'],
+      steering_documenter: ['documentation_generation', 'governance', 'technical_writing'],
     };
 
     return capabilityMap[type] || [];

package/src/hive-mind/types.ts

@@ -5,8 +5,8 @@
  */
 
 // Swarm types
-export type SwarmTopology = 'mesh' | 'hierarchical' | 'ring' | 'star';
-export type QueenMode = 'centralized' | 'distributed';
+export type SwarmTopology = 'mesh' | 'hierarchical' | 'ring' | 'star' | 'specs-driven';
+export type QueenMode = 'centralized' | 'distributed' | 'strategic';
 
 export interface HiveMindConfig {
   name: string;
@@ -16,8 +16,11 @@ export interface HiveMindConfig {
   memoryTTL: number;
   consensusThreshold: number;
   autoSpawn: boolean;
+  enableConsensus?: boolean;
+  enableMemory?: boolean;
+  enableCommunication?: boolean;
   enabledFeatures?: string[];
-  createdAt: Date;
+  createdAt?: Date;
 }
 
 // Agent types
@@ -32,7 +35,14 @@ export type AgentType =
   | 'optimizer'
   | 'documenter'
   | 'monitor'
-  | 'specialist';
+  | 'specialist'
+  // Maestro specs-driven agent types
+  | 'requirements_analyst'
+  | 'design_architect'
+  | 'task_planner'
+  | 'implementation_coder'
+  | 'quality_reviewer'
+  | 'steering_documenter';
 
 export type AgentStatus = 'idle' | 'busy' | 'active' | 'error' | 'offline';
 
@@ -50,8 +60,10 @@ export type AgentCapability =
   | 'performance_metrics'
   | 'bottleneck_detection'
   | 'system_design'
+  | 'architecture'
   | 'architecture_patterns'
   | 'integration_planning'
+  | 'technical_writing'
   | 'test_generation'
   | 'quality_assurance'
   | 'edge_case_detection'
@@ -69,7 +81,14 @@ export type AgentCapability =
   | 'alerting'
   | 'domain_expertise'
   | 'custom_capabilities'
-  | 'problem_solving';
+  | 'problem_solving'
+  // Maestro specs-driven capabilities
+  | 'requirements_analysis'
+  | 'user_story_creation'
+  | 'acceptance_criteria'
+  | 'specs_driven_design'
+  | 'workflow_orchestration'
+  | 'governance';
 
 export interface AgentConfig {
   id?: string;
@@ -84,6 +103,18 @@ export interface AgentSpawnOptions {
   name?: string;
   capabilities?: AgentCapability[];
   autoAssign?: boolean;
+  config?: Partial<AgentConfig>;
+  environment?: Partial<AgentEnvironment>;
+}
+
+export interface AgentEnvironment {
+  workingDirectory?: string;
+  environmentVariables?: Record<string, string>;
+  resourceLimits?: {
+    maxMemory?: number;
+    maxCpu?: number;
+    timeout?: number;
+  };
 }
 
 // Task types
@@ -246,6 +277,8 @@ export interface ConsensusProposal {
   proposal: any;
   requiredThreshold: number;
   deadline?: Date;
+  creator?: string;
+  metadata?: Record<string, any>;
 }
 
 export interface ConsensusVote {

package/src/hooks/index.ts

@@ -0,0 +1,192 @@
+/**
+ * Legacy Hook System - Migration Notice
+ * 
+ * This hook system has been consolidated with the more advanced agentic-flow-hooks system.
+ * All functionality is now available through the modern implementation at:
+ * src/services/agentic-flow-hooks/
+ * 
+ * This file provides backward compatibility redirects while we complete the migration.
+ */
+
+// Re-export the modern agentic-flow-hooks system
+export {
+  agenticHookManager,
+  initializeAgenticFlowHooks,
+} from '../services/agentic-flow-hooks/index.js';
+
+// Re-export modern types with compatibility aliases
+export type {
+  AgenticHookContext as HookExecutionContext,
+  HookRegistration as AgentHook,
+  HookPayload as EventPayload,
+  AgenticHookType as HookTrigger,
+  HookHandlerResult as HookExecutionResult,
+} from '../services/agentic-flow-hooks/types.js';
+
+// Legacy hook templates for backward compatibility
+export const QUALITY_HOOKS = {
+  CODE_QUALITY: {
+    name: 'Code Quality Monitor',
+    description: 'Automatically runs code quality checks on file changes',
+    type: 'workflow-step' as const,
+    priority: 8,
+    enabled: true
+  },
+  SECURITY_SCAN: {
+    name: 'Security Scanner', 
+    description: 'Scans for security vulnerabilities and credential leaks',
+    type: 'workflow-step' as const,
+    priority: 9,
+    enabled: true
+  },
+  DOCUMENTATION_SYNC: {
+    name: 'Documentation Sync',
+    description: 'Automatically updates documentation when specifications change',
+    type: 'workflow-step' as const,
+    priority: 7,
+    enabled: true
+  },
+  PERFORMANCE_MONITOR: {
+    name: 'Performance Monitor',
+    description: 'Analyzes performance impact of code changes', 
+    type: 'workflow-step' as const,
+    priority: 6,
+    enabled: true
+  }
+};
+
+// Legacy constants for backward compatibility
+export const DEFAULT_HOOK_CONFIG = {
+  maxConcurrentHooks: 10,
+  defaultThrottleMs: 1000,
+  defaultDebounceMs: 500,
+  eventQueueSize: 1000,
+  agentPoolSize: 50,
+  enableMetrics: true,
+  enablePersistence: true,
+  logLevel: 'info' as const,
+  watchPatterns: ['**/*.md', '**/*.ts', '**/*.js', '**/*.json'],
+  ignorePatterns: ['node_modules/**', '.git/**', 'dist/**', 'build/**']
+};
+
+export const HOOK_TRIGGERS = {
+  FILE_SAVE: 'workflow-step',
+  FILE_CHANGE: 'workflow-step',
+  FILE_CREATE: 'workflow-start',
+  FILE_DELETE: 'workflow-complete',
+  TASK_COMPLETE: 'workflow-complete',
+  TASK_FAIL: 'workflow-error',
+  SPEC_UPDATE: 'workflow-step',
+  CODE_CHANGE: 'workflow-step',
+  AGENT_SPAWN: 'workflow-start',
+  WORKFLOW_PHASE: 'workflow-step',
+  TIME_INTERVAL: 'performance-metric'
+} as const;
+
+export const AGENT_TYPES = {
+  QUALITY_ASSURANCE: 'quality_assurance',
+  SECURITY_SCAN: 'security_scan', 
+  DOCUMENTATION_SYNC: 'documentation_sync',
+  PERFORMANCE_ANALYSIS: 'performance_analysis'
+} as const;
+
+/**
+ * Migration utility class
+ * Provides backward compatibility while encouraging migration to agentic-flow-hooks
+ */
+export class HookUtils {
+  /**
+   * @deprecated Use agenticHookManager.register() instead
+   */
+  static createFilePatternCondition(pattern: string) {
+    console.warn('HookUtils.createFilePatternCondition is deprecated. Use agenticHookManager.register() with proper HookFilter instead.');
+    return { type: 'file_pattern', pattern };
+  }
+
+  /**
+   * @deprecated Use agenticHookManager.register() instead
+   */
+  static createSpawnAgentAction(agentType: string, config: Record<string, any>) {
+    console.warn('HookUtils.createSpawnAgentAction is deprecated. Use agenticHookManager.register() with proper hook handlers instead.');
+    return { type: 'spawn_agent', agentType, agentConfig: config };
+  }
+
+  /**
+   * @deprecated Use agenticHookManager.register() instead
+   */
+  static createQualityHook(options: any) {
+    console.warn('HookUtils.createQualityHook is deprecated. Use agenticHookManager.register() with workflow-step hooks instead.');
+    return QUALITY_HOOKS.CODE_QUALITY;
+  }
+
+  /**
+   * @deprecated Use agenticHookManager.register() instead  
+   */
+  static createSecurityHook(options: any) {
+    console.warn('HookUtils.createSecurityHook is deprecated. Use agenticHookManager.register() with workflow-step hooks instead.');
+    return QUALITY_HOOKS.SECURITY_SCAN;
+  }
+
+  /**
+   * @deprecated Use agenticHookManager.register() instead
+   */
+  static createDocumentationHook(options: any) {
+    console.warn('HookUtils.createDocumentationHook is deprecated. Use agenticHookManager.register() with workflow-step hooks instead.');
+    return QUALITY_HOOKS.DOCUMENTATION_SYNC;
+  }
+
+  /**
+   * @deprecated Use agenticHookManager.register() instead
+   */
+  static createPerformanceHook(options: any) {
+    console.warn('HookUtils.createPerformanceHook is deprecated. Use agenticHookManager.register() with performance-metric hooks instead.');
+    return QUALITY_HOOKS.PERFORMANCE_MONITOR;
+  }
+}
+
+/**
+ * @deprecated Use initializeAgenticFlowHooks() instead
+ */
+export function createHookEngine(config?: any) {
+  console.warn('createHookEngine is deprecated. Use initializeAgenticFlowHooks() and agenticHookManager instead.');
+  return {
+    registerHook: () => console.warn('Use agenticHookManager.register() instead'),
+    start: () => console.warn('Hooks are automatically initialized with agenticHookManager'),
+    stop: () => console.warn('Use agenticHookManager shutdown methods instead')
+  };
+}
+
+/**
+ * @deprecated Use agenticHookManager.register() for individual hooks instead
+ */
+export async function setupDefaultHooks(engine?: any) {
+  console.warn('setupDefaultHooks is deprecated. Use agenticHookManager.register() to register specific hooks instead.');
+  console.info('Consider migrating to agentic-flow-hooks for advanced pipeline management and neural integration.');
+  return 4; // Return count for backward compatibility
+}
+
+// Migration notice for users
+console.info(`
+🔄 MIGRATION NOTICE: Hook System Consolidation
+
+The legacy hook system in src/hooks/ has been consolidated with the advanced
+agentic-flow-hooks system for better performance and functionality.
+
+✅ New System Features:
+  - Advanced pipeline management
+  - Neural pattern learning  
+  - Performance optimization
+  - Memory coordination hooks
+  - LLM integration hooks
+
+📖 Migration Guide:
+  - Replace AgentHookEngine with agenticHookManager
+  - Update hook registrations to use modern HookRegistration interface
+  - Leverage new hook types: LLM, memory, neural, performance, workflow
+  - See docs/maestro/specs/hooks-refactoring-plan.md for details
+
+🚀 Get Started:
+  import { agenticHookManager, initializeAgenticFlowHooks } from '../services/agentic-flow-hooks/'
+  await initializeAgenticFlowHooks()
+  agenticHookManager.register({ ... })
+`);