@polymorphism-tech/morph-spec 3.1.0 → 4.2.0

package/src/ui/wizard-questions.js

@@ -0,0 +1,188 @@
+/**
+ * @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

@@ -0,0 +1,70 @@
+/**
+ * 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/file-copier.js

@@ -1,189 +1,188 @@
-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 resolveStackPath(frameworkRoot);
-}
-
-export async function copyDirectory(src, dest, options = {}) {
-  if (isSamePath(src, dest)) return;
-
-  const { filter, overwrite = true } = options;
-
-  await fs.copy(src, dest, {
-    overwrite,
-    filter: filter || (() => true),
-    errorOnExist: false
-  });
-}
-
-export async function copyFile(src, dest) {
-  if (isSamePath(src, dest)) return;
-
-  await fs.ensureDir(dirname(dest));
-  await fs.copy(src, dest, { overwrite: true });
-}
-
-export async function pathExists(path) {
-  return fs.pathExists(path);
-}
-
-export async function readJson(path) {
-  return fs.readJson(path);
-}
-
-export async function writeJson(path, data) {
-  await fs.ensureDir(dirname(path));
-  await fs.writeJson(path, data, { spaces: 2 });
-}
-
-export async function ensureDir(path) {
-  await fs.ensureDir(path);
-}
-
-export async function writeFile(path, content) {
-  await fs.ensureDir(dirname(path));
-  await fs.writeFile(path, content, 'utf8');
-}
-
-export async function removeDir(path) {
-  await fs.remove(path);
-}
-
-export async function readFile(path) {
-  return fs.readFile(path, 'utf8');
-}
-
-/**
- * Create symlink with fallback to copy if symlink fails
- * @param {string} target - Path to the original file/folder
- * @param {string} link - Path where symlink should be created
- * @param {string} type - 'file' or 'dir'
- * @returns {Promise<'symlink' | 'copy'>} - Returns how the link was created
- */
-export async function createSymlink(target, link, type = 'file') {
-  await fs.ensureDir(dirname(link));
-
-  try {
-    // Try to create symlink
-    await fs.ensureSymlink(target, link, type);
-    return 'symlink';
-  } catch (error) {
-    // Fallback: copy the file/directory if symlink fails
-    // (Windows may require admin permissions for symlinks)
-    if (type === 'file') {
-      await copyFile(target, link);
-    } else {
-      await copyDirectory(target, link);
-    }
-    return 'copy';
-  }
-}
-
-/**
- * Create a directory link (junction on Windows, symlink on other platforms)
- * with fallback to directory copy if linking fails.
- * @param {string} target - Path to the original directory
- * @param {string} link - Path where the link should be created
- * @returns {Promise<'junction' | 'symlink' | 'copy'>} - How the link was created
- */
-export async function createDirectoryLink(target, link) {
-  await fs.ensureDir(dirname(link));
-
-  // Remove existing link/directory before recreating
-  if (await pathExists(link)) {
-    await fs.remove(link);
-  }
-
-  if (process.platform === 'win32') {
-    try {
-      // Junction on Windows - does NOT require admin privileges
-      await fs.symlink(target, link, 'junction');
-      return 'junction';
-    } catch {
-      try {
-        await fs.ensureSymlink(target, link, 'dir');
-        return 'symlink';
-      } catch {
-        await copyDirectory(target, link);
-        return 'copy';
-      }
-    }
-  } else {
-    try {
-      await fs.ensureSymlink(target, link, 'dir');
-      return 'symlink';
-    } catch {
-      await copyDirectory(target, link);
-      return 'copy';
-    }
-  }
-}
-
-export async function updateGitignore(projectPath) {
-  const gitignorePath = join(projectPath, '.gitignore');
-
-  const morphRules = [
-    '',
-    '# MORPH-SPEC',
-    '.morph/examples/',
-    '.morph/templates/',
-    '.claude/settings.local.json',
-    ''
-  ];
-
-  let content = '';
-  let hasMorphSection = false;
-
-  // Read existing .gitignore if it exists
-  if (await pathExists(gitignorePath)) {
-    content = await readFile(gitignorePath);
-    hasMorphSection = content.includes('# MORPH-SPEC');
-  }
-
-  // If MORPH section already exists, check if rules are up to date
-  if (hasMorphSection) {
-    const lines = content.split('\n');
-    const morphStartIndex = lines.findIndex(line => line.trim() === '# MORPH-SPEC');
-
-    // Find the end of MORPH section (next empty line or section header)
-    let morphEndIndex = morphStartIndex + 1;
-    while (morphEndIndex < lines.length &&
-           lines[morphEndIndex].trim() !== '' &&
-           !lines[morphEndIndex].startsWith('#')) {
-      morphEndIndex++;
-    }
-
-    // Extract current MORPH rules
-    const currentMorphRules = lines.slice(morphStartIndex, morphEndIndex + 1);
-    const expectedMorphRules = morphRules.slice(1, -1); // Remove empty lines from comparison
-
-    // Check if all expected rules are present
-    const missingRules = expectedMorphRules.filter(rule =>
-      rule.startsWith('#') || !currentMorphRules.some(line => line.trim() === rule)
-    );
-
-    if (missingRules.length > 0) {
-      // Update the section with all rules
-      lines.splice(morphStartIndex, morphEndIndex - morphStartIndex, ...morphRules.slice(1, -1));
-      content = lines.join('\n');
-    }
-  } else {
-    // Add MORPH section
-    if (content && !content.endsWith('\n')) {
-      content += '\n';
-    }
-    content += morphRules.join('\n');
-  }
-
-  await writeFile(gitignorePath, content);
-}
+import fs from 'fs-extra';
+import { join, dirname, resolve } from 'path';
+import { fileURLToPath } from 'url';
+import { resolveStackPath } from '../lib/stacks/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 resolveStackPath(frameworkRoot);
+}
+
+export async function copyDirectory(src, dest, options = {}) {
+  if (isSamePath(src, dest)) return;
+
+  const { filter, overwrite = true } = options;
+
+  await fs.copy(src, dest, {
+    overwrite,
+    filter: filter || (() => true),
+    errorOnExist: false
+  });
+}
+
+export async function copyFile(src, dest) {
+  if (isSamePath(src, dest)) return;
+
+  await fs.ensureDir(dirname(dest));
+  await fs.copy(src, dest, { overwrite: true });
+}
+
+export async function pathExists(path) {
+  return fs.pathExists(path);
+}
+
+export async function readJson(path) {
+  return fs.readJson(path);
+}
+
+export async function writeJson(path, data) {
+  await fs.ensureDir(dirname(path));
+  await fs.writeJson(path, data, { spaces: 2 });
+}
+
+export async function ensureDir(path) {
+  await fs.ensureDir(path);
+}
+
+export async function writeFile(path, content) {
+  await fs.ensureDir(dirname(path));
+  await fs.writeFile(path, content, 'utf8');
+}
+
+export async function removeDir(path) {
+  await fs.remove(path);
+}
+
+export async function readFile(path) {
+  return fs.readFile(path, 'utf8');
+}
+
+/**
+ * Create symlink with fallback to copy if symlink fails
+ * @param {string} target - Path to the original file/folder
+ * @param {string} link - Path where symlink should be created
+ * @param {string} type - 'file' or 'dir'
+ * @returns {Promise<'symlink' | 'copy'>} - Returns how the link was created
+ */
+export async function createSymlink(target, link, type = 'file') {
+  await fs.ensureDir(dirname(link));
+
+  try {
+    // Try to create symlink
+    await fs.ensureSymlink(target, link, type);
+    return 'symlink';
+  } catch (error) {
+    // Fallback: copy the file/directory if symlink fails
+    // (Windows may require admin permissions for symlinks)
+    if (type === 'file') {
+      await copyFile(target, link);
+    } else {
+      await copyDirectory(target, link);
+    }
+    return 'copy';
+  }
+}
+
+/**
+ * Create a directory link (junction on Windows, symlink on other platforms)
+ * with fallback to directory copy if linking fails.
+ * @param {string} target - Path to the original directory
+ * @param {string} link - Path where the link should be created
+ * @returns {Promise<'junction' | 'symlink' | 'copy'>} - How the link was created
+ */
+export async function createDirectoryLink(target, link) {
+  await fs.ensureDir(dirname(link));
+
+  // Remove existing link/directory before recreating
+  if (await pathExists(link)) {
+    await fs.remove(link);
+  }
+
+  if (process.platform === 'win32') {
+    try {
+      // Junction on Windows - does NOT require admin privileges
+      await fs.symlink(target, link, 'junction');
+      return 'junction';
+    } catch {
+      try {
+        await fs.ensureSymlink(target, link, 'dir');
+        return 'symlink';
+      } catch {
+        await copyDirectory(target, link);
+        return 'copy';
+      }
+    }
+  } else {
+    try {
+      await fs.ensureSymlink(target, link, 'dir');
+      return 'symlink';
+    } catch {
+      await copyDirectory(target, link);
+      return 'copy';
+    }
+  }
+}
+
+export async function updateGitignore(projectPath) {
+  const gitignorePath = join(projectPath, '.gitignore');
+
+  const morphRules = [
+    '',
+    '# MORPH-SPEC',
+    '.morph/templates/',
+    '.claude/settings.local.json',
+    ''
+  ];
+
+  let content = '';
+  let hasMorphSection = false;
+
+  // Read existing .gitignore if it exists
+  if (await pathExists(gitignorePath)) {
+    content = await readFile(gitignorePath);
+    hasMorphSection = content.includes('# MORPH-SPEC');
+  }
+
+  // If MORPH section already exists, check if rules are up to date
+  if (hasMorphSection) {
+    const lines = content.split('\n');
+    const morphStartIndex = lines.findIndex(line => line.trim() === '# MORPH-SPEC');
+
+    // Find the end of MORPH section (next empty line or section header)
+    let morphEndIndex = morphStartIndex + 1;
+    while (morphEndIndex < lines.length &&
+           lines[morphEndIndex].trim() !== '' &&
+           !lines[morphEndIndex].startsWith('#')) {
+      morphEndIndex++;
+    }
+
+    // Extract current MORPH rules
+    const currentMorphRules = lines.slice(morphStartIndex, morphEndIndex + 1);
+    const expectedMorphRules = morphRules.slice(1, -1); // Remove empty lines from comparison
+
+    // Check if all expected rules are present
+    const missingRules = expectedMorphRules.filter(rule =>
+      rule.startsWith('#') || !currentMorphRules.some(line => line.trim() === rule)
+    );
+
+    if (missingRules.length > 0) {
+      // Update the section with all rules
+      lines.splice(morphStartIndex, morphEndIndex - morphStartIndex, ...morphRules.slice(1, -1));
+      content = lines.join('\n');
+    }
+  } else {
+    // Add MORPH section
+    if (content && !content.endsWith('\n')) {
+      content += '\n';
+    }
+    content += morphRules.join('\n');
+  }
+
+  await writeFile(gitignorePath, content);
+}