@polymorphism-tech/morph-spec 8.32.0 → 8.34.2

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

@@ -8,32 +8,46 @@
  *      .sln) → "dotnet test <proj> --nologo -v q" for each match
  *   4. package.json present AND has scripts.test → "npm test"
  *   5. null (no test suite detected)
+ *
+ * Step 3 deliberately does NOT see linked git worktrees. A worktree is another
+ * feature's checkout of the SAME repo: its `tests/X.Tests.csproj` is a copy of
+ * the one already matched at the root, so including it both doubles the wall
+ * clock and reports on code that is not the tree under verification. In the
+ * field this produced a red `tests` node — "fail" at exactly the timeout, with
+ * the first run's own summary reading "Com falha: 0" — while nothing had
+ * failed. Two independent filters carry that rule (see collectDotnetTestProjects):
+ * the CONVENTION path (worktrees/, .worktrees/) and, for worktrees created
+ * anywhere else, the registry git itself keeps.
  */
 
-import { execSync } from 'child_process';
-import { existsSync, readFileSync, readdirSync } from 'fs';
-import { join } from 'path';
+import { execSync, execFileSync } from 'child_process';
+import { existsSync, readFileSync, readdirSync, realpathSync } from 'fs';
+import { join, resolve, relative, isAbsolute } from 'path';
 import { globSync } from 'glob';
 
+import { WORKTREES_DIR, LEGACY_WORKTREES_DIR } from '../../commands/project/worktree.js';
+
 /**
- * Resolve the test command for a project.
+ * Timeout budget granted to ONE test project. The chained `a && b` command is
+ * given this much per link: a fixed cap made every multi-project chain born
+ * condemned — it timed out for being long, not for being broken.
+ */
+export const DEFAULT_TEST_TIMEOUT_PER_PROJECT = 120_000;
+
+/**
+ * Resolve the test command for a project, together with how many test projects
+ * it chains — the timeout budget is derived from that count.
  *
  * @param {string} [projectPath] - Project root directory (defaults to '.')
- * @returns {string | null} The test command to run, or null if none found
+ * @returns {{ command: string | null, projectCount: number, source: string }}
+ *   `source` is one of 'config' | 'dotnet-root' | 'dotnet-scan' | 'npm' | 'none'.
  */
-export function resolveTestCommand(projectPath = '.') {
+export function resolveTestPlan(projectPath = '.') {
   // 1. Read from .morph/config/config.json
-  const configPath = join(projectPath, '.morph', 'config', 'config.json');
-  if (existsSync(configPath)) {
-    try {
-      const config = JSON.parse(readFileSync(configPath, 'utf8'));
-      const cmd = config?.project?.testCommand;
-      if (cmd && typeof cmd === 'string') {
-        return cmd;
-      }
-    } catch {
-      // Malformed config — fall through to detection
-    }
+  const config = readConfig(projectPath);
+  const configured = config?.project?.testCommand;
+  if (configured && typeof configured === 'string') {
+    return { command: configured, projectCount: 1, source: 'config' };
   }
 
   // 2. Detect .NET project (sln/csproj at root) → dotnet test
@@ -43,7 +57,7 @@ export function resolveTestCommand(projectPath = '.') {
       (entry) => entry.endsWith('.sln') || entry.endsWith('.csproj')
     );
     if (hasDotnetProject) {
-      return 'dotnet test';
+      return { command: 'dotnet test', projectCount: 1, source: 'dotnet-root' };
     }
   } catch {
     // Unreadable project directory — fall through to next detection
@@ -53,19 +67,13 @@ export function resolveTestCommand(projectPath = '.') {
   // (e.g. tests/MyApp.Tests/MyApp.Tests.csproj), common in monorepos that
   // have no root .sln. Run each matched project explicitly rather than a
   // bare `dotnet test` (which finds nothing to build at the root).
-  try {
-    const testProjects = globSync('**/*Tests.csproj', {
-      cwd: projectPath,
-      ignore: ['**/bin/**', '**/obj/**', '**/node_modules/**'],
-    });
-    if (testProjects.length > 0) {
-      return testProjects
-        .sort()
-        .map((p) => `dotnet test "${p}" --nologo -v q`)
-        .join(' && ');
-    }
-  } catch {
-    // Glob failure — fall through to next detection
+  const testProjects = collectDotnetTestProjects(projectPath);
+  if (testProjects.length > 0) {
+    return {
+      command: testProjects.map((p) => `dotnet test "${p}" --nologo -v q`).join(' && '),
+      projectCount: testProjects.length,
+      source: 'dotnet-scan',
+    };
   }
 
   // 4. package.json present AND has scripts.test → npm test
@@ -74,7 +82,7 @@ export function resolveTestCommand(projectPath = '.') {
     try {
       const pkg = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
       if (pkg?.scripts?.test) {
-        return 'npm test';
+        return { command: 'npm test', projectCount: 1, source: 'npm' };
       }
     } catch {
       // Malformed package.json — fall through to null
@@ -82,43 +90,214 @@ export function resolveTestCommand(projectPath = '.') {
   }
 
   // 5. Nothing found
-  return null;
+  return { command: null, projectCount: 0, source: 'none' };
+}
+
+/**
+ * Resolve the test command for a project.
+ *
+ * @param {string} [projectPath] - Project root directory (defaults to '.')
+ * @returns {string | null} The test command to run, or null if none found
+ */
+export function resolveTestCommand(projectPath = '.') {
+  return resolveTestPlan(projectPath).command;
+}
+
+/**
+ * Find the *Tests.csproj files that belong to THIS tree — never to a linked
+ * worktree of the same repo.
+ *
+ * Two filters, because one is not enough:
+ *   - the glob ignore covers worktrees created by convention (`worktrees/{f}`
+ *     and the legacy `.worktrees/{f}`), which is where `morph-spec worktree
+ *     setup` puts them;
+ *   - `git worktree list --porcelain` covers every OTHER location, including a
+ *     worktree someone created by hand outside the convention. Fail-open: no
+ *     git, no answer, no filter — the convention filter still stands.
+ *
+ * @param {string} projectPath
+ * @returns {string[]} Project-relative csproj paths, sorted
+ */
+function collectDotnetTestProjects(projectPath) {
+  let matches;
+  try {
+    matches = globSync('**/*Tests.csproj', {
+      cwd: projectPath,
+      ignore: [
+        '**/bin/**',
+        '**/obj/**',
+        '**/node_modules/**',
+        `${WORKTREES_DIR}/**`,
+        `${LEGACY_WORKTREES_DIR}/**`,
+      ],
+    });
+  } catch {
+    // Glob failure — caller falls through to the next detection step
+    return [];
+  }
+
+  const linked = listLinkedWorktreePaths(projectPath);
+  if (linked.length > 0) {
+    matches = matches.filter(
+      (p) => !linked.some((wt) => isInside(canonicalPath(resolve(projectPath, p)), wt))
+    );
+  }
+
+  return matches.sort();
+}
+
+/**
+ * One spelling per directory. Git prints the LONG form of a path; the tree
+ * under verification may be addressed by its 8.3 SHORT form (`MORPHT~1` —
+ * every GitHub Windows runner's temp dir, and any user path with a short
+ * name). `path.resolve` does not expand aliases, so `isInside(long, short)`
+ * 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).
+ */
+function canonicalPath(p) {
+  try {
+    return realpathSync.native(p);
+  } catch {
+    return resolve(p);
+  }
+}
+
+/**
+ * Absolute paths of the git worktrees linked to this repo, excluding the tree
+ * being verified. Fail-open — a repo without git (or a git that errors) yields
+ * an empty list, and discovery proceeds on the convention filter alone.
+ *
+ * @param {string} projectPath
+ * @returns {string[]}
+ */
+function listLinkedWorktreePaths(projectPath) {
+  let out;
+  try {
+    out = execFileSync('git', ['worktree', 'list', '--porcelain'], {
+      cwd: projectPath,
+      stdio: 'pipe',
+      encoding: 'utf8',
+      windowsHide: true,
+    });
+  } catch {
+    return [];
+  }
+
+  const self = canonicalPath(projectPath);
+  return out
+    .split('\n')
+    .filter((line) => line.startsWith('worktree '))
+    .map((line) => canonicalPath(line.slice('worktree '.length).trim()))
+    .filter((p) => p && p !== self);
+}
+
+/** True when `child` is `parent` or lives under it. */
+function isInside(child, parent) {
+  const rel = relative(parent, child);
+  return rel === '' || (!rel.startsWith('..') && !isAbsolute(rel));
+}
+
+function readConfig(projectPath) {
+  const configPath = join(projectPath, '.morph', 'config', 'config.json');
+  if (!existsSync(configPath)) return null;
+  try {
+    return JSON.parse(readFileSync(configPath, 'utf8'));
+  } catch {
+    // Malformed config — treated as absent by every caller
+    return null;
+  }
+}
+
+/**
+ * Resolve the timeout budget for the test node.
+ *
+ * Precedence: explicit override (`morph-spec verify --timeout`) >
+ * `config.project.testTimeoutMs` > default scaled by the number of chained
+ * test projects.
+ *
+ * @param {string} projectPath
+ * @param {number} projectCount - How many test projects the command chains
+ * @param {number} [override] - Explicit override in ms, if the caller has one
+ * @returns {number} Timeout in ms
+ */
+export function resolveTestTimeout(projectPath, projectCount, override) {
+  if (Number.isFinite(override) && override > 0) return override;
+
+  const configured = readConfig(projectPath)?.project?.testTimeoutMs;
+  if (Number.isFinite(configured) && configured > 0) return configured;
+
+  return DEFAULT_TEST_TIMEOUT_PER_PROJECT * Math.max(1, projectCount);
+}
+
+/**
+ * Count the test runs that reported a summary before the command was cut off.
+ * Heuristic by construction (the summary line is localized), and used only to
+ * name WHICH link of the chain was still running when the clock ran out.
+ */
+function countCompletedRuns(output) {
+  const matches = (output || '').match(
+    /(?:^|\n)\s*(?:Aprovado|Passed|Failed|Reprovado|Com falha|Erro)!/gi
+  );
+  return matches ? matches.length : 0;
 }
 
 /**
  * Run the project's test suite.
  *
  * @param {string} [projectPath] - Project root directory (defaults to '.')
- * @param {object} [opts] - Optional overrides for testing
+ * @param {object} [opts]
+ * @param {number} [opts.timeout] - Explicit timeout in ms (highest precedence)
  * @param {Function} [opts._execSync] - Override execSync for unit testing
- * @returns {{ passed?: boolean, output?: string, exitCode?: number, skipped?: boolean, reason?: string }}
+ * @returns {{ passed?: boolean, output?: string, exitCode?: number, skipped?: boolean, reason?: string, timedOut?: boolean, timeoutMs?: number, message?: string }}
  */
 export function runTestSuite(projectPath = '.', opts = {}) {
-  const cmd = resolveTestCommand(projectPath);
+  const { command: cmd, projectCount } = resolveTestPlan(projectPath);
 
   if (!cmd) {
     return { skipped: true, reason: 'No testCommand configured and no known project file detected' };
   }
 
   const exec = opts._execSync ?? execSync;
+  const timeout = resolveTestTimeout(projectPath, projectCount, opts.timeout);
 
   try {
     const output = exec(cmd, {
       cwd: projectPath,
-      timeout: 120_000,
+      timeout,
       encoding: 'utf8',
       stdio: 'pipe'
     });
-    return { passed: true, output: output ?? '', exitCode: 0 };
+    return { passed: true, output: output ?? '', exitCode: 0, timeoutMs: timeout };
   } catch (err) {
     const output = (err.stdout || '') + (err.stderr || '');
+
+    // A timeout is NOT a red suite: the command was interrupted, so no verdict
+    // exists. Saying so by name is the whole point — the field diagnosis of
+    // this cost a reading of durationMs against a truncated log.
+    if (err.code === 'ETIMEDOUT' || err.killed === true) {
+      const total = Math.max(1, projectCount);
+      const at = Math.min(countCompletedRuns(output) + 1, total);
+      const where = total > 1 ? ` na execução ${at} de ${total}` : '';
+      return {
+        passed: false,
+        timedOut: true,
+        timeoutMs: timeout,
+        buildFailed: false,
+        message: `timeout após ${timeout} ms${where} — nenhum teste falhou, o comando foi interrompido`,
+        output,
+        exitCode: err.status ?? null,
+      };
+    }
+
     const BUILD_FAIL = /Build FAILED|error MSB\d+|error CS\d+|Could not find.*\.csproj/i;
     const buildFailed = BUILD_FAIL.test(output);
     return {
       passed: false,
       buildFailed,
       output,
-      exitCode: err.status ?? 1
+      exitCode: err.status ?? 1,
+      timeoutMs: timeout,
     };
   }
 }

package/src/lib/validators/checkpoint-persistence.js

@@ -1,39 +1,39 @@
-/**
- * Checkpoint Validation Persistence
- *
- * Persists checkpoint validation results to disk for traceability.
- * Each checkpoint writes a JSON file to:
- *   .morph/features/{feature}/3-implement/validations/checkpoint-{N}.json
- */
-
-import { mkdirSync, writeFileSync } from 'fs';
-import { join } from 'path';
-
-/**
- * Persist a checkpoint validation result to disk.
- *
- * @param {string} projectPath - Project root
- * @param {string} featureName - Feature name
- * @param {{ checkpointNum: number, timestamp: string, passed: boolean, validators: Object, summary: string, feature?: string, phase?: string }} result - Validation result
- * @returns {string} Path to the saved JSON file
- */
-export function persistCheckpointValidation(projectPath, featureName, result) {
-  const dir = join(projectPath, `.morph/features/${featureName}/3-implement/validations`);
-  mkdirSync(dir, { recursive: true });
-
-  const filename = `checkpoint-${result.checkpointNum}.json`;
-  const filePath = join(dir, filename);
-
-  const output = {
-    checkpointNum: result.checkpointNum,
-    timestamp: result.timestamp || new Date().toISOString(),
-    passed: result.passed,
-    validators: result.validators || {},
-    summary: result.summary || '',
-    feature: result.feature || featureName,
-    phase: result.phase || 'implement',
-  };
-
-  writeFileSync(filePath, JSON.stringify(output, null, 2), 'utf8');
-  return filePath;
-}
+/**
+ * Checkpoint Validation Persistence
+ *
+ * Persists checkpoint validation results to disk for traceability.
+ * Each checkpoint writes a JSON file to:
+ *   .morph/features/{feature}/3-implement/validations/checkpoint-{N}.json
+ */
+
+import { mkdirSync, writeFileSync } from 'fs';
+import { join } from 'path';
+
+/**
+ * Persist a checkpoint validation result to disk.
+ *
+ * @param {string} projectPath - Project root
+ * @param {string} featureName - Feature name
+ * @param {{ checkpointNum: number, timestamp: string, passed: boolean, validators: Object, summary: string, feature?: string, phase?: string }} result - Validation result
+ * @returns {string} Path to the saved JSON file
+ */
+export function persistCheckpointValidation(projectPath, featureName, result) {
+  const dir = join(projectPath, `.morph/features/${featureName}/3-implement/validations`);
+  mkdirSync(dir, { recursive: true });
+
+  const filename = `checkpoint-${result.checkpointNum}.json`;
+  const filePath = join(dir, filename);
+
+  const output = {
+    checkpointNum: result.checkpointNum,
+    timestamp: result.timestamp || new Date().toISOString(),
+    passed: result.passed,
+    validators: result.validators || {},
+    summary: result.summary || '',
+    feature: result.feature || featureName,
+    phase: result.phase || 'implement',
+  };
+
+  writeFileSync(filePath, JSON.stringify(output, null, 2), 'utf8');
+  return filePath;
+}