claude-flow-novice 1.1.8 → 1.1.9

package/dist/src/slash-commands/workflow.js

@@ -0,0 +1,606 @@
+#!/usr/bin/env node
+
+/**
+ * Workflow Automation Slash Command
+ * Usage: /workflow <action> [options]
+ */
+
+import { SlashCommand } from '../core/slash-command.js';
+
+export class WorkflowCommand extends SlashCommand {
+  constructor() {
+    super('workflow', 'Create and manage automated workflows and CI/CD pipelines');
+  }
+
+  getUsage() {
+    return '/workflow <action> [options]';
+  }
+
+  getExamples() {
+    return [
+      '/workflow create "Build and Test" - Create new workflow',
+      '/workflow execute build-workflow - Execute existing workflow',
+      '/workflow pipeline nodejs - Create CI/CD pipeline',
+      '/workflow automate tests - Setup test automation',
+      '/workflow schedule daily - Setup scheduled workflows',
+      '/workflow template list - List available templates',
+      '/workflow trigger push - Setup event triggers'
+    ];
+  }
+
+  async execute(args, context) {
+    const [action, ...params] = args;
+
+    if (!action) {
+      return this.formatResponse({
+        success: false,
+        error: 'Action required',
+        usage: this.getUsage(),
+        availableActions: [
+          'create', 'execute', 'pipeline', 'automate', 'schedule',
+          'template', 'trigger', 'export', 'batch', 'parallel'
+        ]
+      });
+    }
+
+    try {
+      let result;
+
+      switch (action.toLowerCase()) {
+        case 'create':
+          result = await this.createWorkflow(params);
+          break;
+        
+        case 'execute':
+          result = await this.executeWorkflow(params);
+          break;
+        
+        case 'pipeline':
+          result = await this.createPipeline(params);
+          break;
+        
+        case 'automate':
+          result = await this.setupAutomation(params);
+          break;
+        
+        case 'schedule':
+          result = await this.setupScheduler(params);
+          break;
+        
+        case 'template':
+          result = await this.manageTemplates(params);
+          break;
+        
+        case 'trigger':
+          result = await this.setupTriggers(params);
+          break;
+        
+        case 'export':
+          result = await this.exportWorkflow(params);
+          break;
+        
+        case 'batch':
+          result = await this.batchProcess(params);
+          break;
+        
+        case 'parallel':
+          result = await this.parallelExecute(params);
+          break;
+        
+        default:
+          result = {
+            success: false,
+            error: `Unknown action: ${action}`,
+            availableActions: [
+              'create', 'execute', 'pipeline', 'automate', 'schedule',
+              'template', 'trigger', 'export', 'batch', 'parallel'
+            ]
+          };
+      }
+
+      return this.formatResponse(result);
+    } catch (error) {
+      return this.formatResponse({
+        success: false,
+        error: error.message,
+        action: action
+      });
+    }
+  }
+
+  async createWorkflow(params) {
+    const name = params.join(' ');
+
+    if (!name) {
+      return {
+        success: false,
+        error: 'Workflow name required'
+      };
+    }
+
+    console.log(`⚙️ Creating workflow: ${name}`);
+
+    const prompt = `
+⚙️ **CREATE WORKFLOW**
+
+**Workflow Name:** ${name}
+
+**Create custom workflow with MCP coordination:**
+
+\`\`\`javascript
+// Create custom workflow
+mcp__claude-flow__workflow_create({
+  name: "${name}",
+  steps: [
+    { name: "initialize", type: "setup" },
+    { name: "execute", type: "main" },
+    { name: "validate", type: "test" },
+    { name: "finalize", type: "cleanup" }
+  ],
+  triggers: ["manual", "scheduled", "event"]
+});
+
+// Spawn workflow coordination agents with Claude Code's Task tool
+Task("Workflow Designer", "Design and structure workflow: ${name}", "architect")
+Task("Automation Engineer", "Implement workflow automation", "cicd-engineer")
+Task("Quality Assurance", "Validate workflow steps and outcomes", "tester")
+Task("Documentation Lead", "Document workflow process and usage", "api-docs")
+\`\`\`
+
+**Workflow Features:**
+- 🔄 Event-driven execution
+- ⚡ Parallel step processing
+- 📊 Real-time monitoring
+- 🚫 Error handling and recovery
+- 💾 State persistence
+- 📝 Comprehensive logging
+
+**Execute workflow creation now**:
+`;
+
+    return {
+      success: true,
+      prompt: prompt,
+      workflowName: name,
+      workflowId: `workflow-${Date.now()}`
+    };
+  }
+
+  async executeWorkflow(params) {
+    const [workflowId, ...paramList] = params;
+
+    if (!workflowId) {
+      return {
+        success: false,
+        error: 'Workflow ID required'
+      };
+    }
+
+    console.log(`🚀 Executing workflow: ${workflowId}`);
+
+    const prompt = `
+🚀 **EXECUTE WORKFLOW**
+
+**Workflow ID:** ${workflowId}
+**Parameters:** ${paramList.join(', ') || 'default'}
+
+**Execute predefined workflow:**
+
+\`\`\`javascript
+// Execute predefined workflow
+mcp__claude-flow__workflow_execute({
+  workflowId: "${workflowId}",
+  params: {
+    ${paramList.map((p, i) => `param${i + 1}: "${p}"`).join(',\n    ')}
+  }
+});
+
+// Monitor workflow execution
+mcp__claude-flow__task_status({ taskId: "${workflowId}" });
+\`\`\`
+
+**Execution Monitoring:**
+- 📉 Real-time progress tracking
+- ⚡ Performance metrics
+- 🚫 Error detection and handling
+- 💾 State checkpoints
+- 📝 Execution logs
+
+**Execute workflow now**:
+`;
+
+    return {
+      success: true,
+      prompt: prompt,
+      workflowId: workflowId,
+      parameters: paramList
+    };
+  }
+
+  async createPipeline(params) {
+    const [projectType = 'nodejs', ...features] = params;
+
+    console.log(`🚀 Creating CI/CD pipeline for ${projectType}...`);
+
+    const prompt = `
+🚀 **CREATE CI/CD PIPELINE**
+
+**Project Type:** ${projectType}
+**Features:** ${features.length > 0 ? features.join(', ') : 'standard'}
+
+**Create comprehensive CI/CD pipeline:**
+
+\`\`\`javascript
+// Create CI/CD pipeline
+mcp__claude-flow__pipeline_create({
+  config: {
+    projectType: "${projectType}",
+    features: [${features.length > 0 ? features.map(f => `"${f}"`).join(', ') : '"build", "test", "deploy"'}],
+    stages: ["lint", "test", "build", "security", "deploy"]
+  }
+});
+
+// Spawn pipeline setup agents with Claude Code's Task tool
+Task("DevOps Engineer", "Setup CI/CD pipeline for ${projectType}", "cicd-engineer")
+Task("Security Engineer", "Configure security scanning in pipeline", "security-manager")
+Task("Test Engineer", "Setup automated testing pipeline", "tester")
+Task("Deployment Specialist", "Configure deployment automation", "coordinator")
+\`\`\`
+
+**Pipeline Stages:**
+- 📝 Code quality checks (linting, formatting)
+- ⚙️ Automated testing (unit, integration, e2e)
+- 🛠️ Build and compilation
+- 🔒 Security scanning and vulnerability assessment
+- 🚀 Automated deployment
+- 📈 Performance monitoring
+
+**Execute pipeline creation now**:
+`;
+
+    return {
+      success: true,
+      prompt: prompt,
+      projectType: projectType,
+      features: features
+    };
+  }
+
+  async setupAutomation(params) {
+    const rules = params.join(' ');
+
+    if (!rules) {
+      return {
+        success: false,
+        error: 'Automation rules required'
+      };
+    }
+
+    console.log(`🤖 Setting up automation: ${rules}`);
+
+    const prompt = `
+🤖 **SETUP AUTOMATION**
+
+**Rules:** ${rules}
+
+**Configure automation rules:**
+
+\`\`\`javascript
+// Setup automation rules
+mcp__claude-flow__automation_setup({
+  rules: [
+    { trigger: "file-change", action: "auto-test" },
+    { trigger: "pr-opened", action: "code-review" },
+    { trigger: "issue-created", action: "triage" },
+    { trigger: "${rules}", action: "auto-execute" }
+  ]
+});
+
+// Spawn automation agents with Claude Code's Task tool
+Task("Automation Specialist", "Configure automation for: ${rules}", "coordinator")
+Task("Rule Engine", "Implement automation rules and triggers", "architect")
+Task("Monitor Agent", "Monitor automation execution", "performance-benchmarker")
+\`\`\`
+
+**Automation Capabilities:**
+- 🔄 Event-driven triggers
+- ⚡ Real-time response
+- 📊 Performance monitoring
+- 🚫 Error handling and recovery
+- 📝 Audit logging
+- 💾 State management
+
+**Execute automation setup now**:
+`;
+
+    return {
+      success: true,
+      prompt: prompt,
+      rules: rules
+    };
+  }
+
+  async setupScheduler(params) {
+    const [frequency, ...taskParams] = params;
+    const task = taskParams.join(' ');
+
+    if (!frequency) {
+      return {
+        success: false,
+        error: 'Schedule frequency required',
+        examples: ['daily', 'weekly', 'hourly', 'cron:0 9 * * *']
+      };
+    }
+
+    console.log(`🕰️ Setting up ${frequency} scheduler${task ? ` for: ${task}` : ''}`);
+
+    const prompt = `
+🕰️ **SETUP SCHEDULER**
+
+**Frequency:** ${frequency}
+**Task:** ${task || 'default maintenance'}
+
+**Configure scheduled workflows:**
+
+\`\`\`javascript
+// Manage task scheduling
+mcp__claude-flow__scheduler_manage({
+  action: "create",
+  schedule: {
+    frequency: "${frequency}",
+    task: "${task || 'maintenance'}",
+    enabled: true,
+    timezone: "UTC"
+  }
+});
+
+// Spawn scheduler agents with Claude Code's Task tool
+Task("Scheduler", "Configure ${frequency} scheduling for: ${task || 'maintenance'}", "coordinator")
+Task("Task Manager", "Manage scheduled task execution", "task-orchestrator")
+Task("Monitor", "Monitor scheduled task performance", "performance-benchmarker")
+\`\`\`
+
+**Scheduler Features:**
+- 🕰️ Flexible scheduling (cron, interval, event-based)
+- 🌐 Timezone awareness
+- 📈 Execution monitoring
+- 🚫 Failure recovery
+- 📝 Comprehensive logging
+
+**Execute scheduler setup now**:
+`;
+
+    return {
+      success: true,
+      prompt: prompt,
+      frequency: frequency,
+      task: task
+    };
+  }
+
+  async manageTemplates(params) {
+    const [action = 'list', ...templateParams] = params;
+
+    console.log(`📝 Managing workflow templates: ${action}`);
+
+    const prompt = `
+📝 **WORKFLOW TEMPLATES**
+
+**Action:** ${action}
+
+**Manage workflow templates:**
+
+\`\`\`javascript
+// Manage workflow templates
+mcp__claude-flow__workflow_template({
+  action: "${action}",
+  ${templateParams.length > 0 ? `template: { ${templateParams.map(p => `"${p}"`).join(', ')} }` : ''}
+});
+\`\`\`
+
+**Available Templates:**
+- 🚀 CI/CD Pipeline Templates
+- 🤖 Automation Workflow Templates
+- 📈 Monitoring and Analytics Templates
+- 🔒 Security Audit Templates
+- 📝 Documentation Generation Templates
+- ⚙️ Custom Integration Templates
+
+**Execute template management now**:
+`;
+
+    return {
+      success: true,
+      prompt: prompt,
+      action: action,
+      templates: templateParams
+    };
+  }
+
+  async setupTriggers(params) {
+    const [eventType, ...actions] = params;
+
+    if (!eventType) {
+      return {
+        success: false,
+        error: 'Event type required',
+        examples: ['push', 'pr', 'issue', 'schedule', 'webhook']
+      };
+    }
+
+    console.log(`⚡ Setting up ${eventType} triggers...`);
+
+    const prompt = `
+⚡ **SETUP EVENT TRIGGERS**
+
+**Event Type:** ${eventType}
+**Actions:** ${actions.length > 0 ? actions.join(', ') : 'default'}
+
+**Configure event-driven triggers:**
+
+\`\`\`javascript
+// Setup event triggers
+mcp__claude-flow__trigger_setup({
+  events: ["${eventType}"],
+  actions: [${actions.length > 0 ? actions.map(a => `"${a}"`).join(', ') : '"auto-test", "notify"'}]
+});
+
+// Spawn trigger management agents with Claude Code's Task tool
+Task("Event Handler", "Handle ${eventType} events and trigger actions", "coordinator")
+Task("Action Executor", "Execute triggered actions", "task-orchestrator")
+Task("Monitor", "Monitor trigger performance and reliability", "performance-benchmarker")
+\`\`\`
+
+**Trigger Events:**
+- 📝 Git push/commit events
+- 📝 Pull request events
+- 📝 Issue creation/updates
+- 🕰️ Scheduled events
+- 🌐 Webhook events
+- 📊 Performance thresholds
+
+**Execute trigger setup now**:
+`;
+
+    return {
+      success: true,
+      prompt: prompt,
+      eventType: eventType,
+      actions: actions
+    };
+  }
+
+  async exportWorkflow(params) {
+    const [workflowId, format = 'yaml'] = params;
+
+    if (!workflowId) {
+      return {
+        success: false,
+        error: 'Workflow ID required'
+      };
+    }
+
+    const validFormats = ['yaml', 'json', 'xml'];
+    if (!validFormats.includes(format)) {
+      return {
+        success: false,
+        error: `Invalid format. Valid options: ${validFormats.join(', ')}`
+      };
+    }
+
+    console.log(`💾 Exporting workflow ${workflowId} as ${format}...`);
+
+    const prompt = `
+💾 **EXPORT WORKFLOW**
+
+**Workflow ID:** ${workflowId}
+**Format:** ${format}
+
+**Export workflow definition:**
+
+\`\`\`javascript
+// Export workflow definition
+mcp__claude-flow__workflow_export({
+  workflowId: "${workflowId}",
+  format: "${format}"
+});
+\`\`\`
+
+**Execute workflow export now**:
+`;
+
+    return {
+      success: true,
+      prompt: prompt,
+      workflowId: workflowId,
+      format: format
+    };
+  }
+
+  async batchProcess(params) {
+    const [operation, ...items] = params;
+
+    if (!operation) {
+      return {
+        success: false,
+        error: 'Operation required for batch processing'
+      };
+    }
+
+    console.log(`📦 Batch processing: ${operation}`);
+
+    const prompt = `
+📦 **BATCH PROCESSING**
+
+**Operation:** ${operation}
+**Items:** ${items.length > 0 ? items.join(', ') : 'auto-detect'}
+
+**Execute batch processing:**
+
+\`\`\`javascript
+// Batch processing
+mcp__claude-flow__batch_process({
+  operation: "${operation}",
+  items: [${items.length > 0 ? items.map(i => `"${i}"`).join(', ') : '"item1", "item2", "item3"'}]
+});
+\`\`\`
+
+**Execute batch processing now**:
+`;
+
+    return {
+      success: true,
+      prompt: prompt,
+      operation: operation,
+      items: items
+    };
+  }
+
+  async parallelExecute(params) {
+    const tasks = params.join(' ').split(',').map(t => t.trim());
+
+    if (tasks.length === 0 || tasks[0] === '') {
+      return {
+        success: false,
+        error: 'Task list required (comma-separated)'
+      };
+    }
+
+    console.log(`⚡ Executing tasks in parallel: ${tasks.join(', ')}`);
+
+    const prompt = `
+⚡ **PARALLEL EXECUTION**
+
+**Tasks:** ${tasks.join(', ')}
+
+**Execute tasks in parallel:**
+
+\`\`\`javascript
+// Execute tasks in parallel
+mcp__claude-flow__parallel_execute({
+  tasks: [${tasks.map(t => `"${t}"`).join(', ')}]
+});
+
+// Spawn parallel execution agents with Claude Code's Task tool
+${tasks.map((task, i) => `Task("Parallel Worker ${i + 1}", "Execute: ${task}", "task-orchestrator")`).join('\n')}
+\`\`\`
+
+**Parallel Execution Benefits:**
+- ⚡  2.8-4.4x speed improvement
+- 📊 Optimal resource utilization
+- 🔄 Automatic load balancing
+- 🚫 Error isolation
+- 📈 Real-time progress tracking
+
+**Execute parallel tasks now**:
+`;
+
+    return {
+      success: true,
+      prompt: prompt,
+      tasks: tasks
+    };
+  }
+}
+
+export default WorkflowCommand;

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "claude-flow-novice",
-  "version": "1.1.8",
+  "version": "1.1.9",
   "description": "Simplified Claude Flow for beginners - AI agent orchestration made easy. Enhanced init command creates complete agent system (8 core agents), MCP configuration with 36 essential tools, and automated hooks. All memory leaks eliminated, zero deprecated dependencies, full project setup in one command.",
   "mcpName": "io.github.ruvnet/claude-flow",
   "main": "dist/index.js",
   "bin": {
     "claude-flow-novice": "dist/src/cli/main.js",
-    "claude-soul": "src/slash-commands/claude-soul.js"
+    "claude-soul": "dist/src/slash-commands/claude-soul.js"
   },
   "scripts": {
     "dev": "tsx src/cli/main.ts",
@@ -26,9 +26,9 @@
     "optimize:validate:hardware": "node scripts/optimization/config-validator.js validate hardware",
     "optimize:validate:monitoring": "node scripts/optimization/config-validator.js validate monitoring",
     "build": "scripts/build/unified-builder.sh safe",
-    "build:swc": "swc src -d dist --only='**/*.ts' --config-file .swcrc",
+    "build:swc": "swc src -d dist --only='**/*.ts' --config-file .swcrc && cp -r src/slash-commands dist/src/ && cp -r src/cli/simple-commands/hooks dist/src/cli/simple-commands/",
     "build:types": "tsc --project config/typescript/tsconfig.json --emitDeclarationOnly --outDir dist --skipLibCheck",
-    "build:watch": "swc src -d dist --watch --config-file .swcrc",
+    "build:watch": "swc src -d dist --watch --config-file .swcrc && cp -r src/slash-commands dist/src/ && cp -r src/cli/simple-commands/hooks dist/src/cli/simple-commands/",
     "build:legacy": "scripts/build/unified-builder.sh migration",
     "build:workaround": "scripts/build/unified-builder.sh workaround",
     "build:force": "scripts/build/unified-builder.sh force",
@@ -124,6 +124,7 @@
     "debug:swarm": "DEBUG=swarm* npm run dev",
     "mcp:start": "node dist/mcp/mcp-server-novice.js",
     "mcp:status": "node -e \"console.log('MCP Server Status: Ready')\"",
+    "mcp:verify": "node scripts/verify-mcp-server.js",
     "security:audit": "node scripts/security/ruv-swarm-safe.js --audit",
     "security:validate": "node scripts/security/ruv-swarm-safe.js",
     "migrate": "node scripts/migration/migrate-hooks.js",
@@ -196,9 +197,9 @@
     "./cli": "./dist/cli/index.js",
     "./mcp": "./dist/mcp/mcp-server.js",
     "./core": "./dist/core/index.js",
-    "./slash-commands/claude-soul": "./src/slash-commands/claude-soul.js",
-    "./slash-commands/register-claude-soul": "./src/slash-commands/register-claude-soul.js",
-    "./hooks/session-start-soul": "./src/cli/simple-commands/hooks/session-start-soul.js"
+    "./slash-commands/claude-soul": "./dist/src/slash-commands/claude-soul.js",
+    "./slash-commands/register-claude-soul": "./dist/src/slash-commands/register-claude-soul.js",
+    "./hooks/session-start-soul": "./dist/src/cli/simple-commands/hooks/session-start-soul.js"
   },
   "dependencies": {
     "boxen": "^8.0.1",