@polymorphism-tech/morph-spec 1.0.2 → 2.0.0

package/src/commands/doctor.js

@@ -2,6 +2,11 @@ import { join } from 'path';
 import chalk from 'chalk';
 import { logger } from '../utils/logger.js';
 import { pathExists, readJson } from '../utils/file-copier.js';
+import {
+  checkCLIOutdated,
+  checkProjectOutdated,
+  getInstalledCLIVersion
+} from '../utils/version-checker.js';
 
 export async function doctorCommand() {
   const targetPath = process.cwd();
@@ -10,6 +15,58 @@ export async function doctorCommand() {
 
   const checks = [];
   let hasErrors = false;
+  let hasWarnings = false;
+
+  // Check versions first
+  const cliCheck = await checkCLIOutdated();
+  const projectCheck = await checkProjectOutdated(targetPath);
+
+  // CLI Version
+  if (cliCheck.latest) {
+    if (cliCheck.isOutdated) {
+      checks.push({
+        name: `CLI version (${cliCheck.current})`,
+        status: 'warn',
+        msg: `outdated, ${cliCheck.latest} available`
+      });
+      hasWarnings = true;
+    } else {
+      checks.push({
+        name: `CLI version (${cliCheck.current})`,
+        status: 'ok',
+        msg: 'latest'
+      });
+    }
+  } else {
+    checks.push({
+      name: `CLI version (${cliCheck.current})`,
+      status: 'ok'
+    });
+  }
+
+  // Project MORPH version
+  if (projectCheck.current) {
+    if (projectCheck.isOutdated) {
+      checks.push({
+        name: `Project MORPH version (${projectCheck.current})`,
+        status: 'warn',
+        msg: `outdated, ${projectCheck.cliVersion} available`
+      });
+      hasWarnings = true;
+    } else {
+      checks.push({
+        name: `Project MORPH version (${projectCheck.current})`,
+        status: 'ok'
+      });
+    }
+  } else {
+    checks.push({
+      name: 'Project MORPH version',
+      status: 'warn',
+      msg: 'not found (legacy installation)'
+    });
+    hasWarnings = true;
+  }
 
   // Check CLAUDE.md
   const claudeMd = join(targetPath, 'CLAUDE.md');
@@ -126,6 +183,16 @@ export async function doctorCommand() {
   if (hasErrors) {
     logger.error('Some checks failed. Run "morph-spec init --force" to fix.');
     process.exit(1);
+  } else if (hasWarnings) {
+    logger.warn('Some checks need attention.');
+    logger.blank();
+
+    if (cliCheck.isOutdated || projectCheck.isOutdated) {
+      logger.info('To update:');
+      logger.dim('  1. Update the CLI: npm install -g @polymorphism-tech/morph-spec@latest');
+      logger.dim('  2. Update the project: morph-spec update');
+      logger.blank();
+    }
   } else {
     logger.success('All checks passed!');
   }

package/src/commands/generate.js

@@ -0,0 +1,149 @@
+/**
+ * MORPH-SPEC Generate Command
+ * CLI wrapper for code generation operations
+ */
+
+import { mkdirSync, writeFileSync } from 'fs';
+import { dirname } from 'path';
+import ora from 'ora';
+import chalk from 'chalk';
+import { logger } from '../utils/logger.js';
+import * as DesignSystemGenerator from '../lib/design-system-generator.js';
+
+// ============================================================================
+// Design System Subcommand
+// ============================================================================
+
+/**
+ * Generate design system files (CSS + themes) from ui-design-system.md
+ * @param {string} designSystemPath - Path to ui-design-system.md
+ * @param {Object} options - CLI options
+ */
+export async function generateDesignSystemCommand(designSystemPath, options) {
+  if (!designSystemPath) {
+    logger.error('Design system file path required');
+    logger.dim('  Usage: morph-spec generate design-system <ui-design-system.md>');
+    logger.blank();
+    logger.dim('  Example:');
+    logger.dim('    morph-spec generate design-system .morph/project/outputs/my-feature/ui-design-system.md');
+    process.exit(1);
+  }
+
+  logger.header('MORPH-SPEC Design System Generator');
+  logger.blank();
+
+  const spinner = ora('Parsing design system...').start();
+
+  try {
+    // Determine mode
+    let mode = 'both';
+    if (options.fluent && !options.mud) mode = 'fluent';
+    if (options.mud && !options.fluent) mode = 'mud';
+
+    // Generate design system
+    const generated = DesignSystemGenerator.generateDesignSystem(designSystemPath, {
+      mode,
+      namespace: options.namespace || 'YourProject.Themes'
+    });
+
+    spinner.succeed('Design system parsed!');
+    logger.blank();
+
+    // Display stats
+    logger.header('Parsed Design System:');
+    logger.info(`Primary Colors: ${chalk.cyan(generated.stats.primaryColors)}`);
+    logger.info(`Neutral Colors: ${chalk.cyan(generated.stats.neutralColors)}`);
+    logger.info(`Semantic Colors: ${chalk.cyan(generated.stats.semanticColors)}`);
+    logger.info(`Font Sizes: ${chalk.cyan(generated.stats.fontSizes)}`);
+    logger.info(`Spacing Values: ${chalk.cyan(generated.stats.spacingValues)}`);
+    logger.blank();
+
+    if (options.dryRun) {
+      logger.warn('Dry run - files not written');
+      logger.blank();
+      logger.header('Would generate:');
+      logger.dim('  - wwwroot/css/design-system.css');
+      if (generated.fluentTheme) logger.dim('  - Themes/FluentDesignTheme.cs');
+      if (generated.mudTheme) logger.dim('  - Themes/MudDesignTheme.cs');
+      logger.blank();
+      return;
+    }
+
+    // Write files
+    const writeSpinner = ora('Writing files...').start();
+
+    // Write CSS
+    const cssPath = options.cssOutput || 'wwwroot/css/design-system.css';
+    mkdirSync(dirname(cssPath), { recursive: true });
+    writeFileSync(cssPath, generated.css);
+    writeSpinner.text = `Created ${cssPath}`;
+
+    // Write Fluent theme
+    if (generated.fluentTheme) {
+      const fluentPath = options.fluentOutput || 'Themes/FluentDesignTheme.cs';
+      mkdirSync(dirname(fluentPath), { recursive: true });
+      writeFileSync(fluentPath, generated.fluentTheme);
+      writeSpinner.text = `Created ${fluentPath}`;
+    }
+
+    // Write MudBlazor theme
+    if (generated.mudTheme) {
+      const mudPath = options.mudOutput || 'Themes/MudDesignTheme.cs';
+      mkdirSync(dirname(mudPath), { recursive: true });
+      writeFileSync(mudPath, generated.mudTheme);
+      writeSpinner.text = `Created ${mudPath}`;
+    }
+
+    writeSpinner.succeed('Files generated!');
+    logger.blank();
+
+    // List generated files
+    logger.header('Generated Files:');
+    logger.success(`  ✓ ${cssPath}`);
+    if (generated.fluentTheme) logger.success(`  ✓ ${options.fluentOutput || 'Themes/FluentDesignTheme.cs'}`);
+    if (generated.mudTheme) logger.success(`  ✓ ${options.mudOutput || 'Themes/MudDesignTheme.cs'}`);
+    logger.blank();
+
+    // Next steps
+    logger.header('Next Steps:');
+    logger.dim('  1. Reference design-system.css in your layout');
+    logger.dim('  2. Register theme in Program.cs');
+    logger.dim('  3. Apply theme to your components');
+    logger.blank();
+
+  } catch (error) {
+    spinner.fail('Generation failed');
+    logger.error(error.message);
+    process.exit(1);
+  }
+}
+
+// ============================================================================
+// Main Generate Command (router for future subcommands)
+// ============================================================================
+
+/**
+ * Main generate command router
+ * Future: Could add more generation commands here
+ */
+export async function generateCommand(subcommand, args, options) {
+  switch (subcommand) {
+    case 'design-system':
+      await generateDesignSystemCommand(args[0], options);
+      break;
+
+    // Future: Add more generation commands
+    // case 'component':
+    //   await generateComponentCommand(args[0], options);
+    //   break;
+
+    default:
+      logger.error(`Unknown subcommand: ${subcommand}`);
+      logger.blank();
+      logger.info('Available subcommands:');
+      logger.dim('  design-system    Generate CSS + theme files from ui-design-system.md');
+      logger.blank();
+      logger.dim('Run "morph-spec generate --help" for more information');
+      process.exit(1);
+  }
+}

package/src/commands/init.js

@@ -10,12 +10,15 @@ import {
   readJson,
   writeJson,
   ensureDir,
-  writeFile
+  writeFile,
+  readFile,
+  updateGitignore
 } from '../utils/file-copier.js';
+import { saveProjectMorphVersion, getInstalledCLIVersion } from '../utils/version-checker.js';
 
 export async function initCommand(options) {
   const targetPath = options.path || process.cwd();
-  const contentDir = getContentDir();
+  const claudeMdPath = join(import.meta.dirname, '..', '..', 'CLAUDE.md');
 
   logger.header('MORPH-SPEC Framework Installation');
   logger.dim(`Target: ${targetPath}`);
@@ -37,80 +40,102 @@ export async function initCommand(options) {
   try {
     // 1. Copy CLAUDE.md
     spinner.text = 'Copying CLAUDE.md...';
-    const claudeMdSrc = join(contentDir, 'CLAUDE.md');
     const claudeMdDest = join(targetPath, 'CLAUDE.md');
 
     // Backup existing CLAUDE.md if not from MORPH
     if (await pathExists(claudeMdDest)) {
-      const existingContent = await import('fs-extra').then(fs => fs.readFile(claudeMdDest, 'utf8'));
+      const existingContent = await readFile(claudeMdDest);
       if (!existingContent.includes('MORPH-SPEC')) {
         await copyFile(claudeMdDest, `${claudeMdDest}.backup`);
         logger.dim('Backed up existing CLAUDE.md');
       }
     }
-    await copyFile(claudeMdSrc, claudeMdDest);
-
-    // 2. Copy .morph folder
-    spinner.text = 'Copying .morph/...';
-    const morphSrc = join(contentDir, '.morph');
-    await copyDirectory(morphSrc, morphPath);
-
-    // 3. Create empty directories with .gitkeep
-    for (const dir of ['specs', 'features', 'archive']) {
-      const dirPath = join(morphPath, dir);
-      await ensureDir(dirPath);
-      const gitkeepPath = join(dirPath, '.gitkeep');
-      if (!(await pathExists(gitkeepPath))) {
-        await writeFile(gitkeepPath, '');
-      }
-    }
+    await copyFile(claudeMdPath, claudeMdDest);
 
-    // 4. Create config.json from template
+    // 2. Create .morph/project structure
+    spinner.text = 'Creating .morph/project structure...';
+    const projectPath = join(morphPath, 'project');
+    await ensureDir(join(projectPath, 'context'));
+    await ensureDir(join(projectPath, 'standards'));
+    await ensureDir(join(projectPath, 'outputs'));
+
+    // 3. Create config.json
     spinner.text = 'Generating config.json...';
-    const configPath = join(morphPath, 'config', 'config.json');
-    const templatePath = join(morphPath, 'config', 'config.template.json');
+    const configPath = join(morphPath, 'config.json');
+    const dirName = targetPath.split(/[\\/]/).pop();
+
+    const config = {
+      framework: 'global',
+      frameworkVersion: getInstalledCLIVersion(),
+      project: {
+        name: dirName,
+        stack: 'unknown',
+        architecture: 'unknown'
+      }
+    };
 
-    if (await pathExists(templatePath)) {
-      const config = await readJson(templatePath);
+    await writeJson(configPath, config);
 
-      // Try to detect project name from directory or .sln
-      const dirName = targetPath.split(/[\\/]/).pop();
-      config.project = config.project || {};
-      config.project.name = dirName;
-      config.project.description = `Projeto ${dirName} gerenciado pelo MORPH-SPEC Framework`;
+    // 4. Create context/README.md
+    spinner.text = 'Creating context README...';
+    const contextReadme = join(projectPath, 'context', 'README.md');
+    const readmeContent = `# ${dirName} - Project Context
 
-      await writeJson(configPath, config);
-    }
+## Overview
 
-    // 5. Copy .claude folder
-    spinner.text = 'Copying .claude/...';
-    const claudeSrc = join(contentDir, '.claude');
-    const claudeDest = join(targetPath, '.claude');
+This file will be auto-updated by MORPH-SPEC detection system.
 
-    if (await pathExists(claudeSrc)) {
-      await copyDirectory(claudeSrc, claudeDest);
-    }
+## Stack
+
+Run \`morph-spec detect\` to analyze your project.
+
+## Technologies
+
+(To be detected)
+
+## Architecture
+
+(To be detected)
+`;
+    await writeFile(contextReadme, readmeContent);
+
+    // 5. Save version info
+    spinner.text = 'Saving version info...';
+    const cliVersion = getInstalledCLIVersion();
+    await saveProjectMorphVersion(targetPath, cliVersion);
+
+    // 6. Update .gitignore
+    spinner.text = 'Updating .gitignore...';
+    await updateGitignore(targetPath);
 
     spinner.succeed('MORPH-SPEC installed successfully!');
 
     // Show next steps
     logger.blank();
+    logger.success(`MORPH-SPEC v${cliVersion} installed successfully!`);
+    logger.blank();
     logger.header('Next Steps');
 
-    logger.step(1, 'Edit .morph/project.md with your project details');
-    logger.step(2, 'Review .morph/config/config.json');
+    logger.step(1, 'Run detection: morph-spec detect');
+    logger.step(2, 'Review .morph/config.json and .morph/project/standards/inferred.md');
     logger.step(3, 'Open project in VS Code with Claude Code');
     logger.step(4, 'Start your first feature:');
     logger.blank();
     logger.box([
-      '/morph-proposal [feature-name]'
+      'Ask Claude Code to implement a feature'
     ]);
     logger.blank();
 
-    logger.info('Documentation:');
-    logger.dim(`CLAUDE.md      → ${join(targetPath, 'CLAUDE.md')}`);
-    logger.dim(`Standards      → ${join(targetPath, '.morph', 'standards')}`);
-    logger.dim(`Templates      → ${join(targetPath, '.morph', 'templates')}`);
+    logger.info('Structure created:');
+    logger.dim(`CLAUDE.md                → ${join(targetPath, 'CLAUDE.md')}`);
+    logger.dim(`.morph/config.json       → Project config`);
+    logger.dim(`.morph/project/context/  → Project context`);
+    logger.dim(`.morph/project/standards/→ Project standards`);
+    logger.dim(`.morph/project/outputs/  → Feature outputs`);
+    logger.blank();
+
+    logger.info('Content (via npm package):');
+    logger.dim(`Templates and standards available via morph-spec update`);
     logger.blank();
 
   } catch (error) {

package/src/commands/shard-spec.js

@@ -0,0 +1,224 @@
+/**
+ * MORPH-SPEC Document Sharding
+ * Splits large spec.md files into manageable shards (BMAD-inspired)
+ * Achieves 90% token savings by loading only relevant sections
+ */
+
+import fs from 'fs';
+import path from 'path';
+import ora from 'ora';
+import chalk from 'chalk';
+import { logger } from '../utils/logger.js';
+import { ensureDir, writeFile } from '../utils/file-copier.js';
+
+// ============================================================================
+// Helper Functions
+// ============================================================================
+
+function parseSpec(specContent) {
+  const sections = [];
+  const lines = specContent.split('\n');
+
+  let currentSection = null;
+  let currentContent = [];
+
+  for (const line of lines) {
+    // Detect level 2 heading (## Heading)
+    if (line.match(/^## /)) {
+      // Save previous section
+      if (currentSection) {
+        sections.push({
+          title: currentSection,
+          slug: toSlug(currentSection),
+          content: currentContent.join('\n').trim(),
+        });
+      }
+
+      // Start new section
+      currentSection = line.replace(/^## /, '').trim();
+      currentContent = [line]; // Include heading in content
+    } else {
+      currentContent.push(line);
+    }
+  }
+
+  // Save last section
+  if (currentSection) {
+    sections.push({
+      title: currentSection,
+      slug: toSlug(currentSection),
+      content: currentContent.join('\n').trim(),
+    });
+  }
+
+  return sections;
+}
+
+function toSlug(title) {
+  return title
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-|-$/g, '');
+}
+
+function generateIndex(sections, featureName) {
+  let index = `# ${toTitleCase(featureName)} - Technical Specification\n\n`;
+  index += `> **Sharded Spec:** This spec has been split into sections for optimal token usage\n`;
+  index += `> **BMAD Pattern:** Load only the section you need during implementation\n\n`;
+  index += `---\n\n`;
+  index += `## 📋 Table of Contents\n\n`;
+
+  sections.forEach((section, i) => {
+    index += `${i + 1}. **[${section.title}](${section.slug}.md)**\n`;
+
+    // Add first 100 chars as description
+    const firstLine = section.content.split('\n').find(l => l.trim() && !l.startsWith('#'));
+    const description = firstLine ? firstLine.substring(0, 100) + '...' : 'See section for details';
+    index += `   > ${description}\n\n`;
+  });
+
+  index += `---\n\n`;
+  index += `## 💡 How to Use Sharded Specs\n\n`;
+  index += `### In Planning Phases (1-3)\n`;
+  index += `Load **all sections** to get complete context:\n`;
+  index += `\`\`\`bash\n`;
+  index += `# Read index.md + all section files\n`;
+  index += `\`\`\`\n\n`;
+
+  index += `### In Implementation Phase (4)\n`;
+  index += `Load **only the relevant section** for your current story:\n`;
+  index += `\`\`\`bash\n`;
+  index += `# Example: Working on entity design story\n`;
+  index += `# Read: spec/index.md + spec/entity-design.md (not the other 10 sections!)\n`;
+  index += `\`\`\`\n\n`;
+
+  index += `**Token Savings:** For a 10-section spec (30k tokens), selective loading = **90% savings**\n\n`;
+  index += `---\n\n`;
+  index += `*Generated by MORPH-SPEC Framework - Document Sharding*\n`;
+  index += `*Inspired by BMAD Method: 90% token reduction for large specs*\n`;
+
+  return index;
+}
+
+function toTitleCase(str) {
+  return str
+    .split('-')
+    .map(word => word.charAt(0).toUpperCase() + word.slice(1))
+    .join(' ');
+}
+
+function estimateTokens(text) {
+  // Rough estimate: 1 token ≈ 4 characters
+  return Math.ceil(text.length / 4);
+}
+
+// ============================================================================
+// Command Function
+// ============================================================================
+
+export async function shardSpecCommand(feature, options) {
+  logger.header('MORPH-SPEC Document Sharding');
+  logger.dim(`Feature: ${feature}`);
+  logger.blank();
+
+  const spinner = ora('Analyzing spec.md...').start();
+
+  try {
+    // Find spec.md
+    const specPath = path.join(process.cwd(), `.morph/project/outputs/${feature}/spec.md`);
+    if (!fs.existsSync(specPath)) {
+      throw new Error(`Spec not found: ${specPath}`);
+    }
+
+    // Read spec content
+    const specContent = fs.readFileSync(specPath, 'utf-8');
+    const totalTokens = estimateTokens(specContent);
+
+    spinner.info(`Original spec.md: ~${totalTokens.toLocaleString()} tokens`);
+    logger.blank();
+
+    // Parse into sections
+    const sections = parseSpec(specContent);
+
+    if (sections.length < 3) {
+      spinner.warn(`Spec has only ${sections.length} sections - sharding not recommended`);
+      logger.dim('  Sharding is most beneficial for specs with 5+ sections');
+      return;
+    }
+
+    spinner.succeed(`Detected ${sections.length} sections`);
+    logger.blank();
+
+    // Generate index
+    const indexContent = generateIndex(sections, feature);
+
+    // Calculate savings
+    const avgShardTokens = sections.reduce((sum, s) => sum + estimateTokens(s.content), 0) / sections.length;
+    const savingsPercent = Math.round(((totalTokens - avgShardTokens) / totalTokens) * 100);
+
+    logger.header('Token Savings (selective load):');
+    logger.info(`  ${chalk.green(`~${savingsPercent}%`)} reduction`);
+    logger.dim(`  - Full load: ~${totalTokens.toLocaleString()} tokens`);
+    logger.dim(`  - Selective load: ~${Math.round(avgShardTokens).toLocaleString()} tokens (index + 1 shard)`);
+    logger.blank();
+
+    if (options.verbose) {
+      logger.header('Shard Details:');
+      logger.blank();
+      sections.forEach((section, i) => {
+        const tokens = estimateTokens(section.content);
+        logger.dim(`  ${i + 1}. ${section.title}`);
+        logger.dim(`     File: ${section.slug}.md`);
+        logger.dim(`     Tokens: ~${tokens.toLocaleString()}`);
+        logger.blank();
+      });
+    }
+
+    // Output
+    const outputDir = path.join(process.cwd(), `.morph/project/outputs/${feature}/spec`);
+
+    if (options.dryRun) {
+      logger.header('DRY RUN - Would create:');
+      logger.dim(`  ${outputDir}/index.md`);
+      sections.forEach(s => logger.dim(`  ${outputDir}/${s.slug}.md`));
+      logger.blank();
+      logger.success('Run without --dry-run to create files');
+    } else {
+      const createSpinner = ora('Creating sharded spec files...').start();
+
+      // Create directory
+      await ensureDir(outputDir);
+
+      // Write index
+      await writeFile(path.join(outputDir, 'index.md'), indexContent);
+      createSpinner.text = 'Created index.md';
+
+      // Write shards
+      for (const section of sections) {
+        const shardPath = path.join(outputDir, `${section.slug}.md`);
+        await writeFile(shardPath, section.content);
+        createSpinner.text = `Created ${section.slug}.md`;
+      }
+
+      createSpinner.succeed('Sharded spec created!');
+      logger.blank();
+
+      // Archive original spec.md
+      const archivePath = specPath.replace('.md', '.original.md');
+      fs.renameSync(specPath, archivePath);
+      logger.dim('  Archived original: spec.original.md');
+      logger.blank();
+
+      logger.header('Next steps:');
+      logger.dim(`  1. Review sharded spec in .morph/project/outputs/${feature}/spec/`);
+      logger.dim(`  2. Create stories: morph-spec story create ${feature} SR-001`);
+      logger.dim('  3. Stories will auto-load only relevant shards (90% token savings)');
+      logger.blank();
+    }
+
+  } catch (error) {
+    spinner.fail('Sharding failed');
+    logger.error(error.message);
+    process.exit(1);
+  }
+}