@polymorphism-tech/morph-spec 8.33.0 → 8.35.0

package/src/commands/project/doctor.js

@@ -19,6 +19,7 @@ import { checkMissingAgents, checkAgentsDrift } from '../../utils/agents-install
 import { getProjectTags } from '../../lib/stack-filter.js';
 import { auditGraph } from '../../lib/graph/graph-health.js';
 import { auditFeatureLifecycle } from '../../core/state/lifecycle-audit.js';
+import { validateTestNodes, morphConfigPath } from '../../lib/tasks/test-nodes.js';
 
 const isWindows = platform() === 'win32';
 /**
@@ -367,6 +368,43 @@ async function doctorFullCommand(frameworkRoot) {
     check('state.json', false, true, 'not found (run: morph-spec init)');
   }
 
+  // ── 8. project.tests[] — o contrato do config, camada 3 ─────────────────
+  //
+  // As outras duas camadas são o `config.schema.json` (declarativa) e
+  // `validateTestNodes()` chamada pelo `verify` (fail-closed, em uso). Esta
+  // aqui existe para o defeito chegar ANTES do gate: um `id` com typo em
+  // `tests[]` só se manifesta quando alguém roda `morph-spec verify` e lê um
+  // nó vermelho — o doctor o mostra na checagem de saúde, que é onde se olha
+  // primeiro. Reusa `validateTestNodes` (a MESMA autoridade que o verify
+  // consulta): uma segunda leitura do mesmo campo aqui seria uma segunda
+  // opinião sobre o que é um nó válido, e as duas divergiriam.
+  //
+  // PULA de verdade — sem check e sem cabeçalho — quando não há `config.json`
+  // ou quando `project.tests` não foi declarado. Um projeto sem declaração usa
+  // o fallback de quatro passos e não tem contrato a violar; este repositório
+  // é exatamente esse caso, e um check que não pode passar aqui é ruído, não
+  // achado (`test/commands/doctor.test.js`: `doctor --full` sem nenhum `✗`).
+  // WARN e nunca ERROR: a barreira fail-closed é o `verify`; o doctor informa.
+  const testsConfigPath = morphConfigPath(frameworkRoot);
+  if (await pathExists(testsConfigPath)) {
+    let testsConfig = null;
+    try {
+      testsConfig = JSON.parse((await fs.readFile(testsConfigPath, 'utf8')).replace(/^\uFEFF/, ''));
+    } catch {
+      testsConfig = null; // config ilegível já é reportado pelo doctor base
+    }
+    if (testsConfig?.project?.tests !== undefined) {
+      console.log(chalk.cyan('\n  .morph/config/config.json — project.tests[]'));
+      const declared = validateTestNodes(testsConfig, frameworkRoot);
+      const broken = declared.filter((n) => n.status === 'fail');
+      check(`config tests[] (${declared.length - broken.length}/${declared.length})`,
+        broken.length === 0, true,
+        broken.length > 0
+          ? broken.map((n) => n.reason ?? `invalid-test-node: ${n.id}`).join('; ')
+          : '');
+    }
+  }
+
   // ── Display ──────────────────────────────────────────────────────────────
   console.log('\n' + '─'.repeat(60));
   console.log(chalk.bold('\nResults:\n'));
@@ -586,11 +624,14 @@ export async function doctorWorktreesCommand(targetPath, options = {}) {
   }
 
   const issues = auditWorktrees(targetPath);
-  // `severity: 'info'` entries (a worktree carrying unintegrated work) are
-  // REPORTED but are not failures — a `doctor --worktrees || ...` in CI must not
-  // go red because somebody has an open PR. The human path below splits the same
-  // way; both surfaces must agree on what counts as broken.
-  const isProblem = (i) => i.severity !== 'info';
+  // `severity: 'info'` entries (a worktree carrying unintegrated work) and
+  // `severity: 'warn'` entries (a worktree created outside morph's container,
+  // and the docker findings from `docker-audit.js`: an orphan stack, a port
+  // held by another compose project) are REPORTED but are not failures — a
+  // `doctor --worktrees || ...` in CI must not go red because somebody has an
+  // open PR, a hand-made tree, or a container still up. The human path below
+  // splits the same way; both surfaces must agree on what counts as broken.
+  const isProblem = (i) => !['info', 'warn'].includes(i.severity);
 
   if (options.json) {
     console.log(JSON.stringify({ issues }, null, 2));
@@ -617,7 +658,7 @@ export async function doctorWorktreesCommand(targetPath, options = {}) {
     console.log(`     → ${i.fix}`);
   }
   for (const i of informational) {
-    console.log(`  ℹ ${i.type}`);
+    console.log(i.severity === 'warn' ? chalk.yellow(`  ⚠ ${i.type}`) : `  ℹ ${i.type}`);
     console.log(`     ${i.detail}`);
     console.log(`     → ${i.fix}`);
   }
@@ -687,6 +728,86 @@ function auditPullRequests(root) {
   return issues;
 }
 
+/**
+ * `morph-spec doctor --ai` — as cinco checagens de projeto .NET com agentes.
+ *
+ * **Superfície própria, no molde do `--mcp`, e é decisão, não acidente.** O
+ * `--ai` NÃO entra no `--full` nem no `doctor` default:
+ *
+ * - o renderer do `--full` é `ok → ✓`, `warn → ⚠`, **`else → ✗`** — não tem o
+ *   ramo `skip → ○`. Uma checagem de IA lá seria VERMELHA neste repositório
+ *   mesmo dizendo "não verificado", e `test/commands/doctor.test.js` exige
+ *   `doesNotMatch(out, /✗/)` para `doctor --full` aqui, com a justificativa
+ *   escrita no próprio teste: *"every check must be satisfiable here — a
+ *   permanently red one teaches nothing"*;
+ * - o `doctor` default é o comando mais rodado do dia, e cinco linhas `○`
+ *   permanentes em todo projeto sem .NET é ruído com custo e sem informação.
+ *
+ * Exit code: 1 se houver ao menos um `error`; 0 caso contrário. `warn` e `skip`
+ * nunca mudam o código de saída.
+ *
+ * @param {string} targetPath
+ * @param {object} [options] - repassado a `collectAiChecks` (`config`, `deps`)
+ * @returns {Promise<Array>} as checagens, para o canário assere-las sem parsear texto
+ */
+export async function doctorAiCommand(targetPath, options = {}) {
+  const { collectAiChecks, aiExitCode, allSkipped } = await import('../../lib/ai/ai-checks.js');
+  const { readMorphConfig } = await import('../../lib/tasks/test-runner.js');
+
+  logger.header('AI Health Check (.NET + agentes)');
+  logger.blank();
+
+  const config = options.config !== undefined ? options.config : readMorphConfig(targetPath);
+  const checks = collectAiChecks(targetPath, { config, deps: options.deps ?? {} });
+
+  if (allSkipped(checks)) {
+    // Condição 4 do silêncio: nenhuma checagem teve insumo. Uma linha, não
+    // cinco `○` vazios — listar cinco vezes "não verificado" é o ruído que
+    // esta superfície existe para não produzir.
+    const reasons = [...new Set(checks.map((c) => c.reason))];
+    for (const reason of reasons) {
+      console.log(chalk.gray(`  ○ Nenhuma das ${checks.length} checagens teve insumo — ${reason}.`));
+    }
+    logger.blank();
+    process.exitCode = 0;
+    return checks;
+  }
+
+  for (const c of checks) {
+    if (c.status === 'ok') {
+      console.log(chalk.green(`  ✓ ${c.name}`));
+    } else if (c.status === 'skip') {
+      console.log(chalk.gray(`  ○ ${c.name}`) + chalk.gray(` — não verificado: ${c.reason}`));
+    } else if (c.status === 'warn') {
+      console.log(chalk.yellow(`  ⚠ ${c.name}`));
+    } else {
+      console.log(chalk.red(`  ✗ ${c.name}`));
+    }
+    for (const f of c.findings) {
+      const mark = f.severity === 'error' ? chalk.red('    ✗') : chalk.yellow('    →');
+      console.log(`${mark} ${chalk.gray(f.message)}`);
+    }
+    for (const file of c.unverified ?? []) {
+      console.log(chalk.gray(`    ○ não verificado: ${relative(targetPath, file) || file} (ilegível)`));
+    }
+  }
+
+  logger.blank();
+  const errors = checks.filter((c) => c.status === 'error').length;
+  const warns = checks.filter((c) => c.status === 'warn').length;
+  const skips = checks.filter((c) => c.status === 'skip').length;
+  const oks = checks.filter((c) => c.status === 'ok').length;
+
+  const summary = `${oks} ok · ${warns} aviso(s) · ${errors} erro(s) · ${skips} não verificada(s)`;
+  if (errors > 0) console.log(chalk.red(`  ❌ ${summary}`));
+  else if (warns > 0) console.log(chalk.yellow(`  ⚠️  ${summary}`));
+  else console.log(chalk.green(`  ✅ ${summary}`));
+  logger.blank();
+
+  process.exitCode = aiExitCode(checks);
+  return checks;
+}
+
 export async function doctorCommand(options = {}) {
   // `--json` and `--prune` only mean something under `--worktrees`. Falling
   // through to the human health check would hand a script a banner and a table
@@ -701,6 +822,22 @@ export async function doctorCommand(options = {}) {
     return false;
   }
 
+  // `--ai` é superfície própria (D1). Combiná-la com outra superfície pediria
+  // dois relatórios com dois códigos de saída no mesmo processo — o segundo
+  // apagaria o primeiro em silêncio. Mesmo molde da guarda acima: recusa em
+  // vez de fingir.
+  if (options.ai) {
+    const conflicts = ['full', 'mcp', 'worktrees'].filter((f) => options[f]);
+    if (conflicts.length) {
+      const flags = conflicts.map((f) => `--${f}`).join(' e ');
+      logger.error(`--ai não se combina com ${flags} — cada superfície tem o seu relatório e o seu código de saída.`);
+      logger.dim('  Rode: morph-spec doctor --ai');
+      process.exitCode = 1;
+      return false;
+    }
+    return doctorAiCommand(process.cwd(), options);
+  }
+
   // Reset mode: remove morph-managed settings entries
   if (options.reset) {
     const targetPath = process.cwd();

package/src/commands/project/env.js

@@ -0,0 +1,95 @@
+/**
+ * `morph-spec env [feature] [--json|--posix|--powershell]` — print the
+ * dedicated environment of a worktree (port block + compose project) in a
+ * shell-loadable form.
+ *
+ * Inside Claude Code the `worktree-env-inject` hook applies this block to
+ * every dev-server / compose launcher automatically. This command is the same
+ * contract for everything OUTSIDE the harness: a human terminal
+ * (`eval "$(morph-spec env)"`), a CI step, a sub-agent running without hooks.
+ * It derives from `buildComposeEnv` — the function the `verify` e2e node and
+ * `e2e up` already use — so a shell and the stack can never disagree.
+ *
+ * Feature resolution: explicit argument, else the `morph/{f}` (or
+ * `morph-task/{n}`) branch of the cwd. Read-only: allocation is idempotent and
+ * never moves an existing block.
+ */
+
+import { execFileSync } from 'child_process';
+import { readFileSync } from 'fs';
+import { join, resolve } from 'path';
+import chalk from 'chalk';
+import { buildComposeEnv } from '../../lib/e2e/compose-env.js';
+import { resolvePrimaryRoot } from './worktree.js';
+import { currentBranch } from '../../lib/worktree/feature-truth.js';
+
+/** `morph/<f>` → `<f>`; `morph-task/<n>` → `task/<n>`; anything else → null. */
+export function envKeyFromBranch(branch) {
+  if (!branch) return null;
+  const feature = branch.match(/^morph\/(.+)$/)?.[1];
+  if (feature) return feature;
+  const task = branch.match(/^morph-task\/(.+)$/)?.[1];
+  return task ? `task/${task}` : null;
+}
+
+function readConfig(root) {
+  try {
+    return JSON.parse(readFileSync(join(root, '.morph', 'config', 'config.json'), 'utf8').replace(/^/, ''));
+  } catch {
+    return null;
+  }
+}
+
+function gitCommonDir(cwd) {
+  try {
+    const out = execFileSync('git', ['rev-parse', '--git-common-dir'], { cwd, stdio: 'pipe' }).toString().trim();
+    return out ? resolve(cwd, out) : null;
+  } catch {
+    return null;
+  }
+}
+
+/** POSIX single-quote. */
+const shq = (v) => `'${String(v).replace(/'/g, "'\\''")}'`;
+
+/**
+ * Pure: the env map for a key, or `{ error }`.
+ * @param {string|null} featureArg
+ * @param {string} cwd
+ */
+export function resolveWorktreeEnv(featureArg, cwd = process.cwd()) {
+  const key = featureArg || envKeyFromBranch(currentBranch(cwd));
+  if (!key) {
+    return { error: 'no-feature', message: 'Nenhuma feature: passe o nome ou rode de uma branch morph/{f} / morph-task/{n}.' };
+  }
+  const common = gitCommonDir(cwd);
+  if (!common) {
+    return { error: 'not-a-git-repo', message: 'Fora de um repositório git não há bloco de portas.' };
+  }
+  const root = resolvePrimaryRoot(cwd);
+  const env = buildComposeEnv({ cwd: root, config: readConfig(root), featureName: key, gitCommonDir: common });
+  return { key, env };
+}
+
+export function render(env, format) {
+  const entries = Object.entries(env);
+  if (format === 'json') return JSON.stringify(env, null, 2);
+  if (format === 'powershell') return entries.map(([k, v]) => `$env:${k}="${String(v).replace(/"/g, '`"')}"`).join('\n');
+  return entries.map(([k, v]) => `export ${k}=${shq(v)}`).join('\n');
+}
+
+/**
+ * @param {string|undefined} featureArg
+ * @param {{ json?: boolean, posix?: boolean, powershell?: boolean }} options
+ */
+export function envCommand(featureArg, options = {}) {
+  const result = resolveWorktreeEnv(featureArg || null, process.cwd());
+  if (result.error) {
+    if (options.json) console.log(JSON.stringify({ error: result.error, message: result.message }));
+    else console.error(chalk.red(`✗ ${result.message}`));
+    process.exit(1);
+  }
+  const format = options.json ? 'json' : options.powershell ? 'powershell' : 'posix';
+  console.log(render(result.env, format));
+  process.exit(0);
+}