@polymorphism-tech/morph-spec 8.46.0 → 9.0.0

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

@@ -1,30 +0,0 @@
-/**
- * Task classifier — identifies test/validation and infrastructure tasks by title.
- */
-
-const TEST_TASK_PATTERN = /\b(tests?|testing|specs?|coverage|e2e|unit|integration|integra[cç][aã]o|valida[cç][aã]o|cobertura|testes?)\b/i;
-
-/**
- * Returns true if the task title indicates a testing or validation task.
- *
- * @param {string} taskTitle
- * @returns {boolean}
- */
-export function isTestTask(taskTitle) {
-  if (!taskTitle) return false;
-  return TEST_TASK_PATTERN.test(taskTitle);
-}
-
-const INFRA_TASK_PATTERN = /\b(infrastructure|infra|cleanup|migration|migra[cç][aã]o|config|setup|ci\/cd|devops|deploy|docker|packages?|dependencies|tags)\b/i;
-
-/**
- * Returns true if the task title indicates an infrastructure/cleanup/migration task.
- * Used to skip contract validation and suppress breaking change warnings.
- *
- * @param {string} taskTitle
- * @returns {boolean}
- */
-export function isInfrastructureTask(taskTitle) {
-  if (!taskTitle) return false;
-  return INFRA_TASK_PATTERN.test(taskTitle);
-}

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

@@ -1,209 +0,0 @@
-/**
- * Task Parser — Shared utilities for reading, parsing, and grouping tasks.
- *
- * Extracted from bin/task-manager.cjs and dispatch-agents.js so all
- * consumers share the same parsing logic without duplication.
- */
-
-import { readFile } from 'fs/promises';
-import { readFileSync, existsSync } from 'fs';
-import { join } from 'path';
-
-// ============================================================================
-// TASK_CATEGORY_TO_GROUP — maps task categories to parallel groups
-// ============================================================================
-
-const TASK_CATEGORY_TO_GROUP = {
-  'domain': 'backend',
-  'domain-bc': 'backend',
-  'infrastructure': 'backend',
-  'application': 'backend',
-  'presentation': 'frontend',
-  'tests': 'tests',
-  'infra': 'infra',
-  'docs': 'docs',
-};
-
-// ============================================================================
-// parseTaskList — structured task parsing with error reporting
-// ============================================================================
-
-/**
- * Parse tasks.md content into structured task objects with error reporting.
- *
- * @param {string} content - Raw tasks.md content
- * @returns {{ tasks: ParsedTask[], errors: TaskParseError[], groups: Object<string, string[]> }}
- */
-export function parseTaskList(content) {
-  const tasks = [];
-  const errors = [];
-  const groups = {};
-
-  const taskHeadingRe = /^###\s+(T\d{3,})\s*[—–:\-]\s*(.+)$/gm;
-  const groupRe = /(?:\*\*Group\*\*\s*:\s*`?([a-z-]+)`?|- \*\*Group:\*\*\s*`?([a-z-]+)`?)/i;
-  const categoryRe = /(?:\*\*category\*\*\s*:\s*`?([a-z-]+)`?|category:\s*([a-z-]+))/i;
-
-  let headingMatch;
-  const taskPositions = [];
-
-  while ((headingMatch = taskHeadingRe.exec(content)) !== null) {
-    taskPositions.push({ id: headingMatch[1], title: headingMatch[2].trim(), pos: headingMatch.index });
-  }
-
-  for (let i = 0; i < taskPositions.length; i++) {
-    const { id, title, pos } = taskPositions[i];
-    const end = i + 1 < taskPositions.length ? taskPositions[i + 1].pos : content.length;
-    const block = content.slice(pos, end);
-
-    // Try group field first (v4), fall back to category field (v3)
-    const grpMatch = groupRe.exec(block);
-    const catMatch = categoryRe.exec(block);
-    let group;
-    if (grpMatch) {
-      group = (grpMatch[1] || grpMatch[2]).toLowerCase();
-    } else if (catMatch) {
-      const category = (catMatch[1] || catMatch[2]).toLowerCase();
-      group = TASK_CATEGORY_TO_GROUP[category] || 'backend';
-    } else {
-      group = 'backend';
-    }
-
-    tasks.push({ id, title, group });
-
-    if (!groups[group]) groups[group] = [];
-    groups[group].push(id);
-  }
-
-  return { tasks, errors, groups };
-}
-
-// ============================================================================
-// parseAndGroupTasks — drop-in replacement for dispatch-agents.js
-// ============================================================================
-
-/**
- * Parse tasks.md and return a map of { group -> taskId[] }.
- * Gracefully returns {} if the file doesn't exist or is unparseable.
- *
- * @param {string} tasksPath - Absolute path to tasks.md
- * @returns {Object<string, string[]>}
- */
-export function parseAndGroupTasks(tasksPath) {
-  if (!existsSync(tasksPath)) return {};
-
-  try {
-    const content = readFileSync(tasksPath, 'utf8');
-    return parseTaskList(content).groups;
-  } catch {
-    return {};
-  }
-}
-
-// ============================================================================
-// 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}/2-plan/tasks.md`);
-  let content = '';
-  try {
-    content = await readFile(tasksPath, 'utf-8');
-  } catch {
-    return [];
-  }
-
-  // Phase 1: collect heading positions
-  const headingRe = /^###\s+(T\d+)\s*[—–:\-]\s*(.+)$/gm;
-  const depRe = /\*\*Dependenc(?:y|ies):\*\*\s*(.+)/i;
-  const positions = [];
-  let match;
-  while ((match = headingRe.exec(content)) !== null) {
-    positions.push({ id: match[1], title: match[2].trim(), pos: match.index });
-  }
-
-  // Phase 2: extract body and parse dependencies
-  const tasks = [];
-  for (let i = 0; i < positions.length; i++) {
-    const { id, title, pos } = positions[i];
-    const end = i + 1 < positions.length ? positions[i + 1].pos : content.length;
-    const block = content.slice(pos, end);
-
-    let dependencies = [];
-    const depMatch = depRe.exec(block);
-    if (depMatch) {
-      const val = depMatch[1].trim();
-      if (val.toLowerCase() !== 'none') {
-        dependencies = val.split(/[,\s]+/).filter(s => /^T\d+$/.test(s));
-      }
-    }
-
-    tasks.push({ id, title, 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).
- *
- * @deprecated Prefer reading directly from feature.taskList. Counter fields
- * (feature.tasks) duplicate native Claude Code task tracking. This function
- * is kept for backward compatibility but will be removed in a future version.
- *
- * @param {Object} feature - Feature state object (mutated in place)
- */
-export function syncCounters(feature) {
-  if (Array.isArray(feature.tasks)) return; // v2 format — nothing to sync
-  // Safety: ensure feature.tasks is an object (may be undefined after migration or corruption)
-  if (!feature.tasks || typeof feature.tasks !== 'object') {
-    feature.tasks = { total: 0, completed: 0, inProgress: 0, pending: 0 };
-  }
-  const list = feature.taskList || [];
-  // Exclude expanded tasks — they are replaced by their sub-tasks
-  const active = list.filter(t => t.status !== 'expanded');
-  feature.tasks.total = active.length;
-  feature.tasks.completed = active.filter(t => t.status === 'completed').length;
-  feature.tasks.inProgress = active.filter(t => t.status === 'in_progress').length;
-  feature.tasks.pending = active.filter(t => t.status === 'pending').length;
-}

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

@@ -1,296 +0,0 @@
-/**
- * tasks-json-parser.js — read, validate, query, mutate tasks.json
- *
- * Replaces the prior Markdown-based tasks.md parser for new features.
- * Legacy features that still use tasks.md are handled by task-parser.js.
- *
- * Uses a minimal hand-rolled JSON Schema validator (no AJV dep) — sufficient
- * for the controlled schema in framework/schemas/tasks.schema.json.
- */
-
-import fs from 'fs-extra';
-import { readFileSync, existsSync } from 'fs';
-import { join, dirname } from 'path';
-import { fileURLToPath } from 'url';
-import { UC_ID_RE } from '../specs/acervo-format.js';
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const SCHEMA_PATH = join(__dirname, '..', '..', '..', 'framework', 'schemas', 'tasks.schema.json');
-
-let cachedSchema = null;
-export function getSchema() {
-  if (cachedSchema) return cachedSchema;
-  cachedSchema = JSON.parse(readFileSync(SCHEMA_PATH, 'utf8'));
-  return cachedSchema;
-}
-
-const VALID_STATUS = ['pending', 'in_progress', 'done', 'skipped', 'blocked'];
-const VALID_EFFORT = ['S', 'M', 'L', 'XL'];
-const VALID_GROUP = ['backend', 'frontend', 'tests', 'infra', 'docs'];
-/** Veredito de reuso por conceito — ver framework/schemas/tasks.schema.json. */
-const VALID_REUSE_VERDICT = ['REUSAR', 'ESTENDER', 'CRIAR'];
-
-/**
- * Validate a tasks.json structure.
- * @returns {{ valid: boolean, errors: string[] }}
- */
-export function validateTasksJson(data) {
-  const errors = [];
-  if (!data || typeof data !== 'object') {
-    errors.push('tasks.json must be an object');
-    return { valid: false, errors };
-  }
-  if (data.version !== '1.0') errors.push('version must be "1.0"');
-  if (typeof data.feature !== 'string' || !data.feature) {
-    errors.push('feature must be a non-empty string');
-  }
-  if (!Array.isArray(data.tasks)) {
-    errors.push('tasks must be an array');
-    return { valid: false, errors };
-  }
-
-  const ids = new Set();
-  for (const [i, task] of data.tasks.entries()) {
-    const ctx = `tasks[${i}]`;
-    if (!task.id || !/^T\d+$/.test(task.id)) {
-      errors.push(`${ctx}.id must match /^T\\d+$/`);
-    } else if (ids.has(task.id)) {
-      errors.push(`${ctx}.id duplicate: ${task.id}`);
-    }
-    ids.add(task.id);
-
-    if (typeof task.title !== 'string' || !task.title) errors.push(`${ctx}.title required`);
-    if (typeof task.description !== 'string' || !task.description) errors.push(`${ctx}.description required`);
-    if (!Array.isArray(task.dependencies)) {
-      errors.push(`${ctx}.dependencies must be array`);
-    } else {
-      for (const dep of task.dependencies) {
-        if (typeof dep !== 'string' || !/^T\d+$/.test(dep)) {
-          errors.push(`${ctx}.dependencies[${dep}] must match /^T\\d+$/`);
-        }
-      }
-    }
-    if (!VALID_EFFORT.includes(task.effort)) {
-      errors.push(`${ctx}.effort must be one of ${VALID_EFFORT.join(', ')}`);
-    }
-    if (typeof task.doneCriteria !== 'string' || !task.doneCriteria) {
-      errors.push(`${ctx}.doneCriteria required`);
-    }
-    if (!VALID_STATUS.includes(task.status)) {
-      errors.push(`${ctx}.status must be one of ${VALID_STATUS.join(', ')}`);
-    }
-    if (task.group !== undefined && !VALID_GROUP.includes(task.group)) {
-      errors.push(`${ctx}.group must be one of ${VALID_GROUP.join(', ')}`);
-    }
-    // Optional: a task with no observable behaviour references no use case.
-    // When present it must be the bare ID — `morph-spec dag` is the gate that
-    // catches "UC-07-listar.md" or "UC7" before the plan reaches Gate 2.
-    if (task.usecase !== undefined && (typeof task.usecase !== 'string' || !UC_ID_RE.test(task.usecase))) {
-      errors.push(`${ctx}.usecase must match /^UC-\\d+$/ (the ID alone, e.g. "UC-07")`);
-    }
-
-    // Optional: morph-plan may stamp a persona + standards per task (R2 token
-    // cut — `morph-spec standards --find` replaces reading the whole
-    // STANDARDS.json). Both are part of the plan contract and frozen after
-    // Gate 2 by protect-spec-files (any key outside MUTABLE_SPEC_FIELDS is
-    // blocked by construction — see that hook's top comment). Type-check
-    // only here: no cross-check against agents.json, since stack-filtered
-    // installs carry fewer personas than the full set and would false-fail.
-    if (task.agent !== undefined) {
-      if (typeof task.agent !== 'string' || !task.agent.trim()) {
-        errors.push(`${ctx}.agent must be a non-empty string (persona id, e.g. "dotnet-senior")`);
-      } else if (task.agent.startsWith('morph-')) {
-        errors.push(`${ctx}.agent must be the bare persona id — no "morph-" prefix (got "${task.agent}")`);
-      }
-    }
-    // Type-check e enum apenas: quem cobra o veredito contra o código é o
-    // reuse-validator, no `morph-spec verify`.
-    if (task.reuse !== undefined) {
-      if (!Array.isArray(task.reuse)) {
-        errors.push(`${ctx}.reuse must be an array of { concept, verdict, target?, why? }`);
-      } else {
-        task.reuse.forEach((entry, j) => {
-          if (!entry || typeof entry !== 'object' || Array.isArray(entry)) {
-            errors.push(`${ctx}.reuse[${j}] must be an object { concept, verdict, target?, why? }`);
-            return;
-          }
-          if (typeof entry.concept !== 'string' || !entry.concept.trim()) {
-            errors.push(`${ctx}.reuse[${j}].concept must be a non-empty string`);
-          }
-          if (!VALID_REUSE_VERDICT.includes(entry.verdict)) {
-            errors.push(`${ctx}.reuse[${j}].verdict must be one of ${VALID_REUSE_VERDICT.join(', ')}`);
-          }
-          if (entry.target !== undefined && typeof entry.target !== 'string') {
-            errors.push(`${ctx}.reuse[${j}].target must be a string path`);
-          }
-          if (entry.why !== undefined && typeof entry.why !== 'string') {
-            errors.push(`${ctx}.reuse[${j}].why must be a string`);
-          }
-        });
-      }
-    }
-    if (task.standards !== undefined) {
-      if (!Array.isArray(task.standards)) {
-        errors.push(`${ctx}.standards must be an array of paths`);
-      } else {
-        task.standards.forEach((s, i) => {
-          if (typeof s !== 'string' || !s.trim()) {
-            errors.push(`${ctx}.standards[${i}] must be a non-empty string path`);
-          }
-        });
-      }
-    }
-  }
-
-  return { valid: errors.length === 0, errors };
-}
-
-/**
- * Read and parse tasks.json from disk. Throws on validation errors.
- * @param {string} filePath - Absolute path to tasks.json
- * @returns {Promise<object>}
- */
-export async function parseTasksJson(filePath) {
-  const data = await fs.readJson(filePath);
-  const { valid, errors } = validateTasksJson(data);
-  if (!valid) {
-    throw new Error(`Invalid tasks.json:\n  ${errors.join('\n  ')}`);
-  }
-  return data;
-}
-
-/**
- * Lenient variant for read-only analysis commands (e.g. `morph-spec dag`):
- * a missing `version` field is defaulted to "1.0" instead of failing
- * validation — legacy tasks.json predating the field is still analyzable.
- * All other schema errors still throw exactly like `parseTasksJson`.
- *
- * @param {string} filePath - Absolute path to tasks.json
- * @returns {Promise<{ data: object, versionDefaulted: boolean }>}
- */
-export async function parseTasksJsonLenient(filePath) {
-  const data = await fs.readJson(filePath);
-  const versionDefaulted = data.version === undefined;
-  if (versionDefaulted) data.version = '1.0';
-
-  const { valid, errors } = validateTasksJson(data);
-  if (!valid) {
-    throw new Error(`Invalid tasks.json:\n  ${errors.join('\n  ')}`);
-  }
-  return { data, versionDefaulted };
-}
-
-/**
- * Synchronous variant — used by hooks.
- */
-export function parseTasksJsonSync(filePath) {
-  if (!existsSync(filePath)) {
-    throw new Error(`tasks.json not found: ${filePath}`);
-  }
-  const data = JSON.parse(readFileSync(filePath, 'utf8'));
-  const { valid, errors } = validateTasksJson(data);
-  if (!valid) {
-    throw new Error(`Invalid tasks.json:\n  ${errors.join('\n  ')}`);
-  }
-  return data;
-}
-
-/**
- * Teto de `outputs` por task: a task inteira tem de caber num dispatch. Medido
- * em campo (chat-demo-simulacao): tasks de 12 a 30 outputs levaram 6 de 10
- * sub-agents ao teto de turnos, e cada retomada custou um contexto frio.
- */
-export const MAX_TASK_OUTPUTS = 8;
-
-/**
- * A régua única de "task grande demais", lida pelo `dag` e pelo `gate-check`.
- * Fora de `validateTasksJson` de propósito: `outputs` segue mutável depois do
- * Gate 2, e o teto num write de status travaria feature em voo.
- *
- * @returns {{ id: string, outputs: number }[]}
- */
-export function oversizedTasks(data) {
-  const tasks = Array.isArray(data?.tasks) ? data.tasks : [];
-  return tasks
-    .filter(t => Array.isArray(t?.outputs) && t.outputs.length > MAX_TASK_OUTPUTS)
-    .map(t => ({ id: t.id, outputs: t.outputs.length }));
-}
-
-/**
- * @returns {object[]} tasks with status === 'pending'
- */
-export function getPendingTasks(data) {
-  return data.tasks.filter(t => t.status === 'pending');
-}
-
-/**
- * Tasks ready to run: pending AND all dependencies are 'done'.
- */
-export function getReadyTasks(data) {
-  const doneIds = new Set(data.tasks.filter(t => t.status === 'done').map(t => t.id));
-  return data.tasks.filter(t =>
-    t.status === 'pending' && t.dependencies.every(dep => doneIds.has(dep))
-  );
-}
-
-/**
- * Mutate `data` to set task status. Returns `data` for chaining.
- */
-export function updateTaskStatus(data, taskId, newStatus) {
-  if (!VALID_STATUS.includes(newStatus)) {
-    throw new Error(`Invalid status: ${newStatus}`);
-  }
-  const task = data.tasks.find(t => t.id === taskId);
-  if (!task) throw new Error(`Task not found: ${taskId}`);
-  task.status = newStatus;
-  return data;
-}
-
-/**
- * Write tasks.json to disk. Validates before writing.
- */
-export async function writeTasksJson(filePath, data) {
-  const { valid, errors } = validateTasksJson(data);
-  if (!valid) {
-    throw new Error(`Cannot write invalid tasks.json:\n  ${errors.join('\n  ')}`);
-  }
-  await fs.writeJson(filePath, data, { spaces: 2 });
-}
-
-/**
- * Group tasks by `group` field, falling back to 'backend' when absent.
- * Returns `{ [group]: taskId[] }` shape matching the legacy parseAndGroupTasks output.
- */
-export function groupTasks(data) {
-  const groups = {};
-  for (const task of data.tasks) {
-    const group = task.group || 'backend';
-    if (!groups[group]) groups[group] = [];
-    groups[group].push(task.id);
-  }
-  return groups;
-}
-
-/**
- * Convert tasks.json to the legacy taskList shape used in state.json.
- * Lets the rest of the codebase keep using feature.taskList while migration
- * is in progress.
- *
- * BOUNDARY — this is the ONE place `done` becomes `completed`, and it is a
- * one-way translation OUT of the tasks.json vocabulary. In tasks.json the
- * terminal status is `done` (tasks.schema.json's enum has no `completed`);
- * `completed` belongs to the legacy taskList and to Claude Code's native
- * session tasks. Leaking `completed` back into a tasks.json write is rejected
- * by `protect-spec-files` — see framework/rules/morph-task-tracking.md, which
- * spells the split out for the author.
- */
-export function toTaskList(data) {
-  return data.tasks.map(t => ({
-    id: t.id,
-    title: t.title,
-    status: t.status === 'done' ? 'completed' : t.status,
-    dependencies: [...t.dependencies],
-    files: t.outputs || [],
-    checkpoint: null,
-  }));
-}