@polymorphism-tech/morph-spec 4.8.19 → 4.10.0

package/src/commands/project/monitor.js

@@ -1,295 +0,0 @@
-/**
- * morph-spec monitor — Live TUI Dashboard
- *
- * Opens a live-updating terminal UI showing:
- *   - Active agents by tier
- *   - Hook events (chronological feed)
- *   - Skills invoked this session
- *   - Rules in effect
- *   - Overview summary
- *
- * Reads .morph/logs/activity.json (written by hooks via activity-logger.js).
- * Uses fs.watch for live updates (no polling, no chokidar).
- *
- * Usage:
- *   morph-spec monitor [feature]
- *   morph-spec monitor --compact
- *   morph-spec monitor --mode hooks
- */
-
-import { watch, existsSync, readFileSync, readdirSync, statSync } from 'fs';
-import { join, basename } from 'path';
-import chalk from 'chalk';
-
-import {
-  renderBox,
-  renderFeed,
-  renderAgents,
-  renderSkills,
-  renderRules,
-  renderOverview,
-  renderStatusBar,
-  renderHeader,
-} from '../../lib/monitor/renderer.js';
-
-import { getActiveAgents } from '../../lib/monitor/agent-resolver.js';
-import { readActivity } from '../../../framework/hooks/shared/activity-logger.js';
-import { loadState, getActiveFeature, derivePhaseForFeature } from '../../../framework/hooks/shared/state-reader.js';
-
-const MODES = ['overview', 'hooks', 'agents', 'skills', 'rules'];
-const ACTIVITY_FILE = '.morph/logs/activity.json';
-const RULES_DIR_PROJECT = '.claude/rules';
-const RULES_DIR_FRAMEWORK = '.morph/framework/rules';
-
-// ─────────────────────────────────────────────────────────
-// Rules loading
-// ─────────────────────────────────────────────────────────
-
-function loadRules(cwd) {
-  const rules = [];
-  const dirs = [
-    join(cwd, RULES_DIR_PROJECT),
-    join(cwd, RULES_DIR_FRAMEWORK),
-    join(cwd, 'framework/rules'),
-  ];
-
-  for (const dir of dirs) {
-    if (!existsSync(dir)) continue;
-    try {
-      const files = readdirSync(dir).filter(f => f.endsWith('.md'));
-      for (const file of files) {
-        // Parse front-matter paths glob if present
-        let glob = '*';
-        try {
-          const content = readFileSync(join(dir, file), 'utf-8');
-          const match = content.match(/paths:\s*\n((?:\s*-\s*.+\n?)+)/);
-          if (match) {
-            const paths = match[1].match(/- (.+)/g);
-            if (paths) glob = paths.map(p => p.replace('- ', '').trim()).join(', ');
-          }
-        } catch { /* skip */ }
-        rules.push({ name: basename(file, '.md'), glob });
-      }
-    } catch { /* skip */ }
-  }
-  return rules;
-}
-
-// ─────────────────────────────────────────────────────────
-// Available skills loading
-// ─────────────────────────────────────────────────────────
-
-function loadAvailableSkills(cwd) {
-  const skillDirs = [
-    join(cwd, '.claude/skills'),
-    join(cwd, 'framework/skills'),
-  ];
-  const names = [];
-  for (const dir of skillDirs) {
-    if (!existsSync(dir)) continue;
-    try {
-      const entries = readdirSync(dir, { withFileTypes: true });
-      for (const entry of entries) {
-        if (entry.isDirectory()) {
-          // Level-N-meta/skill-name or direct skill dirs
-          const sub = readdirSync(join(dir, entry.name), { withFileTypes: true });
-          for (const s of sub) {
-            if (s.isDirectory()) names.push(s.name);
-          }
-        }
-      }
-    } catch { /* skip */ }
-  }
-  return [...new Set(names)];
-}
-
-// ─────────────────────────────────────────────────────────
-// Screen rendering
-// ─────────────────────────────────────────────────────────
-
-function render(state) {
-  const { feature, phase, tasks, agentsByTier, activity, rules, availableSkills, mode, compact } = state;
-
-  const hooks = activity?.hooks || [];
-  const skills = activity?.skills || [];
-
-  // Clear screen
-  process.stdout.write('\x1Bc');
-
-  // Header
-  process.stdout.write(renderHeader(feature, phase, tasks) + '\n');
-
-  if (compact) {
-    // Compact: just show overview
-    const overviewData = { feature, phase, agentsByTier, hooks, skills, rules };
-    process.stdout.write(renderOverview(overviewData) + '\n');
-  } else {
-    switch (mode) {
-      case 'hooks':
-        process.stdout.write(renderFeed(hooks) + '\n');
-        break;
-
-      case 'agents':
-        process.stdout.write(renderAgents(agentsByTier, phase) + '\n');
-        break;
-
-      case 'skills':
-        process.stdout.write(renderSkills(skills, availableSkills) + '\n');
-        break;
-
-      case 'rules':
-        process.stdout.write(renderRules(rules) + '\n');
-        break;
-
-      case 'overview':
-      default: {
-        const overviewData = { feature, phase, agentsByTier, hooks, skills, rules };
-        process.stdout.write(renderOverview(overviewData) + '\n');
-        break;
-      }
-    }
-  }
-
-  // Status bar
-  process.stdout.write(renderStatusBar(mode, MODES) + '\n');
-}
-
-// ─────────────────────────────────────────────────────────
-// State loading
-// ─────────────────────────────────────────────────────────
-
-function loadMonitorState(cwd, featureArg) {
-  let feature = featureArg || '';
-  let phase = '';
-  let tasks = null;
-
-  try {
-    const morphState = loadState(cwd);
-    if (!feature && morphState) {
-      const active = getActiveFeature(cwd);
-      if (active) {
-        feature = active.name;
-        tasks = active.feature.tasks || null;
-      }
-    }
-    if (feature) {
-      phase = derivePhaseForFeature(feature, cwd);
-    }
-  } catch { /* fail-open */ }
-
-  const agentsByTier = getActiveAgents(cwd, phase);
-  const activity = readActivity(cwd);
-  const rules = loadRules(cwd);
-  const availableSkills = loadAvailableSkills(cwd);
-
-  return { feature, phase, tasks, agentsByTier, activity, rules, availableSkills };
-}
-
-// ─────────────────────────────────────────────────────────
-// Main command
-// ─────────────────────────────────────────────────────────
-
-/**
- * @param {string|undefined} featureArg
- * @param {{ compact: boolean, mode: string }} opts
- */
-export function monitorCommand(featureArg, opts = {}) {
-  const cwd = process.cwd();
-  const compact = !!opts.compact;
-  const startMode = MODES.includes(opts.mode) ? opts.mode : 'overview';
-
-  let modeIndex = MODES.indexOf(startMode);
-  let currentMode = startMode;
-
-  // Initial render
-  let monitorState = loadMonitorState(cwd, featureArg);
-  render({ ...monitorState, mode: currentMode, compact });
-
-  // Watch activity.json for changes
-  const activityPath = join(cwd, ACTIVITY_FILE);
-  let watcher = null;
-
-  function startWatcher() {
-    if (!existsSync(activityPath)) {
-      // Retry watch setup when file is created
-      setTimeout(startWatcher, 2000);
-      return;
-    }
-
-    try {
-      watcher = watch(activityPath, { persistent: true }, () => {
-        try {
-          monitorState = loadMonitorState(cwd, featureArg);
-          render({ ...monitorState, mode: currentMode, compact });
-        } catch { /* fail-open */ }
-      });
-    } catch {
-      // fs.watch not supported — fall back to polling
-      setInterval(() => {
-        try {
-          monitorState = loadMonitorState(cwd, featureArg);
-          render({ ...monitorState, mode: currentMode, compact });
-        } catch { /* fail-open */ }
-      }, 2000);
-    }
-  }
-
-  startWatcher();
-
-  // Keyboard input: raw mode
-  if (process.stdin.isTTY) {
-    process.stdin.setRawMode(true);
-    process.stdin.resume();
-    process.stdin.setEncoding('utf8');
-
-    process.stdin.on('data', (key) => {
-      // q or Ctrl-C → quit
-      if (key === 'q' || key === '\u0003') {
-        if (watcher) watcher.close();
-        process.stdin.setRawMode(false);
-        process.stdout.write('\n' + chalk.gray('morph-spec monitor closed.\n'));
-        process.exit(0);
-      }
-
-      // shift+tab → cycle modes (forward)
-      // \x1b[Z is the standard escape for shift+tab
-      if (key === '\x1b[Z' || key === '\t') {
-        modeIndex = (modeIndex + 1) % MODES.length;
-        currentMode = MODES[modeIndex];
-        render({ ...monitorState, mode: currentMode, compact });
-      }
-
-      // Arrow keys: left/right also cycle
-      if (key === '\x1b[C') { // right arrow
-        modeIndex = (modeIndex + 1) % MODES.length;
-        currentMode = MODES[modeIndex];
-        render({ ...monitorState, mode: currentMode, compact });
-      }
-      if (key === '\x1b[D') { // left arrow
-        modeIndex = (modeIndex - 1 + MODES.length) % MODES.length;
-        currentMode = MODES[modeIndex];
-        render({ ...monitorState, mode: currentMode, compact });
-      }
-
-      // r → force refresh
-      if (key === 'r') {
-        monitorState = loadMonitorState(cwd, featureArg);
-        render({ ...monitorState, mode: currentMode, compact });
-      }
-    });
-  } else {
-    // Non-TTY: just render once and exit (useful for scripting/piping)
-    process.stdout.write('\n' + chalk.gray('(non-interactive mode — run in a real terminal for live updates)\n'));
-  }
-
-  // Handle process signals
-  process.on('SIGINT', () => {
-    if (watcher) watcher.close();
-    process.stdout.write('\n' + chalk.gray('morph-spec monitor closed.\n'));
-    process.exit(0);
-  });
-  process.on('SIGTERM', () => {
-    if (watcher) watcher.close();
-    process.exit(0);
-  });
-}

package/src/commands/project/tutorial.js

@@ -1,115 +0,0 @@
-/**
- * Tutorial Command
- *
- * Prints the MORPH-SPEC workflow pipeline and getting-started steps.
- * Pure stdout — no file I/O, no network, no side effects.
- *
- * Usage: morph-spec tutorial
- */
-
-import chalk from 'chalk';
-
-const PHASES = [
-  {
-    label: 'FASE 0 · PROPOSAL',
-    what: 'Captures user story + acceptance criteria.',
-    produces: '0-proposal/proposal.md',
-    how: '/morph-proposal <feature>  (in Claude Code)',
-  },
-  {
-    label: 'FASE 1 · SETUP',
-    what: 'Detects stack, activates agents, confirms environment.',
-    produces: '.morph/state.json initialized',
-    how: 'auto-triggered inside /morph-proposal',
-  },
-  {
-    label: 'FASE 1.5 · UI/UX',
-    what: 'Design system, mockups, component specs, user flows.',
-    produces: '2-ui/{design-system,mockups,components,flows}.md',
-    how: '/phase-uiux <feature>  (in Claude Code)',
-    optional: true,
-  },
-  {
-    label: 'FASE 2 · DESIGN',
-    what: 'Technical spec + C# contracts + architecture decisions.',
-    produces: '1-design/{spec.md, contracts-level{N}.cs, decisions.md}',
-    how: '/phase-design <feature>  (in Claude Code)',
-  },
-  {
-    label: 'FASE 3 · CLARIFY',
-    what: 'Reviews spec for ambiguities, adds edge cases.',
-    produces: '1-design/spec.md (updated with clarifications)',
-    how: '/phase-clarify <feature>  (in Claude Code)',
-  },
-  {
-    label: 'FASE 4 · TASKS',
-    what: 'Atomic task breakdown, DDD-aware.',
-    produces: '3-tasks/tasks.md',
-    how: 'auto-generated during /morph-proposal, or /phase-tasks <feature>',
-  },
-  {
-    label: 'FASE 5 · IMPLEMENT',
-    what: 'Code implementation with checkpoints every 3 tasks.',
-    produces: '4-implement/recap.md + source code',
-    how: '/morph-apply <feature>  (in Claude Code)',
-  },
-  {
-    label: 'FASE 6 · SYNC',
-    what: 'Syncs decisions back to project standards.',
-    produces: '.morph/framework/standards/ (updated)',
-    how: 'morph-spec sync <feature>',
-    optional: true,
-  },
-];
-
-const SEP = chalk.dim('─'.repeat(58));
-
-export function tutorialCommand() {
-  console.log('');
-  console.log(chalk.cyan.bold('  MORPH-SPEC Workflow Tutorial'));
-  console.log(SEP);
-  console.log('');
-  console.log(
-    chalk.white(
-      '  MORPH-SPEC is spec-first: every feature goes through phases\n' +
-      '  before any code is written. Each phase produces structured\n' +
-      '  outputs that feed the next.'
-    )
-  );
-  console.log('');
-  console.log(SEP);
-  console.log(chalk.cyan.bold('  PIPELINE'));
-  console.log(SEP);
-  console.log('');
-  console.log(
-    chalk.white('  proposal → setup → ') +
-    chalk.dim('[uiux]') +
-    chalk.white(' → design → clarify → tasks → implement → ') +
-    chalk.dim('[sync]')
-  );
-  console.log(chalk.dim('  (phases in brackets are optional)'));
-  console.log('');
-
-  for (const phase of PHASES) {
-    console.log(SEP);
-    const label = phase.optional
-      ? chalk.cyan.bold(`  ${phase.label}`) + chalk.dim('  [optional]')
-      : chalk.cyan.bold(`  ${phase.label}`);
-    console.log(label);
-    console.log(chalk.white(`  What:     ${phase.what}`));
-    console.log(chalk.dim(`  Produces: ${phase.produces}`));
-    console.log(chalk.green(`  How:      ${phase.how}`));
-    console.log('');
-  }
-
-  console.log(SEP);
-  console.log(chalk.cyan.bold('  GETTING STARTED'));
-  console.log(SEP);
-  console.log('');
-  console.log(chalk.white('  1. Open Claude Code in your project'));
-  console.log(chalk.white('  2. Run:  ') + chalk.green('/morph-proposal <your-feature-name>'));
-  console.log(chalk.white('  3. Answer the questions — morph-spec handles the rest'));
-  console.log('');
-  console.log(chalk.dim('  Tip: run `morph-spec doctor` to verify your installation first.'));
-  console.log('');
-}

package/src/commands/state/validate-phase.js

@@ -1,238 +0,0 @@
-/**
- * MORPH-SPEC Phase Validator Command
- *
- * Validates that required previous phases have been completed before advancing.
- * Prevents skipping phases accidentally.
- *
- * Usage:
- *   morph-spec validate-phase <feature-name> <target-phase>
- *
- * Example:
- *   morph-spec validate-phase scheduled-reports implement
- */
-
-import fs from 'fs';
-import path from 'path';
-import chalk from 'chalk';
-import { loadState, getFeature } from '../../core/state/state-manager.js';
-
-// Phase definitions with requirements
-const PHASES = {
-  'proposal': {
-    order: 0,
-    name: 'FASE 0: PROPOSAL',
-    requiredOutputs: [],
-    description: 'Initial proposal and agent detection'
-  },
-  'setup': {
-    order: 1,
-    name: 'FASE 1: SETUP',
-    requiredOutputs: ['proposal.md'],
-    description: 'Load context and standards'
-  },
-  'uiux': {
-    order: 2,
-    name: 'FASE 1.5: UI/UX DESIGN',
-    requiredOutputs: ['proposal.md'],
-    optionalOutputs: ['ui-design-system.md', 'ui-mockups.md', 'ui-components.md', 'ui-flows.md'],
-    description: 'UI/UX design (conditional - only if frontend)',
-    optional: true
-  },
-  'design': {
-    order: 3,
-    name: 'FASE 2: DESIGN',
-    requiredOutputs: ['proposal.md'],
-    description: 'Technical specification and contracts'
-  },
-  'clarify': {
-    order: 4,
-    name: 'FASE 3: CLARIFY',
-    requiredOutputs: ['proposal.md', 'spec.md'],
-    description: 'Clarify ambiguities and edge cases'
-  },
-  'tasks': {
-    order: 5,
-    name: 'FASE 4: TASKS',
-    requiredOutputs: ['proposal.md', 'spec.md'],
-    description: 'Break down into executable tasks'
-  },
-  'implement': {
-    order: 6,
-    name: 'FASE 5: IMPLEMENT',
-    requiredOutputs: ['proposal.md', 'spec.md'],
-    description: 'Execute tasks and implement code'
-  },
-  'sync': {
-    order: 7,
-    name: 'FASE 6: SYNC',
-    requiredOutputs: ['proposal.md', 'spec.md', 'decisions.md'],
-    description: 'Sync decisions to project standards',
-    optional: true
-  }
-};
-
-// Map output filenames to their phase subfolders
-const OUTPUT_PHASE_MAP = {
-  'proposal.md': '0-proposal',
-  'schema-analysis.md': '1-design',
-  'spec.md': '1-design',
-  'clarifications.md': '1-design',
-  'contracts.cs': '1-design',
-  'decisions.md': '1-design',
-  'ui-design-system.md': '2-ui',
-  'ui-mockups.md': '2-ui',
-  'ui-components.md': '2-ui',
-  'ui-flows.md': '2-ui',
-  'tasks.md': '3-tasks',
-  'recap.md': '4-implement'
-};
-
-/**
- * Check if output file exists
- */
-function checkOutput(featurePath, outputFile) {
-  const phaseDir = OUTPUT_PHASE_MAP[outputFile] || '';
-  const filePath = path.join(featurePath, phaseDir, outputFile);
-  return fs.existsSync(filePath);
-}
-
-/**
- * Validate phase requirements
- */
-function validatePhase(featureName, targetPhase) {
-  const featurePath = path.join(process.cwd(), '.morph/features', featureName);
-
-  // Check if feature directory exists
-  if (!fs.existsSync(featurePath)) {
-    return {
-      valid: false,
-      error: `Feature directory not found: ${featurePath}`,
-      suggestion: `Run 'morph-spec state set ${featureName} phase proposal' to start`,
-      missingOutputs: [],
-      phase: null
-    };
-  }
-
-  // Get target phase definition
-  const phaseDefinition = PHASES[targetPhase];
-  if (!phaseDefinition) {
-    return {
-      valid: false,
-      error: `Unknown phase: ${targetPhase}`,
-      validPhases: Object.keys(PHASES),
-      missingOutputs: [],
-      phase: null
-    };
-  }
-
-  // Check required outputs
-  const missingOutputs = [];
-  for (const output of phaseDefinition.requiredOutputs) {
-    if (!checkOutput(featurePath, output)) {
-      missingOutputs.push(output);
-    }
-  }
-
-  // Check state.json for current phase
-  let stateWarning = null;
-  try {
-    const feature = getFeature(featureName);
-    if (feature) {
-      const currentPhaseOrder = PHASES[feature.phase]?.order ?? -1;
-      const targetPhaseOrder = phaseDefinition.order;
-
-      if (targetPhaseOrder > currentPhaseOrder + 1) {
-        stateWarning = `Skipping phases: current is '${feature.phase}' (order ${currentPhaseOrder}), target is '${targetPhase}' (order ${targetPhaseOrder})`;
-      }
-    }
-  } catch {
-    // State file may not exist, that's OK
-  }
-
-  // Special validation: if target is 'implement', check tasks exist in state
-  if (targetPhase === 'implement') {
-    try {
-      const feature = getFeature(featureName);
-      if (feature && (!feature.tasks || feature.tasks.total === 0)) {
-        missingOutputs.push('tasks in state.json (run morph-spec task to add tasks)');
-      }
-    } catch {
-      // State file may not exist
-    }
-  }
-
-  return {
-    valid: missingOutputs.length === 0,
-    error: null,
-    missingOutputs,
-    phase: phaseDefinition,
-    featurePath,
-    stateWarning
-  };
-}
-
-/**
- * Main command handler
- */
-export async function validatePhaseCommand(feature, phase, options = {}) {
-  console.log(chalk.cyan('\n╔════════════════════════════════════════════════╗'));
-  console.log(chalk.cyan('║     MORPH-SPEC PHASE VALIDATOR                 ║'));
-  console.log(chalk.cyan('╚════════════════════════════════════════════════╝\n'));
-
-  const result = validatePhase(feature, phase);
-
-  console.log(chalk.gray('Feature:'), feature);
-  console.log(chalk.gray('Target Phase:'), result.phase ? result.phase.name : phase);
-
-  if (result.phase) {
-    console.log(chalk.gray('Description:'), result.phase.description);
-  }
-
-  if (result.stateWarning) {
-    console.log(chalk.yellow(`\n⚠️  Warning: ${result.stateWarning}`));
-  }
-
-  if (result.valid) {
-    console.log(chalk.green('\n✓ VALIDATION PASSED'));
-    console.log(chalk.green('  All required outputs are present.'));
-    console.log(chalk.green(`  Safe to proceed to ${result.phase.name}\n`));
-
-    if (options.verbose) {
-      console.log(chalk.gray('Required outputs found:'));
-      result.phase.requiredOutputs.forEach(output => {
-        console.log(chalk.gray(`  ✓ ${output}`));
-      });
-      console.log('');
-    }
-  } else {
-    console.log(chalk.red('\n✗ VALIDATION FAILED'));
-
-    if (result.error) {
-      console.log(chalk.red(`  Error: ${result.error}\n`));
-
-      if (result.suggestion) {
-        console.log(chalk.yellow(`  Suggestion: ${result.suggestion}\n`));
-      }
-
-      if (result.validPhases) {
-        console.log(chalk.yellow('Valid phases:'));
-        result.validPhases.forEach(p => {
-          const def = PHASES[p];
-          console.log(chalk.gray(`  - ${p}: ${def.name}${def.optional ? ' (optional)' : ''}`));
-        });
-      }
-    } else {
-      console.log(chalk.red('  Missing required outputs:'));
-      result.missingOutputs.forEach(output => {
-        console.log(chalk.gray(`  - ${output}`));
-      });
-
-      console.log(chalk.yellow(`\n  Action required:`));
-      console.log(chalk.yellow(`  Complete the missing outputs before advancing to ${result.phase.name}`));
-    }
-    console.log('');
-    process.exit(1);
-  }
-}
-
-export { PHASES, validatePhase };