@polymorphism-tech/morph-spec 4.7.2 → 4.8.1

package/src/commands/templates/index.js

@@ -1,8 +1,4 @@
 /**
  * Template Commands
  */
-export { templateListCommand } from './template-list.js';
-export { templateShowCommand } from './template-show.js';
 export { templateRenderCommand } from './template-render.js';
-export { templateCustomizeCommand } from './template-customize.js';
-export { templateValidateCommand } from './template-validate.js';

package/src/commands/trust/trust.js

@@ -4,17 +4,13 @@
  * Usage:
  *   morph-spec trust status [feature]
  *   morph-spec trust set <feature> <level> [reason]
- *   morph-spec trust history
- *   morph-spec trust auto-calculate <feature>
  */
 
 import chalk from 'chalk';
 import {
   getTrust,
   setTrust,
-  clearTrustOverride,
   getTrustHistory,
-  autoCalculateTrust,
   TRUST_THRESHOLDS,
   AUTO_APPROVE_GATES
 } from '../../lib/trust/trust-manager.js';
@@ -108,98 +104,10 @@ export async function trustSetCommand(featureName, level, reason, options) {
     console.log(`  Level:         ${result.level}`);
     console.log(`  Auto-approves: ${result.autoApprove.join(', ') || 'none'}`);
     console.log(`  Reason:        ${result.reason}`);
-    console.log(chalk.gray('\n  Note: Use "trust auto-calculate" to revert to calculated trust.\n'));
+    console.log(chalk.gray('\n  Note: Trust reverts to calculated level after next checkpoint.\n'));
   } catch (err) {
     console.error(chalk.red(`Error: ${err.message}`));
     process.exit(1);
   }
 }
 
-/**
- * Trust history — table of all features with checkpoint pass rates
- */
-export async function trustHistoryCommand(options) {
-  const history = getTrustHistory();
-
-  console.log(chalk.bold('\n  Trust History'));
-  console.log('  ' + '─'.repeat(80));
-
-  if (history.length === 0) {
-    console.log(chalk.gray('  No features found.\n'));
-    return;
-  }
-
-  for (const f of history) {
-    const levelColor = f.level === 'maximum' ? chalk.green
-      : f.level === 'high' ? chalk.cyan
-      : f.level === 'medium' ? chalk.yellow
-      : chalk.red;
-
-    console.log(`\n  ${chalk.bold(f.feature)}`);
-    console.log(`    Trust:       ${levelColor(f.level)} (${Math.round(f.passRate * 100)}% pass rate)`);
-    console.log(`    Checkpoints: ${f.checkpointsPassed}/${f.checkpointsTotal} passed`);
-    console.log(`    Phase:       ${f.phase || 'N/A'} | Status: ${f.status || 'N/A'}`);
-    console.log(`    Source:      ${f.source}`);
-
-    if (f.autoApprove.length > 0) {
-      console.log(`    Auto-approves: ${chalk.green(f.autoApprove.join(', '))}`);
-    }
-  }
-
-  console.log('\n  ' + '─'.repeat(80));
-  console.log(chalk.gray(`  Total features: ${history.length}\n`));
-}
-
-/**
- * Trust auto-calculate — recalculate from checkpoint history
- */
-export async function trustAutoCalculateCommand(featureName, options) {
-  if (!featureName) {
-    console.error(chalk.red('Usage: morph-spec trust auto-calculate <feature>'));
-    process.exit(1);
-  }
-
-  try {
-    const result = autoCalculateTrust(featureName);
-
-    const levelColor = result.level === 'maximum' ? chalk.green
-      : result.level === 'high' ? chalk.cyan
-      : result.level === 'medium' ? chalk.yellow
-      : chalk.red;
-
-    console.log(chalk.bold(`\n  Trust Calculated — ${featureName}`));
-    console.log('  ' + '─'.repeat(40));
-    console.log(`  Level:         ${levelColor(result.level.toUpperCase())}`);
-    console.log(`  Pass Rate:     ${Math.round(result.passRate * 100)}%`);
-    console.log(`  Checkpoints:   ${result.passed}/${result.total} passed`);
-    console.log(`  Auto-approves: ${result.autoApprove.join(', ') || 'none'}`);
-
-    if (result.level === 'maximum') {
-      console.log(chalk.green('\n  ✓ Feature is eligible for zero-touch execution!'));
-      console.log(chalk.gray('  All gates will be auto-approved.\n'));
-    } else {
-      const nextLevel = result.passRate < TRUST_THRESHOLDS.medium ? 'medium'
-        : result.passRate < TRUST_THRESHOLDS.high ? 'high'
-        : 'maximum';
-      const needed = Math.ceil(TRUST_THRESHOLDS[nextLevel] * result.total) - result.passed;
-      console.log(chalk.gray(`\n  Next level: ${nextLevel} (need ${needed} more passing checkpoints)\n`));
-    }
-  } catch (err) {
-    console.error(chalk.red(`Error: ${err.message}`));
-    process.exit(1);
-  }
-}
-
-/**
- * Trust clear — remove manual override
- */
-export async function trustClearCommand(featureName, options) {
-  if (!featureName) {
-    console.error(chalk.red('Usage: morph-spec trust clear <feature>'));
-    process.exit(1);
-  }
-
-  clearTrustOverride(featureName);
-  console.log(chalk.green(`\n✓ Manual trust override cleared for ${featureName}`));
-  console.log(chalk.gray('  Trust will now be calculated from checkpoint history.\n'));
-}

package/src/commands/utils/index.js

@@ -1,7 +1,3 @@
 /**
- * Utility Commands
+ * Utility Commands — no active commands after CLI simplification
  */
-export { troubleshootCommand } from './troubleshoot.js';
-export { sessionSummaryCommand } from './session-summary.js';
-export { migrateStateCommand } from './migrate-state.js';
-export { upgradeCommand } from './upgrade.js';

package/src/commands/validation/index.js

@@ -1,8 +1,4 @@
 /**
  * Validation Commands
  */
-export { validateBlazorCommand } from './validate-blazor.js';
-export { validateBlazorStateCommand } from './validate-blazor-state.js';
-export { validateCssCommand } from './validate-css.js';
-export { analyzeBlazorConcurrencyCommand } from './analyze-blazor-concurrency.js';
-export { lintFluentCommand } from './lint-fluent.js';
+export { validateFeatureCommand } from './validate-feature.js';

package/src/core/registry/command-registry.js

@@ -1,302 +1,28 @@
 /**
- * Command Registry - Auto-Discovery System
+ * Command Registry — DEPRECATED
  *
- * Metadata-driven command loading eliminates hardcoded imports.
- * Enables dynamic command registration and discovery.
+ * This module is no longer used. CLI commands are registered directly
+ * in bin/morph-spec.js via Commander.js. This file is kept as an empty
+ * stub to prevent import errors from any remaining references.
  *
  * @module command-registry
+ * @deprecated
  */
 
-/**
- * Command Metadata Registry
- *
- * Maps command names to their module paths and metadata.
- * Auto-discovered from src/commands/{category}/ structure.
- */
-export const commandMetadata = {
-  // Feature Management
-  'create-story': {
-    category: 'feature',
-    description: 'Create a new user story with acceptance criteria',
-    module: () => import('../../commands/feature/create-story.js'),
-    exportName: 'createStoryCommand',
-  },
-  'shard-spec': {
-    category: 'feature',
-    description: 'Shard a large spec into manageable chunks',
-    module: () => import('../../commands/feature/shard-spec.js'),
-    exportName: 'shardSpecCommand',
-  },
-  'sprint-status': {
-    category: 'feature',
-    description: 'Show sprint progress and completion status',
-    module: () => import('../../commands/feature/sprint-status.js'),
-    exportName: 'sprintStatusCommand',
-  },
-
-  // State Management
-  'state': {
-    category: 'state',
-    description: 'Manage feature state (init, get, set, list)',
-    module: () => import('../../commands/state/state.js'),
-    exportName: 'stateCommand',
-  },
-  'advance-phase': {
-    category: 'state',
-    description: 'Advance feature to next phase with validation',
-    module: () => import('../../commands/state/advance-phase.js'),
-    exportName: 'advancePhaseCommand',
-  },
-  'rollback-phase': {
-    category: 'state',
-    description: 'Rollback feature to previous phase',
-    module: () => import('../../commands/state/rollback-phase.js'),
-    exportName: 'rollbackPhaseCommand',
-  },
-  'approve': {
-    category: 'state',
-    description: 'Approve or reject approval gates',
-    module: () => import('../../commands/state/approve.js'),
-    exportName: 'approveCommand',
-  },
-  'validate-phase': {
-    category: 'state',
-    description: 'Validate phase transition requirements',
-    module: () => import('../../commands/state/validate-phase.js'),
-    exportName: 'validatePhaseCommand',
-  },
-
-  // Generation
-  'generate': {
-    category: 'generation',
-    description: 'Generate design system files from spec',
-    module: () => import('../../commands/generation/generate.js'),
-    exportName: 'generateCommand',
-  },
-  'generate-context': {
-    category: 'generation',
-    description: 'Generate CONTEXT.md for LLM agents',
-    module: () => import('../../commands/generation/generate-context.js'),
-    exportName: 'generateContextCommand',
-  },
-
-  // Validation
-  'validate-blazor': {
-    category: 'validation',
-    description: 'Validate Blazor components and patterns',
-    module: () => import('../../commands/validation/validate-blazor.js'),
-    exportName: 'validateBlazorCommand',
-  },
-  'validate-blazor-state': {
-    category: 'validation',
-    description: 'Validate Blazor state management patterns',
-    module: () => import('../../commands/validation/validate-blazor-state.js'),
-    exportName: 'validateBlazorStateCommand',
-  },
-  'validate-css': {
-    category: 'validation',
-    description: 'Validate CSS classes and design system',
-    module: () => import('../../commands/validation/validate-css.js'),
-    exportName: 'validateCssCommand',
-  },
-  'analyze-blazor-concurrency': {
-    category: 'validation',
-    description: 'Analyze Blazor concurrency issues',
-    module: () => import('../../commands/validation/analyze-blazor-concurrency.js'),
-    exportName: 'analyzeBlazorConcurrencyCommand',
-  },
-  'lint-fluent': {
-    category: 'validation',
-    description: 'Lint Fluent UI Blazor usage',
-    module: () => import('../../commands/validation/lint-fluent.js'),
-    exportName: 'lintFluentCommand',
-  },
-
-  // Templates
-  'template-list': {
-    category: 'templates',
-    description: 'List available templates',
-    module: () => import('../../commands/templates/template-list.js'),
-    exportName: 'templateListCommand',
-  },
-  'template-show': {
-    category: 'templates',
-    description: 'Show template details and preview',
-    module: () => import('../../commands/templates/template-show.js'),
-    exportName: 'templateShowCommand',
-  },
-  'template-render': {
-    category: 'templates',
-    description: 'Render template with variables',
-    module: () => import('../../commands/templates/template-render.js'),
-    exportName: 'templateRenderCommand',
-  },
-  'template-customize': {
-    category: 'templates',
-    description: 'Customize template for stack',
-    module: () => import('../../commands/templates/template-customize.js'),
-    exportName: 'templateCustomizeCommand',
-  },
-  'template-validate': {
-    category: 'templates',
-    description: 'Validate template structure',
-    module: () => import('../../commands/templates/template-validate.js'),
-    exportName: 'templateValidateCommand',
-  },
+export const commandMetadata = {};
 
-  // Project
-  'init': {
-    category: 'project',
-    description: 'Initialize MORPH-SPEC in current directory',
-    module: () => import('../../commands/project/init.js'),
-    exportName: 'initCommand',
-  },
-  'doctor': {
-    category: 'project',
-    description: 'Check project health and configuration',
-    module: () => import('../../commands/project/doctor.js'),
-    exportName: 'doctorCommand',
-  },
-  'detect': {
-    category: 'project',
-    description: 'Auto-detect project stack and configuration',
-    module: () => import('../../commands/project/detect.js'),
-    exportName: 'detectCommand',
-  },
-  'detect-workflow': {
-    category: 'project',
-    description: 'Detect appropriate workflow for request',
-    module: () => import('../../commands/project/detect-workflow.js'),
-    exportName: 'detectWorkflowCommand',
-  },
-  'detect-agents': {
-    category: 'project',
-    description: 'Detect required agents for request',
-    module: () => import('../../commands/project/detect-agents.js'),
-    exportName: 'detectAgentsCommand',
-  },
-  'sync': {
-    category: 'project',
-    description: 'Sync standards from framework',
-    module: () => import('../../commands/project/sync.js'),
-    exportName: 'syncCommand',
-  },
-  'update': {
-    category: 'project',
-    description: 'Update MORPH-SPEC framework',
-    module: () => import('../../commands/project/update.js'),
-    exportName: 'updateCommand',
-  },
-
-  // Learning
-  'capture-pattern': {
-    category: 'learning',
-    description: 'Capture learned pattern to memory',
-    module: () => import('../../commands/learning/capture-pattern.js'),
-    exportName: 'capturePatternCommand',
-  },
-  'search-patterns': {
-    category: 'learning',
-    description: 'Search learned patterns',
-    module: () => import('../../commands/learning/search-patterns.js'),
-    exportName: 'searchPatternsCommand',
-  },
-
-  // Tasks
-  'task': {
-    category: 'tasks',
-    description: 'Manage tasks (done, start, next)',
-    module: () => import('../../commands/tasks/task.js'),
-    exportName: 'taskCommand',
-  },
-
-  // Agents
-  'spawn-team': {
-    category: 'agents',
-    description: 'Spawn agent team for feature',
-    module: () => import('../../commands/agents/spawn-team.js'),
-    exportName: 'spawnTeamCommand',
-  },
-
-  // Utils
-  'troubleshoot': {
-    category: 'utils',
-    description: 'Troubleshoot common errors',
-    module: () => import('../../commands/utils/troubleshoot.js'),
-    exportName: 'troubleshootCommand',
-  },
-  'session-summary': {
-    category: 'utils',
-    description: 'Generate session summary and recap',
-    module: () => import('../../commands/utils/session-summary.js'),
-    exportName: 'sessionSummaryCommand',
-  },
-  'migrate-state': {
-    category: 'utils',
-    description: 'Migrate state to new version',
-    module: () => import('../../commands/utils/migrate-state.js'),
-    exportName: 'migrateStateCommand',
-  },
-  'upgrade': {
-    category: 'utils',
-    description: 'Upgrade project to latest framework',
-    module: () => import('../../commands/utils/upgrade.js'),
-    exportName: 'upgradeCommand',
-  },
-};
-
-/**
- * Load command dynamically
- *
- * @param {string} commandName - Command name (e.g., 'init', 'template-list')
- * @returns {Promise<Function>} Command function
- */
 export async function loadCommand(commandName) {
-  const meta = commandMetadata[commandName];
-
-  if (!meta) {
-    const availableCommands = Object.keys(commandMetadata).join(', ');
-    throw new Error(`Unknown command: ${commandName}\n\nAvailable: ${availableCommands}`);
-  }
-
-  const module = await meta.module();
-  const commandFn = module[meta.exportName] || module.default;
-
-  if (!commandFn) {
-    throw new Error(`Command '${commandName}' module does not export '${meta.exportName}'`);
-  }
-
-  return commandFn;
+  throw new Error(`Command registry is deprecated. Use bin/morph-spec.js directly.`);
 }
 
-/**
- * Get all command names
- *
- * @returns {string[]} Array of command names
- */
 export function getAllCommandNames() {
-  return Object.keys(commandMetadata);
+  return [];
 }
 
-/**
- * Get commands by category
- *
- * @param {string} category - Category name
- * @returns {string[]} Array of command names in category
- */
-export function getCommandsByCategory(category) {
-  return Object.entries(commandMetadata)
-    .filter(([_, meta]) => meta.category === category)
-    .map(([name, _]) => name);
+export function getCommandsByCategory() {
+  return [];
 }
 
-/**
- * Get all categories
- *
- * @returns {string[]} Array of unique category names
- */
 export function getAllCategories() {
-  const categories = new Set();
-  Object.values(commandMetadata).forEach(meta => categories.add(meta.category));
-  return Array.from(categories).sort();
+  return [];
 }

package/src/core/state/state-manager.js

@@ -5,7 +5,7 @@
  * Used both by CLI commands and internal automation.
  */
 
-import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
+import { readFileSync, writeFileSync, renameSync, existsSync, mkdirSync } from 'fs';
 import { join, dirname } from 'path';
 import { detectWorkflow } from '../workflows/workflow-detector.js';
 import { getAllOutputPaths, getOutputPath } from '../paths/output-schema.js';
@@ -137,7 +137,10 @@ export function saveState(state) {
     mkdirSync(stateDir, { recursive: true });
   }
 
-  writeFileSync(statePath, JSON.stringify(state, null, 2), 'utf8');
+  // Atomic write: write to temp then rename to avoid partial-write corruption
+  const tmpPath = statePath + '.tmp';
+  writeFileSync(tmpPath, JSON.stringify(state, null, 2), 'utf8');
+  renameSync(tmpPath, statePath);
 }
 
 /**

package/src/lib/detectors/index.js

@@ -1,87 +1,81 @@
-/**
- * MORPH-SPEC Detectors - Main Orchestrator
- *
- * Coordinates all detection modules to build a complete picture of the project.
- */
-
-import { detectStructure } from './structure-detector.js';
-import { detectConfig } from './config-detector.js';
-import { analyzeConversation } from './conversation-analyzer.js';
-import { generateStandards } from './standards-generator.js';
-
-// Re-export individual detectors
-export * from './design-system-detector.js';
-
-/**
- * Main detection orchestrator
- * @param {string} projectPath - Path to project root
- * @param {Object} options - Detection options
- * @returns {Promise<Object>} Detection results
- */
-export async function detectProject(projectPath, options = {}) {
-  const results = {
-    path: projectPath,
-    timestamp: new Date().toISOString(),
-    structure: null,
-    config: null,
-    conversation: null,
-    inferred: null
-  };
-
-  try {
-    // 1. Detect structure (stack, architecture, patterns)
-    if (options.structure !== false) {
-      results.structure = await detectStructure(projectPath);
-    }
-
-    // 2. Detect config (technologies, dependencies, versions)
-    if (options.config !== false) {
-      results.config = await detectConfig(projectPath);
-    }
-
-    // 3. Analyze conversation history (if available)
-    if (options.conversation !== false) {
-      results.conversation = await analyzeConversation(projectPath);
-    }
-
-    // 4. Generate inferred standards
-    if (options.generateStandards !== false) {
-      results.inferred = await generateStandards(results);
-    }
-
-    return results;
-  } catch (error) {
-    throw new Error(`Detection failed: ${error.message}`);
-  }
-}
-
-/**
- * Get detection summary
- * @param {Object} results - Detection results
- * @returns {string} Human-readable summary
- */
-export function getDetectionSummary(results) {
-  const { structure, config } = results;
-
-  const lines = [
-    '## Detection Summary',
-    '',
-    '### Stack',
-    `- **Type**: ${structure?.stack || 'unknown'}`,
-    `- **Architecture**: ${structure?.architecture || 'unknown'}`,
-    ...(structure?.uiLibrary ? [`- **UI Library**: ${structure.uiLibrary}`] : []),
-    '',
-    '### Technologies',
-    `- **Language**: ${config?.language || 'unknown'}`,
-    `- **Version**: ${config?.version || 'unknown'}`,
-    `- **Package Manager**: ${config?.packageManager || 'unknown'}`,
-    '',
-    '### Patterns Detected',
-    ...(structure?.patterns || []).map(p => `- ${p}`),
-    '',
-    '### Recommendations',
-    ...(results.inferred?.recommendations || []).map(r => `- ${r}`)
-  ];
-
-  return lines.join('\n');
-}
+/**
+ * MORPH-SPEC Detectors - Main Orchestrator
+ *
+ * Coordinates all detection modules to build a complete picture of the project.
+ */
+
+import { detectStructure } from './structure-detector.js';
+import { detectConfig } from './config-detector.js';
+import { generateStandards } from './standards-generator.js';
+
+// Re-export individual detectors
+export * from './design-system-detector.js';
+
+/**
+ * Main detection orchestrator
+ * @param {string} projectPath - Path to project root
+ * @param {Object} options - Detection options
+ * @returns {Promise<Object>} Detection results
+ */
+export async function detectProject(projectPath, options = {}) {
+  const results = {
+    path: projectPath,
+    timestamp: new Date().toISOString(),
+    structure: null,
+    config: null,
+    conversation: null,
+    inferred: null
+  };
+
+  try {
+    // 1. Detect structure (stack, architecture, patterns)
+    if (options.structure !== false) {
+      results.structure = await detectStructure(projectPath);
+    }
+
+    // 2. Detect config (technologies, dependencies, versions)
+    if (options.config !== false) {
+      results.config = await detectConfig(projectPath);
+    }
+
+    // 3. Generate inferred standards
+    if (options.generateStandards !== false) {
+      results.inferred = await generateStandards(results);
+    }
+
+    return results;
+  } catch (error) {
+    throw new Error(`Detection failed: ${error.message}`);
+  }
+}
+
+/**
+ * Get detection summary
+ * @param {Object} results - Detection results
+ * @returns {string} Human-readable summary
+ */
+export function getDetectionSummary(results) {
+  const { structure, config } = results;
+
+  const lines = [
+    '## Detection Summary',
+    '',
+    '### Stack',
+    `- **Type**: ${structure?.stack || 'unknown'}`,
+    `- **Architecture**: ${structure?.architecture || 'unknown'}`,
+    ...(structure?.uiLibrary ? [`- **UI Library**: ${structure.uiLibrary}`] : []),
+    '',
+    '### Technologies',
+    `- **Language**: ${config?.language || 'unknown'}`,
+    `- **Version**: ${config?.version || 'unknown'}`,
+    `- **Package Manager**: ${config?.packageManager || 'unknown'}`,
+    '',
+    '### Patterns Detected',
+    ...(structure?.patterns || []).map(p => `- ${p}`),
+    '',
+    '### Recommendations',
+    ...(results.inferred?.recommendations || []).map(r => `- ${r}`)
+  ];
+
+  return lines.join('\n');
+}