@polymorphism-tech/morph-spec 4.8.12 → 4.8.14

package/bin/{task-manager.cjs → task-manager.js}

@@ -7,84 +7,21 @@
  * Part of MORPH-SPEC 3.0 - Event-driven state management.
  */
 
-const fs = require('fs').promises;
-const fsSync = require('fs');
-const path = require('path');
-
-// Simple ANSI color helpers (chalk v5 is ESM-only, can't require in CJS)
-const chalk = {
-  red: (s) => `\x1b[31m${s}\x1b[0m`,
-  green: (s) => `\x1b[32m${s}\x1b[0m`,
-  yellow: (s) => `\x1b[33m${s}\x1b[0m`,
-  blue: (s) => `\x1b[34m${s}\x1b[0m`,
-  magenta: (s) => `\x1b[35m${s}\x1b[0m`,
-  cyan: (s) => `\x1b[36m${s}\x1b[0m`,
-  gray: (s) => `\x1b[90m${s}\x1b[0m`,
-  bold: (s) => `\x1b[1m${s}\x1b[0m`,
-};
+import { fileURLToPath } from 'url';
+import { join, dirname } from 'path';
+import { access } from 'fs/promises';
+import { execSync } from 'child_process';
+import chalk from 'chalk';
 
-// ============================================================================
-// v3 Schema Helpers
-// ============================================================================
-
-/**
- * Parse tasks.md to extract task stubs for v3 state format.
- * Looks for headings like: ### T001 — Task title
- */
-async function parseTasksMd(featureName) {
-  const tasksPath = path.join(process.cwd(), `.morph/features/${featureName}/3-tasks/tasks.md`);
-  let content = '';
-  try {
-    content = await fs.readFile(tasksPath, 'utf-8');
-  } catch {
-    return [];
-  }
-
-  const tasks = [];
-  const headingRe = /^###\s+(T\d+)\s+[—–-]\s+(.+)$/gm;
-  let match;
-  while ((match = headingRe.exec(content)) !== null) {
-    tasks.push({
-      id: match[1],
-      title: match[2].trim(),
-      status: 'pending',
-      dependencies: [],
-      files: [],
-      checkpoint: null
-    });
-  }
-  return tasks;
-}
+import { loadState, saveState } from '../src/core/state/state-manager.js';
+import { parseTasksMd, ensureTaskList, syncCounters } from '../src/lib/tasks/task-parser.js';
 
-/**
- * Ensure feature.taskList exists (array of individual task objects).
- * In v3 state, feature.tasks is a counter object {total, completed, ...}.
- * Individual task objects live in feature.taskList.
- */
-async function ensureTaskList(feature, featureName) {
-  if (Array.isArray(feature.tasks)) {
-    // v2 format: tasks IS the array
-    return feature.tasks;
-  }
-  // v3 format: use taskList or build from tasks.md
-  if (!feature.taskList || feature.taskList.length === 0) {
-    feature.taskList = await parseTasksMd(featureName);
-  }
-  return feature.taskList;
-}
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
 
-/**
- * After modifying taskList, sync counts back to feature.tasks counter.
- * tasks.total is derived from the actual taskList length (Problem 3 fix).
- */
-function syncCounters(feature) {
-  if (Array.isArray(feature.tasks)) return; // v2, nothing to sync
-  const list = feature.taskList || [];
-  feature.tasks.total = list.length; // Auto-sync total from parsed taskList
-  feature.tasks.completed = list.filter(t => t.status === 'completed').length;
-  feature.tasks.inProgress = list.filter(t => t.status === 'in_progress').length;
-  feature.tasks.pending = list.filter(t => t.status === 'pending').length;
-}
+// ============================================================================
+// Breaking-Change Detection
+// ============================================================================
 
 /**
  * Detect potentially broken consumers of recently removed exports.
@@ -102,7 +39,6 @@ function syncCounters(feature) {
  */
 async function detectBreakingChanges() {
   try {
-    const { execSync } = require('child_process');
     const execOpts = { cwd: process.cwd(), stdio: ['pipe', 'pipe', 'pipe'], maxBuffer: 5 * 1024 * 1024 };
 
     // Collect diff from staged + unstaged changes in source files
@@ -133,7 +69,6 @@ async function detectBreakingChanges() {
     const warnings = [];
     for (const sym of removedExports) {
       try {
-        // git grep returns exit code 1 when nothing found — that's handled by catch
         const result = execSync(`git grep -l "${sym}"`, execOpts).toString().trim();
         if (result) {
           const consumers = result.split('\n').filter(Boolean);
@@ -150,39 +85,11 @@ async function detectBreakingChanges() {
   }
 }
 
-class TaskManager {
-  constructor(statePath = '.morph/state.json') {
-    this.statePath = statePath;
-  }
-
-  /**
-   * Load state.json
-   */
-  async loadState() {
-    try {
-      const content = await fs.readFile(this.statePath, 'utf-8');
-      return JSON.parse(content);
-    } catch (error) {
-      if (error.code === 'ENOENT') {
-        throw new Error(`State file not found: ${this.statePath}. Run 'npx morph-spec state init' first.`);
-      }
-      throw error;
-    }
-  }
-
-  /**
-   * Save state.json
-   */
-  async saveState(state) {
-    // v3 state uses metadata.lastUpdated, v2 used project.updatedAt
-    if (state.metadata) {
-      state.metadata.lastUpdated = new Date().toISOString();
-    } else if (state.project) {
-      state.project.updatedAt = new Date().toISOString();
-    }
-    await fs.writeFile(this.statePath, JSON.stringify(state, null, 2), 'utf-8');
-  }
+// ============================================================================
+// TaskManager
+// ============================================================================
 
+class TaskManager {
   /**
    * Complete one or more tasks (runs validation first)
    * @param {string} featureName - Feature name
@@ -191,7 +98,7 @@ class TaskManager {
    * @param {boolean} options.skipValidation - Skip code validation
    */
   async completeTasks(featureName, taskIds, options = {}) {
-    const state = await this.loadState();
+    const state = loadState();
     const feature = state.features[featureName];
 
     if (!feature) {
@@ -201,12 +108,12 @@ class TaskManager {
     const taskList = await ensureTaskList(feature, featureName);
 
     if (taskList.length === 0) {
-      const tasksPath = path.join(process.cwd(), `.morph/features/${featureName}/3-tasks/tasks.md`);
-      const tasksExist = await fs.access(tasksPath).then(() => true).catch(() => false);
+      const tasksPath = join(process.cwd(), `.morph/features/${featureName}/3-tasks/tasks.md`);
+      const tasksExist = await access(tasksPath).then(() => true).catch(() => false);
       if (!tasksExist) {
         throw new Error(`No tasks found for '${featureName}' — tasks.md not generated yet.\n  Complete the tasks phase first: run /phase-tasks`);
       }
-      throw new Error(`tasks.md found but no tasks could be parsed for '${featureName}'.\n  Ensure tasks use the format: ### T001 — Title`);
+      throw new Error(`tasks.md found but no tasks could be parsed for '${featureName}'.\n  Ensure tasks use the format: ### T001 — Title  or  ### T001: Title`);
     }
 
     const results = [];
@@ -296,8 +203,8 @@ class TaskManager {
       }
     }
 
-    // Save state
-    await this.saveState(state);
+    // Persist state (atomic write via state-manager)
+    saveState(state);
 
     // Run TaskCompleted agent-teams hook for each completed task (non-blocking)
     for (const task of results) {
@@ -351,7 +258,7 @@ class TaskManager {
     } catch (error) {
       // If validation runner fails to load, warn but don't block task completion.
       // This is fail-open by design: a broken validator shouldn't block commits.
-      // Common cause: ESM import failure on Windows or missing optional deps.
+      // Common cause: missing optional deps.
       console.log(chalk.yellow(`\n⚠️  Validation skipped (${error.message})`));
       console.log(chalk.gray('   Run manually: npx morph-spec validate --verbose'));
       return true;
@@ -382,13 +289,7 @@ class TaskManager {
     const pending = tasks.filter(t => t.status === 'pending').length;
     const percentage = total > 0 ? Math.round((completed / total) * 100) : 0;
 
-    return {
-      total,
-      completed,
-      inProgress,
-      pending,
-      percentage
-    };
+    return { total, completed, inProgress, pending, percentage };
   }
 
   /**
@@ -420,7 +321,6 @@ class TaskManager {
     let checkpointResult = null;
     let validationNote = '';
 
-    // Run checkpoint hooks (new enhanced validation system)
     try {
       const { runCheckpointHooks, shouldRunCheckpoint } = await import('../src/lib/checkpoints/checkpoint-hooks.js');
 
@@ -432,7 +332,6 @@ class TaskManager {
         } else {
           validationNote = ` | ✗ ${checkpointResult.summary.errors} errors, ${checkpointResult.summary.warnings} warnings`;
 
-          // Check if we should block progress
           const config = await this.loadCheckpointConfig();
           if (config.checkpoints?.onFailure?.blockProgress && checkpointResult.summary.errors > 0) {
             console.log(chalk.red('\n❌ Checkpoint FAILED - Fix violations before proceeding'));
@@ -442,7 +341,7 @@ class TaskManager {
       }
     } catch (error) {
       if (error.message === 'Checkpoint validation failed') {
-        throw error; // Re-throw to block task completion
+        throw error;
       }
       // Fallback to old validation if checkpoint-hooks not available
       console.log(chalk.yellow('⚠️  Checkpoint hooks not available, using legacy validation'));
@@ -457,7 +356,6 @@ class TaskManager {
       }
     }
 
-    // Create checkpoint record
     const checkpoint = {
       id: `CHECKPOINT_AUTO_${Date.now()}`,
       timestamp: new Date().toISOString(),
@@ -483,18 +381,16 @@ class TaskManager {
    */
   async loadCheckpointConfig() {
     try {
-      const configPath = path.join(process.cwd(), '.morph/config/llm-interaction.json');
-      const content = await fs.readFile(configPath, 'utf-8');
+      const { readFile } = await import('fs/promises');
+      const configPath = join(process.cwd(), '.morph/config/llm-interaction.json');
+      const content = await readFile(configPath, 'utf-8');
       return JSON.parse(content);
     } catch {
-      // Return defaults if config doesn't exist
       return {
         checkpoints: {
           frequency: 3,
           autoValidate: true,
-          onFailure: {
-            blockProgress: false
-          }
+          onFailure: { blockProgress: false }
         }
       };
     }
@@ -507,7 +403,6 @@ class TaskManager {
     try {
       const config = await this.loadCheckpointConfig();
 
-      // Check if auto-generation is enabled
       if (!config.metadata?.autoGenerate) {
         return;
       }
@@ -515,21 +410,14 @@ class TaskManager {
       const { extractFeatureMetadata } = await import('../src/lib/generators/metadata-extractor.js');
       const metadata = extractFeatureMetadata(feature);
 
-      const outputPath = path.join(
-        process.cwd(),
-        `.morph/features/${featureName}/metadata.json`
-      );
-
-      // Ensure directory exists
-      const outputDir = path.dirname(outputPath);
-      await fs.mkdir(outputDir, { recursive: true });
+      const outputPath = join(process.cwd(), `.morph/features/${featureName}/metadata.json`);
 
-      // Write metadata
-      await fs.writeFile(outputPath, JSON.stringify(metadata, null, 2), 'utf-8');
+      const { mkdir, writeFile } = await import('fs/promises');
+      await mkdir(dirname(outputPath), { recursive: true });
+      await writeFile(outputPath, JSON.stringify(metadata, null, 2), 'utf-8');
 
-      console.log(chalk.gray(`   📊 Metadata updated: ${path.relative(process.cwd(), outputPath)}`));
+      console.log(chalk.gray(`   📊 Metadata updated: .morph/features/${featureName}/metadata.json`));
     } catch (error) {
-      // Don't block task completion if metadata generation fails
       console.log(chalk.yellow(`   ⚠️  Metadata generation failed: ${error.message}`));
     }
   }
@@ -551,7 +439,6 @@ class TaskManager {
   getNextTask(tasks) {
     const pending = tasks.filter(t => t.status === 'pending');
 
-    // Find first task with all dependencies completed
     for (const task of pending) {
       const missingDeps = this.checkDependencies(task, tasks);
       if (missingDeps.length === 0) {
@@ -571,7 +458,6 @@ class TaskManager {
     console.log(chalk.bold(`\n📊 Progress: ${percentage}% (${completed}/${total})`));
     console.log(chalk.gray(`   Completed: ${completed} | In Progress: ${inProgress} | Pending: ${pending}`));
 
-    // Progress bar
     const barLength = 30;
     const filledLength = Math.round((percentage / 100) * barLength);
     const bar = '█'.repeat(filledLength) + '░'.repeat(barLength - filledLength);
@@ -582,7 +468,7 @@ class TaskManager {
    * Start a task (mark as in_progress)
    */
   async startTask(featureName, taskId) {
-    const state = await this.loadState();
+    const state = loadState();
     const feature = state.features[featureName];
 
     if (!feature) {
@@ -592,12 +478,12 @@ class TaskManager {
     const taskList = await ensureTaskList(feature, featureName);
 
     if (taskList.length === 0) {
-      const tasksPath = path.join(process.cwd(), `.morph/features/${featureName}/3-tasks/tasks.md`);
-      const tasksExist = await fs.access(tasksPath).then(() => true).catch(() => false);
+      const tasksPath = join(process.cwd(), `.morph/features/${featureName}/3-tasks/tasks.md`);
+      const tasksExist = await access(tasksPath).then(() => true).catch(() => false);
       if (!tasksExist) {
         throw new Error(`No tasks found for '${featureName}' — tasks.md not generated yet.\n  Complete the tasks phase first: run /phase-tasks`);
       }
-      throw new Error(`tasks.md found but no tasks could be parsed for '${featureName}'.\n  Ensure tasks use the format: ### T001 — Title`);
+      throw new Error(`tasks.md found but no tasks could be parsed for '${featureName}'.\n  Ensure tasks use the format: ### T001 — Title  or  ### T001: Title`);
     }
 
     const task = taskList.find(t => t.id === taskId);
@@ -611,7 +497,6 @@ class TaskManager {
       return;
     }
 
-    // Validate dependencies
     const missingDeps = this.checkDependencies(task, taskList);
     if (missingDeps.length > 0) {
       throw new Error(`Cannot start ${taskId}: missing dependencies: ${missingDeps.join(', ')}`);
@@ -621,7 +506,7 @@ class TaskManager {
     task.startedAt = new Date().toISOString();
     syncCounters(feature);
 
-    await this.saveState(state);
+    saveState(state);
 
     console.log(chalk.blue(`▶️  Task ${taskId} started: ${task.title}`));
   }
@@ -630,7 +515,7 @@ class TaskManager {
    * Get next task suggestion
    */
   async getNext(featureName) {
-    const state = await this.loadState();
+    const state = loadState();
     const feature = state.features[featureName];
 
     if (!feature) {
@@ -655,7 +540,10 @@ class TaskManager {
   }
 }
 
-// CLI
+// ============================================================================
+// CLI entry point
+// ============================================================================
+
 async function main() {
   const args = process.argv.slice(2);
   const command = args[0];
@@ -719,8 +607,9 @@ async function main() {
   }
 }
 
-if (require.main === module) {
+// ESM equivalent of `if (require.main === module)`
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
   main();
 }
 
-module.exports = TaskManager;
+export default TaskManager;

package/claude-plugin.json

@@ -1,14 +1,14 @@
-{
-  "name": "morph-spec",
-  "version": "4.8.12",
-  "displayName": "MORPH-SPEC Framework",
-  "description": "Spec-driven development with 38 agents and 8-phase workflow for .NET/Blazor/Next.js/Azure",
-  "publisher": "polymorphism-tech",
-  "skills": {
-    "directory": "framework/skills",
-    "namespace": "morph-spec"
-  },
-  "hooks": {
-    "directory": "framework/hooks/claude-code"
-  }
-}
+{
+  "name": "morph-spec",
+  "version": "4.8.14",
+  "displayName": "MORPH-SPEC Framework",
+  "description": "Spec-driven development with 38 agents and 8-phase workflow for .NET/Blazor/Next.js/Azure",
+  "publisher": "polymorphism-tech",
+  "skills": {
+    "directory": "framework/skills",
+    "namespace": "morph-spec"
+  },
+  "hooks": {
+    "directory": "framework/hooks/claude-code"
+  }
+}