myaidev-method 0.2.2 → 0.2.4

package/src/lib/dev-workflow/task-manager.js

@@ -0,0 +1,313 @@
+/**
+ * MyAIDev Method - Task Manager
+ * Simple priority-based task queue with JSON persistence
+ * Version: 1.0.0
+ */
+
+import { existsSync, mkdirSync, writeFileSync, readFileSync, readdirSync, unlinkSync } from 'fs';
+import { join } from 'path';
+
+export class TaskManager {
+  constructor(workingDir = process.cwd()) {
+    this.workingDir = workingDir;
+    this.myaidevDir = join(workingDir, '.myaidev-method');
+    this.tasksDir = join(this.myaidevDir, 'tasks');
+
+    this.initializeDirectories();
+  }
+
+  /**
+   * Initialize task directories
+   */
+  initializeDirectories() {
+    if (!existsSync(this.tasksDir)) {
+      mkdirSync(this.tasksDir, { recursive: true });
+    }
+  }
+
+  /**
+   * Create a new task
+   * @param {string} description - Task description
+   * @param {Object} options - Task options
+   * @returns {Object} Created task object
+   */
+  createTask(description, options = {}) {
+    const task = {
+      id: `task_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+      description,
+      type: options.type || 'development',
+      priority: this.validatePriority(options.priority),
+      status: 'queued',
+      assignTo: options.assignTo || null,
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+      metadata: options.metadata || {},
+      dependencies: options.dependencies || [],
+      outputs: []
+    };
+
+    const taskFile = join(this.tasksDir, `${task.id}.json`);
+    writeFileSync(taskFile, JSON.stringify(task, null, 2), 'utf8');
+
+    console.log(`✅ Task created: ${task.id}`);
+    console.log(`   Description: ${description}`);
+    console.log(`   Priority: ${task.priority}`);
+    console.log(`   Type: ${task.type}`);
+
+    return task;
+  }
+
+  /**
+   * Validate priority value (1-10)
+   * @param {number} priority - Priority value
+   * @returns {number} Validated priority (default: 5)
+   */
+  validatePriority(priority) {
+    if (typeof priority !== 'number') return 5;
+    return Math.max(1, Math.min(10, Math.floor(priority)));
+  }
+
+  /**
+   * Get task by ID
+   * @param {string} taskId - Task identifier
+   * @returns {Object|null} Task object or null if not found
+   */
+  getTask(taskId) {
+    const taskFile = join(this.tasksDir, `${taskId}.json`);
+    if (!existsSync(taskFile)) {
+      return null;
+    }
+    return JSON.parse(readFileSync(taskFile, 'utf8'));
+  }
+
+  /**
+   * Update task
+   * @param {string} taskId - Task identifier
+   * @param {Object} updates - Fields to update
+   * @returns {Object} Updated task object
+   */
+  updateTask(taskId, updates) {
+    const task = this.getTask(taskId);
+    if (!task) {
+      throw new Error(`Task not found: ${taskId}`);
+    }
+
+    // Merge updates
+    Object.assign(task, updates, {
+      updatedAt: new Date().toISOString()
+    });
+
+    // Validate priority if updated
+    if (updates.priority !== undefined) {
+      task.priority = this.validatePriority(updates.priority);
+    }
+
+    const taskFile = join(this.tasksDir, `${taskId}.json`);
+    writeFileSync(taskFile, JSON.stringify(task, null, 2), 'utf8');
+
+    return task;
+  }
+
+  /**
+   * Update task status
+   * @param {string} taskId - Task identifier
+   * @param {string} status - New status (queued, running, completed, failed)
+   * @returns {Object} Updated task
+   */
+  updateStatus(taskId, status) {
+    const validStatuses = ['queued', 'running', 'completed', 'failed', 'cancelled'];
+    if (!validStatuses.includes(status)) {
+      throw new Error(`Invalid status: ${status}. Must be one of: ${validStatuses.join(', ')}`);
+    }
+
+    return this.updateTask(taskId, { status });
+  }
+
+  /**
+   * Add output to task
+   * @param {string} taskId - Task identifier
+   * @param {string} output - Output file path or description
+   * @returns {Object} Updated task
+   */
+  addOutput(taskId, output) {
+    const task = this.getTask(taskId);
+    if (!task) {
+      throw new Error(`Task not found: ${taskId}`);
+    }
+
+    task.outputs.push({
+      path: output,
+      timestamp: new Date().toISOString()
+    });
+
+    return this.updateTask(taskId, { outputs: task.outputs });
+  }
+
+  /**
+   * List tasks with optional filtering
+   * @param {Object} filter - Filter criteria
+   * @returns {Array} Array of tasks
+   */
+  listTasks(filter = {}) {
+    if (!existsSync(this.tasksDir)) {
+      return [];
+    }
+
+    const taskFiles = readdirSync(this.tasksDir).filter(f => f.endsWith('.json'));
+    let tasks = taskFiles.map(file =>
+      JSON.parse(readFileSync(join(this.tasksDir, file), 'utf8'))
+    );
+
+    // Apply filters
+    if (filter.status) {
+      tasks = tasks.filter(t => t.status === filter.status);
+    }
+    if (filter.assignTo) {
+      tasks = tasks.filter(t => t.assignTo === filter.assignTo);
+    }
+    if (filter.type) {
+      tasks = tasks.filter(t => t.type === filter.type);
+    }
+    if (filter.priority) {
+      tasks = tasks.filter(t => t.priority === filter.priority);
+    }
+
+    // Sort by priority (descending) then by creation time
+    tasks.sort((a, b) => {
+      if (b.priority !== a.priority) {
+        return b.priority - a.priority;
+      }
+      return new Date(b.createdAt) - new Date(a.createdAt);
+    });
+
+    return tasks;
+  }
+
+  /**
+   * Get next task in queue (highest priority, queued status)
+   * @returns {Object|null} Next task or null if queue is empty
+   */
+  getNextTask() {
+    const queuedTasks = this.listTasks({ status: 'queued' });
+    return queuedTasks.length > 0 ? queuedTasks[0] : null;
+  }
+
+  /**
+   * Delete task
+   * @param {string} taskId - Task identifier
+   * @returns {boolean} True if deleted, false if not found
+   */
+  deleteTask(taskId) {
+    const taskFile = join(this.tasksDir, `${taskId}.json`);
+    if (existsSync(taskFile)) {
+      unlinkSync(taskFile);
+      console.log(`✅ Task deleted: ${taskId}`);
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Clear all completed tasks
+   * @returns {number} Number of tasks cleared
+   */
+  clearCompleted() {
+    const completedTasks = this.listTasks({ status: 'completed' });
+    let count = 0;
+
+    for (const task of completedTasks) {
+      if (this.deleteTask(task.id)) {
+        count++;
+      }
+    }
+
+    console.log(`✅ Cleared ${count} completed tasks`);
+    return count;
+  }
+
+  /**
+   * Get task queue summary
+   * @returns {Object} Queue statistics
+   */
+  getQueueSummary() {
+    const allTasks = this.listTasks();
+
+    const summary = {
+      total: allTasks.length,
+      queued: allTasks.filter(t => t.status === 'queued').length,
+      running: allTasks.filter(t => t.status === 'running').length,
+      completed: allTasks.filter(t => t.status === 'completed').length,
+      failed: allTasks.filter(t => t.status === 'failed').length,
+      cancelled: allTasks.filter(t => t.status === 'cancelled').length
+    };
+
+    return summary;
+  }
+
+  /**
+   * Print queue summary
+   */
+  printQueueSummary() {
+    const summary = this.getQueueSummary();
+
+    console.log('\n📊 MyAIDev Method - Task Queue Summary');
+    console.log('═'.repeat(40));
+    console.log(`Total Tasks: ${summary.total}`);
+    console.log(`  ⏳ Queued: ${summary.queued}`);
+    console.log(`  🔄 Running: ${summary.running}`);
+    console.log(`  ✅ Completed: ${summary.completed}`);
+    console.log(`  ❌ Failed: ${summary.failed}`);
+    console.log(`  🚫 Cancelled: ${summary.cancelled}`);
+    console.log('');
+  }
+
+  /**
+   * Export tasks to JSON file
+   * @param {string} outputPath - Output file path
+   * @returns {string} Path to exported file
+   */
+  exportTasks(outputPath) {
+    const tasks = this.listTasks();
+    const exportData = {
+      exportedAt: new Date().toISOString(),
+      taskCount: tasks.length,
+      tasks
+    };
+
+    writeFileSync(outputPath, JSON.stringify(exportData, null, 2), 'utf8');
+    console.log(`✅ Exported ${tasks.length} tasks to: ${outputPath}`);
+
+    return outputPath;
+  }
+
+  /**
+   * Import tasks from JSON file
+   * @param {string} inputPath - Input file path
+   * @returns {number} Number of tasks imported
+   */
+  importTasks(inputPath) {
+    if (!existsSync(inputPath)) {
+      throw new Error(`Import file not found: ${inputPath}`);
+    }
+
+    const importData = JSON.parse(readFileSync(inputPath, 'utf8'));
+    const tasks = importData.tasks || [];
+
+    let count = 0;
+    for (const task of tasks) {
+      // Create new task with imported data
+      this.createTask(task.description, {
+        type: task.type,
+        priority: task.priority,
+        assignTo: task.assignTo,
+        metadata: task.metadata
+      });
+      count++;
+    }
+
+    console.log(`✅ Imported ${count} tasks`);
+    return count;
+  }
+}
+
+export default TaskManager;

package/src/scripts/dev-architect.js

@@ -0,0 +1,99 @@
+#!/usr/bin/env node
+
+/**
+ * MyAIDev Method - Architecture Design CLI
+ *
+ * Invokes the dev-architect agent to design system architecture,
+ * create API specifications, and plan technology stack.
+ *
+ * Usage:
+ *   npx myaidev-method dev:architect "Design authentication system"
+ *   npx myaidev-method dev:architect "Create e-commerce platform" --tech-stack "node,postgres,redis"
+ */
+
+import { SparcWorkflow } from '../lib/dev-workflow/sparc-workflow.js';
+import { getAgentByPhase } from '../lib/dev-workflow/agent-types.js';
+
+async function main() {
+  const args = process.argv.slice(2);
+
+  if (args.length === 0 || args.includes('--help') || args.includes('-h')) {
+    console.log(`
+🏗️  MyAIDev Method - Architecture Design
+
+Usage:
+  npx myaidev-method dev:architect "Design authentication system"
+  npx myaidev-method dev:architect "Create API endpoints" --tech-stack "node,express"
+
+Options:
+  --tech-stack <stack>    Preferred technology stack (comma-separated)
+  --existing-code         Analyze existing codebase before designing
+  --output-dir <path>     Custom output directory (default: .myaidev-method/sparc/)
+  --help, -h              Show this help message
+
+Examples:
+  npx myaidev-method dev:architect "Design real-time chat app"
+  npx myaidev-method dev:architect "Review current architecture" --existing-code
+  npx myaidev-method dev:architect "Design microservices" --tech-stack "node,kubernetes,mongodb"
+
+Output:
+  .myaidev-method/sparc/architecture.md
+
+Next Phase:
+  After architecture is complete, run:
+  npx myaidev-method dev:code "Implement [feature]"
+    `);
+    process.exit(0);
+  }
+
+  const taskDescription = args[0];
+
+  // Parse options
+  const options = {
+    workingDir: process.cwd(),
+  };
+
+  for (let i = 1; i < args.length; i++) {
+    if (args[i] === '--tech-stack' && args[i + 1]) {
+      options.techStack = args[i + 1];
+      i++;
+    } else if (args[i] === '--existing-code') {
+      options.analyzeExisting = true;
+    } else if (args[i] === '--output-dir' && args[i + 1]) {
+      options.outputDir = args[i + 1];
+      i++;
+    }
+  }
+
+  try {
+    console.log('🏗️  MyAIDev Method - Architecture Design');
+    console.log('📋 Task:', taskDescription);
+    if (options.techStack) {
+      console.log('🔧 Tech Stack:', options.techStack);
+    }
+    console.log('');
+
+    const workflow = new SparcWorkflow(taskDescription, options);
+    const agent = getAgentByPhase('architecture');
+
+    console.log(`🚀 Invoking ${agent.emoji} ${agent.name}...`);
+    console.log('');
+
+    const result = await workflow.runPhase('architecture');
+
+    console.log('');
+    console.log('✅ Architecture design complete!');
+    console.log('📄 Output:', result.outputFile);
+    console.log('');
+    console.log('📌 Next Steps:');
+    console.log('  1. Review architecture.md in .myaidev-method/sparc/');
+    console.log('  2. Run: npx myaidev-method dev:code "Implement [feature]"');
+    console.log('');
+
+  } catch (error) {
+    console.error('❌ Error:', error.message);
+    process.exit(1);
+  }
+}
+
+main();

package/src/scripts/dev-code.js

@@ -0,0 +1,106 @@
+#!/usr/bin/env node
+
+/**
+ * MyAIDev Method - Code Implementation CLI
+ *
+ * Invokes the dev-coder agent to implement features based on
+ * architecture specifications using SOLID principles and best practices.
+ *
+ * Usage:
+ *   npx myaidev-method dev:code "Implement user authentication"
+ *   npx myaidev-method dev:code "Build payment processing" --test-driven
+ */
+
+import { SparcWorkflow } from '../lib/dev-workflow/sparc-workflow.js';
+import { getAgentByPhase } from '../lib/dev-workflow/agent-types.js';
+
+async function main() {
+  const args = process.argv.slice(2);
+
+  if (args.length === 0 || args.includes('--help') || args.includes('-h')) {
+    console.log(`
+💻 MyAIDev Method - Code Implementation
+
+Usage:
+  npx myaidev-method dev:code "Implement authentication"
+  npx myaidev-method dev:code "Build API endpoints" --test-driven
+
+Options:
+  --architecture <file>   Path to architecture spec (default: .myaidev-method/sparc/architecture.md)
+  --test-driven          Use TDD approach (write tests first)
+  --output-dir <path>    Custom output directory (default: .myaidev-method/sparc/code-output/)
+  --help, -h             Show this help message
+
+Examples:
+  npx myaidev-method dev:code "Implement JWT authentication"
+  npx myaidev-method dev:code "Create REST API for users" --test-driven
+  npx myaidev-method dev:code "Refactor database queries" --architecture custom-arch.md
+
+Code Quality Standards:
+  - SOLID Principles (Single Responsibility, DRY, KISS)
+  - Security best practices (OWASP Top 10)
+  - Error handling and input validation
+  - Inline documentation (JSDoc, etc.)
+  - 80%+ test coverage target
+
+Output:
+  .myaidev-method/sparc/code-output/
+
+Next Phase:
+  After implementation, run:
+  npx myaidev-method dev:test "Test [feature]"
+    `);
+    process.exit(0);
+  }
+
+  const taskDescription = args[0];
+
+  // Parse options
+  const options = {
+    workingDir: process.cwd(),
+  };
+
+  for (let i = 1; i < args.length; i++) {
+    if (args[i] === '--architecture' && args[i + 1]) {
+      options.architectureFile = args[i + 1];
+      i++;
+    } else if (args[i] === '--test-driven') {
+      options.testDriven = true;
+    } else if (args[i] === '--output-dir' && args[i + 1]) {
+      options.outputDir = args[i + 1];
+      i++;
+    }
+  }
+
+  try {
+    console.log('💻 MyAIDev Method - Code Implementation');
+    console.log('📋 Task:', taskDescription);
+    if (options.testDriven) {
+      console.log('🧪 Mode: Test-Driven Development (TDD)');
+    }
+    console.log('');
+
+    const workflow = new SparcWorkflow(taskDescription, options);
+    const agent = getAgentByPhase('implementation');
+
+    console.log(`🚀 Invoking ${agent.emoji} ${agent.name}...`);
+    console.log('');
+
+    const result = await workflow.runPhase('implementation');
+
+    console.log('');
+    console.log('✅ Implementation complete!');
+    console.log('📁 Output:', result.outputDir);
+    console.log('');
+    console.log('📌 Next Steps:');
+    console.log('  1. Review code in .myaidev-method/sparc/code-output/');
+    console.log('  2. Run: npx myaidev-method dev:test "Test [feature]"');
+    console.log('');
+
+  } catch (error) {
+    console.error('❌ Error:', error.message);
+    process.exit(1);
+  }
+}
+
+main();

package/src/scripts/dev-docs.js

@@ -0,0 +1,122 @@
+#!/usr/bin/env node
+
+/**
+ * MyAIDev Method - Documentation Generation CLI
+ *
+ * Invokes the dev-documenter agent to generate comprehensive
+ * API documentation, user guides, and technical specifications.
+ *
+ * Usage:
+ *   npx myaidev-method dev:docs "Document authentication API"
+ *   npx myaidev-method dev:docs "Create user guide" --type user-guide
+ */
+
+import { SparcWorkflow } from '../lib/dev-workflow/sparc-workflow.js';
+import { getAgentByPhase } from '../lib/dev-workflow/agent-types.js';
+
+async function main() {
+  const args = process.argv.slice(2);
+
+  if (args.length === 0 || args.includes('--help') || args.includes('-h')) {
+    console.log(`
+📚 MyAIDev Method - Documentation
+
+Usage:
+  npx myaidev-method dev:docs "Document authentication API"
+  npx myaidev-method dev:docs "Create user guide" --type user-guide --format html
+
+Options:
+  --type <type>         Documentation type: api, user-guide, architecture, technical
+  --format <format>     Output format: markdown, html, openapi, swagger
+  --output-dir <path>   Custom output directory (default: .myaidev-method/sparc/documentation/)
+  --help, -h            Show this help message
+
+Examples:
+  npx myaidev-method dev:docs "Document REST API endpoints"
+  npx myaidev-method dev:docs "Create user guide for checkout flow" --type user-guide
+  npx myaidev-method dev:docs "Generate OpenAPI spec" --format openapi
+  npx myaidev-method dev:docs "Document system architecture" --type architecture
+
+Documentation Standards:
+  - Clarity: Simple language, clear examples, visual aids
+  - Completeness: All public APIs documented
+  - Accuracy: Code examples tested and verified
+  - Accessibility: Multiple formats, searchable
+  - Maintenance: Version-controlled, synchronized with code
+
+Output:
+  .myaidev-method/sparc/documentation/
+
+Completion:
+  This is the final phase of the SPARC workflow.
+  All phases complete! 🎉
+    `);
+    process.exit(0);
+  }
+
+  const taskDescription = args[0];
+
+  // Parse options
+  const options = {
+    workingDir: process.cwd(),
+  };
+
+  for (let i = 1; i < args.length; i++) {
+    if (args[i] === '--type' && args[i + 1]) {
+      options.docType = args[i + 1];
+      i++;
+    } else if (args[i] === '--format' && args[i + 1]) {
+      options.format = args[i + 1];
+      i++;
+    } else if (args[i] === '--output-dir' && args[i + 1]) {
+      options.outputDir = args[i + 1];
+      i++;
+    }
+  }
+
+  try {
+    console.log('📚 MyAIDev Method - Documentation');
+    console.log('📋 Task:', taskDescription);
+    if (options.docType) {
+      console.log('📖 Type:', options.docType);
+    }
+    if (options.format) {
+      console.log('📄 Format:', options.format);
+    }
+    console.log('');
+
+    const workflow = new SparcWorkflow(taskDescription, options);
+    const agent = getAgentByPhase('documentation');
+
+    console.log(`🚀 Invoking ${agent.emoji} ${agent.name}...`);
+    console.log('');
+
+    const result = await workflow.runPhase('documentation');
+
+    console.log('');
+    console.log('✅ Documentation complete!');
+    console.log('📁 Output:', result.outputDir);
+    console.log('');
+    console.log('🎉 SPARC Workflow Complete!');
+    console.log('');
+    console.log('📌 Final Deliverables:');
+    console.log('  ✅ Architecture: .myaidev-method/sparc/architecture.md');
+    console.log('  ✅ Code: .myaidev-method/sparc/code-output/');
+    console.log('  ✅ Tests: .myaidev-method/sparc/test-results/');
+    console.log('  ✅ Review: .myaidev-method/sparc/review-report.md');
+    console.log('  ✅ Documentation: .myaidev-method/sparc/documentation/');
+    console.log('');
+    console.log('📌 Next Steps:');
+    console.log('  1. Review all deliverables in .myaidev-method/sparc/');
+    console.log('  2. Address any review findings');
+    console.log('  3. Integrate code into your project');
+    console.log('  4. Deploy with confidence! 🚀');
+    console.log('');
+
+  } catch (error) {
+    console.error('❌ Error:', error.message);
+    process.exit(1);
+  }
+}
+
+main();