claude-flow-novice 2.8.1 → 2.9.1

package/.claude/commands/workflow.js

@@ -1,606 +0,0 @@
-#!/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/.claude/commands/workflows/README.md

@@ -1,9 +0,0 @@
-# Workflows Commands
-
-Commands for workflows operations in Claude Flow.
-
-## Available Commands
-
-- [workflow-create](./workflow-create.md)
-- [workflow-execute](./workflow-execute.md)
-- [workflow-export](./workflow-export.md)

package/.claude/commands/workflows/development.md

@@ -1,78 +0,0 @@
-# Development Workflow Coordination
-
-## Purpose
-Structure Claude Code's approach to complex development tasks for maximum efficiency.
-
-## Step-by-Step Coordination
-
-### 1. Initialize Development Framework
-```
-Tool: mcp__claude-flow__swarm_init
-Parameters: {"topology": "hierarchical", "maxAgents": 8, "strategy": "specialized"}
-```
-Creates hierarchical structure for organized, top-down development.
-
-### 2. Define Development Perspectives
-```
-Tool: mcp__claude-flow__agent_spawn
-Parameters: {
-  "type": "architect",
-  "name": "System Design",
-  "capabilities": ["api-design", "database-schema"]
-}
-```
-```
-Tool: mcp__claude-flow__agent_spawn
-Parameters: {
-  "type": "coder",
-  "name": "Implementation Focus",
-  "capabilities": ["nodejs", "typescript", "express"]
-}
-```
-```
-Tool: mcp__claude-flow__agent_spawn
-Parameters: {
-  "type": "tester",
-  "name": "Quality Assurance",
-  "capabilities": ["unit-testing", "integration-testing"]
-}
-```
-Sets up architectural and implementation thinking patterns.
-
-### 3. Coordinate Implementation
-```
-Tool: mcp__claude-flow__task_orchestrate
-Parameters: {
-  "task": "Build REST API with authentication",
-  "strategy": "parallel",
-  "priority": "high",
-  "dependencies": ["database setup", "auth system"]
-}
-```
-
-### 4. Monitor Progress
-```
-Tool: mcp__claude-flow__task_status
-Parameters: {"taskId": "api-build-task-123"}
-```
-
-## What Claude Code Actually Does
-1. Uses **Write** tool to create new files
-2. Uses **Edit/MultiEdit** tools for code modifications
-3. Uses **Bash** tool for testing and building
-4. Uses **TodoWrite** tool for task tracking
-5. Follows coordination patterns for systematic implementation
-
-Remember: All code is written by Claude Code using its native tools!
-
-## CLI Usage
-```bash
-# Start development workflow via CLI
-npx claude-flow-novice workflow dev "REST API with auth"
-
-# Create custom workflow
-npx claude-flow-novice workflow create --name "api-dev" --steps "design,implement,test,deploy"
-
-# Execute saved workflow
-npx claude-flow-novice workflow execute api-dev
-```