@polymorphism-tech/morph-spec 8.35.0 → 8.36.0

package/src/lib/tasks/test-nodes.js

@@ -13,9 +13,14 @@
  * So the unit of verification becomes a LIST of nodes. `project.tests[]` in
  * `.morph/config/config.json` declares them; when it is absent, the four-step
  * fallback still runs and is synthesized into exactly one node. Declared beats
- * guessed (D3): deeper auto-detection would only trade one silent false
- * negative for another, and the cost of the error here is a green gate over
- * untested code.
+ * guessed (D3): a declaration — `tests[]` OR `testCommand` — still wins
+ * completely, and deeper auto-detection would only trade one silent false
+ * negative for another there. But with NOTHING declared, the guess stops
+ * being allowed to be a single answer: the old first-match fallback still
+ * picks the primary node exactly as before, and any vitest/jest suite found
+ * under a `package.json` (issue #87) is added BESIDE it, because that single
+ * guess is exactly what hid 3.082 vitest tests behind a green gate (F30) —
+ * the fallback found `.sln`, answered "dotnet test", and never looked twice.
  *
  * WHY VALIDATION IS FAIL-CLOSED HERE (D4)
  *
@@ -32,11 +37,12 @@
  */
 
 import { existsSync, readFileSync } from 'fs';
-import { join, resolve } from 'path';
+import { join, resolve, relative, sep } from 'path';
 
 import { resolveTestPlan, readMorphConfig, isInside } from './test-runner.js';
 import { EVAL_RUNNER, evalBlockProblem } from './eval-node.js';
 import { atomicWriteJson, CONFIG_FILE_NAME } from '../../core/state/state-manager.js';
+import { PACKAGE_LOCATIONS } from '../detectors/index.js';
 
 /**
  * The count extractors that exist (one per runner, see parseTestCount).
@@ -45,6 +51,41 @@ import { atomicWriteJson, CONFIG_FILE_NAME } from '../../core/state/state-manage
  */
 export const TEST_RUNNERS = ['dotnet', 'vitest', 'jest', 'node-test', 'playwright', 'none', EVAL_RUNNER];
 
+/**
+ * The task-group vocabulary a node can declare via `groups`, and that
+ * `tasks.json` entries declare via `group` (framework/schemas/tasks.schema.json
+ * `~:28`) — ONE enum, checked to agree by canary, never two that drift.
+ * Single home for B3's task-scope selection (`test-scope.js`) to import from.
+ */
+export const TASK_GROUPS = ['backend', 'frontend', 'tests', 'infra', 'docs'];
+
+/**
+ * Which group(s) a node serves when it does NOT declare `groups` itself,
+ * keyed by runner. `none` and `evals` are deliberately ABSENT — a command
+ * nobody could read (`none`) and a declared eval suite (`evals`) have no
+ * honest default group, so `effectiveGroups()` answers null for them rather
+ * than guessing one.
+ */
+export const RUNNER_DEFAULT_GROUPS = {
+  dotnet: ['backend'],
+  'node-test': ['backend'],
+  vitest: ['frontend'],
+  jest: ['frontend'],
+  playwright: ['frontend'],
+};
+
+/**
+ * Which task group(s) this node answers to: what it DECLARED, or else its
+ * runner's default. **null is "no mapping"**, never an invented guess — B3's
+ * task-scope selection reads null as "this node is unscoped, always runs".
+ *
+ * @param {import('./test-nodes.js').TestNode} node
+ * @returns {string[]|null}
+ */
+export function effectiveGroups(node) {
+  return node?.groups ?? RUNNER_DEFAULT_GROUPS[node?.runner] ?? null;
+}
+
 /**
  * A node id is what `--filter` matches and what keys `runs[]`. Lowercase and
  * dash-only so it survives a shell argument and a JSON key without quoting.
@@ -168,6 +209,11 @@ function makeNode(partial) {
     // eval node"** — distinct from an eval node with an empty block, which
     // `validateTestNodes` already refused.
     evals: partial.evals ?? null,
+    // Declared task-group(s) this node serves (§B3 task-scope selection).
+    // **null is "not declared"**, distinct from an empty array (which
+    // `firstProblem` refuses outright) — effectiveGroups() falls back to the
+    // runner's default only when this is null.
+    groups: partial.groups ?? null,
     status: partial.status ?? null,
     reason: partial.reason ?? null,
   };
@@ -250,6 +296,28 @@ function firstProblem(raw, projectPath) {
     return `evals applies only to runner "${EVAL_RUNNER}"`;
   }
 
+  if (raw.groups !== undefined) {
+    if (!Array.isArray(raw.groups)) {
+      return 'groups must be a non-empty array';
+    }
+    if (raw.groups.length === 0) {
+      return 'groups must be a non-empty array';
+    }
+    const invalid = raw.groups.filter((g) => !TASK_GROUPS.includes(g));
+    if (invalid.length > 0) {
+      return `groups must contain only ${TASK_GROUPS.join(' | ')} (invalid: ${invalid.join(', ')})`;
+    }
+    const seenGroups = new Set();
+    const duplicates = new Set();
+    for (const g of raw.groups) {
+      if (seenGroups.has(g)) duplicates.add(g);
+      seenGroups.add(g);
+    }
+    if (duplicates.size > 0) {
+      return `groups must not contain duplicates (repeated: ${[...duplicates].join(', ')})`;
+    }
+  }
+
   // The cwd checks come last because they are the expensive ones, and because
   // a node that is malformed in shape has a better error to report first.
   const cwd = typeof raw.cwd === 'string' ? raw.cwd.trim() : '.';
@@ -322,11 +390,97 @@ export function validateTestNodes(config, projectPath = null) {
       e2e: entry.e2e ?? false,
       linuxImage: entry.linuxImage ?? null,
       evals: entry.evals ?? null,
+      groups: entry.groups ?? null,
       projectCount: 1,
     });
   });
 }
 
+/** Turn a relative path into an id-safe slug matching TEST_NODE_ID_PATTERN. */
+function slugifyForId(text) {
+  return text
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '');
+}
+
+/**
+ * Guess which frontend test suites this project has, from `package.json`
+ * alone — a GUESS (issue #87), never a declaration. Only called by the
+ * fallback of `resolveTestNodes()`, and only when nothing was declared: a
+ * `package.json` that names `vitest`/`jest` in `dependencies` or
+ * `devDependencies` becomes one candidate suite, exactly the shape F30
+ * exploited when a repo had .NET AND a frontend and the first-match fallback
+ * only ever answered "dotnet test".
+ *
+ * Fail-open by construction (it IS a guess): an unreadable or malformed
+ * `package.json` is skipped silently, never a `fail` node — that fail-closed
+ * treatment is reserved for a DECLARATION (`tests[]`), which this is not.
+ *
+ * @param {string} projectPath - Project root
+ * @param {object|null} config - Parsed `.morph/config/config.json`, or null
+ * @returns {Array<{ id: string, cwd: string, runner: 'vitest'|'jest', command: string }>}
+ */
+export function discoverFrontendPackages(projectPath, config) {
+  const root = resolve(projectPath);
+  const candidates = [...PACKAGE_LOCATIONS];
+
+  const frontendPath = config?.project?.frontendPath;
+  if (typeof frontendPath === 'string' && frontendPath.trim()) {
+    const abs = resolve(root, frontendPath.trim());
+    // Outside the root is IGNORED, not refused — this is a guess reusing
+    // another guess (detectProject's own frontendPath), and neither one gets
+    // to address another tree.
+    if (isInside(abs, root)) candidates.push(frontendPath.trim());
+  }
+
+  const seenDirs = new Set();
+  const seenIds = new Set();
+  const found = [];
+
+  for (const loc of candidates) {
+    const dirAbs = resolve(root, loc);
+    if (seenDirs.has(dirAbs)) continue;
+    seenDirs.add(dirAbs);
+
+    const pkgPath = join(dirAbs, 'package.json');
+    if (!existsSync(pkgPath)) continue;
+
+    let pkg;
+    try {
+      pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+    } catch {
+      continue; // unreadable/invalid — skipped silently, fail-open (it's a guess)
+    }
+
+    const deps = { ...(pkg?.dependencies ?? {}), ...(pkg?.devDependencies ?? {}) };
+    let runner = null;
+    let command = null;
+    if (deps.vitest) {
+      runner = 'vitest';
+      command = 'npx vitest run';
+    } else if (deps.jest) {
+      runner = 'jest';
+      command = 'npx jest --ci';
+    }
+    if (!runner) continue;
+
+    const cwd = dirAbs === root ? '.' : relative(root, dirAbs).split(sep).join('/');
+    const baseId = cwd === '.' ? runner : `${runner}-${slugifyForId(cwd)}`;
+    let id = baseId;
+    let n = 2;
+    while (seenIds.has(id)) {
+      id = `${baseId}-${n}`;
+      n += 1;
+    }
+    seenIds.add(id);
+
+    found.push({ id, cwd, runner, command });
+  }
+
+  return found;
+}
+
 /**
  * Resolve every test suite of a project, in the order the verifier must run them.
  *
@@ -372,22 +526,28 @@ export function resolveTestNodes(projectPath = '.') {
 
   const plan = resolveTestPlan(projectPath);
 
-  if (!plan.command) {
-    return {
-      nodes: [makeNode({ id: FALLBACK_NODE_ID, status: 'skip', reason: NO_SUITE_REASON })],
-      source: plan.source,
-    };
+  const nodes = [
+    plan.command
+      ? makeNode({ id: FALLBACK_NODE_ID, command: plan.command, cwd: '.', projectCount: plan.projectCount })
+      : makeNode({ id: FALLBACK_NODE_ID, status: 'skip', reason: NO_SUITE_REASON }),
+  ];
+
+  // The union (#87 PR B / F30): add discovered frontend suites BESIDE the
+  // fallback node — but only when nothing was declared. `plan.source ===
+  // 'config'` means `project.testCommand` IS a declaration (it lives inside
+  // resolveTestPlan's own step 1), and a declaration wins completely: nothing
+  // is added beside it, same as the `project.tests[]` branch above.
+  if (plan.source !== 'config') {
+    const discovered = discoverFrontendPackages(projectPath, config)
+      // The root package is already run by `npm test` when that is the
+      // fallback's own answer — adding it again would run the same suite
+      // twice under two different commands.
+      .filter((pkg) => !(pkg.cwd === '.' && plan.source === 'npm'))
+      .map((pkg) => makeNode({ id: pkg.id, command: pkg.command, cwd: pkg.cwd, runner: pkg.runner }));
+    nodes.push(...discovered);
   }
 
-  return {
-    nodes: [makeNode({
-      id: FALLBACK_NODE_ID,
-      command: plan.command,
-      cwd: '.',
-      projectCount: plan.projectCount,
-    })],
-    source: plan.source,
-  };
+  return { nodes, source: plan.source };
 }
 
 /**
@@ -425,10 +585,15 @@ export function morphConfigPath(projectPath = '.') {
  *   - a measured id that is not declared (appending a node would be inventing
  *     the declaration the command came to update);
  *   - a declared node with no measurement (a baseline recorded for part of a
- *     fleet says nothing true about the rest of it).
+ *     fleet says nothing true about the rest of it);
+ *   - a measurement carrying a task-scope `selection` (#87): narrowed, scoped
+ *     out or run whole INSIDE a task-scoped verify, it measured a recorte, and
+ *     `expectedCount` is the whole suite's number. `verify` already refuses
+ *     `--record-baseline` with a task id before the build; this is the second
+ *     barrier, at the writer, so no caller can route around it.
  *
  * @param {string} projectPath - Project root
- * @param {Array<{id: string, count: number|null}>} measurements - One per node that ran
+ * @param {Array<{id: string, count: number|null, selection?: object|null}>} measurements - One per node that ran
  * @returns {{ recorded: boolean, reason: string|null, updates: Array<{id: string, from: number|null, to: number}>, path: string }}
  */
 export function recordTestBaselines(projectPath, measurements) {
@@ -449,6 +614,11 @@ export function recordTestBaselines(projectPath, measurements) {
     return refuse('config.json não declara project.tests[] — não há entrada onde gravar a baseline');
   }
 
+  const recortes = measurements.filter((m) => m.selection != null).map((m) => m.id);
+  if (recortes.length > 0) {
+    return refuse(`medição de recorte de task em: ${recortes.join(', ')} — baseline só de execução inteira, sem {task}`);
+  }
+
   const unreadable = measurements.filter((m) => !Number.isInteger(m.count)).map((m) => m.id);
   if (unreadable.length > 0) {
     return refuse(`contagem desconhecida em: ${unreadable.join(', ')} — desconhecido nunca vira 0`);

package/src/lib/tasks/test-runner.js

@@ -170,8 +170,13 @@ function collectDotnetTestProjects(projectPath) {
  * says "not inside" for the same directory and a linked worktree leaks into
  * the test command. Only `realpathSync.native` asks the OS. Fail-open to the
  * plain resolve for a path that does not exist (yet).
+ *
+ * Exported because test-scope.js spells every task output with it (#87 F4): a
+ * mis-cased output resolves on a case-insensitive disk and was forwarded to the
+ * runner verbatim — and the `--linux` container is case-sensitive. The OS also
+ * returns the real CASE of each component, so this one call is both answers.
  */
-function canonicalPath(p) {
+export function canonicalPath(p) {
   try {
     return realpathSync.native(p);
   } catch {
@@ -488,6 +493,32 @@ function parseJestCount(output) {
   };
 }
 
+/**
+ * CSI (`ESC [ ... <final byte @-~>`, e.g. SGR color codes) and OSC (`ESC ] ...
+ * BEL|ESC\`, e.g. hyperlinks/terminal titles) escape sequences — the two
+ * shapes a captured terminal transcript actually carries (issue #110: a
+ * vitest summary piped through `execSync` kept its SGR bytes, and every count
+ * regex in this file is anchored on `^` / exact literals, so a color code
+ * sitting between "Tests" and the number silently defeated the whole line).
+ */
+const ANSI_PATTERN = /\x1b(?:\[[0-?]*[ -/]*[@-~]|\][^\x07\x1b]*(?:\x07|\x1b\\))/g;
+
+/**
+ * Strip ANSI escape sequences (CSI/SGR and OSC) from captured process output.
+ *
+ * Non-string input is returned UNCHANGED, never coerced to `''` — the callers
+ * that matter (`parseTestCount`, `isZeroTestRun`) already treat a non-string
+ * output as "nothing to read" on their own; making this function opinionated
+ * about that too would be a second place for the same rule to drift.
+ *
+ * @param {string} text
+ * @returns {string} `text` with escape sequences removed; unchanged if not a string
+ */
+export function stripAnsi(text) {
+  if (typeof text !== 'string') return text;
+  return text.replace(ANSI_PATTERN, '');
+}
+
 /** Playwright: `8 passed (12.4s)` and/or `2 failed`, on their own lines. */
 function parsePlaywrightCount(output) {
   const passed = /^\s*(\d+)\s+passed\b/im.exec(output);
@@ -529,7 +560,96 @@ export function parseTestCount(output, runner) {
   if (typeof output !== 'string' || !output) return null;
   const extractor = COUNT_EXTRACTORS[runner];
   if (!extractor) return null;
-  return extractor(output);
+  // SINGLE call site: every extractor reads ANSI-stripped text, never raw
+  // bytes — a captured terminal transcript may carry SGR color codes right
+  // inside a summary line (#110) and every regex above is anchored on exact
+  // literals that a stray `\x1b[32m` would defeat.
+  return extractor(stripAnsi(output));
+}
+
+// ============================================================================
+// "Zero tests ran" signatures, per runner (#87 PR B / #110 parte 1)
+// ============================================================================
+
+/**
+ * Per-runner signal for "the run matched/executed NOTHING" — a category
+ * distinct from both a genuine `{ total: 0, ... }` summary (a suite that
+ * legitimately declares zero cases) and from a summary `parseTestCount`
+ * simply could not read (`null`, UNKNOWN). Its reader is `judgeNarrowedRun`
+ * (verify-runner.js, #87): a narrowed `verify {feature} {task}` run that FAILED
+ * with this signature, and with no count proving tests ran, is named
+ * `narrowed-zero-tests (…)` instead of an anonymous red. (A PASSED narrowed run
+ * needs its own proof there — a count > 0, or MTP's exit 0 — never this table.)
+ *
+ * Every entry was MEASURED against a real runner, not invented, and the two
+ * dotnet entries disagree with each other on purpose:
+ *
+ *   - **MTP** (`--filter-class`, this repo's own `ai-kit`, xunit.v3 4.x):
+ *     a non-matching filter exits **8** (`ZeroTests`) — reliable BY EXIT
+ *     CODE. See `test/fixtures/test-output/mtp-zero-tests.txt`.
+ *   - **VSTest** (`--filter "FullyQualifiedName~..."`, classic xunit 2.x):
+ *     a non-matching filter exits **0** — exit code CANNOT tell a zero-match
+ *     run from a green one here. Only the OUTPUT STRING can:
+ *     `test/fixtures/test-output/vstest-zero-tests.txt` (pt-BR, measured).
+ *     The en-US wording is the brief's documented string, not measured on
+ *     this pt-BR machine — kept alongside the pt-BR one because neither is
+ *     derivable from the other and the machine that runs `verify` may be in
+ *     either locale.
+ *
+ * Exit code 8 is therefore listed ONLY as a dotnet exit code, never paired
+ * with a string requirement — and exit code 9
+ * (`MinimumExpectedTestsPolicyViolation`, this repo's own
+ * `--minimum-expected-tests 275`) is deliberately ABSENT: it fires on a run
+ * that executed fewer cases than the configured floor, including a run that
+ * was entirely green (measured:
+ * `test/fixtures/test-output/mtp-filter-class-policy-violation.txt`, 10/10
+ * passed, exit 9). Folding 9 into this table would misreport a real pass as
+ * "zero tests ran".
+ */
+export const ZERO_RUN_SIGNATURES = {
+  dotnet: {
+    exitCodes: [8],
+    strings: [
+      // en-US, VSTest — documented by the brief, not measured here (pt-BR machine).
+      'No test matches the given testcase filter',
+      // pt-BR, VSTest — MEASURED, test/fixtures/test-output/vstest-zero-tests.txt.
+      'Nenhum teste corresponde ao filtro de testcase',
+    ],
+  },
+  vitest: {
+    exitCodes: [],
+    strings: ['No test files found'],
+  },
+  jest: {
+    exitCodes: [],
+    strings: ['No tests found'],
+  },
+};
+
+/**
+ * True when `output`/`exitCode` carries this runner's "zero tests ran"
+ * signature. Every other runner (`node-test`, `playwright`, `evals`, `none`,
+ * or anything not in `ZERO_RUN_SIGNATURES`) answers `false` — an absent entry
+ * is an honest "this primitive does not know that runner's zero-tests shape
+ * yet", the same doctrine `COUNT_EXTRACTORS` uses for an unknown runner.
+ *
+ * Called by `judgeNarrowedRun` (verify-runner.js) on a FAILED narrowed run, to
+ * name it `narrowed-zero-tests (…)`.
+ *
+ * @param {string|null|undefined} output - Combined stdout+stderr of the run
+ * @param {string} runner - One of TEST_RUNNERS
+ * @param {number|null|undefined} exitCode - Must be a NUMBER to match: the
+ *   exit-code check is a strict `includes`, so the string `'8'` never matches 8.
+ * @returns {boolean}
+ */
+export function isZeroTestRun(output, runner, exitCode) {
+  const signature = ZERO_RUN_SIGNATURES[runner];
+  if (!signature) return false;
+
+  if (signature.exitCodes.includes(exitCode)) return true;
+
+  const text = stripAnsi(typeof output === 'string' ? output : '');
+  return signature.strings.some((needle) => text.includes(needle));
 }
 
 /**