@polymorphism-tech/morph-spec 3.1.0 → 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/writer/file-writer.js

@@ -0,0 +1,86 @@
+/**
+ * @fileoverview FileWriter - Saves generated configs to filesystem
+ * @module morph-spec/writer/file-writer
+ */
+
+import { writeFile, mkdir, access } from 'fs/promises';
+import { join, dirname } from 'path';
+import chalk from 'chalk';
+
+/**
+ * @typedef {import('../types/index.js').GeneratedConfigs} GeneratedConfigs
+ */
+
+/**
+ * FileWriter - Saves configuration files to .morph/ directory
+ * @class
+ */
+export class FileWriter {
+  /**
+   * Save generated configs to filesystem
+   * @param {string} cwd - Current working directory
+   * @param {GeneratedConfigs} configs - Configs to save
+   * @returns {Promise<void>}
+   */
+  async save(cwd, configs) {
+    const morphDir = join(cwd, '.morph');
+    const configDir = join(morphDir, 'config');
+
+    // Ensure directories exist
+    await this.ensureDirectoryExists(morphDir);
+    await this.ensureDirectoryExists(configDir);
+
+    // Write files
+    const projectMdPath = join(morphDir, 'project.md');
+    const configJsonPath = join(configDir, 'config.json');
+
+    await Promise.all([
+      this.writeProjectMd(projectMdPath, configs.projectMd),
+      this.writeConfigJson(configJsonPath, configs.configJson)
+    ]);
+
+    // Display success message
+    console.log(chalk.bold.green('\n✅ Configuration files saved:\n'));
+    console.log(chalk.cyan(`  📄 ${projectMdPath}`));
+    console.log(chalk.cyan(`  ⚙️  ${configJsonPath}`));
+    console.log();
+  }
+
+  /**
+   * Write project.md file
+   * @param {string} filepath - File path
+   * @param {string} content - File content
+   * @returns {Promise<void>}
+   */
+  async writeProjectMd(filepath, content) {
+    await writeFile(filepath, content, 'utf-8');
+  }
+
+  /**
+   * Write config.json file (with pretty formatting)
+   * @param {string} filepath - File path
+   * @param {string} content - File content (JSON string)
+   * @returns {Promise<void>}
+   */
+  async writeConfigJson(filepath, content) {
+    // Parse and re-stringify with pretty formatting
+    const parsed = JSON.parse(content);
+    const formatted = JSON.stringify(parsed, null, 2);
+
+    await writeFile(filepath, formatted, 'utf-8');
+  }
+
+  /**
+   * Ensure directory exists (create if not)
+   * @param {string} dirPath - Directory path
+   * @returns {Promise<void>}
+   */
+  async ensureDirectoryExists(dirPath) {
+    try {
+      await access(dirPath);
+    } catch (error) {
+      // Directory doesn't exist, create it
+      await mkdir(dirPath, { recursive: true });
+    }
+  }
+}