@polymorphism-tech/morph-spec 4.8.12 → 4.8.14

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,
+    },
   };
 }