@polymorphism-tech/morph-spec 10.1.1 → 10.2.0

package/src/utils/hooks-installer.js

@@ -6,7 +6,6 @@ import { realEffects } from '../lib/installers/effects.js';
 
 const HOOKS_VERSION = '3.17.0';
 
-const OLD_DISPATCH_COMMAND = 'node framework/hooks/agent-teams/dispatch.js';
 
 // `Edit(path)` only: an Edit rule also covers Write, while a `Write(path)` rule
 // matches nothing and makes Claude Code warn on every session start.
@@ -195,7 +194,6 @@ export async function installClaudeHooks(targetPath, { fx = realEffects() } = {}
   const managed = settings._morph_managed || {};
   const alreadyCurrent = managed.hooks_version === HOOKS_VERSION;
 
-  removeOldDispatch(settings);
   removeMorphHooks(settings);
 
   let installed = 0;
@@ -250,8 +248,6 @@ export async function installClaudeHooks(targetPath, { fx = realEffects() } = {}
   const STALE_ALLOW = [
     'Write(.morph/features/**)',
     'Write(.morph/context/**)',
-    'Bash(morph-spec mutate:*)',
-    'Bash(npx morph-spec mutate:*)',
   ];
   settings.permissions.allow = settings.permissions.allow.filter(
     p => !MORPH_ALLOW.includes(p) && !STALE_ALLOW.includes(p)
@@ -319,22 +315,6 @@ export async function installGlobalStatusline(hooksSourceDir, globalClaudeDirOve
   return { installed: true, globalDir };
 }
 
-function removeOldDispatch(settings) {
-  if (!settings.hooks?.PostToolUse) return;
-
-  settings.hooks.PostToolUse = settings.hooks.PostToolUse.filter(entry => {
-    if (!Array.isArray(entry.hooks)) return true;
-    return !entry.hooks.some(h =>
-      h.command === OLD_DISPATCH_COMMAND ||
-      (typeof h.command === 'string' && h.command.includes('agent-teams/dispatch.js'))
-    );
-  });
-
-  if (settings.hooks.PostToolUse.length === 0) {
-    delete settings.hooks.PostToolUse;
-  }
-}
-
 function removeMorphHooks(settings) {
   const morphPathPattern = /framework\/hooks\/claude-code\//;
 

package/bin/validate.js

@@ -1,212 +0,0 @@
-#!/usr/bin/env node
-
-import chalk from 'chalk';
-import { getStackProfile } from '../src/lib/stack/stack-profile.js';
-
-async function buildValidators(stack) {
-  const validators = {};
-
-  const isDotnet = !stack || ['dotnet', 'blazor', 'aspnet', 'dotnet-blazor'].includes(stack.toLowerCase());
-  const isNextjs = stack && ['nextjs', 'next', 'next.js'].includes(stack.toLowerCase());
-
-  if (isDotnet) {
-    const { validatePackages } = await import('../src/lib/validators/packages/package-validator.js');
-
-    validators.packages = {
-      name: 'Package Compatibility',
-      description: 'Validates NuGet package versions against .NET compatibility matrix',
-      run: validatePackages
-    };
-  }
-
-  if (isNextjs) {
-    const { validateNextComponentFiles } = await import('../src/lib/validators/nextjs/next-component-validator.js');
-    validators['next-components'] = {
-      name: 'Next.js Components',
-      description: "Validates 'use client' directives, hook usage, and file naming conventions",
-      run: (projectPath, opts) => validateNextComponentFiles(projectPath, opts)
-    };
-  }
-
-  return validators;
-}
-
-export async function validateCommand(args = []) {
-  const validatorName = args[0] || 'all';
-  const options = parseOptions(args);
-
-  const { stack } = getStackProfile();
-  const VALIDATORS = await buildValidators(stack);
-
-  console.log(chalk.bold.cyan('\n🔍 MORPH-SPEC Validator\n'));
-  if (stack) {
-    console.log(chalk.gray(`Stack: ${stack}\n`));
-  }
-
-  if (validatorName === 'all') {
-    await runAllValidators(VALIDATORS, options);
-  } else if (VALIDATORS[validatorName]) {
-    await runValidator(VALIDATORS, validatorName, options);
-  } else {
-    console.error(chalk.red(`❌ Unknown validator: ${validatorName}`));
-    console.log(chalk.gray('\nAvailable validators:'));
-    for (const [name, validator] of Object.entries(VALIDATORS)) {
-      console.log(chalk.gray(`  - ${name}: ${validator.description}`));
-    }
-    console.log(chalk.gray('  - all: Run all validators'));
-    process.exit(1);
-  }
-}
-
-async function runAllValidators(VALIDATORS, options) {
-  const results = {};
-  let totalErrors = 0;
-  let totalWarnings = 0;
-
-  console.log(chalk.gray('Running all validators...\n'));
-
-  for (const [name, validator] of Object.entries(VALIDATORS)) {
-    console.log(chalk.cyan(`\n▸ ${validator.name}`));
-    console.log(chalk.gray(`  ${validator.description}\n`));
-
-    try {
-      const result = await validator.run('.', {
-        verbose: options.verbose,
-        autoFix: options.autoFix
-      });
-
-      results[name] = result;
-
-      if (result.errors !== undefined) {
-        totalErrors += result.errors;
-        totalWarnings += result.warnings || 0;
-      } else if (result.results) {
-        const issues = result.results.flatMap(r => r.issues || []);
-        totalErrors += issues.filter(i => i.level === 'error').length;
-        totalWarnings += issues.filter(i => i.level === 'warning').length;
-      }
-
-    } catch (error) {
-      console.error(chalk.red(`  ❌ Failed: ${error.message}`));
-      results[name] = { status: 'error', error: error.message };
-    }
-  }
-
-  console.log(chalk.bold.cyan('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n'));
-  console.log(chalk.bold('📊 Validation Summary\n'));
-
-  if (totalErrors === 0 && totalWarnings === 0) {
-    console.log(chalk.green('✅ All validations passed!'));
-  } else {
-    if (totalErrors > 0) {
-      console.log(chalk.red(`❌ ${totalErrors} error(s) found`));
-    }
-    if (totalWarnings > 0) {
-      console.log(chalk.yellow(`⚠️  ${totalWarnings} warning(s) found`));
-    }
-  }
-
-  console.log('');
-
-  if (totalErrors > 0 && !options.noFail) {
-    process.exit(1);
-  }
-}
-
-async function runValidator(VALIDATORS, name, options) {
-  const validator = VALIDATORS[name];
-
-  console.log(chalk.cyan(`▸ ${validator.name}`));
-  console.log(chalk.gray(`  ${validator.description}\n`));
-
-  try {
-    const result = await validator.run('.', {
-      verbose: true,
-      autoFix: options.autoFix
-    });
-
-    if (result.status === 'ok') {
-      console.log(chalk.green('\n✅ Validation passed!\n'));
-    } else {
-      console.log(chalk.yellow('\n⚠️  Validation completed with issues\n'));
-
-      if (result.errors > 0 && !options.noFail) {
-        process.exit(1);
-      }
-    }
-
-  } catch (error) {
-    console.error(chalk.red(`\n❌ Validation failed: ${error.message}\n`));
-    if (!options.noFail) {
-      process.exit(1);
-    }
-  }
-}
-
-function parseOptions(args) {
-  const options = {
-    verbose: false,
-    autoFix: false,
-    noFail: false
-  };
-
-  for (const arg of args) {
-    if (arg === '--verbose' || arg === '-v') {
-      options.verbose = true;
-    } else if (arg === '--auto-fix' || arg === '--fix') {
-      options.autoFix = true;
-    } else if (arg === '--no-fail') {
-      options.noFail = true;
-    }
-  }
-
-  return options;
-}
-
-export function showValidateHelp() {
-  console.log(`
-${chalk.bold.cyan('morph-spec validate')} - Run project validations
-
-${chalk.bold('USAGE')}
-  morph-spec validate [validator] [options]
-
-${chalk.bold('VALIDATORS')}
-  all             Run all validators (default)
-  packages        Validate NuGet package compatibility (.NET 10)
-
-${chalk.bold('OPTIONS')}
-  --verbose, -v        Show detailed output
-  --auto-fix, --fix    Auto-fix issues where possible
-  --no-fail            Don't exit with error code
-
-${chalk.bold('EXAMPLES')}
-  morph-spec validate                    # Run all validators
-  morph-spec validate packages --fix     # Validate packages and auto-fix
-  morph-spec validate all                # Run all validators
-
-${chalk.bold('EXIT CODES')}
-  0    All validations passed
-  1    Validation errors found (unless --no-fail)
-
-${chalk.bold('INTEGRATION')}
-  Add to pre-commit hook:
-    morph-spec validate --no-fail
-
-  CI/CD pipeline:
-    morph-spec validate || exit 1
-`);
-}
-
-if (import.meta.url === `file://${process.argv[1]}`) {
-  const args = process.argv.slice(2);
-
-  if (args.includes('--help') || args.includes('-h')) {
-    showValidateHelp();
-    process.exit(0);
-  }
-
-  validateCommand(args).catch(error => {
-    console.error(chalk.red(`\n❌ Error: ${error.message}\n`));
-    process.exit(1);
-  });
-}

package/src/commands/observability/telemetry.js

@@ -1,60 +0,0 @@
-import chalk from 'chalk';
-import { loadTelemetry, aggregateTelemetry } from '../../lib/telemetry/telemetry-reader.js';
-
-// A rule injects its standards' digests through Claude Code's rules system,
-// not the Read tool, so no hook sees them: a low count means "few full-text reads".
-const STANDARDS_CAVEAT =
-  'Só reads explícitos (via Read) são observáveis; o resumo que uma rule injeta ao tocar arquivo casado por `paths:` não passa por tool call: não observável aqui.';
-
-function section(title, rows, fmt) {
-  if (!rows.length) return;
-  console.log('\n' + chalk.white.bold(title));
-  for (const r of rows) console.log('  ' + fmt(r));
-}
-
-// Read-only and always exits 0: an empty stream is an answer.
-export function telemetryCommand(options = {}) {
-  const events = loadTelemetry(options.cwd || process.cwd());
-  const summary = aggregateTelemetry(events, { feature: options.feature });
-
-  if (options.json) {
-    console.log(JSON.stringify({ ...summary, notes: { standards: STANDARDS_CAVEAT } }));
-    process.exit(0);
-  }
-
-  if (summary.total === 0) {
-    const scope = options.feature ? ` para a feature "${options.feature}"` : '';
-    console.log(chalk.gray(`Telemetria vazia${scope} — nenhum evento capturado ainda em .morph/logs/events.jsonl.`));
-    process.exit(0);
-  }
-
-  const scope = options.feature ? chalk.cyan(` · feature ${options.feature}`) : '';
-  console.log(chalk.white.bold(`Telemetria do harness — ${summary.total} eventos${scope}`));
-  if (summary.features.length) {
-    console.log(chalk.gray(`Features: ${summary.features.join(', ')}`));
-  }
-
-  section('Skills', summary.skills, s => `${chalk.green(s.name.padEnd(24))} ${s.count}`);
-  section('Sub-agents despachados', summary.personas, p => `${chalk.magenta(p.name.padEnd(24))} ${p.count}`);
-  section('Base de conhecimento (standards lidos explicitamente)', summary.standards,
-    s => `${chalk.yellow(String(s.count).padStart(3))}×  ${s.path}`);
-  if (summary.standards.length || summary.tools.some(t => t.name === 'Read')) {
-    console.log(chalk.gray(`  ⚠ ${STANDARDS_CAVEAT}`));
-  }
-  section('Mix de tools', summary.tools, t => `${t.name.padEnd(16)} ${t.count}`);
-
-  const limit = Number.isInteger(options.limit) && options.limit > 0 ? options.limit : 10;
-  const prompts = summary.prompts.slice(-limit);
-  if (prompts.length) {
-    console.log('\n' + chalk.white.bold(`Prompts (últimos ${prompts.length})`));
-    for (const p of prompts) {
-      const tag = p.source === 'user' ? chalk.blue('user ') : chalk.magenta('agent');
-      const where = p.feature ? chalk.gray(` [${p.feature}/${p.phase || '-'}]`) : '';
-      const oneLine = String(p.text || '').replace(/\s+/g, ' ').trim();
-      const preview = oneLine.length > 120 ? oneLine.slice(0, 117) + '...' : oneLine;
-      console.log(`  ${tag}${where} ${preview}`);
-    }
-  }
-
-  process.exit(0);
-}

package/src/commands/validation/validate-feature.js

@@ -1,337 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import chalk from 'chalk';
-import { parsePlan } from '../../lib/plan/plan-parser.js';
-import { planHash, planRuleOptions, validatePlan } from '../../lib/plan/checks.js';
-
-// Matched against section markers (headings and line-start bold labels), never whole-file
-// substrings. required → ERROR, recommended → WARNING, optional → never penalized; an array is any-of.
-const OUTPUT_SECTIONS = {
-  'verifier.md': {
-    required: [
-      ['Verdict', 'Veredito'],
-    ],
-    recommended: [
-      ['Bloqueadores', 'Bloqueantes', 'Blockers'],
-      'Checks',
-    ],
-    optional: [],
-  },
-  'reviewer.md': {
-    required: [
-      ['Verdict', 'Veredito'],
-    ],
-    recommended: [
-      ['Bloqueadores', 'Bloqueantes', 'Blockers'],
-    ],
-    optional: [],
-  },
-  'security.md': {
-    required: [
-      ['Verdict', 'Veredito'],
-    ],
-    recommended: [
-      ['Bloqueadores', 'Bloqueantes', 'Blockers'],
-    ],
-    optional: [],
-  },
-};
-
-const PHASE_OUTPUTS = {
-  plan: ['plan.md', 'checks.json'],
-  uiux: ['design-system.md', 'mockups.md', 'components.md', 'flows.md'],
-  implement: [],
-  review: ['verifier.md', 'reviewer.md'],
-};
-
-const PHASE_FOLDERS = {
-  plan: '2-plan',
-  uiux: '1-design',
-  implement: '3-implement',
-  review: '4-review',
-};
-
-// Line-start bold labels count: reports write `**Verdict:**` as a label, not a heading.
-function extractSectionMarkers(content) {
-  const markers = [];
-  for (const rawLine of content.split('\n')) {
-    const line = rawLine.trim();
-    const heading = /^#{1,6}\s+(.+)$/.exec(line);
-    if (heading) {
-      markers.push(heading[1].toLowerCase());
-      continue;
-    }
-    const bold = /^\*\*(.+?)\*\*/.exec(line);
-    if (bold) {
-      markers.push(bold[1].toLowerCase());
-    }
-  }
-  return markers;
-}
-
-function validateOutput(featurePath, outputFile) {
-  const filePath = path.join(featurePath, outputFile);
-  const result = {
-    file: outputFile,
-    exists: false,
-    sections: { found: [], missing: [], optional: [] },
-    warnings: [],
-    errors: [],
-    lineCount: 0,
-  };
-
-  if (!fs.existsSync(filePath)) {
-    result.errors.push(`File not found: ${outputFile}`);
-    return result;
-  }
-
-  result.exists = true;
-  const content = fs.readFileSync(filePath, 'utf8');
-  result.lineCount = content.split('\n').length;
-
-  if (outputFile === 'plan.md') {
-    validatePlanOutput(content, featurePath, result);
-    return result;
-  }
-  if (outputFile === 'checks.json') {
-    validateChecksOutput(content, featurePath, result);
-    return result;
-  }
-
-  const sections = OUTPUT_SECTIONS[outputFile];
-  if (!sections) {
-    return result;
-  }
-
-  validateMarkdownSections(content, sections, result);
-
-  if (result.lineCount < 10) {
-    result.warnings.push(`File is very short (${result.lineCount} lines) — may be incomplete`);
-  }
-
-  return result;
-}
-
-// `planDir` is `.morph/features/{f}/2-plan`, so the project is four levels up.
-function validatePlanOutput(content, planDir, result) {
-  const plan = parsePlan(content);
-  const root = path.resolve(planDir, '..', '..', '..', '..');
-  const feature = path.basename(path.resolve(planDir, '..'));
-  const { errors, warnings } = validatePlan(plan, { ...planRuleOptions(root, feature), text: content });
-  result.errors.push(...errors);
-  result.warnings.push(...warnings);
-  result.sections.found.push(...plan.sections.filter((x) => x.key).map((x) => x.name));
-}
-
-function validateChecksOutput(content, planDir, result) {
-  let doc;
-  try {
-    doc = JSON.parse(content);
-  } catch (err) {
-    result.errors.push(`checks.json is not valid JSON: ${err.message}`);
-    return;
-  }
-  const planPath = path.join(planDir, 'plan.md');
-  if (!fs.existsSync(planPath)) return;
-  if (doc?.planHash !== planHash(fs.readFileSync(planPath, 'utf8'))) {
-    result.errors.push('checks.json is stale — plan.md changed after it was generated; run `morph-spec plan-check`');
-    return;
-  }
-  result.sections.found.push(`${doc.checks?.length ?? 0} check(s)`);
-}
-
-function validateMarkdownSections(content, sections, result) {
-  const markers = extractSectionMarkers(content);
-  const match = (entry) => {
-    const candidates = Array.isArray(entry) ? entry : [entry];
-    const hit = candidates.find(c => markers.some(m => m.includes(c.toLowerCase())));
-    return { hit, label: candidates[0] };
-  };
-  const describe = (entry) =>
-    Array.isArray(entry) ? entry.map(s => `"${s}"`).join(' or ') : `"${entry}"`;
-
-  for (const entry of (sections.required || [])) {
-    const { hit, label } = match(entry);
-    if (hit) {
-      result.sections.found.push(hit);
-    } else {
-      result.sections.missing.push(label);
-      result.errors.push(`Missing required section: ${describe(entry)}`);
-    }
-  }
-
-  for (const entry of (sections.recommended || [])) {
-    const { hit } = match(entry);
-    if (hit) {
-      result.sections.found.push(hit);
-    } else {
-      result.warnings.push(`Missing recommended section: ${describe(entry)}`);
-    }
-  }
-
-  for (const entry of (sections.optional || [])) {
-    const { hit } = match(entry);
-    if (hit) result.sections.optional.push(hit);
-  }
-}
-
-function resolveOutputFiles(featurePath, phase) {
-  if (phase) {
-    const files = PHASE_OUTPUTS[phase];
-    if (!files) return { error: `Unknown phase: ${phase}` };
-    const phaseFolder = PHASE_FOLDERS[phase];
-    const searchPath = phaseFolder ? path.join(featurePath, phaseFolder) : featurePath;
-    return { outputFiles: files.map(file => ({ file, dir: searchPath })) };
-  }
-
-  const outputFiles = [];
-  const isOutput = name => name.endsWith('.md') || name.endsWith('.cs') || name === 'checks.json';
-  const entries = fs.readdirSync(featurePath, { withFileTypes: true });
-  for (const entry of entries) {
-    if (entry.isDirectory()) {
-      const subDir = path.join(featurePath, entry.name);
-      for (const f of fs.readdirSync(subDir).filter(isOutput)) {
-        outputFiles.push({ file: f, dir: subDir });
-      }
-    } else if (isOutput(entry.name)) {
-      outputFiles.push({ file: entry.name, dir: featurePath });
-    }
-  }
-  return { outputFiles };
-}
-
-/** Pure core: no console output, no process.exit. */
-export function runFeatureValidation(featurePath, options = {}) {
-  const phase = options.phase || null;
-  const feature = path.basename(featurePath);
-
-  const { outputFiles, error } = resolveOutputFiles(featurePath, phase);
-  if (error) {
-    return {
-      feature,
-      phase: phase || 'all',
-      valid: false,
-      error,
-      totalErrors: 1,
-      totalWarnings: 0,
-      totalFound: 0,
-      results: [],
-    };
-  }
-
-  const results = outputFiles.map(({ file, dir }) => validateOutput(dir, file));
-  const totalErrors = results.reduce((sum, r) => sum + r.errors.length, 0);
-  const totalWarnings = results.reduce((sum, r) => sum + r.warnings.length, 0);
-  const totalFound = results.reduce((sum, r) => sum + r.sections.found.length, 0);
-
-  return {
-    feature,
-    phase: phase || 'all',
-    valid: totalErrors === 0,
-    totalErrors,
-    totalWarnings,
-    totalFound,
-    results,
-  };
-}
-
-export async function validateFeatureCommand(featureName, options = {}) {
-  if (!featureName) {
-    console.error(chalk.red('Error: Feature name required'));
-    console.error(chalk.gray('Usage: morph-spec validate <feature-name> [--phase <phase>]'));
-    process.exit(1);
-  }
-
-  const featurePath = path.join(process.cwd(), '.morph/features', featureName);
-
-  if (!fs.existsSync(featurePath)) {
-    console.error(chalk.red(`Error: Feature directory not found: ${featurePath}`));
-    process.exit(1);
-  }
-
-  const phase = options.phase || null;
-  if (phase && !PHASE_OUTPUTS[phase]) {
-    console.error(chalk.red(`Unknown phase: ${phase}`));
-    console.error(chalk.gray(`Valid phases: ${Object.keys(PHASE_OUTPUTS).join(', ')}`));
-    process.exit(1);
-  }
-
-  const validation = runFeatureValidation(featurePath, { phase });
-  const { results, totalErrors, totalWarnings, totalFound } = validation;
-  const schemaWarnings = [];
-
-  if (options.json) {
-    const output = {
-      feature: featureName,
-      phase: validation.phase,
-      valid: validation.valid,
-      summary: {
-        files: results.length,
-        errors: totalErrors,
-        warnings: totalWarnings + schemaWarnings.length,
-        sectionsFound: totalFound,
-      },
-      results: results.map(r => ({
-        file: r.file,
-        exists: r.exists,
-        lineCount: r.lineCount,
-        errors: r.errors,
-        warnings: r.warnings,
-        sectionsFound: r.sections.found,
-        sectionsMissing: r.sections.missing,
-      })),
-      schemaWarnings,
-    };
-    console.log(JSON.stringify(output, null, 2));
-    return;
-  }
-
-  console.log(chalk.cyan('\n┌────────────────────────────────────────────────────────────┐'));
-  console.log(chalk.cyan('│                MORPH-SPEC FEATURE VALIDATOR                │'));
-  console.log(chalk.cyan('└────────────────────────────────────────────────────────────┘\n'));
-
-  console.log(chalk.white.bold(`Feature: ${featureName}`));
-  if (phase) console.log(chalk.gray(`Phase: ${phase}`));
-  console.log('');
-
-  for (const result of results) {
-    const symbol = result.exists
-      ? (result.errors.length === 0 ? '✅' : '❌')
-      : '⬜';
-    const name = result.exists
-      ? (result.errors.length === 0 ? chalk.green(result.file) : chalk.red(result.file))
-      : chalk.gray(result.file);
-
-    console.log(`${symbol} ${name}${result.exists ? chalk.gray(` (${result.lineCount} lines)`) : ''}`);
-
-    if (result.sections.found.length > 0 && (options.verbose || result.errors.length > 0)) {
-      result.sections.found.forEach(s => {
-        console.log(chalk.green(`   ✓ ${s}`));
-      });
-    }
-
-    result.errors.forEach(err => {
-      console.log(chalk.red(`   ✗ ${err}`));
-    });
-
-    result.warnings.forEach(warn => {
-      console.log(chalk.yellow(`   ⚠ ${warn}`));
-    });
-  }
-
-  console.log('');
-  console.log(chalk.gray('─'.repeat(60)));
-
-  if (totalErrors === 0) {
-    console.log(chalk.green(`\n✓ VALIDATION PASSED — ${results.filter(r => r.exists).length} files validated`));
-    if (totalWarnings > 0) {
-      console.log(chalk.yellow(`  ${totalWarnings} warning(s) — review recommended`));
-    }
-  } else {
-    console.log(chalk.red(`\n✗ VALIDATION FAILED — ${totalErrors} error(s), ${totalWarnings} warning(s)`));
-    console.log(chalk.yellow('  Fix errors before advancing to the next phase'));
-  }
-  console.log('');
-}
-
-export default validateFeatureCommand;