myaidev-method 0.2.2 → 0.2.4

package/src/lib/dev-workflow/agent-types.js

@@ -0,0 +1,163 @@
+/**
+ * MyAIDev Method - Development Agent Types
+ * Defines specialized agents for systematic development workflow
+ * Version: 1.0.0
+ */
+
+export const AGENT_TYPES = {
+  ARCHITECT: {
+    id: 'myaidev-dev-architect',
+    name: 'MyAIDev Architect',
+    description: 'Design system architecture and APIs',
+    emoji: '🏗️',
+    capabilities: [
+      'System design',
+      'API specification',
+      'Data flow modeling',
+      'Technology selection',
+      'Security planning'
+    ],
+    tools: ['read', 'write', 'edit', 'websearch'],
+    outputs: ['.myaidev-method/sparc/architecture.md'],
+    phase: 'architecture'
+  },
+
+  CODER: {
+    id: 'myaidev-dev-coder',
+    name: 'MyAIDev Coder',
+    description: 'Implement features and refactor code',
+    emoji: '💻',
+    capabilities: [
+      'Feature implementation',
+      'Code refactoring',
+      'Bug fixing',
+      'Code optimization',
+      'Pattern application'
+    ],
+    tools: ['read', 'write', 'edit', 'bash', 'grep', 'glob'],
+    outputs: ['.myaidev-method/sparc/code-output/'],
+    phase: 'implementation'
+  },
+
+  TESTER: {
+    id: 'myaidev-dev-tester',
+    name: 'MyAIDev Tester',
+    description: 'Write and execute comprehensive tests',
+    emoji: '🧪',
+    capabilities: [
+      'Unit testing',
+      'Integration testing',
+      'Test coverage analysis',
+      'Quality assurance',
+      'Test automation'
+    ],
+    tools: ['read', 'write', 'edit', 'bash'],
+    outputs: ['.myaidev-method/sparc/test-results/'],
+    phase: 'testing'
+  },
+
+  REVIEWER: {
+    id: 'myaidev-dev-reviewer',
+    name: 'MyAIDev Reviewer',
+    description: 'Analyze code quality and security',
+    emoji: '👁️',
+    capabilities: [
+      'Code review',
+      'Security analysis',
+      'Performance review',
+      'Best practices validation',
+      'Technical debt assessment'
+    ],
+    tools: ['read', 'grep', 'glob', 'bash'],
+    outputs: ['.myaidev-method/sparc/review-report.md'],
+    phase: 'review'
+  },
+
+  DOCUMENTER: {
+    id: 'myaidev-dev-documenter',
+    name: 'MyAIDev Documenter',
+    description: 'Generate comprehensive documentation',
+    emoji: '📚',
+    capabilities: [
+      'API documentation',
+      'User guides',
+      'Architecture documentation',
+      'Code comments',
+      'Tutorial creation'
+    ],
+    tools: ['read', 'write', 'edit', 'grep', 'glob'],
+    outputs: ['.myaidev-method/sparc/documentation/'],
+    phase: 'documentation'
+  }
+};
+
+/**
+ * Get agent definition by ID
+ * @param {string} agentId - Agent identifier
+ * @returns {Object|null} Agent definition or null if not found
+ */
+export function getAgentById(agentId) {
+  return Object.values(AGENT_TYPES).find(agent => agent.id === agentId);
+}
+
+/**
+ * Get agent definition by phase
+ * @param {string} phase - Workflow phase name
+ * @returns {Object|null} Agent definition or null if not found
+ */
+export function getAgentByPhase(phase) {
+  return Object.values(AGENT_TYPES).find(agent => agent.phase === phase);
+}
+
+/**
+ * List all available agents
+ * @returns {Array} Array of all agent definitions
+ */
+export function listAllAgents() {
+  return Object.values(AGENT_TYPES);
+}
+
+/**
+ * Get agent capabilities
+ * @param {string} agentId - Agent identifier
+ * @returns {Array} Array of capabilities or empty array
+ */
+export function getAgentCapabilities(agentId) {
+  const agent = getAgentById(agentId);
+  return agent ? agent.capabilities : [];
+}
+
+/**
+ * Validate agent exists
+ * @param {string} agentId - Agent identifier
+ * @returns {boolean} True if agent exists
+ */
+export function isValidAgent(agentId) {
+  return Object.values(AGENT_TYPES).some(agent => agent.id === agentId);
+}
+
+/**
+ * Get SPARC workflow phases in order
+ * @returns {Array} Ordered array of phase names
+ */
+export function getWorkflowPhases() {
+  return ['architecture', 'implementation', 'testing', 'review', 'documentation'];
+}
+
+/**
+ * Get agent summary for display
+ * @param {string} agentId - Agent identifier
+ * @returns {string} Formatted agent summary
+ */
+export function getAgentSummary(agentId) {
+  const agent = getAgentById(agentId);
+  if (!agent) return 'Unknown agent';
+
+  return `${agent.emoji} ${agent.name}
+Description: ${agent.description}
+Phase: ${agent.phase}
+Capabilities: ${agent.capabilities.join(', ')}
+Tools: ${agent.tools.join(', ')}`;
+}
+
+export default AGENT_TYPES;

package/src/lib/dev-workflow/sparc-workflow.js

@@ -0,0 +1,302 @@
+/**
+ * MyAIDev Method - SPARC Workflow Orchestrator
+ * Systematic development: Specification → Architecture → Code → Test → Review → Documentation
+ * Version: 1.0.0
+ */
+
+import { existsSync, mkdirSync, writeFileSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { AGENT_TYPES, getAgentByPhase, getWorkflowPhases } from './agent-types.js';
+
+export class SparcWorkflow {
+  constructor(task, options = {}) {
+    this.task = task;
+    this.workingDir = options.workingDir || process.cwd();
+    this.myaidevDir = join(this.workingDir, '.myaidev-method');
+    this.sparcDir = join(this.myaidevDir, 'sparc');
+    this.phases = options.phases || getWorkflowPhases();
+    this.currentPhase = null;
+    this.results = {};
+
+    // Create MyAIDev Method directories
+    this.initializeDirectories();
+  }
+
+  /**
+   * Initialize .myaidev-method directory structure
+   */
+  initializeDirectories() {
+    const dirs = [
+      this.myaidevDir,
+      this.sparcDir,
+      join(this.sparcDir, 'code-output'),
+      join(this.sparcDir, 'test-results'),
+      join(this.sparcDir, 'documentation'),
+      join(this.myaidevDir, 'tasks'),
+      join(this.myaidevDir, 'workflows')
+    ];
+
+    for (const dir of dirs) {
+      if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+      }
+    }
+
+    // Create .gitignore if it doesn't exist
+    const gitignorePath = join(this.myaidevDir, '.gitignore');
+    if (!existsSync(gitignorePath)) {
+      writeFileSync(gitignorePath, `# MyAIDev Method - Generated files
+*.log
+temp/
+cache/
+`, 'utf8');
+    }
+  }
+
+  /**
+   * Run a specific SPARC phase
+   * @param {string} phaseName - Phase to execute
+   * @returns {Promise<Object>} Phase execution result
+   */
+  async runPhase(phaseName) {
+    const agent = getAgentByPhase(phaseName);
+
+    if (!agent) {
+      throw new Error(`Unknown phase: ${phaseName}`);
+    }
+
+    this.currentPhase = phaseName;
+
+    console.log(`\n${'='.repeat(60)}`);
+    console.log(`🚀 MyAIDev Method: Running ${phaseName} phase`);
+    console.log(`${'='.repeat(60)}`);
+    console.log(`${agent.emoji} Agent: ${agent.name}`);
+    console.log(`📋 Task: ${this.task}`);
+    console.log(`⚙️  Capabilities: ${agent.capabilities.join(', ')}`);
+    console.log('');
+
+    const result = {
+      phase: phaseName,
+      agent: agent.id,
+      agentName: agent.name,
+      task: this.task,
+      startTime: new Date().toISOString(),
+      status: 'started'
+    };
+
+    try {
+      // Execute agent (this will be implemented by CLI scripts)
+      // For now, create placeholder result
+      const executionResult = await this.executeAgent(agent);
+
+      result.status = 'completed';
+      result.endTime = new Date().toISOString();
+      result.output = executionResult;
+
+      // Save phase result
+      await this.savePhaseResult(phaseName, result);
+
+      console.log(`✅ ${phaseName} phase completed successfully\n`);
+
+    } catch (error) {
+      result.status = 'failed';
+      result.error = error.message;
+      result.endTime = new Date().toISOString();
+
+      console.error(`❌ ${phaseName} phase failed: ${error.message}\n`);
+
+      await this.savePhaseResult(phaseName, result);
+      throw error;
+    }
+
+    return result;
+  }
+
+  /**
+   * Execute agent for current phase
+   * @param {Object} agent - Agent definition
+   * @returns {Promise<Object>} Execution result
+   */
+  async executeAgent(agent) {
+    // This is a placeholder that will be overridden by CLI scripts
+    // The actual implementation will use Claude Code's Task tool or spawn CLI
+
+    return {
+      message: `Agent ${agent.name} executed for task: ${this.task}`,
+      outputs: agent.outputs,
+      timestamp: new Date().toISOString()
+    };
+  }
+
+  /**
+   * Save phase result to file
+   * @param {string} phase - Phase name
+   * @param {Object} result - Phase result object
+   */
+  async savePhaseResult(phase, result) {
+    const resultFile = join(this.sparcDir, `${phase}-result.json`);
+    writeFileSync(resultFile, JSON.stringify(result, null, 2), 'utf8');
+  }
+
+  /**
+   * Load phase result from file
+   * @param {string} phase - Phase name
+   * @returns {Object|null} Phase result or null if not found
+   */
+  loadPhaseResult(phase) {
+    const resultFile = join(this.sparcDir, `${phase}-result.json`);
+    if (!existsSync(resultFile)) {
+      return null;
+    }
+    return JSON.parse(readFileSync(resultFile, 'utf8'));
+  }
+
+  /**
+   * Run complete SPARC workflow (all phases sequentially)
+   * @returns {Promise<Object>} Complete workflow results
+   */
+  async runComplete() {
+    console.log('\n' + '═'.repeat(60));
+    console.log('   🎯 MyAIDev Method - SPARC Workflow');
+    console.log('═'.repeat(60));
+    console.log(`\n📋 Task: ${this.task}`);
+    console.log(`📁 Working Directory: ${this.workingDir}`);
+    console.log(`\n🔄 Phases to Execute:`);
+    this.phases.forEach((phase, index) => {
+      const agent = getAgentByPhase(phase);
+      console.log(`   ${index + 1}. ${agent.emoji} ${phase} (${agent.name})`);
+    });
+    console.log('');
+
+    const workflowStartTime = new Date().toISOString();
+    const results = {};
+
+    for (const phase of this.phases) {
+      try {
+        results[phase] = await this.runPhase(phase);
+      } catch (error) {
+        console.error(`\n⚠️  Workflow stopped at ${phase} phase due to error`);
+        results[phase] = {
+          status: 'failed',
+          error: error.message
+        };
+        break;
+      }
+    }
+
+    const workflowEndTime = new Date().toISOString();
+
+    // Save complete workflow summary
+    const summary = {
+      task: this.task,
+      workingDir: this.workingDir,
+      startTime: workflowStartTime,
+      endTime: workflowEndTime,
+      phases: results,
+      status: Object.values(results).every(r => r.status === 'completed') ? 'completed' : 'partial'
+    };
+
+    const summaryFile = join(this.sparcDir, 'workflow-summary.json');
+    writeFileSync(summaryFile, JSON.stringify(summary, null, 2), 'utf8');
+
+    // Print workflow summary
+    this.printWorkflowSummary(summary);
+
+    return summary;
+  }
+
+  /**
+   * Run specific phases only
+   * @param {Array<string>} phaseNames - Phases to execute
+   * @returns {Promise<Object>} Results from specified phases
+   */
+  async runPhases(phaseNames) {
+    const results = {};
+
+    for (const phase of phaseNames) {
+      if (!this.phases.includes(phase)) {
+        console.warn(`⚠️  Skipping unknown phase: ${phase}`);
+        continue;
+      }
+      results[phase] = await this.runPhase(phase);
+    }
+
+    return results;
+  }
+
+  /**
+   * Print workflow summary
+   * @param {Object} summary - Workflow summary object
+   */
+  printWorkflowSummary(summary) {
+    console.log('\n' + '═'.repeat(60));
+    console.log('   ✨ MyAIDev Method SPARC Workflow Complete');
+    console.log('═'.repeat(60));
+    console.log(`\n📊 Summary:`);
+    console.log(`   Status: ${summary.status === 'completed' ? '✅ Completed' : '⚠️  Partial'}`);
+    console.log(`   Start: ${new Date(summary.startTime).toLocaleString()}`);
+    console.log(`   End: ${new Date(summary.endTime).toLocaleString()}`);
+
+    console.log(`\n📋 Phase Results:`);
+    Object.entries(summary.phases).forEach(([phase, result]) => {
+      const agent = getAgentByPhase(phase);
+      const statusEmoji = result.status === 'completed' ? '✅' : '❌';
+      console.log(`   ${statusEmoji} ${agent.emoji} ${phase}: ${result.status}`);
+    });
+
+    console.log(`\n📁 Results saved to: ${this.sparcDir}`);
+    console.log(`   - workflow-summary.json`);
+    Object.keys(summary.phases).forEach(phase => {
+      console.log(`   - ${phase}-result.json`);
+    });
+    console.log('');
+  }
+
+  /**
+   * Get workflow status
+   * @returns {Object} Current workflow status
+   */
+  getStatus() {
+    const summaryFile = join(this.sparcDir, 'workflow-summary.json');
+
+    if (!existsSync(summaryFile)) {
+      return { status: 'not_started' };
+    }
+
+    return JSON.parse(readFileSync(summaryFile, 'utf8'));
+  }
+
+  /**
+   * Clean workflow outputs
+   * @param {boolean} confirm - Confirmation flag
+   */
+  clean(confirm = false) {
+    if (!confirm) {
+      console.warn('⚠️  Use clean(true) to confirm deletion of workflow outputs');
+      return;
+    }
+
+    console.log('🧹 Cleaning MyAIDev Method workflow outputs...');
+
+    // Remove phase results
+    const phases = getWorkflowPhases();
+    phases.forEach(phase => {
+      const resultFile = join(this.sparcDir, `${phase}-result.json`);
+      if (existsSync(resultFile)) {
+        unlinkSync(resultFile);
+        console.log(`   Removed ${phase}-result.json`);
+      }
+    });
+
+    // Remove summary
+    const summaryFile = join(this.sparcDir, 'workflow-summary.json');
+    if (existsSync(summaryFile)) {
+      unlinkSync(summaryFile);
+      console.log(`   Removed workflow-summary.json`);
+    }
+
+    console.log('✅ Workflow outputs cleaned');
+  }
+}
+
+export default SparcWorkflow;