myaidev-method 0.2.2 → 0.2.4

package/dist/mcp/sparc-orchestrator-server.js

@@ -0,0 +1,607 @@
+#!/usr/bin/env node
+
+/**
+ * SPARC Orchestrator MCP Server
+ * Lightweight task orchestration for the 5-phase SPARC development workflow
+ * Part of MyAIDev Method - simplified from cflow's complex swarm system
+ */
+
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} from '@modelcontextprotocol/sdk/types.js';
+import { promises as fs } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+
+class SparcOrchestratorServer {
+  constructor() {
+    this.server = new Server(
+      {
+        name: 'sparc-orchestrator',
+        version: '1.0.0',
+      },
+      {
+        capabilities: {
+          tools: {},
+        },
+      }
+    );
+
+    // SPARC workflow state directory
+    this.workflowDir = join(homedir(), '.myaidev-method', 'workflows');
+    this.tasksDir = join(homedir(), '.myaidev-method', 'tasks');
+
+    this.setupToolHandlers();
+    this.initializeDirectories();
+  }
+
+  async initializeDirectories() {
+    try {
+      await fs.mkdir(this.workflowDir, { recursive: true });
+      await fs.mkdir(this.tasksDir, { recursive: true });
+    } catch (error) {
+      console.error('Failed to initialize directories:', error);
+    }
+  }
+
+  setupToolHandlers() {
+    // List available tools
+    this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
+      tools: [
+        {
+          name: 'sparc_orchestrate',
+          description: 'Orchestrate the complete 5-phase SPARC development workflow with intelligent task routing',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              task: {
+                type: 'string',
+                description: 'Description of the feature/system to build',
+              },
+              strategy: {
+                type: 'string',
+                enum: ['sequential', 'parallel', 'adaptive'],
+                default: 'sequential',
+                description: 'Execution strategy: sequential (one phase at a time), parallel (independent phases concurrently), adaptive (intelligent routing)',
+              },
+              phases: {
+                type: 'array',
+                items: {
+                  type: 'string',
+                  enum: ['architecture', 'implementation', 'testing', 'review', 'documentation'],
+                },
+                description: 'Specific phases to run (default: all 5 phases)',
+              },
+              options: {
+                type: 'object',
+                properties: {
+                  techStack: { type: 'string', description: 'Technology stack (e.g., "nextjs,payloadcms,mongodb")' },
+                  testFramework: { type: 'string', description: 'Testing framework (jest, mocha, pytest)' },
+                  testDriven: { type: 'boolean', description: 'Use TDD approach' },
+                  focusSecurity: { type: 'boolean', description: 'Enhanced security review' },
+                  focusPerformance: { type: 'boolean', description: 'Enhanced performance review' },
+                  outputDir: { type: 'string', description: 'Custom output directory' },
+                },
+              },
+            },
+            required: ['task'],
+          },
+        },
+        {
+          name: 'sparc_status',
+          description: 'Get status of current SPARC workflow execution',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              workflowId: {
+                type: 'string',
+                description: 'Workflow ID to check (optional, returns latest if not provided)',
+              },
+            },
+          },
+        },
+        {
+          name: 'sparc_phase_execute',
+          description: 'Execute a single SPARC phase with detailed configuration',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              phase: {
+                type: 'string',
+                enum: ['architecture', 'implementation', 'testing', 'review', 'documentation'],
+                description: 'The SPARC phase to execute',
+              },
+              task: {
+                type: 'string',
+                description: 'Task description for this phase',
+              },
+              options: {
+                type: 'object',
+                description: 'Phase-specific options',
+              },
+              workflowId: {
+                type: 'string',
+                description: 'Associate with existing workflow (optional)',
+              },
+            },
+            required: ['phase', 'task'],
+          },
+        },
+        {
+          name: 'sparc_workflow_history',
+          description: 'Get history of SPARC workflow executions',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              limit: {
+                type: 'number',
+                default: 10,
+                description: 'Number of workflows to return',
+              },
+              status: {
+                type: 'string',
+                enum: ['running', 'completed', 'failed', 'all'],
+                default: 'all',
+              },
+            },
+          },
+        },
+        {
+          name: 'sparc_task_results',
+          description: 'Get detailed results from a completed SPARC workflow',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              workflowId: {
+                type: 'string',
+                description: 'Workflow ID to get results for',
+              },
+            },
+            required: ['workflowId'],
+          },
+        },
+      ],
+    }));
+
+    // Handle tool execution
+    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+      const { name, arguments: args } = request.params;
+
+      try {
+        switch (name) {
+          case 'sparc_orchestrate':
+            return await this.handleSparcOrchestrate(args);
+
+          case 'sparc_status':
+            return await this.handleSparcStatus(args);
+
+          case 'sparc_phase_execute':
+            return await this.handlePhaseExecute(args);
+
+          case 'sparc_workflow_history':
+            return await this.handleWorkflowHistory(args);
+
+          case 'sparc_task_results':
+            return await this.handleTaskResults(args);
+
+          default:
+            throw new Error(`Unknown tool: ${name}`);
+        }
+      } catch (error) {
+        return {
+          content: [
+            {
+              type: 'text',
+              text: `Error executing ${name}: ${error.message}`,
+            },
+          ],
+          isError: true,
+        };
+      }
+    });
+  }
+
+  async handleSparcOrchestrate(args) {
+    const { task, strategy = 'sequential', phases, options = {} } = args;
+
+    // Generate workflow ID
+    const workflowId = `sparc_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+
+    // Determine phases to execute
+    const allPhases = ['architecture', 'implementation', 'testing', 'review', 'documentation'];
+    const executionPhases = phases && phases.length > 0 ? phases : allPhases;
+
+    // Create workflow state
+    const workflow = {
+      id: workflowId,
+      task,
+      strategy,
+      phases: executionPhases,
+      options,
+      status: 'running',
+      startTime: new Date().toISOString(),
+      currentPhase: null,
+      results: {},
+      metadata: {
+        techStack: options.techStack || 'not specified',
+        testFramework: options.testFramework || 'auto-detect',
+        outputDir: options.outputDir || '.myaidev-method/sparc',
+      },
+    };
+
+    // Save workflow state
+    await this.saveWorkflow(workflow);
+
+    // Generate execution plan based on strategy
+    const executionPlan = this.generateExecutionPlan(executionPhases, strategy, task, options);
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify({
+            workflowId,
+            status: 'initialized',
+            message: 'SPARC workflow orchestration initialized',
+            task,
+            strategy,
+            phases: executionPhases,
+            executionPlan,
+            nextSteps: this.getNextSteps(strategy, executionPhases, options),
+          }, null, 2),
+        },
+      ],
+    };
+  }
+
+  generateExecutionPlan(phases, strategy, task, options) {
+    const plan = {
+      strategy,
+      totalPhases: phases.length,
+      phases: [],
+    };
+
+    phases.forEach((phase, index) => {
+      const phaseConfig = this.getPhaseConfiguration(phase, task, options);
+
+      plan.phases.push({
+        order: index + 1,
+        phase,
+        command: phaseConfig.command,
+        description: phaseConfig.description,
+        expectedOutput: phaseConfig.expectedOutput,
+        estimatedDuration: phaseConfig.estimatedDuration,
+        dependencies: phaseConfig.dependencies,
+        parallelizable: strategy === 'parallel' && phaseConfig.canRunParallel,
+      });
+    });
+
+    return plan;
+  }
+
+  getPhaseConfiguration(phase, task, options) {
+    const configs = {
+      architecture: {
+        command: options.techStack
+          ? `/myai-dev-architect "${task}" --tech-stack "${options.techStack}"`
+          : `/myai-dev-architect "${task}"`,
+        description: 'Design system architecture, APIs, and data models',
+        expectedOutput: '.myaidev-method/sparc/architecture.md',
+        estimatedDuration: '5-10 minutes',
+        dependencies: [],
+        canRunParallel: false,
+      },
+      implementation: {
+        command: options.testDriven
+          ? `/myai-dev-code "${task}" --test-driven`
+          : `/myai-dev-code "${task}"`,
+        description: 'Implement features with SOLID principles',
+        expectedOutput: '.myaidev-method/sparc/code-output/',
+        estimatedDuration: '10-20 minutes',
+        dependencies: ['architecture'],
+        canRunParallel: false,
+      },
+      testing: {
+        command: options.testFramework
+          ? `/myai-dev-test "${task}" --coverage --framework ${options.testFramework}`
+          : `/myai-dev-test "${task}" --coverage`,
+        description: 'Create comprehensive test suites',
+        expectedOutput: '.myaidev-method/sparc/test-results/',
+        estimatedDuration: '8-15 minutes',
+        dependencies: ['implementation'],
+        canRunParallel: false,
+      },
+      review: {
+        command: this.buildReviewCommand(task, options),
+        description: 'Analyze code quality, security, and performance',
+        expectedOutput: '.myaidev-method/sparc/review-report.md',
+        estimatedDuration: '5-10 minutes',
+        dependencies: ['testing'],
+        canRunParallel: true,
+      },
+      documentation: {
+        command: `/myai-dev-docs "${task}"`,
+        description: 'Generate comprehensive documentation',
+        expectedOutput: '.myaidev-method/sparc/documentation/',
+        estimatedDuration: '5-10 minutes',
+        dependencies: ['implementation'],
+        canRunParallel: true,
+      },
+    };
+
+    return configs[phase];
+  }
+
+  buildReviewCommand(task, options) {
+    let command = `/myai-dev-review "${task}"`;
+    if (options.focusSecurity) command += ' --security';
+    if (options.focusPerformance) command += ' --performance';
+    return command;
+  }
+
+  getNextSteps(strategy, phases, options) {
+    const steps = [
+      {
+        step: 1,
+        action: 'Execute phases in order',
+        description: strategy === 'sequential'
+          ? 'Run each phase one at a time, reviewing outputs before proceeding'
+          : strategy === 'parallel'
+          ? 'Run independent phases concurrently (review + documentation can run in parallel after testing)'
+          : 'Intelligently route tasks based on dependencies and available resources',
+      },
+    ];
+
+    phases.forEach((phase, index) => {
+      const config = this.getPhaseConfiguration(phase, 'task', options);
+      steps.push({
+        step: index + 2,
+        phase,
+        command: config.command,
+        description: config.description,
+        output: config.expectedOutput,
+      });
+    });
+
+    steps.push({
+      step: phases.length + 2,
+      action: 'Review workflow results',
+      command: `/sparc_task_results --workflow-id <workflow-id>`,
+      description: 'Review all phase outputs and generate final report',
+    });
+
+    return steps;
+  }
+
+  async handleSparcStatus(args) {
+    const { workflowId } = args;
+
+    if (workflowId) {
+      const workflow = await this.loadWorkflow(workflowId);
+      return {
+        content: [
+          {
+            type: 'text',
+            text: JSON.stringify(workflow, null, 2),
+          },
+        ],
+      };
+    }
+
+    // Get latest workflow
+    const workflows = await this.listWorkflows();
+    const latest = workflows[0];
+
+    if (!latest) {
+      return {
+        content: [
+          {
+            type: 'text',
+            text: JSON.stringify({
+              status: 'no_workflows',
+              message: 'No SPARC workflows found',
+            }, null, 2),
+          },
+        ],
+      };
+    }
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify(latest, null, 2),
+        },
+      ],
+    };
+  }
+
+  async handlePhaseExecute(args) {
+    const { phase, task, options = {}, workflowId } = args;
+
+    const phaseConfig = this.getPhaseConfiguration(phase, task, options);
+
+    const execution = {
+      phase,
+      task,
+      command: phaseConfig.command,
+      status: 'ready',
+      description: phaseConfig.description,
+      expectedOutput: phaseConfig.expectedOutput,
+      estimatedDuration: phaseConfig.estimatedDuration,
+      startTime: new Date().toISOString(),
+      workflowId: workflowId || null,
+    };
+
+    // Save task execution record
+    const taskId = `task_${phase}_${Date.now()}`;
+    await this.saveTask(taskId, execution);
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify({
+            taskId,
+            ...execution,
+            nextAction: `Execute the following command: ${phaseConfig.command}`,
+          }, null, 2),
+        },
+      ],
+    };
+  }
+
+  async handleWorkflowHistory(args) {
+    const { limit = 10, status = 'all' } = args;
+
+    let workflows = await this.listWorkflows();
+
+    if (status !== 'all') {
+      workflows = workflows.filter(w => w.status === status);
+    }
+
+    workflows = workflows.slice(0, limit);
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify({
+            total: workflows.length,
+            workflows: workflows.map(w => ({
+              id: w.id,
+              task: w.task,
+              status: w.status,
+              phases: w.phases,
+              startTime: w.startTime,
+              endTime: w.endTime,
+              duration: w.duration,
+            })),
+          }, null, 2),
+        },
+      ],
+    };
+  }
+
+  async handleTaskResults(args) {
+    const { workflowId } = args;
+
+    const workflow = await this.loadWorkflow(workflowId);
+
+    if (!workflow) {
+      throw new Error(`Workflow ${workflowId} not found`);
+    }
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify({
+            workflowId,
+            task: workflow.task,
+            status: workflow.status,
+            results: workflow.results,
+            summary: this.generateWorkflowSummary(workflow),
+          }, null, 2),
+        },
+      ],
+    };
+  }
+
+  generateWorkflowSummary(workflow) {
+    const completedPhases = Object.keys(workflow.results).length;
+    const totalPhases = workflow.phases.length;
+
+    return {
+      completionRate: `${completedPhases}/${totalPhases} phases`,
+      duration: workflow.duration || 'in progress',
+      outputFiles: this.getOutputFiles(workflow),
+      nextRecommendedAction: this.getNextAction(workflow),
+    };
+  }
+
+  getOutputFiles(workflow) {
+    const files = [];
+
+    workflow.phases.forEach(phase => {
+      const config = this.getPhaseConfiguration(phase, '', {});
+      files.push({
+        phase,
+        location: config.expectedOutput,
+      });
+    });
+
+    return files;
+  }
+
+  getNextAction(workflow) {
+    if (workflow.status === 'completed') {
+      return 'Workflow complete. Review outputs and integrate into your project.';
+    }
+
+    const completedPhases = Object.keys(workflow.results);
+    const nextPhase = workflow.phases.find(p => !completedPhases.includes(p));
+
+    if (nextPhase) {
+      const config = this.getPhaseConfiguration(nextPhase, workflow.task, workflow.options);
+      return `Execute next phase: ${config.command}`;
+    }
+
+    return 'All phases executed. Mark workflow as complete.';
+  }
+
+  // Persistence helpers
+  async saveWorkflow(workflow) {
+    const filePath = join(this.workflowDir, `${workflow.id}.json`);
+    await fs.writeFile(filePath, JSON.stringify(workflow, null, 2));
+  }
+
+  async loadWorkflow(workflowId) {
+    try {
+      const filePath = join(this.workflowDir, `${workflowId}.json`);
+      const data = await fs.readFile(filePath, 'utf-8');
+      return JSON.parse(data);
+    } catch (error) {
+      return null;
+    }
+  }
+
+  async listWorkflows() {
+    try {
+      const files = await fs.readdir(this.workflowDir);
+      const workflows = [];
+
+      for (const file of files) {
+        if (file.endsWith('.json')) {
+          const data = await fs.readFile(join(this.workflowDir, file), 'utf-8');
+          workflows.push(JSON.parse(data));
+        }
+      }
+
+      // Sort by start time (newest first)
+      return workflows.sort((a, b) =>
+        new Date(b.startTime) - new Date(a.startTime)
+      );
+    } catch (error) {
+      return [];
+    }
+  }
+
+  async saveTask(taskId, execution) {
+    const filePath = join(this.tasksDir, `${taskId}.json`);
+    await fs.writeFile(filePath, JSON.stringify(execution, null, 2));
+  }
+
+  async run() {
+    const transport = new StdioServerTransport();
+    await this.server.connect(transport);
+    console.error('SPARC Orchestrator MCP server running on stdio');
+  }
+}
+
+// Start the server
+const server = new SparcOrchestratorServer();
+server.run().catch(console.error);

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "myaidev-method",
-  "version": "0.2.2",
-  "description": "AI CLI tools package with custom subagents and MCP integrations for Claude Code, Gemini CLI, and more",
+  "version": "0.2.4",
+  "description": "Comprehensive development framework with SPARC methodology for AI-assisted software development, multi-platform publishing (WordPress, PayloadCMS, Astro, Docusaurus, Mintlify), and Coolify deployment",
   "mcpName": "io.github.myaione/myaidev-method",
   "main": "src/index.js",
   "bin": {
     "myaidev-method": "./bin/cli.js",
     "myaidev-mcp-server": "./.claude/mcp/wordpress-server.js",
-    "myaidev-mcp-launcher": "./src/mcp/mcp-launcher.js"
+    "myaidev-mcp-launcher": "./src/mcp/mcp-launcher.js",
+    "myaidev-sparc-orchestrator": "./.claude/mcp/sparc-orchestrator-server.js"
   },
   "scripts": {
     "test": "node test/run-tests.js",
@@ -18,11 +19,18 @@
     "mcp:start": "node src/mcp/mcp-launcher.js start",
     "mcp:start:direct": "node .claude/mcp/wordpress-server.js",
     "mcp:start:simple": "node .claude/mcp/wordpress-server-simple.js",
+    "mcp:sparc": "node .claude/mcp/sparc-orchestrator-server.js",
     "mcp:status": "node src/mcp/mcp-launcher.js status",
     "mcp:health": "node src/mcp/mcp-launcher.js health",
     "build:mcp": "mkdir -p dist/mcp && cp .claude/mcp/*.js .claude/mcp/*.json dist/mcp/",
     "prepublishOnly": "npm install && npm test && npm run build:mcp",
     "postinstall": "echo \"MyAIDev Method installed successfully! Run 'npx myaidev-method init --claude' to get started.\"",
+    "dev:architect": "node src/scripts/dev-architect.js",
+    "dev:code": "node src/scripts/dev-code.js",
+    "dev:test": "node src/scripts/dev-test.js",
+    "dev:review": "node src/scripts/dev-review.js",
+    "dev:docs": "node src/scripts/dev-docs.js",
+    "sparc": "node src/scripts/sparc-workflow.js",
     "wordpress:troubleshoot": "node src/templates/docs/wordpress-troubleshoot.js",
     "wordpress:health-check": "node src/scripts/wordpress-health-check.js",
     "wordpress:security-scan": "node src/scripts/wordpress-security-scan.js",
@@ -40,6 +48,14 @@
   "keywords": [
     "claude-code",
     "ai-cli",
+    "sparc",
+    "sparc-methodology",
+    "agentic-development",
+    "spec-kit",
+    "software-development",
+    "code-quality",
+    "testing",
+    "code-review",
     "mcp",
     "wordpress",
     "payloadcms",
@@ -48,6 +64,7 @@
     "mintlify",
     "astro",
     "coolify",
+    "ramnode",
     "content-writer",
     "cms",
     "headless-cms",
@@ -98,6 +115,8 @@
     "USER_GUIDE.md",
     "LICENSE",
     ".env.example",
+    "DEV_WORKFLOW_GUIDE.md",
+    "MCP_INTEGRATION.md",
     "WORDPRESS_ADMIN_SCRIPTS.md",
     "COOLIFY_DEPLOYMENT.md",
     "PAYLOADCMS_PUBLISHING.md",