@polymorphism-tech/morph-spec 8.43.0 → 8.45.0

package/src/lib/scout/scout-check.js

@@ -0,0 +1,293 @@
+import { execFileSync } from 'child_process';
+import { existsSync, readdirSync, readFileSync, statSync } from 'fs';
+import { join, relative, resolve } from 'path';
+import { workTreeTop } from '../../../framework/hooks/shared/git-paths.js';
+
+export const LINE_TOLERANCE = 2;
+
+const SPAN = /`([^`\n]+)`/g;
+const SPAN_CITATION = /^(.+\.[A-Za-z0-9]+):(\d+)(?:-(\d+))?$/;
+const BARE_CITATION = /(?<![\w.:\\/-])(?:[A-Za-z]:)?[\w.\\/-]*\w\.[A-Za-z0-9]+:(\d+)(?:-(\d+))?\b/g;
+const GREP_LINE = /^((?:[A-Za-z]:)?[^\s:]+\.[A-Za-z0-9]+)(?::(\d+):|-(\d+)-)(.*)$/;
+const FENCE = /^\s*(```|~~~)/;
+const HEADING = /^\s{0,3}#{1,6}\s+(.*)$/;
+const INFERENCE_HEADING = /inferid|hip[óo]tese|inferred|hypothes/i;
+const INFERENCE_MARKER = /\b(INFERIDO|hip[óo]tese)\b/i;
+const COMMAND_SPAN = /^(rg|grep|git\s+grep|morph-spec\s+graph|findstr|Select-String|sls)\b/;
+const COUNT = /(?:→|->|=>)\s*\d+|\b\d+\s+(?:ocorr[êe]ncias?|arquivos?|linhas?|hits?|resultados?|matches?|files?|lines?)\b/i;
+const PATH_SPAN = /^(?:[\w.-]*[\\/])+[\w.-]+$|^[\w.-]+\.(?:cs|csproj|fs|vb|razor|js|mjs|cjs|ts|tsx|jsx|json|md|py|go|java|sql|ya?ml|xml|props|targets|sln)$/i;
+
+const VERDICTS = [
+  /\b(?:VIVO|VIVA|MORTO|MORTA|ALIVE|DEAD)\b/,
+  /\b(?:c[óo]digo morto|dead code|unused)\b/i,
+  /\bsem (?:nenhum )?(?:consumidor|chamador|leitor|escritor|setter|uso|refer[êe]ncia|teste)s?\b/i,
+  /(?<!\b(?:execut|rod)\w*\s)\bnenhum[a]? (?:consumidor|chamador|leitor|escritor|setter|uso|refer[êe]ncia|teste|caller|call site)s?\b/i,
+  /\bningu[ée]m (?:chama|usa|l[êe]|escreve|grava|consome|referencia)\b/i,
+  /\bn[ãa]o (?:é|est[áa]) (?:usad|chamad|lid|referenciad|escrit)/i,
+  /\bnunca (?:é )?(?:usad|chamad|lid|escrit)/i,
+  /\bn[ãa]o h[áa] (?:consumidor|chamador|leitor|escritor|uso|teste|refer[êe]ncia)/i,
+  /\bno (?:callers?|consumers?|readers?|writers?|tests?|usages?)\b/i,
+];
+
+const WALK_SKIP = new Set(['node_modules', '.git', 'bin', 'obj', 'worktrees', '.worktrees']);
+
+function splitLines(text) {
+  const lines = text.replace(/^/, '').split(/\r?\n/);
+  if (lines.length > 1 && lines[lines.length - 1] === '') lines.pop();
+  return lines;
+}
+
+const squash = (s) => s.replace(/\s+/g, ' ').trim();
+
+function lineTokens(line) {
+  const tokens = [];
+  const masked = line.replace(SPAN, (whole, inner, index) => {
+    const cite = inner.trim().match(SPAN_CITATION);
+    if (cite) tokens.push({ index, cite: { raw: inner.trim(), path: cite[1], start: +cite[2], end: +(cite[3] ?? cite[2]) } });
+    else tokens.push({ index, quote: inner });
+    return ' '.repeat(whole.length);
+  });
+  for (const m of masked.matchAll(BARE_CITATION)) {
+    const cite = m[0].match(SPAN_CITATION);
+    if (cite) tokens.push({ index: m.index, cite: { raw: m[0], path: cite[1], start: +cite[2], end: +(cite[3] ?? cite[2]) } });
+  }
+  return tokens.sort((a, b) => a.index - b.index);
+}
+
+function citationsOf(line) {
+  const tokens = lineTokens(line);
+  const out = [];
+  tokens.forEach((t, i) => {
+    if (!t.cite) return;
+    let quote = null;
+    for (const next of tokens.slice(i + 1)) {
+      if (next.cite) break;
+      const q = next.quote.trim();
+      if (COMMAND_SPAN.test(q) || PATH_SPAN.test(q)) continue;
+      quote = next.quote;
+      break;
+    }
+    out.push({ ...t.cite, quote });
+  });
+  return out;
+}
+
+function makeFileLister(root) {
+  let files = null;
+  return () => {
+    if (files) return files;
+    try {
+      files = execFileSync('git', ['ls-files', '-z', '--cached', '--others', '--exclude-standard'], {
+        cwd: root, stdio: ['ignore', 'pipe', 'ignore'], windowsHide: true, maxBuffer: 64 * 1024 * 1024,
+      }).toString().split('\0').filter(Boolean);
+    } catch {
+      files = [];
+      const walk = (dir) => {
+        for (const entry of readdirSync(dir, { withFileTypes: true })) {
+          if (WALK_SKIP.has(entry.name)) continue;
+          const full = join(dir, entry.name);
+          if (entry.isDirectory()) walk(full);
+          else files.push(relative(root, full).replace(/\\/g, '/'));
+        }
+      };
+      walk(root);
+    }
+    return files;
+  };
+}
+
+const isFile = (p) => existsSync(p) && statSync(p).isFile();
+
+function resolveCitedPath(rawPath, root, listFiles) {
+  const p = rawPath.replace(/\\/g, '/').replace(/^\.\//, '');
+  if (/^[A-Za-z]:\//.test(p) || p.startsWith('/')) {
+    return isFile(p) ? { path: p } : { problem: 'missing-file' };
+  }
+  const direct = join(root, p);
+  if (isFile(direct)) return { path: direct };
+  const fold = process.platform === 'win32' ? (s) => s.toLowerCase() : (s) => s;
+  const suffix = fold(`/${p}`);
+  const candidates = listFiles().filter((f) => fold(`/${f}`).endsWith(suffix));
+  if (candidates.length === 1) return { path: join(root, candidates[0]) };
+  if (candidates.length > 1) return { problem: 'ambiguous-path', candidates };
+  return { problem: 'missing-file' };
+}
+
+function quoteAppears(quote, lines, start, end) {
+  const from = Math.max(0, start - 1 - LINE_TOLERANCE);
+  const to = Math.min(lines.length, end + LINE_TOLERANCE);
+  const window = squash(lines.slice(from, to).join(' '));
+  let at = 0;
+  for (const fragment of quote.split(/\.\.\.|…/).map(squash).filter(Boolean)) {
+    const found = window.indexOf(fragment, at);
+    if (found === -1) return false;
+    at = found + fragment.length;
+  }
+  return true;
+}
+
+function auditCitation(cite, root, listFiles, readCache) {
+  const where = resolveCitedPath(cite.path, root, listFiles);
+  if (where.problem === 'ambiguous-path') {
+    return { kind: 'ambiguous-path', detail: `${where.candidates.length} arquivos casam: ${where.candidates.slice(0, 5).join(', ')}` };
+  }
+  if (where.problem) return { kind: 'missing-file', detail: `${cite.path} não existe sob ${root}` };
+  if (!readCache.has(where.path)) readCache.set(where.path, splitLines(readFileSync(where.path, 'utf8')));
+  const lines = readCache.get(where.path);
+  cite.resolved = where.path;
+  if (cite.start < 1 || cite.end < cite.start || cite.end > lines.length) {
+    return { kind: 'line-out-of-range', detail: `o arquivo tem ${lines.length} linhas` };
+  }
+  const quotes = cite.quote != null ? [cite.quote] : cite.fence;
+  if (!quotes) {
+    return cite.listing ? null : { kind: 'missing-quote', detail: 'a citação não traz o trecho literal em crase depois dela' };
+  }
+  const missing = quotes.find((q) => !quoteAppears(q, lines, cite.start, cite.end));
+  if (missing != null) {
+    return {
+      kind: 'quote-mismatch',
+      detail: `trecho ausente nas linhas ${Math.max(1, cite.start - LINE_TOLERANCE)}-${Math.min(lines.length, cite.end + LINE_TOLERANCE)}; linha ${cite.start}: ${squash(lines[cite.start - 1])}`,
+    };
+  }
+  cite.verified = true;
+  return null;
+}
+
+const asMention = (line) => line.replace(SPAN, ' ').replace(/"[^"\n]*"|“[^”\n]*”/g, ' ');
+
+const isVerdict = (line) =>
+  VERDICTS[0].test(line.replace(SPAN, ' ')) || VERDICTS.slice(1).some((re) => re.test(asMention(line)));
+
+const hasSearchCommand = (line) => [...line.matchAll(SPAN)].some((m) => COMMAND_SPAN.test(m[1].trim()));
+
+function underSearchCommand(lines, i) {
+  for (let j = i - 1; j >= 0; j--) {
+    if (hasSearchCommand(lines[j])) return true;
+    if (HEADING.test(lines[j])) return false;
+  }
+  return false;
+}
+
+function auditVerdict(line, evidence, inInference) {
+  if (!inInference && !INFERENCE_MARKER.test(line)) {
+    return { kind: 'verdict-outside-inference', detail: 'veredito de ausência/vida fora da seção de hipóteses (Inferido)' };
+  }
+  const spans = [...evidence.matchAll(SPAN)].map((m) => m[1].trim());
+  if (!spans.some((s) => COMMAND_SPAN.test(s))) {
+    return { kind: 'verdict-without-command', detail: 'hipótese de ausência/vida sem o comando de busca usado, em crase' };
+  }
+  if (!COUNT.test(evidence)) return { kind: 'verdict-without-count', detail: 'hipótese de ausência/vida sem a contagem bruta do comando' };
+  return null;
+}
+
+function fenceAfter(lines, i) {
+  let j = i + 1;
+  while (j < lines.length && lines[j].trim() === '') j++;
+  if (j >= lines.length || !FENCE.test(lines[j])) return null;
+  const body = [];
+  for (let k = j + 1; k < lines.length && !FENCE.test(lines[k]); k++) {
+    const text = lines[k].replace(/^\s*:?\d+[:\s]\s*/, '').trim();
+    if (text) body.push(text);
+  }
+  return body.length ? body : null;
+}
+
+const indentOf = (line) => line.match(/^\s*/)[0].length;
+const BULLET = /^\s*([-*+]|\d+[.)])\s/;
+
+function itemStart(lines, i) {
+  let start = i;
+  for (let j = i - 1; j >= 0 && lines[j].trim() !== '' && !HEADING.test(lines[j]); j--) {
+    if (BULLET.test(lines[j]) && indentOf(lines[j]) < indentOf(lines[start])) start = j;
+  }
+  return start;
+}
+
+function continuationEnd(lines, i) {
+  const indent = indentOf(lines[i]);
+  let j = i + 1;
+  while (j < lines.length && lines[j].trim() !== '' && !HEADING.test(lines[j]) && !FENCE.test(lines[j])) {
+    if (indentOf(lines[j]) <= indent && BULLET.test(lines[j])) break;
+    j++;
+  }
+  return j;
+}
+
+export function resolveScoutRoot(root, cwd = process.cwd()) {
+  return root ? resolve(cwd, root) : (workTreeTop(cwd) ?? cwd);
+}
+
+export function checkScoutMap(text, { root }) {
+  const lines = splitLines(text);
+  const listFiles = makeFileLister(root);
+  const readCache = new Map();
+  const failures = [];
+  const citations = [];
+  let verdicts = 0;
+  let inFence = false;
+  let inferenceLevel = null;
+  let subsectionStart = null;
+
+  const audit = (cite, lineNo) => {
+    citations.push(cite);
+    const problem = auditCitation(cite, root, listFiles, readCache);
+    if (problem) failures.push({ line: lineNo, citation: cite.raw, cite, ...problem });
+  };
+  const subsectionText = (from) => {
+    let to = from + 1;
+    while (to < lines.length && !HEADING.test(lines[to])) to++;
+    return lines.slice(from, to).join('\n');
+  };
+
+  lines.forEach((line, i) => {
+    const lineNo = i + 1;
+    if (FENCE.test(line)) { inFence = !inFence; return; }
+    if (inFence) {
+      const grep = line.trim().match(GREP_LINE);
+      if (grep) {
+        const n = +(grep[2] ?? grep[3]);
+        audit({ raw: `${grep[1]}:${n}`, path: grep[1], start: n, end: n, quote: grep[4].trim() || null }, lineNo);
+      }
+      return;
+    }
+    const heading = line.match(HEADING);
+    if (heading) {
+      const level = line.trim().match(/^#+/)[0].length;
+      if (INFERENCE_HEADING.test(heading[1])) { inferenceLevel = level; subsectionStart = null; }
+      else if (inferenceLevel != null && level > inferenceLevel) subsectionStart = i;
+      else { inferenceLevel = null; subsectionStart = null; }
+    }
+
+    const cites = citationsOf(line);
+    const residue = cites.reduce((rest, c) => rest.split(c.raw).join(' '), line)
+      .replace(/[`*_|>()[\]\-+:;,.—–\s]|\d+[.)]/g, '');
+    for (const cite of cites) {
+      if (cite.quote == null) {
+        cite.fence = fenceAfter(lines, i);
+        cite.listing = residue === '' && underSearchCommand(lines, i);
+      }
+      audit(cite, lineNo);
+    }
+
+    if (!isVerdict(line)) return;
+    verdicts++;
+    const evidence = subsectionStart != null
+      ? subsectionText(subsectionStart)
+      : lines.slice(itemStart(lines, i), continuationEnd(lines, itemStart(lines, i))).join('\n');
+    const verdict = auditVerdict(line, evidence, inferenceLevel != null);
+    if (verdict) failures.push({ line: lineNo, text: squash(line), ...verdict });
+  });
+
+  const covered = (c) => citations.some((v) => v.verified && v.resolved === c.resolved && v.start <= c.start && c.end <= v.end);
+  const kept = failures.filter((f) => !(f.kind === 'missing-quote' && covered(f.cite)));
+  if (citations.length === 0) {
+    kept.push({ line: null, kind: 'no-citations', detail: 'o mapa não cita nenhum arquivo:linha — nada nele é verificável' });
+  }
+  return {
+    ok: kept.length === 0,
+    root,
+    citations: citations.map(({ raw, resolved, quote }) => ({ raw, resolved: resolved ?? null, quote })),
+    verdicts,
+    failures: kept.map(({ cite, ...f }) => f),
+  };
+}

package/src/lib/tasks/eval-node.js

@@ -36,7 +36,7 @@ import { join, resolve, sep } from 'path';
 import { tmpdir } from 'os';
 
 import { isInside } from './test-runner.js';
-import { readAiPin } from '../standards/verified-against.js';
+import { resolveAiPin } from '../ai/pin-drift.js';
 
 /** The runner kind. One spelling, imported by every reader. */
 export const EVAL_RUNNER = 'evals';
@@ -72,34 +72,6 @@ export function cacheRelevantPackages(packages) {
   return out;
 }
 
-/**
- * Read the pin from a project, wherever the framework lives.
- *
- * Two roots, ONE reader: this repository carries `framework/ai-pin.json` at the
- * top; an installed project carries it under `.morph/framework/`. `readAiPin`
- * appends `framework/ai-pin.json` to whatever root it is given, so both cases
- * are the same function with a different argument — never a second parser.
- *
- * Returns null when neither exists: a project with no pin simply has no stamp
- * ruler, and refusing to run there would make the eval node unusable outside
- * this framework's own stack.
- *
- * @param {string} projectPath
- * @returns {{pinnedAt: string, packages: object}|null}
- */
-export function readProjectPin(projectPath) {
-  for (const root of [projectPath, join(projectPath, '.morph')]) {
-    try {
-      return readAiPin(root);
-    } catch {
-      // Next candidate. The throw is readAiPin's contract for "no pin here",
-      // and it is the reason this loop exists instead of an existsSync probe
-      // that would duplicate the path knowledge.
-    }
-  }
-  return null;
-}
-
 /**
  * Resolve every path an eval node names, against the project root.
  *
@@ -256,11 +228,9 @@ export function evalPreflight(projectPath, node, options = {}) {
     return { status: 'fail', reason: `eval-cache-empty: ${cacheRoot} não contém nenhuma entrada de cache` };
   }
 
-  const pin = readProjectPin(projectPath);
+  const pin = resolveAiPin(projectPath);
   if (!pin) {
-    // No pin, no ruler — and a project without one is a legitimate case, not a
-    // failure: the stamp check simply does not apply. Saying so is the point;
-    // silently treating it as "stamp ok" would be the same thing said badly.
+    // No pin in the project or in the CLI package: nothing to stamp against.
     return { status: null, reason: null };
   }
 
@@ -315,7 +285,7 @@ export function evalNodeEnv(node, projectPath, options = {}) {
     MORPH_EVAL_ENVFILE: envFile,
   };
 
-  const pin = readProjectPin(projectPath);
+  const pin = resolveAiPin(projectPath);
   if (pin) {
     // Compact, and only the packages that decide the cache format. The fixture
     // stamps from THIS, so it never has to read (or parse) the pin itself.

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

@@ -1,30 +1,30 @@
-/**
- * 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);
-}
+/**
+ * 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);
+}