musubi-sdd 0.8.3 → 0.8.4

package/README.ja.md

@@ -120,6 +120,15 @@ musubi-design add-c4 container --format plantuml  # PlantUMLでコンテナ図
 musubi-design add-adr "JWTトークン使用" # アーキテクチャ決定記録追加
 musubi-design validate                  # 設計完全性を検証
 musubi-design trace                     # 要件トレーサビリティ表示
+
+# 設計をタスクに分解（v0.8.4）
+musubi-tasks init "ユーザー認証"        # タスク分解を初期化
+musubi-tasks add "データベーススキーマ"  # インタラクティブにタスク追加
+musubi-tasks list                       # 全タスクリスト表示
+musubi-tasks list --priority P0         # 重要タスクのみ表示
+musubi-tasks update 001 "In Progress"   # タスクステータス更新
+musubi-tasks validate                   # タスク完全性を検証
+musubi-tasks graph                      # 依存関係グラフ表示
 ```
 
 ### プロジェクトタイプ

package/README.md

@@ -124,6 +124,15 @@ musubi-design add-c4 container --format plantuml # Add Container with PlantUML
 musubi-design add-adr "Use JWT for tokens"      # Add Architecture Decision
 musubi-design validate                          # Validate design completeness
 musubi-design trace                             # Show requirements traceability
+
+# Break down design into tasks (v0.8.4)
+musubi-tasks init "User Authentication"         # Initialize task breakdown
+musubi-tasks add "Database Schema"              # Add task interactively
+musubi-tasks list                               # List all tasks
+musubi-tasks list --priority P0                 # List critical tasks
+musubi-tasks update 001 "In Progress"           # Update task status
+musubi-tasks validate                           # Validate task completeness
+musubi-tasks graph                              # Show dependency graph
 ```
 
 ### Project Types

package/bin/musubi-tasks.js

@@ -0,0 +1,365 @@
+#!/usr/bin/env node
+
+/**
+ * MUSUBI Task Breakdown System CLI
+ * 
+ * Breaks down design into actionable implementation tasks
+ * Complies with Article I-IX and P0-P3 priority labels
+ * 
+ * Usage:
+ *   musubi-tasks init <feature>              # Initialize task breakdown
+ *   musubi-tasks add <title>                 # Add task with interactive prompts
+ *   musubi-tasks list                        # List all tasks
+ *   musubi-tasks update <id> <status>        # Update task status
+ *   musubi-tasks validate                    # Validate task breakdown
+ *   musubi-tasks graph                       # Generate dependency graph
+ */
+
+const { Command } = require('commander');
+const chalk = require('chalk');
+const TasksGenerator = require('../src/generators/tasks');
+
+let inquirer;
+
+/**
+ * Initialize inquirer (ESM module in v9+)
+ */
+async function getInquirer() {
+  if (!inquirer) {
+    inquirer = (await import('inquirer')).default;
+  }
+  return inquirer;
+}
+
+const program = new Command();
+
+program
+  .name('musubi-tasks')
+  .description('MUSUBI Task Breakdown System - Break down design into actionable tasks')
+  .version('0.8.4');
+
+// Initialize task breakdown
+program
+  .command('init <feature>')
+  .description('Initialize task breakdown document from design')
+  .option('-o, --output <path>', 'Output directory', 'docs/tasks')
+  .option('-a, --author <name>', 'Author name')
+  .option('--project <name>', 'Project name')
+  .option('-d, --design <path>', 'Design document path')
+  .option('-r, --requirements <path>', 'Requirements document path')
+  .action(async (feature, options) => {
+    try {
+      console.log(chalk.bold(`\n📋 Initializing task breakdown for: ${feature}\n`));
+      
+      const generator = new TasksGenerator(process.cwd());
+      const result = await generator.init(feature, options);
+      
+      console.log(chalk.green('\n✓ Task breakdown document created'));
+      console.log(chalk.dim(`  ${result.path}`));
+      console.log();
+      console.log(chalk.bold('Next steps:'));
+      console.log(chalk.dim(`  1. Edit ${result.path}`));
+      console.log(chalk.dim('  2. Add tasks: musubi-tasks add <title>'));
+      console.log(chalk.dim('  3. Validate: musubi-tasks validate'));
+      console.log(chalk.dim('  4. Generate graph: musubi-tasks graph'));
+      console.log();
+      
+      process.exit(0);
+    } catch (error) {
+      console.error(chalk.red('✗ Error:'), error.message);
+      process.exit(1);
+    }
+  });
+
+// Add task
+program
+  .command('add <title>')
+  .description('Add new task with interactive prompts')
+  .option('-f, --file <path>', 'Task breakdown file path')
+  .action(async (title, options) => {
+    try {
+      console.log(chalk.bold(`\n📝 Adding task: ${title}\n`));
+      
+      const generator = new TasksGenerator(process.cwd());
+      
+      // Find task file
+      let taskFile = options.file;
+      if (!taskFile) {
+        const files = await generator.findTaskFiles();
+        if (files.length === 0) {
+          console.error(chalk.red('✗ No task files found'));
+          console.log(chalk.dim('  Run: musubi-tasks init <feature>'));
+          process.exit(1);
+        }
+        
+        if (files.length === 1) {
+          taskFile = files[0];
+        } else {
+          const inquirerInst = await getInquirer();
+          const answer = await inquirerInst.prompt([{
+            type: 'list',
+            name: 'file',
+            message: 'Select task file:',
+            choices: files
+          }]);
+          taskFile = answer.file;
+        }
+      }
+      
+      // Interactive prompts for task details
+      const inquirerInst2 = await getInquirer();
+      const answers = await inquirerInst2.prompt([
+        {
+          type: 'list',
+          name: 'priority',
+          message: 'Task priority:',
+          choices: [
+            { name: 'P0 (Critical - Launch Blocker)', value: 'P0' },
+            { name: 'P1 (High - Important)', value: 'P1' },
+            { name: 'P2 (Medium - Nice to have)', value: 'P2' },
+            { name: 'P3 (Low - Future)', value: 'P3' }
+          ],
+          default: 'P1'
+        },
+        {
+          type: 'list',
+          name: 'storyPoints',
+          message: 'Story points (Fibonacci):',
+          choices: ['1', '2', '3', '5', '8', '13'],
+          default: '3'
+        },
+        {
+          type: 'input',
+          name: 'estimatedHours',
+          message: 'Estimated hours:',
+          default: '4',
+          validate: (input) => !isNaN(input) || 'Must be a number'
+        },
+        {
+          type: 'input',
+          name: 'assignee',
+          message: 'Assignee (optional):',
+          default: '[Unassigned]'
+        },
+        {
+          type: 'input',
+          name: 'description',
+          message: 'Task description:',
+          validate: (input) => input.length > 0 || 'Description is required'
+        },
+        {
+          type: 'input',
+          name: 'requirements',
+          message: 'Requirements (comma-separated REQ-XXX-NNN):',
+          filter: (input) => input.split(',').map(s => s.trim()).filter(s => s.length > 0)
+        },
+        {
+          type: 'input',
+          name: 'acceptance',
+          message: 'Acceptance criteria (semicolon-separated):',
+          filter: (input) => input.split(';').map(s => s.trim()).filter(s => s.length > 0)
+        },
+        {
+          type: 'input',
+          name: 'dependencies',
+          message: 'Dependencies (comma-separated TASK-XXX):',
+          filter: (input) => input.split(',').map(s => s.trim()).filter(s => s.length > 0)
+        }
+      ]);
+      
+      const task = {
+        title,
+        priority: answers.priority,
+        storyPoints: parseInt(answers.storyPoints),
+        estimatedHours: parseFloat(answers.estimatedHours),
+        assignee: answers.assignee,
+        status: 'Not Started',
+        description: answers.description,
+        requirements: answers.requirements,
+        acceptance: answers.acceptance,
+        dependencies: answers.dependencies
+      };
+      
+      const result = await generator.addTask(taskFile, task);
+      
+      console.log(chalk.green('\n✓ Task added:'));
+      console.log(chalk.dim(`  TASK-${result.id}: ${result.title}`));
+      console.log(chalk.dim(`  Priority: ${result.priority}, Points: ${result.storyPoints}, Hours: ${result.estimatedHours}`));
+      console.log();
+      
+      process.exit(0);
+    } catch (error) {
+      console.error(chalk.red('✗ Error:'), error.message);
+      process.exit(1);
+    }
+  });
+
+// List all tasks
+program
+  .command('list')
+  .description('List all tasks')
+  .option('-f, --file <path>', 'Specific task file')
+  .option('--format <type>', 'Output format (table|json|markdown)', 'table')
+  .option('--priority <level>', 'Filter by priority (P0|P1|P2|P3)')
+  .option('--status <status>', 'Filter by status')
+  .action(async (options) => {
+    try {
+      console.log(chalk.bold('\n📋 Task List\n'));
+      
+      const generator = new TasksGenerator(process.cwd());
+      const result = await generator.list(options);
+      
+      if (result.tasks.length === 0) {
+        console.log(chalk.yellow('No tasks found'));
+        console.log(chalk.dim('  Run: musubi-tasks add <title>'));
+        process.exit(0);
+      }
+      
+      if (options.format === 'json') {
+        console.log(JSON.stringify(result, null, 2));
+      } else if (options.format === 'markdown') {
+        result.tasks.forEach(t => {
+          console.log(`### TASK-${t.id}: ${t.title}`);
+          console.log(`**Priority**: ${t.priority} | **Points**: ${t.storyPoints} | **Status**: ${t.status}`);
+          console.log();
+        });
+      } else {
+        // Table format
+        console.log(chalk.bold('Summary:'));
+        console.log(chalk.dim(`  Total: ${result.summary.total} tasks`));
+        console.log(chalk.dim(`  P0: ${result.summary.p0}, P1: ${result.summary.p1}, P2: ${result.summary.p2}, P3: ${result.summary.p3}`));
+        console.log(chalk.dim(`  Story Points: ${result.summary.totalPoints}, Hours: ${result.summary.totalHours}`));
+        console.log();
+        
+        result.tasks.forEach(t => {
+          const priorityColor = {
+            'P0': chalk.red,
+            'P1': chalk.yellow,
+            'P2': chalk.blue,
+            'P3': chalk.gray
+          }[t.priority] || chalk.white;
+          
+          console.log(priorityColor(`  TASK-${t.id}: ${t.title}`));
+          console.log(chalk.dim(`    ${t.priority} | ${t.storyPoints}pts | ${t.estimatedHours}h | ${t.status}`));
+        });
+        console.log();
+      }
+      
+      process.exit(0);
+    } catch (error) {
+      console.error(chalk.red('✗ Error:'), error.message);
+      process.exit(1);
+    }
+  });
+
+// Update task status
+program
+  .command('update <id> <status>')
+  .description('Update task status')
+  .option('-f, --file <path>', 'Task breakdown file path')
+  .action(async (id, status, options) => {
+    try {
+      console.log(chalk.bold(`\n📝 Updating TASK-${id}\n`));
+      
+      const generator = new TasksGenerator(process.cwd());
+      const result = await generator.updateStatus(id, status, options.file);
+      
+      console.log(chalk.green('✓ Task updated:'));
+      console.log(chalk.dim(`  TASK-${result.id}: ${result.title}`));
+      console.log(chalk.dim(`  Status: ${result.oldStatus} → ${result.newStatus}`));
+      console.log();
+      
+      process.exit(0);
+    } catch (error) {
+      console.error(chalk.red('✗ Error:'), error.message);
+      process.exit(1);
+    }
+  });
+
+// Validate task breakdown
+program
+  .command('validate')
+  .description('Validate task breakdown completeness')
+  .option('-f, --file <path>', 'Specific task file')
+  .option('-v, --verbose', 'Show detailed validation results')
+  .action(async (options) => {
+    try {
+      console.log(chalk.bold('\n🔍 Validating Task Breakdown\n'));
+      
+      const generator = new TasksGenerator(process.cwd());
+      const results = await generator.validate(options.file);
+      
+      if (results.passed) {
+        console.log(chalk.green('✓ All tasks valid\n'));
+      } else {
+        console.log(chalk.red('✗ Validation failed\n'));
+      }
+      
+      console.log(chalk.bold('Summary:'));
+      console.log(chalk.dim(`  Total: ${results.total}`));
+      console.log(chalk.green(`  Valid: ${results.valid}`));
+      console.log(chalk.red(`  Invalid: ${results.invalid}`));
+      console.log();
+      
+      if (results.violations.length > 0) {
+        console.log(chalk.bold.red('Violations:'));
+        results.violations.forEach(v => {
+          console.log(chalk.red(`  • ${v}`));
+        });
+        console.log();
+      }
+      
+      if (options.verbose && results.details) {
+        console.log(chalk.bold('Details:'));
+        results.details.forEach(d => {
+          const icon = d.valid ? chalk.green('✓') : chalk.red('✗');
+          console.log(`  ${icon} ${d.file}: ${d.message}`);
+        });
+        console.log();
+      }
+      
+      process.exit(results.passed ? 0 : 1);
+    } catch (error) {
+      console.error(chalk.red('✗ Error:'), error.message);
+      process.exit(1);
+    }
+  });
+
+// Generate dependency graph
+program
+  .command('graph')
+  .description('Generate task dependency graph')
+  .option('-f, --file <path>', 'Task breakdown file path')
+  .option('--format <type>', 'Output format (mermaid|dot)', 'mermaid')
+  .action(async (options) => {
+    try {
+      console.log(chalk.bold('\n📊 Generating Dependency Graph\n'));
+      
+      const generator = new TasksGenerator(process.cwd());
+      const result = await generator.generateGraph(options);
+      
+      console.log(chalk.green('✓ Dependency graph generated\n'));
+      console.log(chalk.bold('Graph:'));
+      console.log(chalk.cyan(result.graph));
+      console.log();
+      
+      if (result.parallelGroups) {
+        console.log(chalk.bold('Parallel Execution Groups:'));
+        result.parallelGroups.forEach((group, i) => {
+          console.log(chalk.dim(`  Group ${i + 1}: ${group.join(', ')}`));
+        });
+        console.log();
+      }
+      
+      process.exit(0);
+    } catch (error) {
+      console.error(chalk.red('✗ Error:'), error.message);
+      process.exit(1);
+    }
+  });
+
+program.parse(process.argv);
+
+if (!process.argv.slice(2).length) {
+  program.outputHelp();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "musubi-sdd",
-  "version": "0.8.3",
+  "version": "0.8.4",
   "description": "Ultimate Specification Driven Development Tool with 25 Agents for 7 AI Coding Platforms (Claude Code, GitHub Copilot, Cursor, Gemini CLI, Windsurf, Codex, Qwen Code)",
   "main": "src/index.js",
   "bin": {
@@ -13,7 +13,8 @@
     "musubi-share": "bin/musubi-share.js",
     "musubi-validate": "bin/musubi-validate.js",
     "musubi-requirements": "bin/musubi-requirements.js",
-    "musubi-design": "bin/musubi-design.js"
+    "musubi-design": "bin/musubi-design.js",
+    "musubi-tasks": "bin/musubi-tasks.js"
   },
   "scripts": {
     "test": "jest",

package/src/generators/tasks.js

@@ -0,0 +1,485 @@
+/**
+ * MUSUBI Tasks Generator
+ * 
+ * Generates task breakdown documents with P0-P3 priority labels
+ * Supports dependency graphs and parallel execution planning
+ */
+
+const fs = require('fs-extra');
+const path = require('path');
+const glob = require('glob');
+
+class TasksGenerator {
+  constructor(workspaceRoot) {
+    this.workspaceRoot = workspaceRoot;
+    this.templatePath = path.join(__dirname, '../templates/shared/documents/tasks.md');
+  }
+
+  /**
+   * Initialize task breakdown document
+   */
+  async init(feature, options = {}) {
+    const outputDir = path.join(this.workspaceRoot, options.output || 'docs/tasks');
+    await fs.ensureDir(outputDir);
+
+    const fileName = this.slugify(feature) + '.md';
+    const filePath = path.join(outputDir, fileName);
+
+    // Read template
+    const template = await fs.readFile(this.templatePath, 'utf-8');
+
+    // Replace template variables
+    const content = template
+      .replace(/\{\{FEATURE_NAME\}\}/g, feature)
+      .replace(/\{\{PROJECT_NAME\}\}/g, options.project || '[Project Name]')
+      .replace(/\{\{DATE\}\}/g, new Date().toISOString().split('T')[0])
+      .replace(/\{\{AUTHOR\}\}/g, options.author || '[Author]')
+      .replace(/\{\{COMPONENT\}\}/g, this.slugify(feature));
+
+    await fs.writeFile(filePath, content, 'utf-8');
+
+    return { path: filePath, feature };
+  }
+
+  /**
+   * Find all task breakdown files
+   */
+  async findTaskFiles() {
+    const patterns = [
+      'docs/tasks/**/*.md',
+      'tasks/**/*.md'
+    ];
+
+    const files = [];
+    for (const pattern of patterns) {
+      const matches = glob.sync(pattern, { cwd: this.workspaceRoot, absolute: true });
+      files.push(...matches);
+    }
+
+    return [...new Set(files)];
+  }
+
+  /**
+   * Add task to breakdown document
+   */
+  async addTask(filePath, task) {
+    const content = await fs.readFile(filePath, 'utf-8');
+
+    // Generate task ID
+    const taskId = this.generateTaskId(content);
+
+    // Format task section
+    const taskSection = this.formatTaskSection(taskId, task);
+
+    // Find insertion point based on priority
+    const insertionPoint = this.findTaskInsertionPoint(content, task.priority);
+    const updatedContent = content.slice(0, insertionPoint) + '\n' + taskSection + '\n' + content.slice(insertionPoint);
+
+    await fs.writeFile(filePath, updatedContent, 'utf-8');
+
+    return { id: taskId, ...task };
+  }
+
+  /**
+   * Generate next task ID
+   */
+  generateTaskId(content) {
+    const taskIds = [];
+    const regex = /### TASK-(\d{3}):/g;
+    let match;
+
+    while ((match = regex.exec(content)) !== null) {
+      taskIds.push(parseInt(match[1]));
+    }
+
+    if (taskIds.length === 0) {
+      return '001';
+    }
+
+    const maxId = Math.max(...taskIds);
+    return String(maxId + 1).padStart(3, '0');
+  }
+
+  /**
+   * Format task section
+   */
+  formatTaskSection(taskId, task) {
+    let section = `### TASK-${taskId}: ${task.title}\n\n`;
+    section += `**Priority**: ${task.priority}\n`;
+    section += `**Story Points**: ${task.storyPoints}\n`;
+    section += `**Estimated Hours**: ${task.estimatedHours}\n`;
+    section += `**Assignee**: ${task.assignee}\n`;
+    section += `**Status**: ${task.status}\n\n`;
+    section += `**Description**:\n${task.description}\n\n`;
+
+    if (task.requirements && task.requirements.length > 0) {
+      section += '**Requirements Coverage**:\n';
+      task.requirements.forEach(req => {
+        section += `- ${req}\n`;
+      });
+      section += '\n';
+    }
+
+    if (task.acceptance && task.acceptance.length > 0) {
+      section += '**Acceptance Criteria**:\n';
+      task.acceptance.forEach(criterion => {
+        section += `- [ ] ${criterion}\n`;
+      });
+      section += '\n';
+    }
+
+    if (task.dependencies && task.dependencies.length > 0) {
+      section += '**Dependencies**:\n';
+      task.dependencies.forEach(dep => {
+        section += `- ${dep}\n`;
+      });
+      section += '\n';
+    }
+
+    section += '**Test-First Checklist** (Article III):\n';
+    section += '- [ ] Tests written BEFORE implementation\n';
+    section += '- [ ] Red: Failing test committed\n';
+    section += '- [ ] Green: Minimal implementation passes test\n';
+    section += '- [ ] Blue: Refactored with confidence\n\n';
+
+    section += '**Validation**:\n';
+    section += '```bash\n';
+    section += '# Verify task completion\n';
+    section += 'npm test\n';
+    section += 'npm run lint\n';
+    section += '```\n';
+
+    return section;
+  }
+
+  /**
+   * Find insertion point for task based on priority
+   */
+  findTaskInsertionPoint(content, priority) {
+    const priorityHeaders = {
+      'P0': '## P0 Tasks',
+      'P1': '## P1 Tasks',
+      'P2': '## P2 Tasks',
+      'P3': '## P2 Tasks'
+    };
+
+    const headerPattern = priorityHeaders[priority];
+    if (!headerPattern) {
+      return content.length;
+    }
+
+    const headerIndex = content.indexOf(headerPattern);
+    if (headerIndex === -1) {
+      // Priority section doesn't exist, add at end
+      return content.length;
+    }
+
+    // Find end of section (before next ## header or end of document)
+    const nextHeaderRegex = /\n## /g;
+    nextHeaderRegex.lastIndex = headerIndex + headerPattern.length;
+    const nextMatch = nextHeaderRegex.exec(content);
+
+    if (nextMatch) {
+      return nextMatch.index + 1; // Include the newline
+    }
+
+    return content.length;
+  }
+
+  /**
+   * List all tasks
+   */
+  async list(options = {}) {
+    const files = options.file ? [options.file] : await this.findTaskFiles();
+    const allTasks = [];
+
+    for (const file of files) {
+      const content = await fs.readFile(file, 'utf-8');
+      const tasks = this.parseTasks(content);
+      allTasks.push(...tasks);
+    }
+
+    // Filter by priority
+    let filtered = allTasks;
+    if (options.priority) {
+      filtered = filtered.filter(t => t.priority === options.priority);
+    }
+    if (options.status) {
+      filtered = filtered.filter(t => t.status === options.status);
+    }
+
+    // Calculate summary
+    const summary = {
+      total: filtered.length,
+      p0: filtered.filter(t => t.priority === 'P0').length,
+      p1: filtered.filter(t => t.priority === 'P1').length,
+      p2: filtered.filter(t => t.priority === 'P2').length,
+      p3: filtered.filter(t => t.priority === 'P3').length,
+      totalPoints: filtered.reduce((sum, t) => sum + (t.storyPoints || 0), 0),
+      totalHours: filtered.reduce((sum, t) => sum + (t.estimatedHours || 0), 0)
+    };
+
+    return { tasks: filtered, summary };
+  }
+
+  /**
+   * Parse tasks from content
+   */
+  parseTasks(content) {
+    const tasks = [];
+    const taskRegex = /### TASK-(\d{3}): (.+?)\n\n\*\*Priority\*\*: (P[0-3])\n\*\*Story Points\*\*: (\d+)\n\*\*Estimated Hours\*\*: ([\d.]+)\n\*\*Assignee\*\*: (.+?)\n\*\*Status\*\*: (.+?)\n/g;
+    let match;
+
+    while ((match = taskRegex.exec(content)) !== null) {
+      tasks.push({
+        id: match[1],
+        title: match[2],
+        priority: match[3],
+        storyPoints: parseInt(match[4]),
+        estimatedHours: parseFloat(match[5]),
+        assignee: match[6],
+        status: match[7]
+      });
+    }
+
+    return tasks;
+  }
+
+  /**
+   * Update task status
+   */
+  async updateStatus(taskId, newStatus, filePath = null) {
+    const files = filePath ? [filePath] : await this.findTaskFiles();
+    
+    for (const file of files) {
+      const content = await fs.readFile(file, 'utf-8');
+      const taskPattern = new RegExp(`(### TASK-${taskId}: .+?\\n\\n\\*\\*Priority\\*\\*: .+?\\n\\*\\*Story Points\\*\\*: .+?\\n\\*\\*Estimated Hours\\*\\*: .+?\\n\\*\\*Assignee\\*\\*: .+?\\n\\*\\*Status\\*\\*: )(.+?)(\\n)`, 'g');
+      
+      const match = taskPattern.exec(content);
+      if (match) {
+        const oldStatus = match[2];
+        const updatedContent = content.replace(taskPattern, `$1${newStatus}$3`);
+        await fs.writeFile(file, updatedContent, 'utf-8');
+        
+        // Extract task title
+        const titleMatch = content.match(new RegExp(`### TASK-${taskId}: (.+?)\\n`));
+        const title = titleMatch ? titleMatch[1] : 'Unknown';
+        
+        return { id: taskId, title, oldStatus, newStatus };
+      }
+    }
+
+    throw new Error(`Task TASK-${taskId} not found`);
+  }
+
+  /**
+   * Validate task breakdown
+   */
+  async validate(filePath = null) {
+    const files = filePath ? [filePath] : await this.findTaskFiles();
+    const violations = [];
+    let total = 0;
+    let valid = 0;
+
+    for (const file of files) {
+      const content = await fs.readFile(file, 'utf-8');
+      const tasks = this.parseTasks(content);
+      total += tasks.length;
+
+      tasks.forEach(task => {
+        let isValid = true;
+
+        // Validate required fields
+        if (!task.title || task.title.length === 0) {
+          violations.push(`TASK-${task.id}: Missing title`);
+          isValid = false;
+        }
+        if (!['P0', 'P1', 'P2', 'P3'].includes(task.priority)) {
+          violations.push(`TASK-${task.id}: Invalid priority ${task.priority}`);
+          isValid = false;
+        }
+        if (!task.storyPoints || task.storyPoints <= 0) {
+          violations.push(`TASK-${task.id}: Invalid story points`);
+          isValid = false;
+        }
+        if (!task.estimatedHours || task.estimatedHours <= 0) {
+          violations.push(`TASK-${task.id}: Invalid estimated hours`);
+          isValid = false;
+        }
+
+        if (isValid) {
+          valid++;
+        }
+      });
+    }
+
+    return {
+      passed: violations.length === 0,
+      total,
+      valid,
+      invalid: total - valid,
+      violations
+    };
+  }
+
+  /**
+   * Generate dependency graph
+   */
+  async generateGraph(options = {}) {
+    const files = options.file ? [options.file] : await this.findTaskFiles();
+    const tasks = [];
+    const dependencies = new Map();
+
+    for (const file of files) {
+      const content = await fs.readFile(file, 'utf-8');
+      const fileTasks = this.parseTasksWithDependencies(content);
+      tasks.push(...fileTasks);
+    }
+
+    // Build dependency map
+    tasks.forEach(task => {
+      dependencies.set(task.id, task.dependencies || []);
+    });
+
+    // Generate graph based on format
+    let graph = '';
+    if (options.format === 'dot') {
+      graph = this.generateDotGraph(tasks, dependencies);
+    } else {
+      graph = this.generateMermaidGraph(tasks, dependencies);
+    }
+
+    // Calculate parallel execution groups
+    const parallelGroups = this.calculateParallelGroups(tasks, dependencies);
+
+    return { graph, parallelGroups };
+  }
+
+  /**
+   * Parse tasks with dependencies
+   */
+  parseTasksWithDependencies(content) {
+    const tasks = [];
+    const taskSections = content.split(/### TASK-(\d{3}):/);
+
+    for (let i = 1; i < taskSections.length; i += 2) {
+      const id = taskSections[i];
+      const section = taskSections[i + 1];
+
+      const titleMatch = section.match(/^(.+?)\n/);
+      const title = titleMatch ? titleMatch[1].trim() : 'Unknown';
+
+      const depsMatch = section.match(/\*\*Dependencies\*\*:\n((?:- TASK-\d{3}.+?\n)+)/);
+      const dependencies = [];
+      if (depsMatch) {
+        const depLines = depsMatch[1].match(/TASK-(\d{3})/g);
+        if (depLines) {
+          dependencies.push(...depLines.map(d => d.replace('TASK-', '')));
+        }
+      }
+
+      tasks.push({ id, title, dependencies });
+    }
+
+    return tasks;
+  }
+
+  /**
+   * Generate Mermaid graph
+   */
+  generateMermaidGraph(tasks, dependencies) {
+    let graph = 'graph TD\n';
+
+    tasks.forEach(task => {
+      graph += `  TASK${task.id}["TASK-${task.id}: ${task.title}"]\n`;
+    });
+
+    dependencies.forEach((deps, taskId) => {
+      deps.forEach(depId => {
+        graph += `  TASK${depId} --> TASK${taskId}\n`;
+      });
+    });
+
+    return graph;
+  }
+
+  /**
+   * Generate DOT graph
+   */
+  generateDotGraph(tasks, dependencies) {
+    let graph = 'digraph Tasks {\n';
+    graph += '  rankdir=TB;\n';
+    graph += '  node [shape=box];\n\n';
+
+    tasks.forEach(task => {
+      graph += `  TASK${task.id} [label="TASK-${task.id}\\n${task.title}"];\n`;
+    });
+
+    dependencies.forEach((deps, taskId) => {
+      deps.forEach(depId => {
+        graph += `  TASK${depId} -> TASK${taskId};\n`;
+      });
+    });
+
+    graph += '}';
+    return graph;
+  }
+
+  /**
+   * Calculate parallel execution groups
+   */
+  calculateParallelGroups(tasks, dependencies) {
+    const groups = [];
+    const processed = new Set();
+    const iterations = tasks.length + 1; // Prevent infinite loop
+    let iteration = 0;
+
+    while (processed.size < tasks.length && iteration < iterations) {
+      iteration++;
+      const group = [];
+
+      tasks.forEach(task => {
+        if (processed.has(task.id)) return;
+
+        // Check if all dependencies are processed
+        const deps = dependencies.get(task.id) || [];
+        const allDepsProcessed = deps.every(depId => processed.has(depId) || depId === task.id);
+
+        if (allDepsProcessed) {
+          group.push(`TASK-${task.id}`);
+        }
+      });
+
+      if (group.length === 0 && processed.size < tasks.length) {
+        // Circular dependency detected
+        const remaining = tasks.filter(t => !processed.has(t.id));
+        group.push(...remaining.map(t => `TASK-${t.id} (circular)`));
+        remaining.forEach(t => processed.add(t.id));
+      } else {
+        // Mark this group as processed
+        group.forEach(taskId => {
+          const id = taskId.replace('TASK-', '').replace(' (circular)', '');
+          processed.add(id);
+        });
+      }
+
+      if (group.length > 0) {
+        groups.push(group);
+      }
+    }
+
+    return groups;
+  }
+
+  /**
+   * Slugify feature name
+   */
+  slugify(str) {
+    return str
+      .toLowerCase()
+      .replace(/[^a-z0-9]+/g, '-')
+      .replace(/^-+|-+$/g, '');
+  }
+}
+
+module.exports = TasksGenerator;