@polymorphism-tech/morph-spec 3.0.1 → 3.2.0

package/src/ui/user-review.js

@@ -0,0 +1,211 @@
+/**
+ * @fileoverview UserReview - Prompts user for approval of generated configs
+ * @module morph-spec/ui/user-review
+ */
+
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import { displayDiff, displayConfigSummary } from './diff-display.js';
+import { writeFile, readFile, access } from 'fs/promises';
+import { join } from 'path';
+import { execSync } from 'child_process';
+import { tmpdir } from 'os';
+
+/**
+ * @typedef {import('../types/index.js').GeneratedConfigs} GeneratedConfigs
+ * @typedef {import('../types/index.js').ProjectConfig} ProjectConfig
+ * @typedef {import('../types/index.js').ApprovalResponse} ApprovalResponse
+ */
+
+/**
+ * UserReview - Handles user review and approval of generated configs
+ * @class
+ */
+export class UserReview {
+  /**
+   * Prompt user for approval of generated configs
+   * @param {GeneratedConfigs} configs - Generated configs
+   * @param {ProjectConfig} projectConfig - Detected project config
+   * @param {Object} [existingConfigs] - Existing configs (if updating)
+   * @returns {Promise<ApprovalResponse>}
+   */
+  async promptForApproval(configs, projectConfig, existingConfigs = null) {
+    console.log(chalk.bold.cyan('\n🔍 Auto-Detected Project Configuration\n'));
+
+    // Display summary
+    this.displayPreview(projectConfig);
+
+    // If updating existing configs, show diff
+    if (existingConfigs) {
+      if (existingConfigs.projectMd) {
+        displayDiff(existingConfigs.projectMd, configs.projectMd, 'project.md');
+      }
+      if (existingConfigs.configJson) {
+        try {
+          const oldConfig = JSON.parse(existingConfigs.configJson);
+          displayConfigSummary(oldConfig, configs.configObject);
+        } catch (error) {
+          // Couldn't parse old config, skip summary
+        }
+      }
+    }
+
+    // Prompt for action
+    const { action } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'action',
+        message: 'What would you like to do?',
+        choices: [
+          { name: '✅ Approve and save configs', value: 'approve' },
+          { name: '✏️  Edit configs before saving', value: 'edit' },
+          { name: '❌ Cancel and exit', value: 'cancel' }
+        ],
+        default: 'approve'
+      }
+    ]);
+
+    switch (action) {
+      case 'approve':
+        return { action: 'approve' };
+
+      case 'edit':
+        const editedConfigs = await this.openInEditor(configs);
+        return { action: 'approve', editedConfigs };
+
+      case 'cancel':
+        const { reason } = await inquirer.prompt([
+          {
+            type: 'input',
+            name: 'reason',
+            message: 'Why are you canceling? (optional)',
+            default: 'User canceled'
+          }
+        ]);
+        return { action: 'cancel', cancelReason: reason };
+
+      default:
+        return { action: 'cancel', cancelReason: 'Unknown action' };
+    }
+  }
+
+  /**
+   * Display preview of detected configuration
+   * @param {ProjectConfig} projectConfig - Detected project config
+   */
+  displayPreview(projectConfig) {
+    console.log(chalk.bold('  Name:        ') + chalk.cyan(projectConfig.name));
+    console.log(chalk.bold('  Type:        ') + chalk.yellow(projectConfig.type));
+    console.log(chalk.bold('  Description: ') + chalk.white(projectConfig.description));
+    console.log();
+
+    console.log(chalk.bold('  Stack:'));
+    if (projectConfig.stack.frontend) {
+      console.log(chalk.gray('    Frontend:  ') + chalk.white(`${projectConfig.stack.frontend.tech} ${projectConfig.stack.frontend.version}`));
+    }
+    console.log(chalk.gray('    Backend:   ') + chalk.white(`${projectConfig.stack.backend.tech} ${projectConfig.stack.backend.version}`));
+    if (projectConfig.stack.database) {
+      console.log(chalk.gray('    Database:  ') + chalk.white(`${projectConfig.stack.database.tech} ${projectConfig.stack.database.version}`));
+    }
+    if (projectConfig.stack.hosting) {
+      console.log(chalk.gray('    Hosting:   ') + chalk.white(projectConfig.stack.hosting));
+    }
+    console.log();
+
+    console.log(chalk.bold('  Architecture: ') + chalk.magenta(projectConfig.architecture));
+    console.log(chalk.bold('  Conventions:  ') + chalk.white(projectConfig.conventions));
+    console.log();
+
+    // Infrastructure flags
+    const flags = [];
+    if (projectConfig.hasAzure) flags.push(chalk.blue('Azure'));
+    if (projectConfig.hasDocker) flags.push(chalk.cyan('Docker'));
+    if (projectConfig.hasDevOps) flags.push(chalk.green('CI/CD'));
+
+    if (flags.length > 0) {
+      console.log(chalk.bold('  Infrastructure: ') + flags.join(' • '));
+      console.log();
+    }
+
+    // Confidence and warnings
+    const confidenceColor = projectConfig.confidence >= 90 ? chalk.green : projectConfig.confidence >= 70 ? chalk.yellow : chalk.red;
+    console.log(chalk.bold('  Confidence: ') + confidenceColor(`${projectConfig.confidence}%`));
+
+    if (projectConfig.warnings && projectConfig.warnings.length > 0) {
+      console.log(chalk.bold.yellow('\n  ⚠️  Warnings:'));
+      projectConfig.warnings.forEach(warning => {
+        console.log(chalk.yellow(`    • ${warning}`));
+      });
+    }
+
+    console.log();
+  }
+
+  /**
+   * Display diff between current and generated configs
+   * @param {string} current - Current config content
+   * @param {string} generated - Generated config content
+   */
+  displayDiff(current, generated) {
+    displayDiff(current, generated, 'config');
+  }
+
+  /**
+   * Open configs in editor for manual editing
+   * @param {GeneratedConfigs} configs - Configs to edit
+   * @returns {Promise<GeneratedConfigs>} Edited configs
+   */
+  async openInEditor(configs) {
+    console.log(chalk.cyan('\n📝 Opening configs in editor...\n'));
+
+    // Write to temp files
+    const tempDir = tmpdir();
+    const projectMdPath = join(tempDir, 'morph-project.md');
+    const configJsonPath = join(tempDir, 'morph-config.json');
+
+    await Promise.all([
+      writeFile(projectMdPath, configs.projectMd, 'utf-8'),
+      writeFile(configJsonPath, configs.configJson, 'utf-8')
+    ]);
+
+    // Get editor from environment or use default
+    const editor = process.env.EDITOR || process.env.VISUAL || 'nano';
+
+    console.log(chalk.dim(`  Using editor: ${editor}`));
+    console.log(chalk.dim(`  Files: ${projectMdPath}, ${configJsonPath}`));
+    console.log(chalk.yellow('\n  Press ENTER when done editing...'));
+
+    // Open editor (blocking)
+    try {
+      execSync(`${editor} "${projectMdPath}" "${configJsonPath}"`, {
+        stdio: 'inherit'
+      });
+    } catch (error) {
+      console.log(chalk.yellow('\n⚠️  Editor exited with error, using original configs\n'));
+      return configs;
+    }
+
+    // Read edited files
+    const [editedProjectMd, editedConfigJson] = await Promise.all([
+      readFile(projectMdPath, 'utf-8'),
+      readFile(configJsonPath, 'utf-8')
+    ]);
+
+    // Parse config.json
+    let editedConfigObject;
+    try {
+      editedConfigObject = JSON.parse(editedConfigJson);
+    } catch (error) {
+      console.log(chalk.red('\n❌ Edited config.json is not valid JSON. Using original.\n'));
+      return configs;
+    }
+
+    console.log(chalk.green('\n✅ Configs edited successfully\n'));
+
+    return {
+      projectMd: editedProjectMd,
+      configJson: editedConfigJson,
+      configObject: editedConfigObject
+    };
+  }
+}

package/src/ui/wizard-questions.js

@@ -0,0 +1,190 @@
+/**
+ * @fileoverview Wizard Questions - Defines interactive wizard questions
+ * @module morph-spec/ui/wizard-questions
+ */
+
+/**
+ * Get wizard questions for interactive mode
+ * @returns {Array} Inquirer questions
+ */
+export function getWizardQuestions() {
+  return [
+    {
+      type: 'input',
+      name: 'name',
+      message: '1/7 Project name:',
+      default: process.cwd().split(/[/\\]/).pop(),
+      validate: (input) => {
+        if (!input || input.trim().length === 0) {
+          return 'Project name is required';
+        }
+        return true;
+      }
+    },
+    {
+      type: 'input',
+      name: 'description',
+      message: '2/7 Project description (1-2 sentences):',
+      validate: (input) => {
+        if (!input || input.trim().length < 10) {
+          return 'Description must be at least 10 characters';
+        }
+        return true;
+      }
+    },
+    {
+      type: 'list',
+      name: 'type',
+      message: '3/7 Project type:',
+      choices: [
+        { name: 'Blazor Server (.NET)', value: 'blazor-server' },
+        { name: 'Next.js (React)', value: 'nextjs' },
+        { name: '.NET Web API', value: 'dotnet-api' },
+        { name: 'CLI Tool', value: 'cli-tool' },
+        { name: 'Monorepo (multiple projects)', value: 'monorepo' },
+        { name: 'Other', value: 'other' }
+      ]
+    },
+    {
+      type: 'list',
+      name: 'frontend',
+      message: '4/7 Frontend technology:',
+      choices: [
+        { name: 'Blazor Server', value: 'blazor' },
+        { name: 'Next.js', value: 'nextjs' },
+        { name: 'React', value: 'react' },
+        { name: 'Vue.js', value: 'vue' },
+        { name: 'Angular', value: 'angular' },
+        { name: 'None (backend-only)', value: null }
+      ],
+      when: (answers) => answers.type !== 'cli-tool' && answers.type !== 'dotnet-api'
+    },
+    {
+      type: 'list',
+      name: 'backend',
+      message: '5/7 Backend technology:',
+      choices: [
+        { name: '.NET 10', value: 'dotnet-10' },
+        { name: '.NET 9', value: 'dotnet-9' },
+        { name: '.NET 8', value: 'dotnet-8' },
+        { name: 'Node.js', value: 'nodejs' },
+        { name: 'Supabase', value: 'supabase' },
+        { name: 'Firebase', value: 'firebase' },
+        { name: 'Other', value: 'other' }
+      ],
+      default: 'dotnet-10'
+    },
+    {
+      type: 'list',
+      name: 'database',
+      message: '6/7 Database:',
+      choices: [
+        { name: 'Azure SQL Database', value: 'azure-sql' },
+        { name: 'PostgreSQL', value: 'postgresql' },
+        { name: 'Cosmos DB', value: 'cosmosdb' },
+        { name: 'MongoDB', value: 'mongodb' },
+        { name: 'SQLite', value: 'sqlite' },
+        { name: 'Supabase (PostgreSQL)', value: 'supabase' },
+        { name: 'None (no database)', value: null }
+      ]
+    },
+    {
+      type: 'confirm',
+      name: 'hasAzure',
+      message: '7a/7 Uses Azure infrastructure?',
+      default: false
+    },
+    {
+      type: 'confirm',
+      name: 'hasDocker',
+      message: '7b/7 Uses Docker containerization?',
+      default: true
+    }
+  ];
+}
+
+/**
+ * Map wizard answers to ProjectConfig
+ * @param {Object} answers - Wizard answers from inquirer
+ * @returns {ProjectConfig} Mapped project config
+ */
+export function mapAnswersToConfig(answers) {
+  // Parse backend tech and version
+  const backendParts = answers.backend.split('-');
+  const backendTech = backendParts[0] === 'dotnet' ? '.NET' :
+                      backendParts[0] === 'nodejs' ? 'Node.js' :
+                      answers.backend;
+  const backendVersion = backendParts[1] || 'latest';
+
+  // Map frontend
+  let frontend = null;
+  if (answers.frontend) {
+    const frontendMap = {
+      'blazor': { tech: 'Blazor', version: backendVersion, details: 'Blazor Server' },
+      'nextjs': { tech: 'Next.js', version: '15', details: 'App Router' },
+      'react': { tech: 'React', version: '18', details: null },
+      'vue': { tech: 'Vue.js', version: '3', details: null },
+      'angular': { tech: 'Angular', version: '17', details: null }
+    };
+    frontend = frontendMap[answers.frontend] || null;
+  }
+
+  // Map database
+  let database = null;
+  if (answers.database) {
+    const databaseMap = {
+      'azure-sql': { tech: 'Azure SQL', version: 'latest', details: 'Managed SQL Database' },
+      'postgresql': { tech: 'PostgreSQL', version: '16', details: null },
+      'cosmosdb': { tech: 'Cosmos DB', version: 'latest', details: 'NoSQL' },
+      'mongodb': { tech: 'MongoDB', version: '7', details: null },
+      'sqlite': { tech: 'SQLite', version: '3', details: null },
+      'supabase': { tech: 'PostgreSQL', version: '16', details: 'Managed by Supabase' }
+    };
+    database = databaseMap[answers.database] || null;
+  }
+
+  // Infer architecture from project type
+  const architectureMap = {
+    'blazor-server': 'clean-architecture',
+    'nextjs': 'layered',
+    'dotnet-api': 'clean-architecture',
+    'cli-tool': 'monolith',
+    'monorepo': 'microservices',
+    'other': 'layered'
+  };
+
+  const architecture = architectureMap[answers.type] || 'layered';
+
+  // Infer hosting
+  let hosting = null;
+  if (answers.hasAzure) {
+    hosting = 'Azure';
+  } else if (answers.hasDocker) {
+    hosting = 'Docker';
+  }
+
+  return {
+    name: answers.name,
+    description: answers.description,
+    type: answers.type,
+    stack: {
+      frontend,
+      backend: {
+        tech: backendTech,
+        version: backendVersion,
+        details: null
+      },
+      database,
+      hosting
+    },
+    architecture,
+    projectStructure: 'User-specified configuration via interactive wizard',
+    conventions: 'Standard conventions for ' + backendTech,
+    repository: null,
+    hasAzure: answers.hasAzure,
+    hasDocker: answers.hasDocker,
+    hasDevOps: false,
+    confidence: 100, // User input is 100% confident
+    warnings: ['Configuration was manually entered, not auto-detected']
+  };
+}

package/src/utils/file-copier.js

@@ -1,15 +1,17 @@
 import fs from 'fs-extra';
 import { join, dirname, resolve } from 'path';
 import { fileURLToPath } from 'url';
+import { resolveStackPath } from '../lib/stack-resolver.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
+const frameworkRoot = join(__dirname, '..', '..');
 
 function isSamePath(a, b) {
   return resolve(a) === resolve(b);
 }
 
 export function getContentDir() {
-  return join(__dirname, '..', '..', 'content');
+  return resolveStackPath(frameworkRoot);
 }
 
 export async function copyDirectory(src, dest, options = {}) {

package/src/utils/logger.js

@@ -1,32 +1,32 @@
-import chalk from 'chalk';
-
-export const logger = {
-  info: (msg) => console.log(chalk.cyan(`  ${msg}`)),
-  success: (msg) => console.log(chalk.green(`  ✓ ${msg}`)),
-  warn: (msg) => console.log(chalk.yellow(`  ⚠ ${msg}`)),
-  error: (msg) => console.log(chalk.red(`  ✗ ${msg}`)),
-  dim: (msg) => console.log(chalk.gray(`    ${msg}`)),
-
-  header: (msg) => {
-    console.log('');
-    console.log(chalk.cyan.bold(`  ${msg}`));
-    console.log(chalk.cyan('  ' + '─'.repeat(msg.length)));
-    console.log('');
-  },
-
-  step: (num, msg) => console.log(chalk.white(`  ${num}. ${msg}`)),
-
-  blank: () => console.log(''),
-
-  box: (lines) => {
-    const maxLen = Math.max(...lines.map(l => l.length));
-    const border = '─'.repeat(maxLen + 2);
-
-    console.log(chalk.cyan(`  ┌${border}┐`));
-    lines.forEach(line => {
-      const padded = line.padEnd(maxLen);
-      console.log(chalk.cyan(`  │ ${padded} │`));
-    });
-    console.log(chalk.cyan(`  └${border}┘`));
-  }
-};
+import chalk from 'chalk';
+
+export const logger = {
+  info: (msg) => console.log(chalk.cyan(`  ${msg}`)),
+  success: (msg) => console.log(chalk.green(`  ✓ ${msg}`)),
+  warn: (msg) => console.log(chalk.yellow(`  ⚠ ${msg}`)),
+  error: (msg) => console.log(chalk.red(`  ✗ ${msg}`)),
+  dim: (msg) => console.log(chalk.gray(`    ${msg}`)),
+
+  header: (msg) => {
+    console.log('');
+    console.log(chalk.cyan.bold(`  ${msg}`));
+    console.log(chalk.cyan('  ' + '─'.repeat(msg.length)));
+    console.log('');
+  },
+
+  step: (num, msg) => console.log(chalk.white(`  ${num}. ${msg}`)),
+
+  blank: () => console.log(''),
+
+  box: (lines) => {
+    const maxLen = Math.max(...lines.map(l => l.length));
+    const border = '─'.repeat(maxLen + 2);
+
+    console.log(chalk.cyan(`  ┌${border}┐`));
+    lines.forEach(line => {
+      const padded = line.padEnd(maxLen);
+      console.log(chalk.cyan(`  │ ${padded} │`));
+    });
+    console.log(chalk.cyan(`  └${border}┘`));
+  }
+};