@polymorphism-tech/morph-spec 8.47.0 → 9.1.0

package/src/lib/plan/plan-parser.js

@@ -0,0 +1,204 @@
+import { tableCells, isTableLine, SEPARATOR_ROW_RE } from '../specs/gfm-table.js';
+import { ARTIFACT_MARKER_RE } from './artifact-vocabulary.js';
+import { markdownLines } from '../../../framework/hooks/shared/errata.js';
+
+export const PROOF_KINDS = ['teste', 'e2e', 'eval', 'manual'];
+export const REUSE_VERDICTS = ['REUSAR', 'ESTENDER', 'CRIAR'];
+export const ADR_SCOPES = ['feature', 'projeto'];
+
+export const SECTIONS = {
+  problem: 'Problema',
+  outOfScope: 'Fora de escopo',
+  assumptions: 'Suposições não confirmadas',
+  scenarios: 'Cenários',
+  decisions: 'Decisões',
+  architecture: 'Arquitetura',
+  reuse: 'Reuso',
+  slices: 'Fatias',
+  contract: 'Contrato de implementação',
+  errata: 'Errata',
+};
+
+export const CONFLICTS_HEADING = 'Conflitos com o acervo';
+
+const SLICE_KEYS = {
+  persona: 'persona',
+  'superfície': 'surface',
+  superficie: 'surface',
+  standards: 'standards',
+  arquivos: 'files',
+  depende: 'depends',
+  cobre: 'covers',
+};
+
+const DASH = String.raw`\s+[—–-]\s+`;
+const SCENARIO_RE = new RegExp(String.raw`^[-*]\s+\*\*(C\d+)\*\*${DASH}(.+)$`);
+const ADR_RE = new RegExp(String.raw`^###\s+(ADR-\d+)${DASH}(.+?)\s*$`);
+const SLICE_RE = new RegExp(String.raw`^###\s+(F\d+)${DASH}(.+?)\s*$`);
+const PROOF_RE = /^\s*prova\s*:\s*(.*?)\s*$/i;
+const WHY_RE = new RegExp(String.raw`^\s*>\s*` + ARTIFACT_MARKER_RE.source + String.raw`\s*(.*?)\s*$`, 'i');
+const SCOPE_RE = /^\s*\*\*Alcance:\*\*\s*(.*?)\s*$/i;
+const SLICE_LINE_RE = /^\s*[-*]\s+([\p{L}]+)\s*:\s*(.*?)\s*$/u;
+
+const fold = (s) => s.normalize('NFD').replace(/\p{M}/gu, '').toLowerCase().trim();
+
+const listOf = (value) => value
+  .split(',')
+  .map((v) => v.replace(/`/g, '').trim())
+  .filter((v) => v && !/^[—–-]$/.test(v) && fold(v) !== 'nenhum' && fold(v) !== 'nenhuma');
+
+function splitSections(lines) {
+  const sections = [];
+  let current = null;
+  for (const line of lines) {
+    const h2 = !line.fenced && /^##\s+(.+?)\s*$/.exec(line.raw);
+    if (h2 && !line.raw.startsWith('###')) {
+      current = { name: h2[1], line: line.n, lines: [] };
+      sections.push(current);
+      continue;
+    }
+    if (current) current.lines.push(line);
+  }
+  return sections;
+}
+
+function parseScenarios(lines) {
+  const scenarios = [];
+  let current = null;
+  for (const line of lines) {
+    if (line.fenced) { current = null; continue; }
+    const m = SCENARIO_RE.exec(line.raw);
+    if (m) {
+      current = { id: m[1], text: m[2].trim(), proof: null, artifactWhy: null, line: line.n };
+      scenarios.push(current);
+      continue;
+    }
+    if (!current) continue;
+    if (/^\s*$/.test(line.raw) || /^#/.test(line.raw) || /^[-*]\s/.test(line.raw)) { current = null; continue; }
+    const why = WHY_RE.exec(line.raw);
+    if (why) { current.artifactWhy = why[1] || ''; continue; }
+    const proof = PROOF_RE.exec(line.raw);
+    if (proof && current.proof === null) { current.proof = proof[1]; continue; }
+    if (/^\s*>/.test(line.raw)) continue;
+    current.text = `${current.text} ${line.raw.trim()}`;
+  }
+  return scenarios;
+}
+
+function parseDecisions(lines) {
+  const adrs = [];
+  let conflicts = null;
+  let current = null;
+  for (const line of lines) {
+    if (line.fenced) {
+      if (current?.kind === 'conflicts') conflicts.body.push(line.raw);
+      else if (current?.kind === 'adr') current.entry.body.push(line.raw);
+      continue;
+    }
+    const adr = ADR_RE.exec(line.raw);
+    if (adr) {
+      current = { kind: 'adr', entry: { id: adr[1], title: adr[2], scope: null, body: [], line: line.n } };
+      adrs.push(current.entry);
+      continue;
+    }
+    const h3 = /^###\s+(.+?)\s*$/.exec(line.raw);
+    if (h3) {
+      if (fold(h3[1]) === fold(CONFLICTS_HEADING)) {
+        conflicts = { line: line.n, body: [] };
+        current = { kind: 'conflicts' };
+      } else {
+        current = null;
+      }
+      continue;
+    }
+    if (current?.kind === 'adr') {
+      current.entry.body.push(line.raw);
+      const scope = current.entry.scope === null && SCOPE_RE.exec(line.raw);
+      if (scope) current.entry.scope = scope[1].replace(/`/g, '').trim().toLowerCase();
+    } else if (current?.kind === 'conflicts') {
+      conflicts.body.push(line.raw);
+    }
+  }
+  for (const a of adrs) a.body = a.body.join('\n').trim();
+  return {
+    adrs,
+    conflicts: conflicts && { line: conflicts.line, text: conflicts.body.join('\n').trim() },
+  };
+}
+
+function parseReuse(lines) {
+  const rows = [];
+  let header = null;
+  for (const line of lines) {
+    if (line.fenced || !isTableLine(line.raw) || SEPARATOR_ROW_RE.test(line.raw)) continue;
+    const cells = tableCells(line.raw);
+    if (!header) { header = cells.map(fold); continue; }
+    const at = (name) => cells[header.indexOf(name)] ?? '';
+    rows.push({
+      concept: at('conceito'),
+      verdict: at('veredito').replace(/`|\*/g, '').trim().toUpperCase(),
+      target: at('alvo'),
+      why: at('why'),
+      line: line.n,
+    });
+  }
+  return { header, rows };
+}
+
+function parseSlices(lines) {
+  const slices = [];
+  let current = null;
+  for (const line of lines) {
+    if (line.fenced) continue;
+    const m = SLICE_RE.exec(line.raw);
+    if (m) {
+      current = {
+        id: m[1], title: m[2], persona: null, surface: null,
+        standards: [], files: [], depends: [], covers: [], unknownKeys: [], line: line.n,
+      };
+      slices.push(current);
+      continue;
+    }
+    if (/^###\s/.test(line.raw)) { current = null; continue; }
+    if (!current) continue;
+    const kv = SLICE_LINE_RE.exec(line.raw);
+    if (!kv) continue;
+    const key = SLICE_KEYS[fold(kv[1])] ?? SLICE_KEYS[kv[1].toLowerCase()];
+    if (!key) { current.unknownKeys.push(kv[1]); continue; }
+    if (key === 'persona' || key === 'surface') {
+      const value = kv[2].replace(/`/g, '').trim();
+      current[key] = value && !/^[—–-]$/.test(value) ? value : null;
+    } else {
+      current[key] = listOf(kv[2]);
+    }
+  }
+  return slices;
+}
+
+/** Pure: no validation, no I/O; `checks.js` judges what this returns. */
+export function parsePlan(text) {
+  const lines = markdownLines(text);
+  const sections = splitSections(lines);
+  const byName = new Map();
+  for (const s of sections) {
+    const key = Object.keys(SECTIONS).find((k) => fold(SECTIONS[k]) === fold(s.name));
+    if (key && !byName.has(key)) byName.set(key, s);
+  }
+  const body = (key) => byName.get(key)?.lines ?? [];
+  const decisions = parseDecisions(body('decisions'));
+  const reuse = parseReuse(body('reuse'));
+  const errata = byName.get('errata');
+
+  return {
+    sections: sections.map((s) => ({ name: s.name, line: s.line, key: [...byName].find(([, v]) => v === s)?.[0] ?? null })),
+    present: Object.fromEntries(Object.keys(SECTIONS).map((k) => [k, byName.has(k)])),
+    scenarios: parseScenarios(body('scenarios')),
+    adrs: decisions.adrs,
+    conflicts: decisions.conflicts,
+    reuse: reuse.rows,
+    reuseHeader: reuse.header,
+    slices: parseSlices(body('slices')),
+    errata: errata ? errata.lines.map((l) => l.raw).join('\n').trim() : null,
+    sectionsAfterErrata: errata ? sections.filter((s) => s.line > errata.line).map((s) => s.name) : [],
+  };
+}

package/src/lib/plan/plan-template.js

@@ -0,0 +1,18 @@
+import { readFileSync } from 'fs';
+import { templateSourcePath, writeIfAbsent } from '../../core/templates/template-seed.js';
+import { getAbsoluteOutputPath } from '../../core/paths/output-schema.js';
+
+const FEATURE_PLACEHOLDER = /\{\{FEATURE_NAME\}\}/g;
+
+export function planTemplatePath(cwd = process.cwd()) {
+  return templateSourcePath('plan', cwd);
+}
+
+export function renderPlanSkeleton(featureName, cwd = process.cwd()) {
+  return readFileSync(planTemplatePath(cwd), 'utf8').replace(FEATURE_PLACEHOLDER, featureName);
+}
+
+/** @returns {{ path: string, written: boolean }} `written: false` when the file already existed. */
+export function writePlanSkeleton(featureName, cwd = process.cwd()) {
+  return writeIfAbsent(getAbsoluteOutputPath(cwd, featureName, 'plan'), renderPlanSkeleton(featureName, cwd));
+}

package/src/lib/projects/registry.js

@@ -1,19 +1,5 @@
-/**
- * Where the morph-spec projects on this machine are — the list the dashboard's
- * portfolio reads. Nothing else records it: each project only knows its own
- * `.morph/`.
- *
- * Three writers register a project as a side note of what they already do —
- * `init`, `update` (never under `--dry-run`) and `dashboard` — and the
- * dashboard adds and removes on request. Registering is fail-open: a registry
- * that cannot be read or written never fails the command that tried.
- *
- * The file lives in the user's home (`~/.morph-spec/projects.json`, or
- * `MORPH_PROJECTS_REGISTRY`), read through `os.homedir()` at call time so a
- * suite that isolates the home also isolates this file. Paths under the
- * system temp dir are never registered: the test suites run `init`/`update`
- * there by the hundred, including through spawned CLIs that keep the real home.
- */
+// Paths under the system temp dir are never registered: test suites run `init`/`update` there by the
+// hundred, through spawned CLIs that keep the real home. The home is read at call time so isolating it works.
 
 import { existsSync, readFileSync, readdirSync } from 'fs';
 import { homedir, tmpdir } from 'os';
@@ -35,7 +21,6 @@ export function projectKey(dir) {
 
 const sameDir = (a, b) => (process.platform === 'win32' ? a.toLowerCase() === b.toLowerCase() : a === b);
 
-/** A folder is a morph-spec project when morph-spec installed its config there. */
 export function isMorphProject(dir) {
   return existsSync(join(dir, '.morph', 'config', 'config.json'));
 }
@@ -61,18 +46,13 @@ function projectName(dir) {
   }
 }
 
-/**
- * The registered projects that still exist. A folder that was deleted or lost
- * its `.morph/` drops out on read — the file is rewritten on the next write.
- *
- * @returns {{ version: number, projects: Array<{ dir: string, name: string, addedAt: string, lastSeenAt: string, source: string }> }}
- */
+/** Folders that were deleted or lost `.morph/` drop out on read. */
 export function readRegistry() {
   let data = null;
   try {
     const path = registryPath();
     if (existsSync(path)) data = JSON.parse(readFileSync(path, 'utf8'));
-  } catch { /* unreadable registry reads as empty */ }
+  } catch {}
   const projects = Array.isArray(data?.projects) ? data.projects : [];
   return {
     version: REGISTRY_VERSION,
@@ -84,16 +64,7 @@ function write(projects) {
   atomicWriteJson(registryPath(), { version: REGISTRY_VERSION, projects });
 }
 
-/**
- * Note that `dir` is a morph-spec project. Idempotent; refreshes `lastSeenAt`.
- * Never throws.
- *
- * @param {string} dir
- * @param {'init'|'update'|'dashboard'|'manual'} source
- * @param {{ tempRoot?: string }} [opts] - test seam: the folder whose
- *   projects are never registered (the system temp dir)
- * @returns {boolean} true when the project is in the registry afterwards
- */
+/** Idempotent, never throws; `tempRoot` is the test seam for the never-registered folder. */
 export function registerProject(dir, source, { tempRoot = tmpdir() } = {}) {
   try {
     const key = projectKey(dir);
@@ -115,7 +86,7 @@ export function registerProject(dir, source, { tempRoot = tmpdir() } = {}) {
   }
 }
 
-/** Take a project off the list. Its files are not touched. Never throws. */
+/** Never throws; the project's files are not touched. */
 export function unregisterProject(dir) {
   try {
     const key = projectKey(dir);
@@ -128,15 +99,7 @@ export function unregisterProject(dir) {
   }
 }
 
-/**
- * morph-spec projects directly under each root that are not registered yet —
- * the portfolio offers them, the person decides. One level deep: a repos
- * folder is the expected root, and a deeper walk would enter node_modules and
- * worktrees for nothing.
- *
- * @param {string[]} roots
- * @returns {Array<{ dir: string, name: string }>}
- */
+/** Unregistered projects one level under each root: deeper would walk node_modules and worktrees. */
 export function discoverProjects(roots) {
   const registered = readRegistry().projects.map((p) => p.dir);
   const out = [];

package/src/lib/review-reports.js

@@ -0,0 +1,204 @@
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { OUTPUT_SCHEMA, getAbsoluteOutputPath } from '../core/paths/output-schema.js';
+import { PARTIAL_MARKER } from '../../framework/hooks/shared/slice-progress.js';
+
+export const VERDICT_TOKEN = '**Verdict:**';
+export const REVIEWED_SHA_TOKEN = '**Reviewed-SHA:**';
+export const VERDICTS = ['SHIP', 'FIX'];
+export const BLOCKER_TYPES = ['check', 'teste', 'regressao', 'seguranca', 'escopo', 'arquitetura', 'performance'];
+export const CHECK_STATUSES = ['PROVADO', 'NÃO PROVADO', 'FALHA'];
+
+export const REVIEW_ROLES = {
+  verifier: { output: 'verifierReport', persona: 'morph-verifier' },
+  reviewer: { output: 'reviewerReport', persona: 'morph-reviewer' },
+  security: { output: 'securityReport', persona: 'morph-security' },
+};
+const ROLE_ORDER = Object.keys(REVIEW_ROLES);
+
+export const reviewFileName = (role) => OUTPUT_SCHEMA[REVIEW_ROLES[role].output].filename;
+
+// Append-only: uma reavaliação acrescenta ao fim, e vale o ÚLTIMO token/seção.
+const VERDICT_RE = /\*\*Verdict:\*\*\s*([A-Za-z]+)/g;
+const REVIEWED_SHA_RE = /\*\*Reviewed-SHA:\*\*\s*`?([0-9a-f]{7,40})/gi;
+const sectionRe = (title) => new RegExp(`^##\\s+${title}\\s*$`, 'gim');
+const BLOCKERS_SECTION_RE = sectionRe('Bloqueadores');
+const CHECKS_SECTION_RE = sectionRe('Checks');
+const MEDIA_SECTION_RE = /^##\s+M[íi]dia\s+gerada\s*$/m;
+const SCREEN_CHECKLIST_SECTION_RE = sectionRe('Checklist\\s+de\\s+tela');
+
+/** Hotfix: só o verificador, escrito pelo orquestrador sem dispatch. */
+export function requiredReviewRoles({ workType, securityRequired = false } = {}) {
+  if (workType === 'hotfix') return ['verifier'];
+  return securityRequired ? ['verifier', 'reviewer', 'security'] : ['verifier', 'reviewer'];
+}
+
+function sectionBodies(text, re) {
+  return [...text.matchAll(re)].map((m) => {
+    const rest = text.slice(m.index + m[0].length);
+    const next = rest.search(/^#{1,2}\s/m);
+    return next === -1 ? rest : rest.slice(0, next);
+  });
+}
+
+function lastSectionBody(text, re) {
+  const bodies = sectionBodies(text, re);
+  return bodies.length ? bodies[bodies.length - 1] : null;
+}
+
+const normalize = (s) => String(s ?? '').toLowerCase().normalize('NFD').replace(/[̀-ͯ]/g, '').replace(/\s+/g, ' ').trim();
+const cleanId = (s) => String(s ?? '').replace(/[*`_]/g, '').trim().toUpperCase();
+
+function tableRows(body) {
+  const rows = [];
+  for (const line of body.split(/\r?\n/)) {
+    if (!/^\s*\|/.test(line)) continue;
+    const cells = line.trim().replace(/^\||\|$/g, '').split('|').map((c) => c.trim());
+    if (cells.every((c) => /^:?-{2,}:?$/.test(c) || c === '')) continue;
+    rows.push(cells);
+  }
+  return rows;
+}
+
+// `| id | tipo | onde | evidência |`; `untyped` = tipo fora de BLOCKER_TYPES.
+function parseBlockers(body) {
+  const blockers = [];
+  const untyped = [];
+  for (const cells of tableRows(body)) {
+    if (/^#$|^id$/i.test(cells[0]) && /^tipo$/i.test(cells[1] ?? '')) continue;
+    const row = { id: cleanId(cells[0]), type: normalize(cells[1]), where: cells[2] ?? '', evidence: cells[3] ?? '' };
+    (BLOCKER_TYPES.includes(row.type) ? blockers : untyped).push(row);
+  }
+  return { blockers, untyped };
+}
+
+const STATUS_BY_KEY = Object.fromEntries(CHECK_STATUSES.map((s) => [normalize(s), s]));
+
+// Vale a última linha de cada Cn em todas as seções: uma confirmação traz só os Cn que mudou.
+function parseChecks(bodies) {
+  const byId = new Map();
+  for (const cells of bodies.flatMap(tableRows)) {
+    const id = cleanId(cells[0]);
+    if (!/^C\d+$/.test(id)) continue;
+    const raw = String(cells[1] ?? '').replace(/[*`]/g, '').trim();
+    byId.delete(id);
+    byId.set(id, { id, status: STATUS_BY_KEY[normalize(raw)] ?? raw, evidence: cells[2] ?? '' });
+  }
+  return [...byId.values()];
+}
+
+/** Um relatório de review lido do texto. `checks` é `null` sem a seção `## Checks`. */
+export function parseReviewReport(text) {
+  if (typeof text !== 'string') {
+    return { partial: false, verdict: undefined, blockers: [], untyped: [], superseded: [], checks: null, reviewedSha: null };
+  }
+  const firstLine = text.split(/\r?\n/).find((l) => l.trim() !== '') ?? '';
+  const verdicts = [...text.matchAll(VERDICT_RE)].map((m) => m[1].toUpperCase());
+  const blockersBody = lastSectionBody(text, BLOCKERS_SECTION_RE);
+  const checksBodies = sectionBodies(text, CHECKS_SECTION_RE);
+  const shas = [...text.matchAll(REVIEWED_SHA_RE)].map((m) => m[1]);
+  return {
+    partial: PARTIAL_MARKER.test(firstLine),
+    verdict: verdicts.length ? verdicts[verdicts.length - 1] : undefined,
+    ...(blockersBody === null ? { blockers: [], untyped: [] } : parseBlockers(blockersBody)),
+    superseded: verdicts.slice(0, -1),
+    checks: checksBodies.length === 0 ? null : parseChecks(checksBodies),
+    reviewedSha: shas.length ? shas[shas.length - 1] : null,
+  };
+}
+
+// `partial`: `PARCIAL` na 1ª linha, com ou sem veredito. `ok` só diz legível: quem decide é o risk-detector.
+function stateOf(path, text) {
+  if (text === null) return { status: 'missing', path };
+  const parsed = parseReviewReport(text);
+  if (parsed.partial) return { status: 'partial', path, ...parsed };
+  if (!VERDICTS.includes(parsed.verdict)) return { status: 'unverdicted', path, ...parsed };
+  return { status: 'ok', path, ...parsed };
+}
+
+function readText(path) {
+  try {
+    return existsSync(path) ? readFileSync(path, 'utf8') : null;
+  } catch {
+    return null;
+  }
+}
+
+/** Os três relatórios a partir do diretório da feature — sem git; o dashboard lê árvores arquivadas. */
+export function reviewReportsFromDir(featureDir) {
+  const out = {};
+  for (const role of ROLE_ORDER) {
+    const path = join(featureDir, '4-review', reviewFileName(role));
+    out[role] = stateOf(path, readText(path));
+  }
+  return out;
+}
+
+export function reviewReportPath(cwd, featureName, role) {
+  return getAbsoluteOutputPath(cwd, featureName, REVIEW_ROLES[role].output);
+}
+
+export function reviewReports(cwd, featureName) {
+  return reviewReportsFromDir(join(cwd, '.morph', 'features', featureName));
+}
+
+/** Todo Cn precisa de uma linha, e só `PROVADO` cobre. */
+export function checksCoverage(checkIds, rows) {
+  const byId = new Map((rows ?? []).map((r) => [r.id, r]));
+  const missing = [];
+  const notProven = [];
+  for (const id of checkIds.map(cleanId)) {
+    const row = byId.get(id);
+    if (!row) missing.push(id);
+    else if (row.status !== 'PROVADO') notProven.push({ id, status: row.status || 'vazio' });
+  }
+  return { missing, notProven };
+}
+
+/** O sinal que `reviewPause` lê; `checkIds: null` = cobertura não conferível. */
+export function reviewSignal(reports, { required, checkIds }) {
+  const out = { required, reports: {} };
+  for (const role of ROLE_ORDER) {
+    const r = reports[role];
+    if (!required.includes(role) && r.status === 'missing') continue;
+    out.reports[role] = r.status === 'missing'
+      ? { status: 'missing' }
+      : {
+        status: r.status,
+        verdict: r.verdict ?? null,
+        blockers: r.blockers.length,
+        blockerIds: r.blockers.map((b) => b.id),
+        untyped: r.untyped.length,
+        superseded: r.superseded,
+      };
+  }
+  out.checks = checkIds === null
+    ? { status: 'no-checks', missing: [], notProven: [] }
+    : { status: 'ok', total: checkIds.length, ...checksCoverage(checkIds, reports.verifier.checks) };
+  return out;
+}
+
+/**
+ * Veredito combinado para leitura (dashboard, list): FIX se qualquer relatório
+ * presente diz FIX ou tem bloqueador; SHIP só com todo exigido em SHIP.
+ */
+export function combinedVerdict(reports, required) {
+  const present = ROLE_ORDER.filter((r) => reports[r].status !== 'missing');
+  if (present.some((r) => reports[r].verdict === 'FIX' || reports[r].blockers.length > 0)) return 'FIX';
+  return required.every((r) => reports[r].status === 'ok' && reports[r].verdict === 'SHIP') ? 'SHIP' : null;
+}
+
+export function allBlockers(reports) {
+  return ROLE_ORDER.flatMap((role) => (reports[role].blockers ?? []).map((b) => ({ ...b, role })));
+}
+
+export function verifierMediaSection(cwd, featureName) {
+  const text = readText(reviewReportPath(cwd, featureName, 'verifier'));
+  return text !== null && MEDIA_SECTION_RE.test(text);
+}
+
+export function verifierScreenChecklist(cwd, featureName) {
+  const text = readText(reviewReportPath(cwd, featureName, 'verifier'));
+  const body = text === null ? null : lastSectionBody(text, SCREEN_CHECKLIST_SECTION_RE);
+  return body === null ? { section: false, body: '' } : { section: true, body };
+}