@polymorphism-tech/morph-spec 4.3.6 → 4.5.0

package/src/commands/context/context-prime.js

@@ -1,63 +0,0 @@
-/**
- * Context Prime CLI command — Load minimal context priming files
- *
- * Usage:
- *   morph-spec prime feature   (outputs feature-prime.md to stdout)
- *   morph-spec prime bug
- *   morph-spec prime refactor
- *   morph-spec prime design
- *   morph-spec prime infra
- */
-
-import chalk from 'chalk';
-import { readFileSync, existsSync } from 'fs';
-import { join } from 'path';
-
-const PRIME_FILES = {
-  feature: '.morph/context/feature-prime.md',
-  bug: '.morph/context/bug-prime.md',
-  refactor: '.morph/context/refactor-prime.md',
-  design: '.morph/context/design-prime.md',
-  infra: '.morph/context/infra-prime.md'
-};
-
-const PRIME_TYPES = Object.keys(PRIME_FILES);
-
-export async function contextPrimeCommand(type, options) {
-  if (!type) {
-    console.log(chalk.cyan('\n  Available prime types:\n'));
-    for (const [key, path] of Object.entries(PRIME_FILES)) {
-      const exists = existsSync(join(process.cwd(), path));
-      const status = exists ? chalk.green('✓') : chalk.red('✗');
-      console.log(`  ${status} ${key.padEnd(10)} → ${path}`);
-    }
-    console.log('');
-    console.log(chalk.gray('  Usage: morph-spec prime <type>'));
-    console.log(chalk.gray('  Example: morph-spec prime feature\n'));
-    return;
-  }
-
-  if (!PRIME_TYPES.includes(type)) {
-    console.error(chalk.red(`Unknown prime type: ${type}`));
-    console.error(chalk.gray(`Valid types: ${PRIME_TYPES.join(', ')}`));
-    process.exit(1);
-  }
-
-  const filePath = join(process.cwd(), PRIME_FILES[type]);
-
-  if (!existsSync(filePath)) {
-    console.error(chalk.red(`Prime file not found: ${filePath}`));
-    console.error(chalk.gray('Run `morph-spec init` to initialize MORPH-SPEC files.'));
-    process.exit(1);
-  }
-
-  const content = readFileSync(filePath, 'utf8');
-
-  if (options.json) {
-    console.log(JSON.stringify({ type, path: filePath, content }));
-    return;
-  }
-
-  // Output to stdout — designed to be read into context
-  console.log(content);
-}

package/src/commands/context/core-four.js

@@ -1,54 +0,0 @@
-/**
- * Core Four CLI command — Context/Model/Prompt/Tools dashboard
- *
- * Usage:
- *   morph-spec core-four <feature>
- *   morph-spec core-four <feature> --json
- */
-
-import chalk from 'chalk';
-import { getCoreFour, formatCoreFour, initCoreFour } from '../../lib/context/core-four-tracker.js';
-import { loadState } from '../../core/state/state-manager.js';
-
-export async function coreFourCommand(featureName, options) {
-  try {
-    // Initialize with defaults if not already set
-    initCoreFour({
-      model: 'claude-sonnet-4-6',
-      contextWindow: 200000,
-      feature: featureName
-    });
-
-    // Try to populate context breakdown from feature state
-    try {
-      const state = loadState(false);
-      if (state?.features?.[featureName]) {
-        const feature = state.features[featureName];
-        // Attempt to estimate context breakdown from known files
-        const breakdown = {
-          'CLAUDE.md': 23000,
-          standards: feature.activeAgents ? feature.activeAgents.length * 500 : 0,
-          spec: feature.outputs?.includes('spec') ? 8000 : 0,
-          conversation: 5000,
-          other: 2000
-        };
-        const { updateContextBreakdown } = await import('../../lib/context/core-four-tracker.js');
-        updateContextBreakdown(breakdown);
-      }
-    } catch {
-      // Best-effort
-    }
-
-    if (options.json) {
-      const data = getCoreFour();
-      console.log(JSON.stringify(data, null, 2));
-      return;
-    }
-
-    console.log('\n' + formatCoreFour());
-    console.log('');
-  } catch (err) {
-    console.error(chalk.red(`Error: ${err.message}`));
-    process.exit(1);
-  }
-}

package/src/commands/generation/generate-context.js

@@ -1,40 +0,0 @@
-/**
- * @fileoverview Generate Context Command
- *
- * CLI: morph-spec generate context [feature]
- *
- * Generates CONTEXT.md (project-level) or CONTEXT-{feature}.md (feature-level)
- * with all relevant project data for Claude's consumption.
- *
- * @module generate-context
- */
-
-import { generateContext } from '../../lib/generators/context-generator.js';
-
-/**
- * Generate context files
- * @param {string} projectPath - Root path of the project
- * @param {string} featureName - Optional feature name
- * @returns {Promise<void>}
- */
-export async function generateContextCommand(projectPath, featureName = null) {
-  console.log('📄 Generating CONTEXT files...\n');
-
-  try {
-    const results = await generateContext(projectPath, featureName);
-
-    console.log('✅ Generated:');
-    console.log(`   - ${results.projectContext}`);
-
-    if (results.featureContext) {
-      console.log(`   - ${results.featureContext}`);
-    }
-
-    console.log('\n💡 Use these files to provide full context to Claude Code.');
-
-  } catch (err) {
-    console.error('❌ Error generating context:');
-    console.error(`   ${err.message}`);
-    process.exit(1);
-  }
-}

package/src/commands/project/detect-agents.js

@@ -1,207 +0,0 @@
-import { readFileSync } from 'fs';
-import { join, dirname } from 'path';
-import { fileURLToPath } from 'url';
-import chalk from 'chalk';
-import { logger } from '../../utils/logger.js';
-import { analyzeRequestComplexity } from '../../lib/analysis/complexity-analyzer.js';
-import { LearningSystem } from '../../lib/learning/learning-system.js';
-import { loadStandardsForAgent, getStandardsListForAgent } from '../../lib/standards/standards-context-injector.js';
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const frameworkRoot = join(__dirname, '..', '..', '..');
-
-function loadAgentsConfig() {
-  try {
-    const configPath = join(frameworkRoot, '.morph/config/agents.json');
-    const content = readFileSync(configPath, 'utf8');
-    return JSON.parse(content);
-  } catch (err) {
-    logger.error(`Failed to load agents config: ${err.message}`);
-    process.exit(1);
-  }
-}
-
-function detectAgents(userInput, config) {
-  const input = userInput.toLowerCase();
-
-  // MORPH 3.0 Hierarchical: agents is a flat object, not arrays
-  const allAgents = Object.entries(config.agents || {})
-    .filter(([id]) => !id.startsWith('_comment'))
-    .map(([id, agent]) => ({ id, ...agent }));
-
-  // Core agents = always_active agents (typically Tier 1)
-  const coreAgents = allAgents.filter(a => a.always_active === true);
-  const coreIds = coreAgents.map(a => a.id);
-
-  // Specialist agents = keyword-matched agents
-  const specialistMatches = [];
-
-  for (const agent of allAgents) {
-    if (agent.always_active) continue; // Skip core agents
-
-    // MORPH 3.0.1: Check negative keywords first — if any match, skip agent entirely
-    const negativeKeywords = agent.negativeKeywords || [];
-    const hasNegativeMatch = negativeKeywords.some(neg =>
-      input.includes(neg.toLowerCase())
-    );
-    if (hasNegativeMatch) continue;
-
-    // MORPH 3.0: keywords is directly on agent, not nested in autoActivation
-    const keywords = agent.keywords || [];
-    const matchedKeywords = [];
-
-    for (const keyword of keywords) {
-      if (input.includes(keyword.toLowerCase())) {
-        matchedKeywords.push(keyword);
-      }
-    }
-
-    if (matchedKeywords.length > 0) {
-      specialistMatches.push({
-        id: agent.id,
-        name: agent.title || agent.id, // Use title as name
-        emoji: agent.teammate?.icon || '🤖',
-        matchedKeywords,
-        matchCount: matchedKeywords.length
-      });
-    }
-  }
-
-  specialistMatches.sort((a, b) => b.matchCount - a.matchCount);
-
-  const specialistIds = specialistMatches.map(m => m.id);
-  const allIds = [...new Set([...coreIds, ...specialistIds])];
-
-  return {
-    core: coreIds,
-    specialists: specialistIds,
-    all: allIds,
-    matches: specialistMatches,
-    input: userInput
-  };
-}
-
-function formatVerbose(result) {
-  logger.blank();
-  logger.header('AGENT DETECTION RESULT');
-  logger.info(`Input: ${chalk.white(result.input)}`);
-  logger.blank();
-
-  logger.header('CORE AGENTS (always active)');
-  result.core.forEach(id => {
-    logger.info(`  ${chalk.green('✓')} ${id}`);
-  });
-  logger.blank();
-
-  if (result.matches.length > 0) {
-    logger.header('SPECIALIST AGENTS (keyword matched)');
-    result.matches.forEach(match => {
-      logger.info(`  ${match.emoji} ${chalk.yellow(match.name)} (${match.matchCount} matches)`);
-      logger.dim(`     Keywords: ${match.matchedKeywords.join(', ')}`);
-    });
-  } else {
-    logger.dim('  No specialist agents matched');
-  }
-
-  logger.blank();
-  logger.info(`Total: ${chalk.cyan(result.all.length)} agents activated`);
-  logger.blank();
-}
-
-export { detectAgents, loadAgentsConfig };
-
-export function detectAgentsCommand(input, options) {
-  const userInput = Array.isArray(input) ? input.join(' ') : input;
-
-  if (!userInput) {
-    logger.error('User input is required');
-    logger.dim('Usage: morph-spec detect-agents "your feature description"');
-    process.exit(1);
-  }
-
-  const config = loadAgentsConfig();
-  const result = detectAgents(userInput, config);
-
-  // Stack-aware filtering: penalize stack-mismatched agents
-  try {
-    const projectConfigPath = join(process.cwd(), '.morph/config/config.json');
-    const projectConfig = JSON.parse(readFileSync(projectConfigPath, 'utf8'));
-    const stack = projectConfig?.project?.stack || projectConfig?.project?.language || '';
-    const isJsStack = stack === 'nodejs' || stack === 'javascript' || stack === 'nextjs';
-
-    if (isJsStack) {
-      const dotnetKeywords = ['dotnet', '.net', 'csharp', 'c#', 'blazor', 'razor', 'azure', 'bicep',
-        'ef core', 'entity framework', 'hangfire', 'mudblazor', 'fluent ui', 'asp.net'];
-      const hasExplicitDotnetRequest = dotnetKeywords.some(k => userInput.toLowerCase().includes(k));
-
-      if (!hasExplicitDotnetRequest) {
-        const dotnetAgents = new Set([
-          'dotnet-senior', 'azure-architect', 'ef-modeler', 'bicep-architect',
-          'blazor-builder', 'blazor-concurrency-validator', 'hangfire-orchestrator',
-          'azure-deploy-specialist'
-        ]);
-        result.core = result.core.filter(id => !dotnetAgents.has(id));
-        result.specialists = result.specialists.filter(id => !dotnetAgents.has(id));
-        result.all = result.all.filter(id => !dotnetAgents.has(id));
-        result.matches = result.matches.filter(m => !dotnetAgents.has(m.id));
-      }
-    }
-  } catch {
-    // Config not found or unreadable — skip stack filtering
-  }
-
-  // Enrich with complexity analysis
-  try {
-    result.complexity = analyzeRequestComplexity(userInput);
-    result.suggestedWorkflow = result.complexity.workflow;
-  } catch {
-    result.complexity = null;
-    result.suggestedWorkflow = 'standard';
-  }
-
-  // Enrich with learning suggestions
-  try {
-    const learner = new LearningSystem('.');
-    result.learningSuggestions = learner.getAllSuggestions();
-  } catch {
-    result.learningSuggestions = null;
-  }
-
-  // Enrich with skill paths for each detected agent
-  const allAgents = Object.entries(config.agents || {})
-    .filter(([id]) => !id.startsWith('_'))
-    .map(([id, agent]) => ({ id, ...agent }));
-  result.skillPaths = result.all
-    .map(id => {
-      const agent = allAgents.find(a => a.id === id);
-      return agent?.skillPath || null;
-    })
-    .filter(Boolean);
-
-  // Enrich with standards context when JSON output requested
-  if (options.json) {
-    const projectPath = process.cwd();
-    result.standardsSummary = {};
-
-    for (const agentId of result.all) {
-      const standardsList = getStandardsListForAgent(agentId);
-      const { fullContent } = loadStandardsForAgent(agentId, projectPath);
-
-      result.standardsSummary[agentId] = {
-        standards: standardsList,
-        fullContent: fullContent,
-        count: standardsList.length
-      };
-    }
-  }
-
-  if (options.json) {
-    console.log(JSON.stringify(result, null, 2));
-  } else if (options.verbose) {
-    formatVerbose(result);
-  } else if (options.idsOnly) {
-    result.all.forEach(id => console.log(id));
-  } else {
-    console.log(JSON.stringify(result.all));
-  }
-}

package/src/commands/project/detect-workflow.js

@@ -1,174 +0,0 @@
-/**
- * MORPH-SPEC Detect Workflow Command
- *
- * Analyzes a feature request and detects the most appropriate workflow
- *
- * Usage:
- *   morph-spec detect-workflow "add pagination to users table"
- */
-
-import chalk from 'chalk';
-import { detectWorkflow, getWorkflowConfig } from '../../core/workflows/workflow-detector.js';
-
-/**
- * Main command handler
- * @param {Array<string>} input - User request words
- * @param {Object} options - Command options
- */
-export async function detectWorkflowCommand(input, options = {}) {
-  const userRequest = input.join(' ');
-
-  if (!userRequest || userRequest.trim().length === 0) {
-    console.log(chalk.red('\n✗ Error: Please provide a feature request'));
-    console.log(chalk.gray('\nUsage: morph-spec detect-workflow "add pagination to users table"\n'));
-    process.exit(1);
-  }
-
-  console.log(chalk.cyan('\n╔════════════════════════════════════════════════╗'));
-  console.log(chalk.cyan('║     MORPH-SPEC WORKFLOW DETECTION             ║'));
-  console.log(chalk.cyan('╚════════════════════════════════════════════════╝\n'));
-
-  console.log(chalk.gray('Analyzing request:'), `"${userRequest}"`);
-  console.log('');
-
-  try {
-    // Detect workflow
-    const result = await detectWorkflow({
-      userRequest,
-      projectPath: options.projectPath || '.'
-    });
-
-    // Load workflow config for details
-    const workflowConfig = getWorkflowConfig(result.workflowId);
-
-    if (options.json) {
-      // JSON output mode
-      console.log(JSON.stringify({
-        workflowId: result.workflowId,
-        workflowName: workflowConfig?.name || result.workflowId,
-        confidence: result.confidence,
-        matchedKeywords: result.matchedKeywords,
-        estimatedComplexity: result.estimatedComplexity,
-        reasoning: result.reasoning,
-        alternativeWorkflows: result.alternativeWorkflows,
-        workflowConfig: workflowConfig
-      }, null, 2));
-      return;
-    }
-
-    // Human-readable output
-    const confidencePercent = Math.round(result.confidence * 100);
-    console.log(chalk.green(`✓ Detected Workflow: ${chalk.bold(workflowConfig?.name || result.workflowId)}`));
-    console.log(chalk.gray(`  Confidence: ${confidencePercent}%\n`));
-
-    // Criteria Match
-    console.log(chalk.cyan('Criteria Match:'));
-    if (result.matchedKeywords.length > 0) {
-      console.log(chalk.green(`  ✓ Keywords: ${result.matchedKeywords.join(', ')}`));
-    }
-    console.log(chalk.gray(`  • Estimated complexity: ${result.estimatedComplexity.files} files, ~${result.estimatedComplexity.lines} lines`));
-    if (result.estimatedComplexity.components > 0) {
-      console.log(chalk.gray(`  • Components: ${result.estimatedComplexity.components}`));
-    }
-    if (result.estimatedComplexity.hasInfra) {
-      console.log(chalk.yellow(`  ⚠ Infrastructure keywords detected`));
-    }
-    console.log('');
-
-    // Workflow Details
-    if (workflowConfig) {
-      console.log(chalk.cyan('Workflow Description:'));
-      console.log(chalk.gray(`  ${workflowConfig.description}\n`));
-
-      // Phases to Run
-      console.log(chalk.cyan('Phases to Run:'));
-      const phasesToRun = workflowConfig.phases.run || [];
-      phasesToRun.forEach((phase, index) => {
-        const pausePoint = workflowConfig.pausePoints?.find(p => p.phase === phase);
-        const pauseIndicator = pausePoint ? chalk.yellow(' ⏸️  Pause for approval') : '';
-        console.log(chalk.white(`  ${index + 1}. ${phase.toUpperCase()}${pauseIndicator}`));
-        if (pausePoint) {
-          console.log(chalk.gray(`     Question: "${pausePoint.question}"`));
-        }
-      });
-      console.log('');
-
-      // Phases Skipped
-      if (workflowConfig.phases.skip && workflowConfig.phases.skip.length > 0) {
-        console.log(chalk.cyan('Phases Skipped:'));
-        workflowConfig.phases.skip.forEach(phase => {
-          const reason = getSkipReason(phase, workflowConfig);
-          console.log(chalk.gray(`  ✗ ${phase.toUpperCase()}${reason ? ` - ${reason}` : ''}`));
-        });
-        console.log('');
-      }
-
-      // Combined Phases
-      if (workflowConfig.phases.combined && Object.keys(workflowConfig.phases.combined).length > 0) {
-        console.log(chalk.cyan('Combined Phases:'));
-        for (const [combinedName, phases] of Object.entries(workflowConfig.phases.combined)) {
-          console.log(chalk.gray(`  → ${combinedName.toUpperCase()} combines: ${phases.join(', ')}`));
-        }
-        console.log('');
-      }
-
-      // Required Outputs
-      if (workflowConfig.outputs?.required && workflowConfig.outputs.required.length > 0) {
-        console.log(chalk.cyan('Required Outputs:'));
-        workflowConfig.outputs.required.forEach(output => {
-          console.log(chalk.white(`  • ${output}`));
-        });
-        console.log('');
-      }
-    }
-
-    // Alternative Workflows
-    if (result.alternativeWorkflows.length > 0) {
-      console.log(chalk.cyan('Alternative Workflows:'));
-      result.alternativeWorkflows.forEach(alt => {
-        const altPercent = Math.round(alt.confidence * 100);
-        console.log(chalk.gray(`  - ${alt.workflowId} (${altPercent}%): ${alt.reason}`));
-      });
-      console.log('');
-    }
-
-    // How to Override
-    console.log(chalk.cyan('To override detected workflow:'));
-    console.log(chalk.white(`  morph-spec state set <feature-name> workflow <workflow-id>`));
-    console.log('');
-
-    console.log(chalk.gray('─'.repeat(50)));
-    console.log(chalk.gray('Available workflows: fast-track, standard, full-morph, design-impl, ui-refresh'));
-    console.log('');
-
-  } catch (error) {
-    console.log(chalk.red('\n✗ Workflow detection failed:'));
-    console.log(chalk.red(error.message));
-    if (options.verbose) {
-      console.log(chalk.gray('\nStack trace:'));
-      console.log(chalk.gray(error.stack));
-    }
-    console.log('');
-    process.exit(1);
-  }
-}
-
-/**
- * Get skip reason for a phase
- * @param {string} phase - Phase name
- * @param {Object} workflowConfig - Workflow config
- * @returns {string} Skip reason
- */
-function getSkipReason(phase, workflowConfig) {
-  const reasons = {
-    'setup': 'context already loaded',
-    'uiux': 'no significant UI changes',
-    'clarify': 'spec is clear for this type',
-    'sync': 'tactical decisions, not strategic',
-    'proposal': 'combined into quick-analysis',
-    'design': 'design not needed for visual-only changes',
-    'tasks': 'simple enough for direct implementation'
-  };
-
-  return reasons[phase] || '';
-}

package/src/commands/threads/thread-template.js

@@ -1,103 +0,0 @@
-/**
- * Thread Template CLI command — Thread type management
- *
- * Usage:
- *   morph-spec thread-template list
- *   morph-spec thread-template use <type> --feature=<feature>
- */
-
-import chalk from 'chalk';
-import { THREAD_TYPES } from '../../lib/threads/thread-manager.js';
-
-const THREAD_TYPE_INFO = {
-  [THREAD_TYPES.BASE]: {
-    name: 'B-Thread (Base)',
-    description: 'Standard single-agent thread. Sequential execution, all approval gates required.',
-    useCase: 'Default for simple and medium features',
-    phases: 'All standard phases',
-    approvalGates: 'Manual (all)',
-    maxConcurrent: 1
-  },
-  [THREAD_TYPES.PARALLEL]: {
-    name: 'P-Thread (Parallel)',
-    description: 'Multiple agents run simultaneously on different feature domains.',
-    useCase: 'Full-stack features with independent backend/frontend/infra work',
-    phases: 'All phases (parallel IMPLEMENT)',
-    approvalGates: 'Manual (all)',
-    maxConcurrent: 5
-  },
-  [THREAD_TYPES.FUSION]: {
-    name: 'F-Thread (Fusion)',
-    description: 'N agents independently generate solutions; best-of-N result is selected.',
-    useCase: 'High-uncertainty decisions, critical architecture choices, prototype evaluation',
-    phases: 'DESIGN → parallel IMPLEMENT → AGGREGATE → SYNC',
-    approvalGates: 'Manual select (or auto best-of-n)',
-    maxConcurrent: 3
-  },
-  [THREAD_TYPES.LONG_RUNNING]: {
-    name: 'L-Thread (Long-Running)',
-    description: 'Autonomous agent with stop hooks every 30 minutes for validation.',
-    useCase: 'Large scope features (>10 files), autonomous implementation without interruption',
-    phases: 'IMPLEMENT (continuous) with periodic validation',
-    approvalGates: 'Auto (stop hooks validate)',
-    maxConcurrent: 1
-  },
-  [THREAD_TYPES.ZERO_TOUCH]: {
-    name: 'Z-Thread (Zero-Touch)',
-    description: 'Fully autonomous execution. Auto-approves all gates, auto-commits on success.',
-    useCase: 'Maximum-trust features with >95% checkpoint pass rate',
-    phases: 'All phases (auto-approved)',
-    approvalGates: 'Auto (trust-based)',
-    maxConcurrent: 1
-  }
-};
-
-export async function threadTemplateListCommand(options) {
-  console.log(chalk.cyan('\n  Thread Types\n'));
-  console.log('  ' + '─'.repeat(70));
-
-  for (const [type, info] of Object.entries(THREAD_TYPE_INFO)) {
-    console.log(`\n  ${chalk.bold(info.name)}`);
-    console.log(`  ${info.description}`);
-    console.log(`  ${chalk.gray('Use case:')} ${info.useCase}`);
-    console.log(`  ${chalk.gray('Phases:')} ${info.phases}`);
-    console.log(`  ${chalk.gray('Gates:')} ${info.approvalGates}`);
-    console.log(`  ${chalk.gray('Max concurrent:')} ${info.maxConcurrent}`);
-  }
-
-  console.log('\n  ' + '─'.repeat(70));
-  console.log(chalk.gray('\n  Set thread type: morph-spec thread-template use <type> --feature=<feature>\n'));
-}
-
-export async function threadTemplateUseCommand(type, options) {
-  if (!options.feature) {
-    console.error(chalk.red('--feature is required'));
-    process.exit(1);
-  }
-
-  if (!THREAD_TYPE_INFO[type]) {
-    console.error(chalk.red(`Unknown thread type: ${type}`));
-    console.error(chalk.gray(`Valid types: ${Object.keys(THREAD_TYPE_INFO).join(', ')}`));
-    process.exit(1);
-  }
-
-  const info = THREAD_TYPE_INFO[type];
-
-  // Special checks
-  if (type === THREAD_TYPES.ZERO_TOUCH) {
-    console.log(chalk.yellow('\n  ⚠ Z-Thread requires maximum trust level (>95% checkpoint pass rate)'));
-    console.log(chalk.gray('  Check trust: morph-spec trust status\n'));
-  }
-
-  // Update feature state with thread type
-  try {
-    const { updateFeature } = await import('../../core/state/state-manager.js');
-    await updateFeature(options.feature, 'threadType', type);
-    console.log(chalk.green(`\n  ✓ Thread type set: ${type} for feature: ${options.feature}`));
-    console.log(`  ${info.name}: ${info.description}`);
-    console.log('');
-  } catch (err) {
-    console.error(chalk.red(`  Error updating state: ${err.message}`));
-    process.exit(1);
-  }
-}