@polymorphism-tech/morph-spec 4.8.11 → 4.8.14

package/src/lib/tasks/task-parser.js

@@ -0,0 +1,94 @@
+/**
+ * Task Parser — Shared utilities for reading and syncing task state.
+ *
+ * Extracted from bin/task-manager.cjs so both the task-manager and any
+ * future consumers can share the same parsing logic without duplication.
+ */
+
+import { readFile } from 'fs/promises';
+import { join } from 'path';
+
+// ============================================================================
+// parseTasksMd
+// ============================================================================
+
+/**
+ * Parse tasks.md to extract task stubs for the v3 state format.
+ * Accepts headings in either format:
+ *   ### T001 — Task title   (em-dash / en-dash / hyphen)
+ *   ### T001: Task title    (colon)
+ *
+ * @param {string} featureName
+ * @param {string} [cwd] - Project root (defaults to process.cwd())
+ * @returns {Promise<Array<{id, title, status, dependencies, files, checkpoint}>>}
+ */
+export async function parseTasksMd(featureName, cwd = process.cwd()) {
+  const tasksPath = join(cwd, `.morph/features/${featureName}/3-tasks/tasks.md`);
+  let content = '';
+  try {
+    content = await 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;
+}
+
+// ============================================================================
+// ensureTaskList
+// ============================================================================
+
+/**
+ * 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.
+ *
+ * @param {Object} feature - Feature state object (mutated in place)
+ * @param {string} featureName
+ * @param {string} [cwd]
+ * @returns {Promise<Array>} The task list
+ */
+export async function ensureTaskList(feature, featureName, cwd = process.cwd()) {
+  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, cwd);
+  }
+  return feature.taskList;
+}
+
+// ============================================================================
+// syncCounters
+// ============================================================================
+
+/**
+ * After modifying taskList, sync the counter fields back to feature.tasks.
+ * tasks.total is derived from the actual taskList length (not trusted from state).
+ *
+ * @param {Object} feature - Feature state object (mutated in place)
+ */
+export function syncCounters(feature) {
+  if (Array.isArray(feature.tasks)) return; // v2 format — nothing to sync
+  const list = feature.taskList || [];
+  feature.tasks.total = list.length;
+  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;
+}

package/src/lib/validators/content/content-validator.js

@@ -23,16 +23,19 @@ export function validateSpecContent(specPath) {
 
   const content = readFileSync(specPath, 'utf8');
 
-  // Required sections for a complete spec
+  // Required sections for a complete spec (prefix-match to handle variants like
+  // "## Functional Requirements" and "## Technical Architecture")
   const requiredSections = [
     '## Overview',
-    '## Requirements',
-    '## Technical Design',
+    '## Functional Requirements',
+    '## Technical',
     '## Data Model',
-    '## API Contracts'
   ];
 
-  const missing = requiredSections.filter(section => !content.includes(section));
+  const lines = content.split('\n');
+  const missing = requiredSections.filter(section =>
+    !lines.some(line => line.startsWith(section))
+  );
 
   // Additional quality checks
   const errors = [];
@@ -79,8 +82,8 @@ export function validateSpecContent(specPath) {
 }
 
 /**
- * Validate tasks.json structure
- * @param {string} tasksPath - Path to tasks.json file
+ * Validate tasks.md structure
+ * @param {string} tasksPath - Path to tasks.md file
  * @returns {Object} Validation result
  */
 export function validateTasksContent(tasksPath) {
@@ -91,111 +94,36 @@ export function validateTasksContent(tasksPath) {
     };
   }
 
-  let tasks;
-  try {
-    const content = readFileSync(tasksPath, 'utf8');
-    tasks = JSON.parse(content);
-  } catch (error) {
-    return {
-      valid: false,
-      errors: ['Invalid JSON in tasks file: ' + error.message]
-    };
-  }
-
+  const content = readFileSync(tasksPath, 'utf8');
   const errors = [];
   const warnings = [];
 
-  // Check required top-level fields
-  if (!tasks.feature) {
-    errors.push('Missing "feature" field in tasks.json');
-  }
+  // Extract task IDs from headings: ### T001 — title OR ### T001: title
+  const taskRe = /^###\s+(T\d{3})\s*[—–:\-]\s*(.+)$/gm;
+  const checkpointRe = /^###\s+(CHECKPOINT[_-]\d+)\s*[—–:\-]\s*(.+)$/gm;
 
-  if (!tasks.tasks || !Array.isArray(tasks.tasks)) {
-    errors.push('Missing or invalid "tasks" array in tasks.json');
-    return { valid: false, errors, warnings };
-  }
+  const tasks = [...content.matchAll(taskRe)];
+  const checkpoints = [...content.matchAll(checkpointRe)];
 
-  if (tasks.tasks.length === 0) {
-    errors.push('Tasks array is empty - no tasks defined');
+  if (tasks.length === 0) {
+    errors.push('No tasks found in tasks.md — expected headings like "### T001 — Title" or "### T001: Title"');
     return { valid: false, errors, warnings };
   }
 
-  // Validate individual tasks
-  tasks.tasks.forEach((task, index) => {
-    const taskId = task.id || `Task ${index}`;
+  // Validate no duplicate IDs
+  const ids = tasks.map(m => m[1]);
+  const dupes = ids.filter((id, i) => ids.indexOf(id) !== i);
+  dupes.forEach(id => errors.push(`Duplicate task ID: ${id}`));
 
-    // Check required fields
-    if (!task.id) {
-      errors.push(`${taskId}: Missing "id" field`);
-    } else if (!/^(T\d{3}|CHECKPOINT_\d{3})$/.test(task.id)) {
-      warnings.push(`${taskId}: ID should follow format T### or CHECKPOINT_###`);
-    }
-
-    if (!task.title) {
-      errors.push(`${taskId}: Missing "title" field`);
-    }
-
-    if (!task.description) {
-      errors.push(`${taskId}: Missing "description" field`);
-    }
+  // Check for dependency references (look for "Dependencies: T###")
+  const depRe = /\*\*Dependenc(?:y|ies):\*\*\s*([T\d, ]+)/gi;
+  const allDepRefs = [...content.matchAll(depRe)]
+    .flatMap(m => m[1].split(/[,\s]+/).filter(s => /^T\d{3}$/.test(s)));
 
-    if (!task.dependencies) {
-      errors.push(`${taskId}: Missing "dependencies" field (use empty array if no deps)`);
-    }
-
-    // For regular tasks (not checkpoints)
-    if (task.id && task.id.startsWith('T')) {
-      if (!task.category) {
-        warnings.push(`${taskId}: Missing "category" field`);
-      }
-
-      if (!task.estimatedMinutes) {
-        warnings.push(`${taskId}: Missing "estimatedMinutes" field`);
-      }
-
-      if (!task.files || task.files.length === 0) {
-        warnings.push(`${taskId}: No files specified - consider adding affected files`);
-      }
-    }
-
-    // For checkpoints
-    if (task.id && task.id.startsWith('CHECKPOINT')) {
-      if (!task.afterTasks || task.afterTasks.length === 0) {
-        warnings.push(`${taskId}: Checkpoint should specify "afterTasks"`);
-      }
-
-      if (!task.validations || task.validations.length === 0) {
-        warnings.push(`${taskId}: Checkpoint should specify "validations"`);
-      }
-    }
-  });
-
-  // Check for orphaned tasks (missing dependencies)
-  const taskIds = new Set(tasks.tasks.map(t => t.id));
-  tasks.tasks.forEach(task => {
-    if (task.dependencies && Array.isArray(task.dependencies)) {
-      task.dependencies.forEach(depId => {
-        if (depId && !taskIds.has(depId)) {
-          errors.push(`${task.id}: References non-existent dependency "${depId}"`);
-        }
-      });
-    }
-  });
-
-  // Check for circular dependencies (simple check)
-  const hasCycle = (taskId, visited = new Set()) => {
-    if (visited.has(taskId)) return true;
-    visited.add(taskId);
-
-    const task = tasks.tasks.find(t => t.id === taskId);
-    if (!task || !task.dependencies) return false;
-
-    return task.dependencies.some(depId => hasCycle(depId, new Set(visited)));
-  };
-
-  tasks.tasks.forEach(task => {
-    if (task.id && hasCycle(task.id)) {
-      errors.push(`Circular dependency detected involving task ${task.id}`);
+  const idSet = new Set(ids);
+  allDepRefs.forEach(depId => {
+    if (!idSet.has(depId)) {
+      warnings.push(`Dependency reference "${depId}" not found in task list`);
     }
   });
 
@@ -204,10 +132,10 @@ export function validateTasksContent(tasksPath) {
     errors,
     warnings,
     stats: {
-      totalTasks: tasks.tasks.length,
-      regularTasks: tasks.tasks.filter(t => t.id?.startsWith('T')).length,
-      checkpoints: tasks.tasks.filter(t => t.id?.startsWith('CHECKPOINT')).length
-    }
+      totalTasks: tasks.length + checkpoints.length,
+      regularTasks: tasks.length,
+      checkpoints: checkpoints.length,
+    },
   };
 }