@polymorphism-tech/morph-spec 8.47.0 → 9.1.0

package/src/lib/stack/stack-scan.js

@@ -0,0 +1,260 @@
+import { existsSync, readFileSync, readdirSync, statSync } from 'fs';
+import { join, relative } from 'path';
+import { getProjectTags } from '../stack-filter.js';
+import { PACKAGE_LOCATIONS } from '../detectors/index.js';
+import { isTestPath } from '../graph/sanitize.js';
+import { WORKTREE_DIR_NAMES } from '../worktree/dirs.js';
+
+export const SEVERITIES = ['Bloqueante', 'Alto', 'Médio', 'Baixo'];
+export const MAX_FILES = 20000;
+
+const SKIP_DIRS = new Set([
+  'node_modules', '.git', 'bin', 'obj', 'dist', 'build', 'out', 'coverage', '.next', '.morph', '.claude', '.vs', '.idea',
+  ...WORKTREE_DIR_NAMES,
+]);
+const SOURCE_EXT = /\.(cs|csproj|sln|props|ts|tsx)$/i;
+const DOTNET_EXPECTED_MAJOR = 10;
+const WHERE_LIMIT = 5;
+
+function walk(root) {
+  const files = [];
+  const dirs = new Set();
+  let unreadable = 0;
+  let truncated = false;
+  const stack = [root];
+  while (stack.length > 0) {
+    const dir = stack.pop();
+    let entries;
+    try { entries = readdirSync(dir, { withFileTypes: true }); } catch { unreadable++; continue; }
+    for (const e of entries) {
+      const full = join(dir, e.name);
+      if (e.isDirectory()) {
+        if (SKIP_DIRS.has(e.name)) continue;
+        dirs.add(relative(root, full).replace(/\\/g, '/'));
+        stack.push(full);
+      } else if (SOURCE_EXT.test(e.name) || e.name === 'package.json') {
+        if (files.length >= MAX_FILES) { truncated = true; continue; }
+        files.push(relative(root, full).replace(/\\/g, '/'));
+      }
+    }
+  }
+  return { files, dirs, unreadable, truncated };
+}
+
+function reader(root) {
+  const failed = new Set();
+  const read = (file) => {
+    try { return readFileSync(join(root, file), 'utf8'); } catch { failed.add(file); return null; }
+  };
+  return { read, failed };
+}
+
+const majorOf = (version) => {
+  const m = /(\d+)/.exec(String(version ?? ''));
+  return m ? Number(m[1]) : null;
+};
+
+function dotnetPackages(files, read) {
+  const packages = new Map();
+  for (const f of files.filter((x) => /\.(csproj|props)$/i.test(x))) {
+    const text = read(f);
+    if (!text) continue;
+    for (const m of text.matchAll(/<Package(?:Reference|Version)\s+Include="([^"]+)"(?:\s+Version="([^"]*)")?/g)) {
+      if (!packages.has(m[1]) || m[2]) packages.set(m[1], m[2] ?? packages.get(m[1]) ?? null);
+    }
+  }
+  return packages;
+}
+
+function grepFiles(files, read, re) {
+  const hits = [];
+  for (const f of files) {
+    const text = read(f);
+    if (text && re.test(text)) hits.push(f);
+  }
+  return hits;
+}
+
+function auditDotnet(files, read) {
+  const rows = [];
+  const deviations = [];
+  const add = (severity, rule, where, migration) => deviations.push({ severity, stack: 'dotnet', rule, where, migration });
+  const projects = files.filter((f) => f.endsWith('.csproj'));
+  const source = files.filter((f) => f.endsWith('.cs') && !isTestPath(f));
+
+  const frameworks = new Map();
+  for (const p of projects) {
+    const m = /<TargetFrameworks?>([^<]+)</.exec(read(p) ?? '');
+    if (m) for (const tf of m[1].split(';').map((s) => s.trim()).filter(Boolean)) frameworks.set(tf, [...(frameworks.get(tf) ?? []), p]);
+  }
+  const tfs = [...frameworks.keys()];
+  const old = tfs.filter((tf) => /^net\d/.test(tf) && majorOf(tf) < DOTNET_EXPECTED_MAJOR);
+  rows.push({ layer: 'Runtime', detected: tfs.join(', ') || 'nenhum TargetFramework', expected: `net${DOTNET_EXPECTED_MAJOR}.0`, ok: tfs.length > 0 && old.length === 0 });
+  for (const tf of old) add('Bloqueante', `Runtime diferente (${tf})`, frameworks.get(tf), `subir o TargetFramework para net${DOTNET_EXPECTED_MAJOR}.0`);
+
+  const packages = dotnetPackages(files, read);
+  const has = (re) => [...packages.keys()].filter((p) => re.test(p));
+  const ef = has(/^Microsoft\.EntityFrameworkCore/);
+  const npgsql = has(/Npgsql/);
+  const otherDb = has(/^(Microsoft\.EntityFrameworkCore\.SqlServer|Pomelo\.EntityFrameworkCore\.MySql|MySql\.|MySqlConnector|Microsoft\.Data\.SqlClient|System\.Data\.SqlClient)/);
+  rows.push({ layer: 'ORM', detected: ef.length > 0 ? 'EF Core' : (packages.has('Dapper') ? 'Dapper' : 'ausente'), expected: 'EF Core', ok: ef.length > 0 });
+  rows.push({ layer: 'Banco', detected: npgsql.length > 0 ? 'Postgres (Npgsql)' : (otherDb.join(', ') || 'ausente'), expected: 'Neon (Postgres)', ok: npgsql.length > 0 && otherDb.length === 0 });
+  rows.push({ layer: 'IA', detected: has(/^Microsoft\.(Agents\.AI|Extensions\.AI)/).join(', ') || 'ausente', expected: 'MAF quando houver agentes', ok: true });
+  rows.push({ layer: 'Jobs', detected: has(/^Hangfire/).length > 0 ? 'Hangfire' : 'ausente', expected: 'Hangfire só com razão real', ok: true });
+  if (packages.has('Dapper') && ef.length === 0) add('Bloqueante', 'ORM diferente (Dapper puro sem EF Core)', projects, 'migrar o acesso a dados para EF Core');
+  if (otherDb.length > 0) add('Bloqueante', `Banco diferente (${otherDb.join(', ')})`, projects, 'migrar para Neon (Postgres, Npgsql)');
+  for (const p of has(/^Microsoft\.(EntityFrameworkCore|AspNetCore|Extensions)(?!\.AI)/)) {
+    const major = majorOf(packages.get(p));
+    if (major !== null && major < DOTNET_EXPECTED_MAJOR) add('Baixo', `Pacote desatualizado mas compatível (${p} ${packages.get(p)})`, [], `subir para ${DOTNET_EXPECTED_MAJOR}.x`);
+  }
+
+  const newGuid = grepFiles(source, read, /Guid\.NewGuid\(\)/);
+  if (newGuid.length > 0) add('Alto', '`Guid.NewGuid()`', newGuid, 'trocar por `Guid.CreateVersion7()`');
+  const repository = grepFiles(source, read, /interface\s+(IRepository\s*<|IUnitOfWork\b)/);
+  if (repository.length > 0) {
+    const di = grepFiles(source, read, /Add(Scoped|Transient|Singleton)\s*(<\s*(IRepository|IUnitOfWork)|\(\s*typeof\s*\(\s*(IRepository|IUnitOfWork))/);
+    add('Alto', 'Repository genérico (`IRepository<T>`/`IUnitOfWork`)', [...repository, ...di],
+      'código morto: deletar a pasta `Repository/` e as 2 linhas de DI; confirme os consumidores com `morph-spec graph affected IRepository --uses-only`');
+  }
+  const serviceLayer = source.filter((f) => {
+    const text = read(f);
+    return text && /\bclass\s+\w+(Service|Manager)\b/.test(text) && /DbContext/.test(text);
+  });
+  if (serviceLayer.length > 0) add('Alto', 'Camada de Service/Manager entre handler e dados', serviceLayer, 'o handler fala com o `ApplicationDbContext` direto');
+  const rawSql = grepFiles(source, read, /\b(FromSqlRaw|ExecuteSqlRaw|SqlQueryRaw|ExecuteQuery)\s*\(/);
+  if (rawSql.length > 0) add('Alto', 'SQL cru', rawSql, 'LINQ, ou store dedicado com justificativa em ADR');
+  const notSealed = source.filter((f) => {
+    const text = read(f) ?? '';
+    return [...text.matchAll(/^\s*(?:public|internal)\s+((?:\w+\s+)*)class\s+\w+/gm)]
+      .some((m) => !/\b(sealed|abstract|static|partial)\b/.test(m[1]));
+  });
+  if (notSealed.length > 0) add('Médio', 'Classes não-sealed', notSealed, '`sealed` por padrão');
+  const controllers = grepFiles(source, read, /:\s*Controller(Base)?\b/);
+  rows.push({ layer: 'Estrutura', detected: controllers.length > 0 ? `${controllers.length} controller(s) MVC` : 'sem controllers', expected: 'VSA (endpoint por slice)', ok: controllers.length === 0 });
+  return { rows, deviations };
+}
+
+const UI_LIBRARIES = ['@mui/material', 'antd', '@chakra-ui/react', 'bootstrap', 'react-bootstrap', '@mantine/core'];
+
+function auditNextjs(root, read) {
+  const rows = [];
+  const deviations = [];
+  const add = (severity, rule, where, migration) => deviations.push({ severity, stack: 'nextjs', rule, where, migration });
+  const packages = PACKAGE_LOCATIONS
+    .map((loc) => ({ loc, file: loc === '.' ? 'package.json' : `${loc}/package.json` }))
+    .filter(({ file }) => existsSync(join(root, file)))
+    .map((p) => {
+      const text = read(p.file);
+      let deps = null;
+      try { const pkg = JSON.parse(text); deps = { ...pkg.dependencies, ...pkg.devDependencies }; } catch { deps = null; }
+      return { ...p, deps };
+    })
+    .filter((p) => p.deps);
+  const next = packages.find((p) => p.deps.next);
+  if (!next) {
+    const other = packages.find((p) => p.deps.react || p.deps.vue);
+    rows.push({ layer: 'Frontend', detected: other ? (other.deps.vue ? 'Vue' : 'React sem Next.js') : 'sem frontend', expected: 'Next.js App Router', ok: !other });
+    if (other) add('Bloqueante', 'Frontend sem Next.js', [other.file], 'migrar para Next.js App Router');
+    return { rows, deviations };
+  }
+  const base = next.loc === '.' ? '' : `${next.loc}/`;
+  const isDir = (p) => { try { return statSync(join(root, p)).isDirectory(); } catch { return false; } };
+  const appRouter = isDir(`${base}app`) || isDir(`${base}src/app`);
+  const pagesRouter = isDir(`${base}pages`) || isDir(`${base}src/pages`);
+  rows.push({ layer: 'Frontend', detected: `Next.js ${next.deps.next}`, expected: 'Next.js App Router', ok: true });
+  rows.push({ layer: 'Roteamento', detected: appRouter ? 'App Router' : (pagesRouter ? 'Pages Router' : 'não detectado'), expected: 'App Router', ok: appRouter || !pagesRouter });
+  if (pagesRouter && !appRouter) add('Médio', 'Pages Router em vez de App Router', [next.file], 'migrar as rotas para `app/`');
+  rows.push({ layer: 'Estilo', detected: next.deps.tailwindcss ? 'Tailwind' : 'ausente', expected: 'Tailwind', ok: Boolean(next.deps.tailwindcss) });
+  rows.push({ layer: 'Motion', detected: next.deps['framer-motion'] || next.deps.motion ? 'Framer Motion' : 'ausente', expected: 'Framer Motion', ok: true });
+  const shadcn = existsSync(join(root, base, 'components.json'));
+  const otherUi = UI_LIBRARIES.filter((lib) => next.deps[lib]);
+  rows.push({ layer: 'UI', detected: otherUi.join(', ') || (shadcn ? 'shadcn' : 'ausente'), expected: 'shadcn', ok: otherUi.length === 0 });
+  if (otherUi.length > 0) add('Médio', `Biblioteca de UI diferente (${otherUi.join(', ')})`, [next.file], 'shadcn sobre Tailwind');
+  return { rows, deviations };
+}
+
+const AUDITS = { dotnet: auditDotnet, nextjs: auditNextjs };
+
+/** Only the stacks in `config.project.stack` are judged; none configured means no rule runs. */
+export function scanStack(root, config) {
+  const stack = typeof config?.project?.stack === 'string' ? config.project.stack : null;
+  const tags = getProjectTags(config);
+  const { files, unreadable, truncated } = walk(root);
+  const { read, failed } = reader(root);
+  const hasDotnet = files.some((f) => /\.(csproj|sln|cs)$/i.test(f));
+  const hasNode = files.some((f) => f.endsWith('package.json') || /\.(ts|tsx)$/i.test(f));
+  const greenfield = !hasDotnet && !hasNode;
+
+  const rows = [];
+  const deviations = [];
+  const notes = [];
+  if (!greenfield) {
+    for (const tag of tags) {
+      const audit = AUDITS[tag];
+      if (!audit) continue;
+      const result = tag === 'nextjs' ? audit(root, read) : audit(files, read);
+      rows.push(...result.rows);
+      deviations.push(...result.deviations);
+    }
+    if (hasDotnet && !tags.includes('dotnet')) notes.push('Há código .NET, mas `dotnet` não está em `project.stack` — não auditado.');
+    if (hasNode && !tags.includes('nextjs') && files.some((f) => f.endsWith('package.json'))) notes.push('Há `package.json`, mas `nextjs` não está em `project.stack` — não auditado.');
+  }
+  const unjudged = tags.filter((t) => !AUDITS[t]);
+  if (unjudged.length > 0) notes.push(`Sem regras de varredura para: ${unjudged.join(', ')}.`);
+  if (truncated) notes.push(`Varredura parou em ${MAX_FILES} arquivos.`);
+  if (unreadable + failed.size > 0) notes.push(`${unreadable + failed.size} arquivo(s) ou pasta(s) ilegível(is) ignorado(s).`);
+
+  deviations.sort((a, b) => SEVERITIES.indexOf(a.severity) - SEVERITIES.indexOf(b.severity));
+  const audited = tags.some((t) => AUDITS[t]);
+  return { stack, tags, greenfield, audited, rows, deviations, notes, filesScanned: files.length };
+}
+
+const cell = (s) => String(s).replace(/\|/g, '\\|');
+
+function whereText(where) {
+  if (!where || where.length === 0) return '';
+  const unique = [...new Set(where)];
+  const shown = unique.slice(0, WHERE_LIMIT).map((w) => `\`${w}\``).join(', ');
+  return ` — onde: ${shown}${unique.length > WHERE_LIMIT ? ` (+${unique.length - WHERE_LIMIT})` : ''} (${unique.length} arquivo(s))`;
+}
+
+export function notAuditedReason(result) {
+  return result.stack
+    ? `não auditado: nenhuma regra de varredura para \`${result.stack}\``
+    : 'não auditado: project.stack ausente em .morph/config/config.json';
+}
+
+export function renderStackScan(result, title) {
+  const out = [`# Stack Scan — ${title}`, ''];
+  out.push(`**Stack configurado:** ${result.stack ? `\`${result.stack}\`` : 'ausente em `project.stack` — nenhuma regra aplicada'}`);
+  const blocking = result.deviations.filter((d) => d.severity === 'Bloqueante' || d.severity === 'Alto');
+  const status = result.greenfield ? 'GREENFIELD (sem código fonte)'
+    : !result.audited ? notAuditedReason(result)
+    : result.deviations.length === 0 ? 'Em compliance' : `Desvios detectados (${result.deviations.length})`;
+  out.push(`**Resultado:** ${status}`, '');
+
+  if (result.rows.length > 0) {
+    out.push('## Stack detectado', '', '| Camada | Detectado | Esperado | Status |', '|---|---|---|---|');
+    for (const r of result.rows) out.push(`| ${cell(r.layer)} | ${cell(r.detected)} | ${cell(r.expected)} | ${r.ok ? '✓' : '✗'} |`);
+    out.push('');
+  }
+  if (result.deviations.length > 0) {
+    out.push('## Desvios (por severidade)', '');
+    for (const severity of SEVERITIES) {
+      const list = result.deviations.filter((d) => d.severity === severity);
+      if (list.length === 0) continue;
+      out.push(`### ${severity}`, '');
+      for (const d of list) out.push(`- ${d.rule}${whereText(d.where)} — migração: ${d.migration}`);
+      out.push('');
+    }
+  }
+  out.push('## Notas', '');
+  out.push('- Contagens por varredura de texto (grep): superestimam consumidores, porque não separam herança de uso. Para um símbolo, `morph-spec graph affected <símbolo> --uses-only`.');
+  for (const n of result.notes) out.push(`- ${n}`);
+  out.push('', '## Recomendação', '');
+  if (result.greenfield) out.push('Compliance trivial: aplicar o stack padrão de `MORPH.md`.');
+  else if (!result.audited) out.push('Nenhuma regra rodou, então nada aqui atesta compliance: declare `project.stack` e rode o stack-scan de novo.');
+  else if (blocking.length > 0) out.push('Há desvio Bloqueante ou Alto: entra na árvore de decisões como "a migração entra nesta feature ou vira feature separada?".');
+  else out.push('Nenhum desvio Bloqueante ou Alto: prossiga com o plano.');
+  return `${out.join('\n')}\n`;
+}

package/src/lib/stack-filter.js

@@ -1,14 +1,4 @@
-/**
- * Parse `stacks:` from YAML frontmatter content.
- * Returns ['*'] if no stacks field found (backwards compatible — always install).
- *
- * Supports:
- *   stacks:\n  - dotnet\n  - blazor   (YAML list)
- *   stacks: [dotnet, blazor]           (inline array)
- *
- * @param {string} content - Raw file content with YAML frontmatter
- * @returns {string[]}
- */
+/** `['*']` without a `stacks:` field (always install); accepts a YAML list or an inline array. */
 export function parseStacks(content) {
   const normalized = content.replace(/\r\n/g, '\n');
   const fmMatch = normalized.match(/^---\n([\s\S]*?)\n---/);
@@ -16,9 +6,7 @@ export function parseStacks(content) {
 
   const fm = fmMatch[1];
 
-  // Try inline format: stacks: [dotnet, blazor] — quotes stripped like the
-  // list branch below; `["umbraco"]` sem isso parseava como a string literal
-  // `"umbraco"` (com aspas) e nunca casava tag nenhuma.
+  // Quotes stripped like the list branch: `["umbraco"]` would otherwise never match a tag.
   const inlineMatch = fm.match(/^stacks:\s*\[([^\]]*)\]/m);
   if (inlineMatch) {
     const items = inlineMatch[1]
@@ -28,7 +16,6 @@ export function parseStacks(content) {
     return items.length > 0 ? items : ['*'];
   }
 
-  // Try YAML list format: stacks:\n  - dotnet\n  - blazor
   const listMatch = fm.match(/^stacks:\s*\n((?:\s+-\s+.+\n?)*)/m);
   if (listMatch) {
     const items = listMatch[1]
@@ -41,12 +28,7 @@ export function parseStacks(content) {
   return ['*'];
 }
 
-/**
- * Extract project tags from config object.
- * Combines stack tags (from `project.stack` split by '-' or '+')
- * with integration tags (from `project.integrations` array).
- * Deduplicates the result.
- */
+/** Stack tags (`project.stack` split by '-' or '+') plus `project.integrations`, deduplicated. */
 export function getProjectTags(config) {
   const stack = config?.project?.stack;
   const stackTags = (stack && typeof stack === 'string')
@@ -58,12 +40,7 @@ export function getProjectTags(config) {
   return [...new Set([...stackTags, ...integrations])];
 }
 
-/**
- * Determine if an asset should be installed for the given project tags.
- * - stacks includes '*' → always install
- * - stacks is empty → treat as '*' (backwards compatible)
- * - Otherwise → install if intersection with projectTags is non-empty
- */
+/** Empty or '*' stacks always install; otherwise any intersection with the project tags. */
 export function shouldInstall(assetStacks, projectTags) {
   if (assetStacks.length === 0 || assetStacks.includes('*')) return true;
   return assetStacks.some(s => projectTags.includes(s));

package/src/lib/standards/registry.js

@@ -0,0 +1,37 @@
+import { existsSync, readFileSync } from 'fs';
+import { dirname, join } from 'path';
+
+export const STANDARDS_FILE = 'STANDARDS.json';
+export const STANDARDS_META_FILE = 'STANDARDS.meta.json';
+
+/** Per-standard fields that live in the sidecar, keyed by id: no runtime reader needs them to pick a standard. */
+export const META_FIELDS = ['aliases', 'verifiedAgainst', 'provedBy'];
+
+export function metaPathFor(standardsJsonPath) {
+  return join(dirname(standardsJsonPath), STANDARDS_META_FILE);
+}
+
+function readMeta(standardsJsonPath) {
+  const path = metaPathFor(standardsJsonPath);
+  if (!existsSync(path)) return { standards: {}, sharedAliases: {} };
+  try {
+    const meta = JSON.parse(readFileSync(path, 'utf8'));
+    return { standards: meta?.standards || {}, sharedAliases: meta?.sharedAliases || {} };
+  } catch {
+    return { standards: {}, sharedAliases: {} };
+  }
+}
+
+/** Sidecar merged by id. Missing/unreadable sidecar = no aliases; missing STANDARDS.json throws. */
+export function loadStandardsRegistry(standardsJsonPath) {
+  const runtime = JSON.parse(readFileSync(standardsJsonPath, 'utf8'));
+  const meta = readMeta(standardsJsonPath);
+  const standards = (Array.isArray(runtime.standards) ? runtime.standards : []).map((s) => {
+    const extra = meta.standards[s.id];
+    if (!extra) return s;
+    const merged = { ...s };
+    for (const field of META_FIELDS) if (extra[field] !== undefined) merged[field] = extra[field];
+    return merged;
+  });
+  return { version: runtime.version ?? null, standards, sharedAliases: meta.sharedAliases };
+}

package/src/lib/standards/sections.js

@@ -0,0 +1,47 @@
+// The literal regex of the `github-slugger` package: anchors are read off the rendered .md.
+const SLUG_STRIP = /[ -⸀-⹿\\'!"#$%&()*+,./:;<=>?@[\]^`{|}~ ]/g;
+
+export function ghSlug(heading) {
+  return heading.trim().toLowerCase().replace(SLUG_STRIP, '').replace(/ /g, '-');
+}
+
+/** Headings outside code fences, repeated slugs suffixed `-1`, `-2` as GitHub does. */
+export function markdownHeadings(text) {
+  const out = [];
+  const seen = new Map();
+  let inFence = false;
+  const lines = text.split('\n');
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (/^\s*```/.test(line)) { inFence = !inFence; continue; }
+    if (inFence) continue;
+    const m = /^(#{1,6})\s+(.+?)\s*#*\s*$/.exec(line.replace(/\r$/, ''));
+    if (!m) continue;
+    let slug = ghSlug(m[2]);
+    if (seen.has(slug)) {
+      const n = seen.get(slug) + 1;
+      seen.set(slug, n);
+      slug = `${slug}-${n}`;
+    } else {
+      seen.set(slug, 0);
+    }
+    out.push({ level: m[1].length, title: m[2], slug, line: i });
+  }
+  return out;
+}
+
+export function headingSlugs(text) {
+  return new Set(markdownHeadings(text).map((h) => h.slug));
+}
+
+/** Heading through the line before the next heading of same or higher level; slug may carry `#`. */
+export function sectionBySlug(text, slug) {
+  const want = String(slug).replace(/^#/, '');
+  const all = markdownHeadings(text);
+  const idx = all.findIndex((h) => h.slug === want);
+  if (idx === -1) return null;
+  const start = all[idx];
+  const next = all.slice(idx + 1).find((h) => h.level <= start.level);
+  const lines = text.split('\n');
+  return lines.slice(start.line, next ? next.line : lines.length).join('\n').replace(/\s+$/, '') + '\n';
+}