@polymorphism-tech/morph-spec 4.3.7 → 4.6.0

package/src/commands/project/cost.js

@@ -0,0 +1,179 @@
+/**
+ * MORPH-SPEC Cost Tracking Command
+ *
+ * Track and estimate costs (token usage, Azure resources) across phases.
+ *
+ * Usage:
+ *   morph-spec cost <feature-name>
+ *   morph-spec cost <feature-name> --json
+ */
+
+import chalk from 'chalk';
+import { getFeature, loadState, saveState } from '../../core/state/state-manager.js';
+
+/**
+ * Phase cost weights (relative token usage)
+ */
+const PHASE_COST_WEIGHTS = {
+  proposal: 5,
+  setup: 3,
+  uiux: 12,
+  design: 18,
+  clarify: 20,
+  tasks: 17,
+  implement: 80
+};
+
+/**
+ * Cost per 1K tokens (approximate for Claude models)
+ */
+const COST_PER_1K_INPUT = 0.003;
+const COST_PER_1K_OUTPUT = 0.015;
+
+/**
+ * Record token usage for a phase
+ */
+export function recordPhaseUsage(featureName, phase, inputTokens, outputTokens) {
+  const state = loadState();
+  const feature = state.features[featureName];
+  if (!feature) return;
+
+  if (!feature.costs) {
+    feature.costs = { phases: {}, estimated: 0, approved: false };
+  }
+
+  if (!feature.costs.phases[phase]) {
+    feature.costs.phases[phase] = { inputTokens: 0, outputTokens: 0, usd: 0 };
+  }
+
+  feature.costs.phases[phase].inputTokens += inputTokens;
+  feature.costs.phases[phase].outputTokens += outputTokens;
+  feature.costs.phases[phase].usd =
+    (feature.costs.phases[phase].inputTokens / 1000 * COST_PER_1K_INPUT) +
+    (feature.costs.phases[phase].outputTokens / 1000 * COST_PER_1K_OUTPUT);
+
+  saveState(state);
+}
+
+/**
+ * Calculate estimated remaining cost
+ */
+function estimateRemaining(feature) {
+  const currentPhaseIndex = Object.keys(PHASE_COST_WEIGHTS).indexOf(feature.phase);
+  const completedWeight = Object.entries(PHASE_COST_WEIGHTS)
+    .filter(([_, __], i) => i <= currentPhaseIndex)
+    .reduce((sum, [_, w]) => sum + w, 0);
+
+  const totalWeight = Object.values(PHASE_COST_WEIGHTS).reduce((a, b) => a + b, 0);
+  const remainingWeight = totalWeight - completedWeight;
+
+  // Estimate based on actual usage so far
+  const actualSpent = Object.values(feature.costs?.phases || {})
+    .reduce((sum, p) => sum + p.usd, 0);
+
+  if (completedWeight === 0 || actualSpent === 0) {
+    // No data yet, use default estimates
+    const estimatedTokens = remainingWeight * 1000;
+    return (estimatedTokens / 1000 * COST_PER_1K_INPUT) + (estimatedTokens / 1000 * COST_PER_1K_OUTPUT);
+  }
+
+  const costPerWeight = actualSpent / completedWeight;
+  return costPerWeight * remainingWeight;
+}
+
+/**
+ * Main cost command
+ */
+export async function costCommand(featureName, options = {}) {
+  if (!featureName) {
+    console.error(chalk.red('Error: Feature name required'));
+    console.error(chalk.gray('Usage: morph-spec cost <feature-name>'));
+    process.exit(1);
+  }
+
+  const feature = getFeature(featureName);
+  if (!feature) {
+    console.error(chalk.red(`Error: Feature '${featureName}' not found`));
+    process.exit(1);
+  }
+
+  const costs = feature.costs || { phases: {} };
+  const totalSpent = Object.values(costs.phases)
+    .reduce((sum, p) => sum + (p.usd || 0), 0);
+  const estimatedRemaining = estimateRemaining(feature);
+  const totalTokens = Object.values(costs.phases)
+    .reduce((sum, p) => sum + (p.inputTokens || 0) + (p.outputTokens || 0), 0);
+
+  // JSON output
+  if (options.json) {
+    const output = {
+      feature: featureName,
+      currentPhase: feature.phase,
+      totalTokens,
+      totalSpentUsd: Math.round(totalSpent * 100) / 100,
+      estimatedRemainingUsd: Math.round(estimatedRemaining * 100) / 100,
+      estimatedTotalUsd: Math.round((totalSpent + estimatedRemaining) * 100) / 100,
+      phases: Object.entries(costs.phases).map(([phase, data]) => ({
+        phase,
+        inputTokens: data.inputTokens,
+        outputTokens: data.outputTokens,
+        usd: Math.round(data.usd * 100) / 100
+      })),
+      infraCosts: {
+        estimated: costs.estimated || 0,
+        approved: costs.approved || false
+      }
+    };
+    console.log(JSON.stringify(output, null, 2));
+    return;
+  }
+
+  // Visual output
+  console.log(chalk.cyan('\n┌────────────────────────────────────────────────────────────┐'));
+  console.log(chalk.cyan('│                 MORPH-SPEC COST TRACKER                    │'));
+  console.log(chalk.cyan('└────────────────────────────────────────────────────────────┘\n'));
+
+  console.log(chalk.white.bold(`Feature: ${featureName}`));
+  console.log(chalk.gray(`Current Phase: ${feature.phase}\n`));
+
+  console.log(chalk.white.bold('Token usage by phase:'));
+
+  const allPhases = Object.keys(PHASE_COST_WEIGHTS);
+  for (const phase of allPhases) {
+    const data = costs.phases[phase];
+    const weight = PHASE_COST_WEIGHTS[phase];
+    const phaseIndex = allPhases.indexOf(phase);
+    const currentIndex = allPhases.indexOf(feature.phase);
+    const isLast = phaseIndex === allPhases.length - 1;
+    const prefix = isLast ? '└─' : '├─';
+
+    if (data) {
+      const tokens = (data.inputTokens || 0) + (data.outputTokens || 0);
+      const usd = Math.round((data.usd || 0) * 100) / 100;
+      const tokensStr = tokens >= 1000 ? `${Math.round(tokens / 1000)}k` : `${tokens}`;
+      console.log(`${prefix} ${phase.toUpperCase()}: ${chalk.white(tokensStr)} tokens ${chalk.gray(`($${usd})`)}`);
+    } else if (phaseIndex <= currentIndex) {
+      console.log(`${prefix} ${phase.toUpperCase()}: ${chalk.gray('(no data recorded)')}`);
+    } else {
+      console.log(`${prefix} ${phase.toUpperCase()}: ${chalk.gray(`~${weight}k tokens (estimated)`)}`);
+    }
+  }
+
+  console.log('');
+  console.log(chalk.gray('─'.repeat(60)));
+
+  const totalTokensStr = totalTokens >= 1000 ? `${Math.round(totalTokens / 1000)}k` : `${totalTokens}`;
+  console.log(chalk.white(`Total spent: ${totalTokensStr} tokens ($${Math.round(totalSpent * 100) / 100})`));
+  console.log(chalk.yellow(`Estimated remaining: ~$${Math.round(estimatedRemaining * 100) / 100}`));
+  console.log(chalk.white.bold(`Estimated total: ~$${Math.round((totalSpent + estimatedRemaining) * 100) / 100}`));
+
+  // Infrastructure costs
+  if (costs.estimated > 0) {
+    console.log(chalk.white(`\nInfra costs (monthly): $${costs.estimated}`));
+    console.log(costs.approved ? chalk.green('  ✓ Approved') : chalk.yellow('  ⚠ Not yet approved'));
+  }
+
+  console.log('');
+}
+
+export default costCommand;

package/src/commands/project/diff.js

@@ -0,0 +1,278 @@
+/**
+ * MORPH-SPEC Diff Command
+ *
+ * Track changes to specifications since last approval.
+ * Shows added/removed functional requirements, entity changes, and new decisions.
+ *
+ * Usage:
+ *   morph-spec diff <feature-name> [output-file]
+ *   morph-spec diff <feature-name> spec.md
+ *   morph-spec diff <feature-name> --json
+ */
+
+import fs from 'fs';
+import path from 'path';
+import chalk from 'chalk';
+import { getFeature } from '../../core/state/state-manager.js';
+
+/**
+ * Load snapshot from checkpoints directory
+ */
+function loadSnapshot(featureName, outputFile) {
+  const snapshotDir = path.join(process.cwd(), '.morph/checkpoints', featureName);
+  const snapshotPath = path.join(snapshotDir, outputFile);
+
+  if (!fs.existsSync(snapshotPath)) {
+    return null;
+  }
+
+  return fs.readFileSync(snapshotPath, 'utf8');
+}
+
+/**
+ * Load current version of output file
+ */
+function loadCurrent(featureName, outputFile) {
+  const currentPath = path.join(process.cwd(), '.morph/features', featureName, outputFile);
+
+  if (!fs.existsSync(currentPath)) {
+    return null;
+  }
+
+  return fs.readFileSync(currentPath, 'utf8');
+}
+
+/**
+ * Extract functional requirements from spec content
+ */
+function extractRequirements(content) {
+  const requirements = [];
+  const regex = /###\s+(FR[-_]?\d+):?\s*(.+)/gi;
+  let match;
+  while ((match = regex.exec(content)) !== null) {
+    requirements.push({ id: match[1], title: match[2].trim() });
+  }
+  return requirements;
+}
+
+/**
+ * Extract entities from spec or contracts
+ */
+function extractEntities(content) {
+  const entities = [];
+  // Markdown entities
+  const mdRegex = /###\s+(?:Entity|Table):?\s*(.+)/gi;
+  let match;
+  while ((match = mdRegex.exec(content)) !== null) {
+    entities.push(match[1].trim());
+  }
+  // C# records
+  const csRegex = /public\s+record\s+(\w+)/g;
+  while ((match = csRegex.exec(content)) !== null) {
+    entities.push(match[1]);
+  }
+  return entities;
+}
+
+/**
+ * Extract ADRs from decisions
+ */
+function extractDecisions(content) {
+  const decisions = [];
+  const regex = /###\s+ADR[-_]?\d*:?\s*(.+)/gi;
+  let match;
+  while ((match = regex.exec(content)) !== null) {
+    decisions.push(match[1].trim());
+  }
+  return decisions;
+}
+
+/**
+ * Compute diff between two content versions
+ */
+function computeDiff(oldContent, newContent, outputFile) {
+  const diff = {
+    file: outputFile,
+    added: [],
+    removed: [],
+    modified: []
+  };
+
+  if (!oldContent) {
+    diff.added.push('(entire file is new)');
+    return diff;
+  }
+
+  if (!newContent) {
+    diff.removed.push('(file was deleted)');
+    return diff;
+  }
+
+  // Compare requirements
+  if (outputFile.endsWith('spec.md')) {
+    const oldReqs = extractRequirements(oldContent);
+    const newReqs = extractRequirements(newContent);
+
+    const oldIds = new Set(oldReqs.map(r => r.id));
+    const newIds = new Set(newReqs.map(r => r.id));
+
+    for (const req of newReqs) {
+      if (!oldIds.has(req.id)) {
+        diff.added.push(`${req.id}: ${req.title}`);
+      }
+    }
+    for (const req of oldReqs) {
+      if (!newIds.has(req.id)) {
+        diff.removed.push(`${req.id}: ${req.title}`);
+      }
+    }
+
+    // Compare entities
+    const oldEntities = new Set(extractEntities(oldContent));
+    const newEntities = new Set(extractEntities(newContent));
+
+    for (const entity of newEntities) {
+      if (!oldEntities.has(entity)) {
+        diff.added.push(`Entity: ${entity}`);
+      }
+    }
+    for (const entity of oldEntities) {
+      if (!newEntities.has(entity)) {
+        diff.removed.push(`Entity: ${entity}`);
+      }
+    }
+  }
+
+  // Compare decisions
+  if (outputFile.endsWith('decisions.md')) {
+    const oldDecisions = new Set(extractDecisions(oldContent));
+    const newDecisions = new Set(extractDecisions(newContent));
+
+    for (const decision of newDecisions) {
+      if (!oldDecisions.has(decision)) {
+        diff.added.push(`ADR: ${decision}`);
+      }
+    }
+    for (const decision of oldDecisions) {
+      if (!newDecisions.has(decision)) {
+        diff.removed.push(`ADR: ${decision}`);
+      }
+    }
+  }
+
+  // Line count change
+  const oldLines = oldContent.split('\n').length;
+  const newLines = newContent.split('\n').length;
+  if (oldLines !== newLines) {
+    const delta = newLines - oldLines;
+    diff.modified.push(`${delta > 0 ? '+' : ''}${delta} lines (${oldLines} → ${newLines})`);
+  }
+
+  return diff;
+}
+
+/**
+ * Save current version as snapshot for future diffs
+ */
+export function saveSnapshot(featureName) {
+  const outputDir = path.join(process.cwd(), '.morph/features', featureName);
+  const snapshotDir = path.join(process.cwd(), '.morph/checkpoints', featureName);
+
+  if (!fs.existsSync(outputDir)) return;
+
+  fs.mkdirSync(snapshotDir, { recursive: true });
+
+  const files = fs.readdirSync(outputDir).filter(f => f.endsWith('.md') || f.endsWith('.cs') || f.endsWith('.json'));
+  for (const file of files) {
+    const src = path.join(outputDir, file);
+    const dest = path.join(snapshotDir, file);
+    fs.copyFileSync(src, dest);
+  }
+}
+
+/**
+ * Main diff command
+ */
+export async function diffCommand(featureName, outputFile, options = {}) {
+  if (!featureName) {
+    console.error(chalk.red('Error: Feature name required'));
+    console.error(chalk.gray('Usage: morph-spec diff <feature-name> [output-file]'));
+    process.exit(1);
+  }
+
+  const outputDir = path.join(process.cwd(), '.morph/features', featureName);
+  if (!fs.existsSync(outputDir)) {
+    console.error(chalk.red(`Error: Feature directory not found: ${outputDir}`));
+    process.exit(1);
+  }
+
+  // Determine which files to diff
+  let files;
+  if (outputFile) {
+    files = [outputFile];
+  } else {
+    files = fs.readdirSync(outputDir).filter(f => f.endsWith('.md') || f.endsWith('.cs'));
+  }
+
+  const diffs = files.map(file => {
+    const oldContent = loadSnapshot(featureName, file);
+    const newContent = loadCurrent(featureName, file);
+    return computeDiff(oldContent, newContent, file);
+  }).filter(d => d.added.length > 0 || d.removed.length > 0 || d.modified.length > 0);
+
+  // JSON output
+  if (options.json) {
+    console.log(JSON.stringify({ feature: featureName, diffs }, null, 2));
+    return;
+  }
+
+  // Visual output
+  console.log(chalk.cyan('\n┌────────────────────────────────────────────────────────────┐'));
+  console.log(chalk.cyan('│                    MORPH-SPEC DIFF                         │'));
+  console.log(chalk.cyan('└────────────────────────────────────────────────────────────┘\n'));
+
+  console.log(chalk.white.bold(`Feature: ${featureName}`));
+  console.log(chalk.gray('Changes since last snapshot:\n'));
+
+  if (diffs.length === 0) {
+    console.log(chalk.green('  No changes detected since last snapshot.'));
+    console.log(chalk.gray('  Run "morph-spec diff-save <feature>" to create a snapshot.\n'));
+    return;
+  }
+
+  for (const diff of diffs) {
+    console.log(chalk.white.bold(`  ${diff.file}:`));
+
+    for (const item of diff.added) {
+      console.log(chalk.green(`    + ${item}`));
+    }
+    for (const item of diff.removed) {
+      console.log(chalk.red(`    - ${item}`));
+    }
+    for (const item of diff.modified) {
+      console.log(chalk.yellow(`    ~ ${item}`));
+    }
+    console.log('');
+  }
+
+  const totalAdded = diffs.reduce((sum, d) => sum + d.added.length, 0);
+  const totalRemoved = diffs.reduce((sum, d) => sum + d.removed.length, 0);
+  console.log(chalk.gray('─'.repeat(60)));
+  console.log(chalk.gray(`${totalAdded} addition(s), ${totalRemoved} removal(s) across ${diffs.length} file(s)\n`));
+}
+
+/**
+ * Save snapshot command
+ */
+export async function diffSaveCommand(featureName) {
+  if (!featureName) {
+    console.error(chalk.red('Error: Feature name required'));
+    process.exit(1);
+  }
+
+  saveSnapshot(featureName);
+  console.log(chalk.green(`✓ Snapshot saved for '${featureName}'`));
+  console.log(chalk.gray('  Future "morph-spec diff" will compare against this snapshot.\n'));
+}
+
+export default diffCommand;

package/src/commands/project/doctor.js

@@ -10,6 +10,7 @@ import {
   checkProjectOutdated,
   getInstalledCLIVersion
 } from '../../utils/version-checker.js';
+import { resetMorphSettings } from '../../utils/claude-settings-manager.js';
 
 const isWindows = platform() === 'win32';
 
@@ -65,7 +66,7 @@ const REQUIRED_LIB_FILES = [
   'src/lib/context/mcp-optimizer.js',
   'src/lib/agents/micro-agent-factory.js',
   'src/lib/execution/parallel-executor.js',
-  'src/lib/hooks/stop-hook-executor.js',
+  'src/lib/hooks/stop-hook-executor.js',  // Legacy — retained for backward compat
   'src/lib/threads/thread-coordinator.js',
   'src/lib/threads/thread-manager.js',
   'src/lib/trust/trust-manager.js'
@@ -198,8 +199,8 @@ async function doctorFullCommand(frameworkRoot) {
     missingStds.length > 0 ? `missing: ${missingStds.join(', ')}` : '');
 
   // ── 5. Required Agents in agents.json ───────────────────────────────────
-  console.log(chalk.cyan(`\n  .morph/config/agents.json — Required Agents (${REQUIRED_AGENTS.length})`));
-  const agentsPath = join(frameworkRoot, '.morph/config/agents.json');
+  console.log(chalk.cyan(`\n  .morph/framework/agents.json — Required Agents (${REQUIRED_AGENTS.length})`));
+  const agentsPath = join(frameworkRoot, '.morph/framework/agents.json');
   if (await pathExists(agentsPath)) {
     try {
       const agentsConfig = JSON.parse(await fs.readFile(agentsPath, 'utf8'));
@@ -264,6 +265,31 @@ async function doctorFullCommand(frameworkRoot) {
 }
 
 export async function doctorCommand(options = {}) {
+  // Reset mode: remove morph-managed settings entries
+  if (options.reset) {
+    const targetPath = process.cwd();
+    logger.header('MORPH-SPEC Settings Reset');
+
+    const result = await resetMorphSettings(targetPath);
+
+    if (!result.removed) {
+      logger.warn(`Nothing to reset: ${result.reason}`);
+      return;
+    }
+
+    logger.success('Morph-managed settings removed.');
+    if (result.permissionsRemoved?.length > 0) {
+      logger.dim(`  Permissions removed: ${result.permissionsRemoved.join(', ')}`);
+    }
+    if (result.envRemoved?.length > 0) {
+      logger.dim(`  Env vars removed: ${result.envRemoved.join(', ')}`);
+    }
+    if (result.backupPath) {
+      logger.dim(`  Backup saved: ${result.backupPath}`);
+    }
+    return;
+  }
+
   // full health check mode
   if (options.full) {
     const frameworkRoot = process.cwd();
@@ -383,7 +409,7 @@ export async function doctorCommand(options = {}) {
   }
 
   // Check agents.json
-  const agentsPath = join(morphPath, 'config', 'agents.json');
+  const agentsPath = join(morphPath, 'framework', 'agents.json');
   if (await pathExists(agentsPath)) {
     checks.push({ name: 'agents.json', status: 'ok' });
   } else {
@@ -391,8 +417,8 @@ export async function doctorCommand(options = {}) {
     hasErrors = true;
   }
 
-  // Check standards (either in project .morph/standards/ or in framework package)
-  const standardsPath = join(morphPath, 'standards');
+  // Check standards (either in project .morph/framework/standards/ or in framework package)
+  const standardsPath = join(morphPath, 'framework', 'standards');
   const frameworkStdsRoot = join(import.meta.dirname, '..', '..', '..', 'framework', 'standards');
   if (await pathExists(standardsPath)) {
     // Check for core standards in hierarchy (copied by init) or flat layout
@@ -416,7 +442,7 @@ export async function doctorCommand(options = {}) {
   }
 
   // Check templates
-  const templatesPath = join(morphPath, 'templates');
+  const templatesPath = join(morphPath, 'framework', 'templates');
   if (await pathExists(templatesPath)) {
     checks.push({ name: 'templates/', status: 'ok' });
   } else {
@@ -459,6 +485,28 @@ export async function doctorCommand(options = {}) {
           hasWarnings = true;
         }
       }
+
+      // Check .claude/rules/
+      const rulesPath = join(claudePath, 'rules');
+      if (await pathExists(rulesPath)) {
+        const ruleFiles = await fs.readdir(rulesPath);
+        const mdRules = ruleFiles.filter(f => f.endsWith('.md'));
+        checks.push({ name: '.claude/rules/', status: 'ok', msg: `${mdRules.length} rules` });
+      } else {
+        checks.push({ name: '.claude/rules/', status: 'warn', msg: 'missing — run morph-spec update' });
+        hasWarnings = true;
+      }
+
+      // Check .claude/agents/
+      const agentsPath = join(claudePath, 'agents');
+      if (await pathExists(agentsPath)) {
+        const agentFiles = await fs.readdir(agentsPath);
+        const morphAgents = agentFiles.filter(f => f.startsWith('morph-') && f.endsWith('.md'));
+        checks.push({ name: '.claude/agents/', status: 'ok', msg: `${morphAgents.length} agents` });
+      } else {
+        checks.push({ name: '.claude/agents/', status: 'warn', msg: 'missing — run morph-spec update' });
+        hasWarnings = true;
+      }
     } else {
       checks.push({ name: '.claude/', status: 'warn', msg: 'incomplete structure' });
     }