musubi-sdd 3.5.1 → 3.6.1

package/README.md

@@ -71,7 +71,23 @@ musubi init --windsurf  # Windsurf IDE
 
 ---
 
-## 📊 What's New in v2.1.0
+## 📊 What's New in v3.6.1
+
+- 🚀 **ProactivePathOptimizer** - Continuous path optimization even during successful execution
+- 🎯 **GoalProgressTracker** - Real-time goal progress monitoring with milestone management
+- 🔄 **AdaptiveGoalModifier** - Dynamic goal adjustment based on execution context
+- 🛠️ **New CLI Commands** - `replan`, `goal`, `optimize`, `path` subcommands for orchestration
+- 📚 **Updated Agent Templates** - All 7 platforms with replanning command documentation
+
+### Previous (v3.6.0)
+
+- 🧠 **Dynamic Replanning Engine** - AI agents can now dynamically adjust plans when tasks fail
+- 🔌 **LLM Provider Abstraction** - Multi-provider support (Copilot, Anthropic, OpenAI)
+- 📡 **Real-time Plan Monitoring** - Detect failures, timeouts, and quality degradation
+- 🔄 **Alternative Path Generation** - LLM-powered alternative strategies with confidence scoring
+- 📝 **Replan History & Audit** - Full audit trail with JSONL persistence and export
+
+### Previous (v3.5.1)
 
 - 🔄 **Workflow Engine** - New `musubi-workflow` CLI for stage management and metrics
 - 📊 **Metrics Collection** - Track time per stage, iteration counts, feedback loops
@@ -80,7 +96,12 @@ musubi init --windsurf  # Windsurf IDE
 - 🔄 **Retrospective Stage** - Stage 9 for continuous improvement
 - ✅ **Stage Validation Guide** - Checklists for stage transition validation
 
-### Previous (v2.0.0)
+### Previous (v3.5.1)
+
+- 🔧 **CLI Integration** - Added CLI command references to all 8 Claude Code skills
+- 📚 **Platform Documentation** - CLI Commands section added to all 6 non-Claude platforms
+
+### v2.1.0
 
 - 🔌 **CodeGraphMCPServer Integration** - 14 MCP tools for enhanced code analysis
 - 🧠 **GraphRAG-Powered Search** - Semantic code understanding with Louvain community detection
@@ -89,7 +110,8 @@ musubi init --windsurf  # Windsurf IDE
 ## Features
 
 - 🤖 **Multi-Agent Support** - Works with 7 AI coding agents (Claude Code, GitHub Copilot, Cursor, Gemini CLI, Codex CLI, Qwen Code, Windsurf)
-- 🔌 **MCP Server Integration** - CodeGraphMCPServer for advanced code analysis (NEW in v2.0.0)
+- 🧠 **Dynamic Replanning** - AI agents dynamically adjust plans on failure with LLM-powered alternatives (v3.6.0+)
+- 🔌 **MCP Server Integration** - CodeGraphMCPServer for advanced code analysis (v2.0.0)
 - 📄 **Flexible Command Formats** - Supports Markdown, TOML, and AGENTS.md formats
 - 🎯 **25 Specialized Agents (All Platforms)** - Orchestrator, Steering, Requirements, Architecture, Development, Quality, Security, Infrastructure
   - Claude Code: Skills API (25 skills)

package/bin/musubi-orchestrate.js

@@ -26,6 +26,15 @@ const {
   Priority
 } = require('../src/orchestration');
 
+const {
+  ReplanningEngine,
+  GoalProgressTracker,
+  Goal,
+  AdaptiveGoalModifier,
+  ProactivePathOptimizer,
+  ModificationReason
+} = require('../src/orchestration/replanning');
+
 const program = new Command();
 
 program
@@ -406,6 +415,306 @@ program
     }
   });
 
+// ============================================================================
+// Replanning Commands
+// ============================================================================
+
+// Goal tracking command
+program
+  .command('goal')
+  .description('Manage goals for goal-driven replanning')
+  .argument('<action>', 'Action: list, add, update, remove, status')
+  .option('-n, --name <name>', 'Goal name')
+  .option('-d, --description <desc>', 'Goal description')
+  .option('-p, --priority <priority>', 'Priority (1-10)', '5')
+  .option('--deadline <date>', 'Deadline (ISO date)')
+  .option('--progress <progress>', 'Progress (0-1)')
+  .option('--id <id>', 'Goal ID')
+  .option('-f, --format <type>', 'Output format (text|json)', 'text')
+  .action(async (action, options) => {
+    try {
+      const tracker = new GoalProgressTracker();
+      
+      switch (action) {
+        case 'add': {
+          if (!options.name) {
+            console.error(chalk.red('Error: --name is required'));
+            process.exit(1);
+          }
+          
+          const goal = tracker.registerGoal({
+            name: options.name,
+            description: options.description || '',
+            priority: parseInt(options.priority, 10),
+            deadline: options.deadline ? new Date(options.deadline).getTime() : null
+          });
+          
+          console.log(chalk.green(`\n✓ Goal created: ${goal.id}\n`));
+          console.log(chalk.cyan(`  Name: ${goal.name}`));
+          console.log(chalk.dim(`  Priority: ${goal.priority}`));
+          if (goal.deadline) {
+            console.log(chalk.dim(`  Deadline: ${new Date(goal.deadline).toISOString()}`));
+          }
+          console.log('');
+          break;
+        }
+        
+        case 'list': {
+          console.log(chalk.bold('\n🎯 Registered Goals\n'));
+          
+          const goals = Array.from(tracker.goals.values());
+          
+          if (options.format === 'json') {
+            console.log(JSON.stringify(goals.map(g => g.toJSON()), null, 2));
+          } else if (goals.length === 0) {
+            console.log(chalk.yellow('  No goals registered'));
+          } else {
+            for (const goal of goals) {
+              const statusIcon = goal.isComplete() ? chalk.green('✓') : 
+                                 goal.status === 'in-progress' ? chalk.yellow('◐') : 
+                                 chalk.dim('○');
+              console.log(`  ${statusIcon} ${chalk.cyan(goal.name)} (${goal.id})`);
+              console.log(chalk.dim(`     Progress: ${(goal.progress * 100).toFixed(0)}% | Priority: ${goal.priority} | Status: ${goal.status}`));
+            }
+          }
+          console.log('');
+          break;
+        }
+        
+        case 'update': {
+          if (!options.id) {
+            console.error(chalk.red('Error: --id is required'));
+            process.exit(1);
+          }
+          
+          if (options.progress) {
+            tracker.updateProgress(options.id, parseFloat(options.progress));
+            console.log(chalk.green(`\n✓ Goal ${options.id} updated to ${(parseFloat(options.progress) * 100).toFixed(0)}% progress\n`));
+          }
+          break;
+        }
+        
+        case 'status': {
+          console.log(chalk.bold('\n📊 Goal Tracking Status\n'));
+          console.log(`  Goals: ${tracker.goals.size}`);
+          console.log(`  Tracking: ${tracker.isTracking ? chalk.green('Active') : chalk.dim('Inactive')}`);
+          console.log('');
+          break;
+        }
+        
+        default:
+          console.error(chalk.red(`Unknown action: ${action}`));
+          console.log('Available actions: list, add, update, remove, status');
+          process.exit(1);
+      }
+      
+    } catch (error) {
+      console.error(chalk.red(`\n✗ Error: ${error.message}\n`));
+      process.exit(1);
+    }
+  });
+
+// Replan command
+program
+  .command('replan')
+  .description('Trigger replanning analysis')
+  .option('-p, --plan <json>', 'Current plan as JSON')
+  .option('-f, --plan-file <file>', 'Plan file path')
+  .option('--trigger <type>', 'Trigger type (failure|timeout|manual|resource)', 'manual')
+  .option('--context <json>', 'Execution context as JSON')
+  .option('-o, --output <file>', 'Output file for alternatives')
+  .option('--format <type>', 'Output format (text|json)', 'text')
+  .action(async (options) => {
+    try {
+      console.log(chalk.bold('\n🔄 Replanning Analysis\n'));
+      
+      let plan;
+      if (options.planFile) {
+        plan = await fs.readJson(options.planFile);
+      } else if (options.plan) {
+        plan = JSON.parse(options.plan);
+      } else {
+        // Demo plan
+        plan = {
+          id: 'demo-plan',
+          name: 'Demo Plan',
+          tasks: [
+            { id: 't1', skill: 'requirements-analyst', name: 'Analyze Requirements' },
+            { id: 't2', skill: 'system-architect', name: 'Design Architecture', dependencies: ['t1'] },
+            { id: 't3', skill: 'code-generator', name: 'Generate Code', dependencies: ['t2'] }
+          ]
+        };
+        console.log(chalk.dim('  Using demo plan (provide --plan or --plan-file for custom plan)\n'));
+      }
+      
+      const engine = new ReplanningEngine();
+      const normalized = engine.normalizePlan(plan);
+      
+      console.log(chalk.bold('  Plan:'));
+      console.log(`    ID: ${chalk.cyan(normalized.id)}`);
+      console.log(`    Tasks: ${normalized.tasks.length}`);
+      
+      // Show tasks
+      for (const task of normalized.tasks) {
+        console.log(chalk.dim(`      - ${task.name || task.skill} (${task.id})`));
+      }
+      
+      console.log(chalk.bold('\n  Analysis:'));
+      console.log(`    Trigger: ${chalk.yellow(options.trigger)}`);
+      console.log(`    Status: ${chalk.green('Ready for replanning')}`);
+      
+      if (options.output) {
+        await fs.writeJson(options.output, {
+          plan: normalized,
+          trigger: options.trigger,
+          timestamp: new Date().toISOString()
+        }, { spaces: 2 });
+        console.log(chalk.dim(`\n  Output written to: ${options.output}`));
+      }
+      
+      console.log('');
+      
+    } catch (error) {
+      console.error(chalk.red(`\n✗ Error: ${error.message}\n`));
+      process.exit(1);
+    }
+  });
+
+// Goal modification command
+program
+  .command('modify-goal')
+  .description('Adaptively modify a goal based on constraints')
+  .option('--id <id>', 'Goal ID to modify')
+  .option('--reason <reason>', 'Modification reason (time|resource|dependency|priority)', 'time')
+  .option('--approve', 'Auto-approve modification')
+  .option('-f, --format <type>', 'Output format (text|json)', 'text')
+  .action(async (options) => {
+    try {
+      console.log(chalk.bold('\n🔧 Adaptive Goal Modification\n'));
+      
+      const modifier = new AdaptiveGoalModifier({ requireApproval: !options.approve });
+      
+      // Demo goal if no ID provided
+      const goal = modifier.registerGoal({
+        id: options.id || 'demo-goal',
+        name: 'Demo Goal',
+        priority: 'high',
+        targetDate: new Date(Date.now() + 86400000 * 7).toISOString(),
+        deliverables: [
+          { id: 'd1', name: 'Core Feature', priority: 'critical' },
+          { id: 'd2', name: 'Documentation', priority: 'normal' }
+        ]
+      });
+      
+      const reasonMap = {
+        time: ModificationReason.TIME_CONSTRAINT,
+        resource: ModificationReason.RESOURCE_CONSTRAINT,
+        dependency: ModificationReason.DEPENDENCY_FAILURE,
+        priority: ModificationReason.PRIORITY_SHIFT
+      };
+      
+      const trigger = { reason: reasonMap[options.reason] || ModificationReason.TIME_CONSTRAINT };
+      
+      console.log(chalk.bold('  Goal:'));
+      console.log(`    ID: ${chalk.cyan(goal.id)}`);
+      console.log(`    Name: ${goal.name}`);
+      console.log(`    Priority: ${goal.priority}`);
+      
+      console.log(chalk.bold('\n  Trigger:'));
+      console.log(`    Reason: ${chalk.yellow(trigger.reason)}`);
+      
+      const result = await modifier.triggerModification(goal.id, trigger);
+      
+      console.log(chalk.bold('\n  Result:'));
+      console.log(`    Status: ${result.status === 'applied' ? chalk.green(result.status) : chalk.yellow(result.status)}`);
+      
+      if (result.modification) {
+        console.log(`    Strategy: ${chalk.cyan(result.modification.strategy.type)}`);
+        console.log(`    Confidence: ${(result.modification.confidence * 100).toFixed(0)}%`);
+        
+        if (result.modification.impact) {
+          console.log(`    Impact Score: ${(result.modification.impact.totalScore * 100).toFixed(0)}%`);
+          console.log(`    Risk Level: ${result.modification.impact.riskLevel}`);
+        }
+      }
+      
+      if (options.format === 'json') {
+        console.log('\n' + JSON.stringify(result, null, 2));
+      }
+      
+      console.log('');
+      
+    } catch (error) {
+      console.error(chalk.red(`\n✗ Error: ${error.message}\n`));
+      process.exit(1);
+    }
+  });
+
+// Path optimization command
+program
+  .command('optimize-path')
+  .description('Analyze and optimize execution path')
+  .option('-p, --path <json>', 'Execution path as JSON')
+  .option('-f, --path-file <file>', 'Path file')
+  .option('--format <type>', 'Output format (text|json)', 'text')
+  .action(async (options) => {
+    try {
+      console.log(chalk.bold('\n⚡ Path Optimization Analysis\n'));
+      
+      const optimizer = new ProactivePathOptimizer(null);
+      
+      let pathData;
+      if (options.pathFile) {
+        pathData = await fs.readJson(options.pathFile);
+      } else if (options.path) {
+        pathData = JSON.parse(options.path);
+      } else {
+        // Demo path
+        pathData = {
+          pending: [
+            { id: 't1', name: 'Task 1', estimatedDuration: 10000, dependencies: [] },
+            { id: 't2', name: 'Task 2', estimatedDuration: 5000, dependencies: [] },
+            { id: 't3', name: 'Task 3', estimatedDuration: 8000, dependencies: ['t1'] },
+            { id: 't4', name: 'Task 4', estimatedDuration: 3000, dependencies: ['t2', 't3'] }
+          ]
+        };
+        console.log(chalk.dim('  Using demo path (provide --path or --path-file for custom)\n'));
+      }
+      
+      const metrics = optimizer.calculatePathMetrics(pathData);
+      
+      console.log(chalk.bold('  Path Metrics:'));
+      console.log(`    Estimated Time: ${chalk.cyan(metrics.estimatedTime + 'ms')}`);
+      console.log(`    Parallelization Factor: ${(metrics.parallelizationFactor * 100).toFixed(0)}%`);
+      console.log(`    Risk Score: ${metrics.riskScore.toFixed(2)}`);
+      console.log(`    Overall Score: ${metrics.getScore().toFixed(2)}`);
+      
+      console.log(chalk.bold('\n  Tasks:'));
+      for (const task of pathData.pending) {
+        const deps = task.dependencies?.length ? ` -> [${task.dependencies.join(', ')}]` : '';
+        console.log(chalk.dim(`    - ${task.name} (${task.id})${deps}`));
+      }
+      
+      if (options.format === 'json') {
+        console.log('\n' + JSON.stringify({
+          path: pathData,
+          metrics: {
+            estimatedTime: metrics.estimatedTime,
+            parallelizationFactor: metrics.parallelizationFactor,
+            riskScore: metrics.riskScore,
+            score: metrics.getScore()
+          }
+        }, null, 2));
+      }
+      
+      console.log('');
+      
+    } catch (error) {
+      console.error(chalk.red(`\n✗ Error: ${error.message}\n`));
+      process.exit(1);
+    }
+  });
+
 // Status command
 program
   .command('status')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "musubi-sdd",
-  "version": "3.5.1",
+  "version": "3.6.1",
   "description": "Ultimate Specification Driven Development Tool with 27 Agents for 7 AI Coding Platforms + MCP Integration (Claude Code, GitHub Copilot, Cursor, Gemini CLI, Windsurf, Codex, Qwen Code)",
   "main": "src/index.js",
   "bin": {

package/src/llm-providers/anthropic-provider.js

@@ -0,0 +1,175 @@
+/**
+ * @fileoverview Anthropic Claude API Provider for MUSUBI Replanning Engine
+ * @module llm-providers/anthropic-provider
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const { LLMProvider } = require('./base-provider');
+
+/**
+ * Anthropic Claude API Provider
+ * Used when running outside VS Code or when Claude is preferred
+ */
+class AnthropicLMProvider extends LLMProvider {
+  /**
+   * Create an Anthropic provider
+   * @param {Object} config - Provider configuration
+   * @param {string} [config.apiKey] - Anthropic API key
+   * @param {string} [config.model='claude-sonnet-4-20250514'] - Model to use
+   */
+  constructor(config = {}) {
+    super(config);
+    this.name = 'anthropic';
+    this.apiKey = config.apiKey || process.env.ANTHROPIC_API_KEY;
+    this.config.model = config.model || 'claude-sonnet-4-20250514';
+    this.endpoint = config.endpoint || 'https://api.anthropic.com/v1/messages';
+    this.rateLimiter = this.createRateLimiter(60); // 60 RPM
+  }
+
+  /**
+   * Initialize the Anthropic provider
+   * @returns {Promise<void>}
+   */
+  async initialize() {
+    if (!this.apiKey) {
+      throw new Error('Anthropic API key not found. Set ANTHROPIC_API_KEY environment variable.');
+    }
+    this.isInitialized = true;
+  }
+
+  /**
+   * Complete a prompt using Anthropic Claude API
+   * @param {string} prompt - The prompt to complete
+   * @param {Object} [options={}] - Completion options
+   * @returns {Promise<LLMCompletionResult>} Completion result
+   */
+  async complete(prompt, options = {}) {
+    if (!this.isInitialized) {
+      await this.initialize();
+    }
+
+    const systemPrompt = options.systemPrompt || this.getDefaultSystemPrompt();
+
+    return this.rateLimiter(async () => {
+      return this.retryWithBackoff(async () => {
+        const response = await fetch(this.endpoint, {
+          method: 'POST',
+          headers: {
+            'x-api-key': this.apiKey,
+            'anthropic-version': '2023-06-01',
+            'content-type': 'application/json'
+          },
+          body: JSON.stringify({
+            model: this.config.model,
+            max_tokens: options.maxTokens || this.config.maxTokens,
+            system: systemPrompt,
+            messages: [
+              { role: 'user', content: prompt }
+            ]
+          }),
+          signal: AbortSignal.timeout(this.config.timeout)
+        });
+
+        if (!response.ok) {
+          const error = await response.text();
+          throw new Error(`Anthropic API error: ${response.status} - ${error}`);
+        }
+
+        const data = await response.json();
+
+        return {
+          content: data.content[0].text,
+          model: data.model,
+          usage: {
+            promptTokens: data.usage?.input_tokens || 0,
+            completionTokens: data.usage?.output_tokens || 0,
+            totalTokens: (data.usage?.input_tokens || 0) + (data.usage?.output_tokens || 0)
+          },
+          finishReason: data.stop_reason
+        };
+      });
+    });
+  }
+
+  /**
+   * Generate embeddings (not natively supported by Anthropic)
+   * @param {string} text - Text to embed
+   * @returns {Promise<number[]>}
+   */
+  async embed(text) {
+    throw new Error('Embedding not supported by Anthropic Claude API. Use OpenAI or a dedicated embedding service.');
+  }
+
+  /**
+   * Check if the provider is available
+   * @returns {Promise<boolean>}
+   */
+  async isAvailable() {
+    if (!this.apiKey) {
+      return false;
+    }
+
+    try {
+      // Simple validation - check if API key format is valid
+      // Anthropic API keys start with 'sk-ant-'
+      return this.apiKey.startsWith('sk-ant-') || this.apiKey.length > 20;
+    } catch (e) {
+      return false;
+    }
+  }
+
+  /**
+   * Get provider information
+   * @returns {ProviderInfo}
+   */
+  getInfo() {
+    return {
+      name: this.name,
+      model: this.config.model,
+      isInitialized: this.isInitialized,
+      capabilities: {
+        completion: true,
+        embedding: false,
+        streaming: true,
+        functionCalling: true
+      }
+    };
+  }
+
+  /**
+   * Get default system prompt for replanning
+   * @returns {string}
+   * @private
+   */
+  getDefaultSystemPrompt() {
+    return `You are an AI assistant helping with task replanning in a software development workflow.
+Your role is to analyze failed tasks, understand the goal, and generate alternative approaches.
+
+Guidelines:
+1. Be concise and specific in your recommendations
+2. Prioritize practical, actionable alternatives
+3. Consider resource constraints and dependencies
+4. Provide confidence scores for each alternative (0.0 to 1.0)
+5. Explain the reasoning behind each suggestion
+
+When generating alternatives, output valid JSON with this structure:
+{
+  "analysis": "Brief analysis of the failure",
+  "goal": "Extracted goal from the task",
+  "alternatives": [
+    {
+      "id": "alt-1",
+      "description": "Alternative approach",
+      "task": { "name": "task-name", "skill": "skill-name", "parameters": {} },
+      "confidence": 0.8,
+      "reasoning": "Why this might work",
+      "risks": ["potential risk"]
+    }
+  ]
+}`;
+  }
+}
+
+module.exports = { AnthropicLMProvider };