@polymorphism-tech/morph-spec 4.8.19 → 4.9.0

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

@@ -0,0 +1,16 @@
+/**
+ * Task classifier — identifies test/validation 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);
+}

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

@@ -0,0 +1,77 @@
+/**
+ * Test Runner — Resolves and executes the project's test suite.
+ *
+ * Resolution order for test command:
+ *   1. .morph/config/config.json → project.testCommand
+ *   2. package.json present → "npm test"
+ *   3. null (no test suite detected)
+ */
+
+import { execSync } from 'child_process';
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+
+/**
+ * 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 = '.') {
+  // 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
+    }
+  }
+
+  // 2. Detect package.json → npm test
+  const packageJsonPath = join(projectPath, 'package.json');
+  if (existsSync(packageJsonPath)) {
+    return 'npm test';
+  }
+
+  // 3. Nothing found
+  return null;
+}
+
+/**
+ * Run the project's test suite.
+ *
+ * @param {string} [projectPath] - Project root directory (defaults to '.')
+ * @param {object} [opts] - Optional overrides for testing
+ * @param {Function} [opts._execSync] - Override execSync for unit testing
+ * @returns {{ passed?: boolean, output?: string, exitCode?: number, skipped?: boolean, reason?: string }}
+ */
+export function runTestSuite(projectPath = '.', opts = {}) {
+  const cmd = resolveTestCommand(projectPath);
+
+  if (!cmd) {
+    return { skipped: true, reason: 'No testCommand configured and no known project file detected' };
+  }
+
+  const exec = opts._execSync ?? execSync;
+
+  try {
+    const output = exec(cmd, {
+      cwd: projectPath,
+      timeout: 120_000,
+      encoding: 'utf8',
+      stdio: 'pipe'
+    });
+    return { passed: true, output: output ?? '', exitCode: 0 };
+  } catch (err) {
+    return {
+      passed: false,
+      output: (err.stdout || '') + (err.stderr || ''),
+      exitCode: err.status ?? 1
+    };
+  }
+}

package/src/lib/trust/trust-manager.js

@@ -1,32 +1,25 @@
 /**
- * Trust Manager — Track-record and auto-approval logic
- *
- * Computes trust level from checkpoint pass rate history.
- * Enables auto-approval gates for features with proven track records.
+ * Trust Manager — Simplified 3-level trust model
  *
  * Trust levels:
- *   low     < 80% pass rate
- *   medium  80–90%
- *   high    90–95%
- *   maximum > 95%
+ *   manual  — nothing auto-approved (default)
+ *   high    — auto-approve low-risk gates (design, tasks)
+ *   auto    — auto-approve all gates
+ *
+ * Set with: morph-spec trust set <feature> <level>
  */
 
-import { readFileSync, writeFileSync, existsSync } from 'fs';
+import { readFileSync, existsSync } from 'fs';
 import { join } from 'path';
+import { saveState } from '../../core/state/state-manager.js';
 
-// Default trust config (matches llm-interaction.json thresholds)
-const TRUST_THRESHOLDS = {
-  low: 0,
-  medium: 0.80,
-  high: 0.90,
-  maximum: 0.95
-};
+const VALID_LEVELS = ['manual', 'high', 'auto'];
 
-// Gates that can be auto-approved by trust level
-const AUTO_APPROVE_GATES = {
-  medium: ['design'],
+// Gates that can be auto-approved at each trust level
+export const AUTO_APPROVE_GATES = {
+  manual: [],
   high: ['design', 'tasks'],
-  maximum: ['design', 'tasks', 'proposal']
+  auto: ['design', 'tasks', 'proposal', 'uiux']
 };
 
 /**
@@ -43,86 +36,41 @@ function loadState() {
   }
 }
 
-/**
- * Save state.json
- * @param {Object} state
- */
-function saveState(state) {
-  const statePath = join(process.cwd(), '.morph/state.json');
-  writeFileSync(statePath, JSON.stringify(state, null, 2), 'utf8');
-}
-
-/**
- * Calculate trust level from checkpoint history
- * @param {Array} checkpoints - Array of { passed: boolean, ... }
- * @returns {{ level: string, passRate: number, total: number, passed: number }}
- */
-export function calculateTrust(checkpoints = []) {
-  if (checkpoints.length === 0) {
-    return { level: 'low', passRate: 0, total: 0, passed: 0 };
-  }
-
-  const total = checkpoints.length;
-  const passed = checkpoints.filter(c => c.passed).length;
-  const passRate = passed / total;
-
-  let level = 'low';
-  if (passRate >= TRUST_THRESHOLDS.maximum) level = 'maximum';
-  else if (passRate >= TRUST_THRESHOLDS.high) level = 'high';
-  else if (passRate >= TRUST_THRESHOLDS.medium) level = 'medium';
-
-  return { level, passRate, total, passed };
-}
-
 /**
  * Get current trust config for a feature
  * @param {string} featureName
- * @returns {{ level: string, passRate: number, autoApprove: string[], override?: string }}
+ * @returns {{ level: string, autoApprove: string[], source: string, overrideReason?: string }}
  */
 export function getTrust(featureName) {
   const state = loadState();
   const feature = state.features?.[featureName];
 
   if (!feature) {
-    return { level: 'low', passRate: 0, autoApprove: [], source: 'default' };
-  }
-
-  // Check for manual override first
-  if (feature.trustConfig?.override) {
-    return {
-      level: feature.trustConfig.override.level,
-      passRate: feature.trustConfig.passRate || 0,
-      autoApprove: AUTO_APPROVE_GATES[feature.trustConfig.override.level] || [],
-      source: 'manual',
-      overrideReason: feature.trustConfig.override.reason,
-      overrideAt: feature.trustConfig.override.setAt
-    };
+    return { level: 'manual', autoApprove: [], source: 'default' };
   }
 
-  // Calculate from checkpoint history
-  const checkpoints = feature.checkpoints || [];
-  const { level, passRate, total, passed } = calculateTrust(checkpoints);
+  const override = feature.trustConfig?.override;
+  const level = VALID_LEVELS.includes(override?.level) ? override.level : 'manual';
+  const source = override ? 'manual' : 'default';
 
   return {
     level,
-    passRate,
-    total,
-    passed,
     autoApprove: AUTO_APPROVE_GATES[level] || [],
-    source: 'calculated'
+    source,
+    overrideReason: override?.reason,
+    overrideAt: override?.setAt
   };
 }
 
 /**
  * Manually set trust level with reason
  * @param {string} featureName
- * @param {string} level - 'low' | 'medium' | 'high' | 'maximum'
- * @param {string} reason
+ * @param {string} level - 'manual' | 'high' | 'auto'
+ * @param {string} [reason]
  */
 export function setTrust(featureName, level, reason) {
-  const validLevels = ['low', 'medium', 'high', 'maximum'];
-  if (!validLevels.includes(level)) {
-    throw new Error(`Invalid trust level: ${level}. Valid: ${validLevels.join(', ')}`);
+  if (!VALID_LEVELS.includes(level)) {
+    throw new Error(`Invalid trust level: ${level}. Valid: ${VALID_LEVELS.join(', ')}`);
   }
 
   const state = loadState();
@@ -136,7 +84,7 @@ export function setTrust(featureName, level, reason) {
 
   state.features[featureName].trustConfig.override = {
     level,
-    reason,
+    reason: reason || `Manual override to ${level}`,
     setAt: new Date().toISOString(),
     setBy: 'manual'
   };
@@ -147,12 +95,12 @@ export function setTrust(featureName, level, reason) {
     feature: featureName,
     level,
     autoApprove: AUTO_APPROVE_GATES[level] || [],
-    reason
+    reason: state.features[featureName].trustConfig.override.reason
   };
 }
 
 /**
- * Clear manual trust override (revert to calculated)
+ * Clear manual trust override (reverts to default: manual)
  * @param {string} featureName
  */
 export function clearTrustOverride(featureName) {
@@ -166,7 +114,7 @@ export function clearTrustOverride(featureName) {
 /**
  * Check if a gate should be auto-approved based on trust level
  * @param {string} featureName
- * @param {string} gate - 'design' | 'tasks' | 'proposal'
+ * @param {string} gate - 'design' | 'tasks' | 'proposal' | 'uiux'
  * @returns {{ autoApprove: boolean, level: string, reason: string }}
  */
 export function shouldAutoApprove(featureName, gate) {
@@ -176,33 +124,19 @@ export function shouldAutoApprove(featureName, gate) {
     return {
       autoApprove: false,
       level: trust.level,
-      reason: `Trust level "${trust.level}" does not auto-approve "${gate}" gate (need: ${getMinLevelForGate(gate)})`
+      reason: `Trust level "${trust.level}" does not auto-approve "${gate}" gate`
     };
   }
 
   return {
     autoApprove: true,
     level: trust.level,
-    reason: `Auto-approved: ${trust.level} trust (${Math.round(trust.passRate * 100)}% pass rate, ${trust.total} checkpoints)`,
-    passRate: trust.passRate,
-    checkpointsTotal: trust.total
+    reason: `Auto-approved: trust level "${trust.level}" includes gate "${gate}"`
   };
 }
 
 /**
- * Get minimum trust level required for a gate
- * @param {string} gate
- * @returns {string}
- */
-function getMinLevelForGate(gate) {
-  for (const [level, gates] of Object.entries(AUTO_APPROVE_GATES)) {
-    if (gates.includes(gate)) return level;
-  }
-  return 'maximum';
-}
-
-/**
- * Get trust history for all features
+ * Get trust info for all features
  * @returns {Array} Feature trust summaries
  */
 export function getTrustHistory() {
@@ -214,9 +148,6 @@ export function getTrustHistory() {
     return {
       feature: name,
       level: trust.level,
-      passRate: trust.passRate,
-      checkpointsTotal: trust.total || 0,
-      checkpointsPassed: trust.passed || 0,
       autoApprove: trust.autoApprove,
       source: trust.source,
       phase: feature.phase,
@@ -224,46 +155,3 @@ export function getTrustHistory() {
     };
   });
 }
-
-/**
- * Auto-calculate and update trust in state
- * @param {string} featureName
- * @returns {Object} Updated trust config
- */
-export function autoCalculateTrust(featureName) {
-  const state = loadState();
-  const feature = state.features?.[featureName];
-
-  if (!feature) {
-    throw new Error(`Feature not found: ${featureName}`);
-  }
-
-  const checkpoints = feature.checkpoints || [];
-  const { level, passRate, total, passed } = calculateTrust(checkpoints);
-
-  if (!state.features[featureName].trustConfig) {
-    state.features[featureName].trustConfig = {};
-  }
-
-  state.features[featureName].trustConfig = {
-    ...state.features[featureName].trustConfig,
-    level,
-    passRate,
-    checkpointsTotal: total,
-    checkpointsPassed: passed,
-    lastCalculated: new Date().toISOString()
-  };
-
-  saveState(state);
-
-  return {
-    feature: featureName,
-    level,
-    passRate,
-    total,
-    passed,
-    autoApprove: AUTO_APPROVE_GATES[level] || []
-  };
-}
-
-export { TRUST_THRESHOLDS, AUTO_APPROVE_GATES };

package/src/lib/validators/spec-validator.js

@@ -9,7 +9,8 @@
 
 import { readFileSync, existsSync } from 'fs';
 import { join } from 'path';
-import { getAbsoluteOutputPath } from '../../core/paths/output-schema.js';
+import { getAbsoluteOutputPath, resolveContractsOutputType } from '../../core/paths/output-schema.js';
+import { getStackProfile } from '../stack/stack-profile.js';
 
 /**
  * Validate spec.md and contracts.cs at design time
@@ -20,8 +21,11 @@ import { getAbsoluteOutputPath } from '../../core/paths/output-schema.js';
  * @returns {Object} { status, errors, warnings, issues }
  */
 export async function validateSpec(projectPath, featureName, options = {}) {
+  const { stack, isNextjs } = getStackProfile(projectPath);
+  const contractsType = resolveContractsOutputType(stack);
+
   const specPath = getAbsoluteOutputPath(projectPath, featureName, 'spec');
-  const contractsPath = getAbsoluteOutputPath(projectPath, featureName, 'contracts');
+  const contractsPath = getAbsoluteOutputPath(projectPath, featureName, contractsType);
 
   const issues = [];
 
@@ -32,10 +36,12 @@ export async function validateSpec(projectPath, featureName, options = {}) {
     issues.push(...specIssues);
   }
 
-  // Validate contracts.cs
+  // Validate contracts file (stack-aware)
   if (existsSync(contractsPath)) {
     const contractsContent = readFileSync(contractsPath, 'utf8');
-    const contractsIssues = validateContractsCs(contractsContent);
+    const contractsIssues = isNextjs
+      ? validateContractsTs(contractsContent)
+      : validateContractsCs(contractsContent);
     issues.push(...contractsIssues);
   }
 
@@ -240,6 +246,54 @@ function validateContractsCs(content) {
   return issues;
 }
 
+/**
+ * Validate contracts.ts structure for Next.js projects.
+ * Checks: has exports, has Zod schemas, no C# syntax.
+ */
+function validateContractsTs(content) {
+  const issues = [];
+
+  // Must have at least one export
+  if (!/^export\s+(interface|type|const|function)/m.test(content)) {
+    issues.push({
+      level: 'error',
+      type: 'contracts',
+      message: 'contracts.ts has no exported types, interfaces, or schemas',
+      solution: 'Add at least one export interface or export type'
+    });
+  }
+
+  // Should have at least one Zod schema (warning only)
+  if (!content.includes('z.object(')) {
+    issues.push({
+      level: 'warning',
+      type: 'contracts',
+      message: 'contracts.ts has no Zod schemas (z.object)',
+      solution: "Add Zod schemas for runtime validation. Import from 'zod'."
+    });
+  }
+
+  // Must NOT contain C# syntax
+  const csharpPatterns = [
+    { re: /^namespace\s+/m, name: 'namespace declaration' },
+    { re: /^using\s+System/m, name: 'C# using directive' },
+    { re: /\bpublic\s+record\b/m, name: 'C# record type' },
+    { re: /\bpublic\s+class\b/m, name: 'C# class declaration' },
+  ];
+  for (const { re, name } of csharpPatterns) {
+    if (re.test(content)) {
+      issues.push({
+        level: 'error',
+        type: 'contracts',
+        message: `contracts.ts contains C# syntax (${name})`,
+        solution: 'This file was generated for .NET — regenerate contracts using the phase-design skill for a Next.js project'
+      });
+    }
+  }
+
+  return issues;
+}
+
 /**
  * Check if a string is PascalCase
  */

package/src/lib/validators/validation-runner.js

@@ -11,7 +11,14 @@ import { existsSync, readFileSync } from 'fs';
 import { join } from 'path';
 import chalk from 'chalk';
 import { loadState } from '../../core/state/state-manager.js';
-import { getAbsoluteOutputPath } from '../../core/paths/output-schema.js';
+import { getAbsoluteOutputPath, resolveContractsOutputType } from '../../core/paths/output-schema.js';
+import { getStackProfile } from '../stack/stack-profile.js';
+
+/** Validators that only make sense for .NET/Blazor projects. */
+const DOTNET_ONLY_VALIDATORS = new Set([
+  'architecture', 'packages', 'blazor', 'blazor-concurrency',
+  'blazor-state', 'contract-compliance'
+]);
 
 /**
  * Load agent → validators map from agents.json (data-driven)
@@ -92,9 +99,11 @@ export async function runValidation(projectPath, featureName, options = {}) {
     console.log(chalk.gray(`  (+ ${constraints.enabledValidators.length} from decisions)`));
   }
 
-  // Always run contract compliance if contracts.cs exists
-  const contractsPath = getAbsoluteOutputPath(projectPath, featureName, 'contracts');
-  if (existsSync(contractsPath)) {
+  // Always run contract compliance if the contracts file exists (stack-aware)
+  const _profileForContracts = getStackProfile(projectPath);
+  const contractsType = resolveContractsOutputType(_profileForContracts.stack);
+  const contractsPath = getAbsoluteOutputPath(projectPath, featureName, contractsType);
+  if (existsSync(contractsPath) && !_profileForContracts.isNextjs) {
     validatorIds.push('contract-compliance');
   }
 
@@ -152,26 +161,29 @@ export async function runValidation(projectPath, featureName, options = {}) {
  * @returns {string[]} Array of validator IDs to run
  */
 function detectValidators(featureName, projectPath = '.') {
+  const profile = getStackProfile(projectPath);
   const state = loadState(false);
+
   if (!state || !state.features[featureName]) {
-    return ['architecture', 'packages']; // Default validators
+    return [...profile.defaultValidators]; // stack-aware defaults
   }
 
   const feature = state.features[featureName];
   const agents = feature.activeAgents || [];
-  const validatorSet = new Set();
+  const validatorSet = new Set(profile.defaultValidators); // stack defaults first
 
-  // Load agent → validators map from agents.json (data-driven)
   const agentValidatorMap = loadAgentValidatorMap(projectPath);
-
   for (const agentId of agents) {
     const validators = agentValidatorMap[agentId] || [];
     validators.forEach(v => validatorSet.add(v));
   }
 
-  // Always include architecture and packages as baseline
-  validatorSet.add('architecture');
-  validatorSet.add('packages');
+  // Filter out .NET-only validators for non-.NET projects
+  if (!profile.isDotnet) {
+    for (const v of DOTNET_ONLY_VALIDATORS) {
+      validatorSet.delete(v);
+    }
+  }
 
   return Array.from(validatorSet);
 }