@polymorphism-tech/morph-spec 4.8.19 → 4.10.0

package/src/ui/wizard-questions.js

@@ -1,188 +0,0 @@
-/**
- * @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: '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/color-utils.js

@@ -1,70 +0,0 @@
-/**
- * Unified color utilities for CLI output
- *
- * Replaces manual ANSI codes with consistent chalk usage.
- * Standardizes color handling across the codebase.
- */
-
-import chalk from 'chalk';
-
-// Re-export chalk for direct usage
-export { chalk };
-
-/**
- * Predefined color functions for common use cases
- */
-export const colors = {
-  error: chalk.red,
-  success: chalk.green,
-  warning: chalk.yellow,
-  info: chalk.blue,
-  dim: chalk.gray,
-  bold: chalk.bold,
-  highlight: chalk.cyan,
-};
-
-/**
- * Status indicators with colors
- */
-export const status = {
-  success: chalk.green('✓'),
-  error: chalk.red('✗'),
-  warning: chalk.yellow('⚠'),
-  info: chalk.blue('ℹ'),
-};
-
-/**
- * Format a success message
- * @param {string} message - Message to format
- * @returns {string} Formatted message
- */
-export function formatSuccess(message) {
-  return `${status.success} ${chalk.green(message)}`;
-}
-
-/**
- * Format an error message
- * @param {string} message - Message to format
- * @returns {string} Formatted message
- */
-export function formatError(message) {
-  return `${status.error} ${chalk.red(message)}`;
-}
-
-/**
- * Format a warning message
- * @param {string} message - Message to format
- * @returns {string} Formatted message
- */
-export function formatWarning(message) {
-  return `${status.warning} ${chalk.yellow(message)}`;
-}
-
-/**
- * Format an info message
- * @param {string} message - Message to format
- * @returns {string} Formatted message
- */
-export function formatInfo(message) {
-  return `${status.info} ${chalk.blue(message)}`;
-}

package/src/utils/process-handler.js

@@ -1,97 +0,0 @@
-/**
- * Process Handler - Testable Exit Strategy
- *
- * Replaces direct process.exit() calls with a mockable handler.
- * Makes the codebase testable by allowing exit behavior to be intercepted.
- *
- * @module process-handler
- */
-
-import chalk from 'chalk';
-
-/**
- * Process Handler Class
- *
- * Provides testable process exit functionality.
- */
-export class ProcessHandler {
-  /**
-   * @param {Function} exitFn - Exit function (defaults to process.exit)
-   */
-  constructor(exitFn = process.exit.bind(process)) {
-    this.exitFn = exitFn;
-  }
-
-  /**
-   * Exit the process with optional message
-   *
-   * @param {number} code - Exit code (0 = success, non-zero = error)
-   * @param {string} [message] - Optional message to display
-   */
-  exit(code = 0, message = null) {
-    if (message) {
-      if (code === 0) {
-        console.log(message);
-      } else {
-        console.error(message);
-      }
-    }
-    this.exitFn(code);
-  }
-
-  /**
-   * Exit with error message (code 1)
-   *
-   * @param {string} message - Error message
-   * @param {number} [code=1] - Error code
-   */
-  exitWithError(message, code = 1) {
-    this.exit(code, chalk.red(message));
-  }
-
-  /**
-   * Exit with success message (code 0)
-   *
-   * @param {string} message - Success message
-   */
-  exitWithSuccess(message) {
-    this.exit(0, chalk.green(message));
-  }
-
-  /**
-   * Exit with warning message (code 0, but highlighted)
-   *
-   * @param {string} message - Warning message
-   */
-  exitWithWarning(message) {
-    this.exit(0, chalk.yellow(message));
-  }
-}
-
-// Default instance for general use
-export const processHandler = new ProcessHandler();
-
-/**
- * Create a test handler for unit tests
- *
- * @returns {{handler: ProcessHandler, getExitCode: Function, getExited: Function}}
- */
-export function createTestHandler() {
-  let exitCode = null;
-  let exited = false;
-
-  const handler = new ProcessHandler((code) => {
-    exitCode = code;
-    exited = true;
-  });
-
-  return {
-    handler,
-    getExitCode: () => exitCode,
-    getExited: () => exited,
-    reset: () => {
-      exitCode = null;
-      exited = false;
-    },
-  };
-}

package/src/writer/file-writer.js

@@ -1,86 +0,0 @@
-/**
- * @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 });
-    }
-  }
-}