@polymorphism-tech/morph-spec 3.1.0 → 4.2.0

package/src/scanner/project-scanner.js

@@ -0,0 +1,242 @@
+/**
+ * @fileoverview ProjectScanner - Scans project directory and collects context
+ * @module morph-spec/scanner/project-scanner
+ */
+
+import { readFile, access } from 'fs/promises';
+import { join, dirname, relative } from 'path';
+import { readdir, stat } from 'fs/promises';
+import { execSync } from 'child_process';
+import { glob } from 'glob';
+
+/**
+ * @typedef {import('../types/index.js').ProjectContext} ProjectContext
+ * @typedef {import('../types/index.js').PackageJson} PackageJson
+ * @typedef {import('../types/index.js').DirectoryStructure} DirectoryStructure
+ * @typedef {import('../types/index.js').InfraFiles} InfraFiles
+ */
+
+/**
+ * ProjectScanner - Scans project directory and collects context for LLM analysis
+ * @class
+ */
+export class ProjectScanner {
+  /**
+   * Scan the project directory and collect complete context
+   * @param {string} cwd - Current working directory (absolute path)
+   * @returns {Promise<ProjectContext>}
+   */
+  async scan(cwd) {
+    const [
+      packageJson,
+      csprojFiles,
+      solutionFile,
+      readme,
+      claudeMd,
+      structure,
+      infraFiles,
+      gitRemote
+    ] = await Promise.all([
+      this.readPackageJson(cwd),
+      this.findCsprojFiles(cwd),
+      this.findSolutionFile(cwd),
+      this.readFileIfExists(join(cwd, 'README.md')),
+      this.readFileIfExists(join(cwd, 'CLAUDE.md')),
+      this.detectDirectoryStructure(cwd),
+      this.findInfraFiles(cwd),
+      this.getGitRemote(cwd)
+    ]);
+
+    return {
+      cwd,
+      packageJson,
+      csprojFiles,
+      solutionFile,
+      readme,
+      claudeMd,
+      structure,
+      infraFiles,
+      gitRemote,
+      scannedAt: new Date()
+    };
+  }
+
+  /**
+   * Read and parse package.json
+   * @param {string} cwd - Current working directory
+   * @returns {Promise<PackageJson|null>}
+   */
+  async readPackageJson(cwd) {
+    try {
+      const packageJsonPath = join(cwd, 'package.json');
+      const content = await readFile(packageJsonPath, 'utf-8');
+      return JSON.parse(content);
+    } catch (error) {
+      // No package.json or parse error
+      return null;
+    }
+  }
+
+  /**
+   * Find all .csproj files recursively
+   * @param {string} cwd - Current working directory
+   * @returns {Promise<string[]>}
+   */
+  async findCsprojFiles(cwd) {
+    try {
+      const pattern = '**/*.csproj';
+      const options = {
+        cwd,
+        ignore: ['**/node_modules/**', '**/bin/**', '**/obj/**', '**/.git/**'],
+        absolute: false
+      };
+
+      const files = await glob(pattern, options);
+      return files;
+    } catch (error) {
+      return [];
+    }
+  }
+
+  /**
+   * Find solution file (.sln)
+   * @param {string} cwd - Current working directory
+   * @returns {Promise<string|null>}
+   */
+  async findSolutionFile(cwd) {
+    try {
+      const pattern = '**/*.sln';
+      const options = {
+        cwd,
+        ignore: ['**/node_modules/**', '**/.git/**'],
+        absolute: false
+      };
+
+      const files = await glob(pattern, options);
+      return files.length > 0 ? files[0] : null;
+    } catch (error) {
+      return null;
+    }
+  }
+
+  /**
+   * Detect directory structure and patterns
+   * @param {string} cwd - Current working directory
+   * @returns {Promise<DirectoryStructure>}
+   */
+  async detectDirectoryStructure(cwd) {
+    try {
+      const entries = await readdir(cwd, { withFileTypes: true });
+      const dirs = entries
+        .filter(entry => entry.isDirectory())
+        .map(entry => entry.name)
+        .filter(name => !name.startsWith('.') && name !== 'node_modules');
+
+      const hasSrc = dirs.includes('src');
+      const hasBackend = dirs.some(d => ['backend', 'server', 'api'].includes(d.toLowerCase()));
+      const hasFrontend = dirs.some(d => ['frontend', 'client', 'web', 'app'].includes(d.toLowerCase()));
+      const hasTests = dirs.some(d => ['test', 'tests', '__tests__'].includes(d.toLowerCase()));
+
+      // Detect pattern
+      let pattern = 'single-project';
+      if (hasBackend && hasFrontend) {
+        pattern = 'multi-stack';
+      } else if (dirs.length > 5 && dirs.some(d => d.includes('packages') || d.includes('apps'))) {
+        pattern = 'monorepo';
+      }
+
+      return {
+        hasSrc,
+        hasBackend,
+        hasFrontend,
+        hasTests,
+        topLevelDirs: dirs,
+        pattern
+      };
+    } catch (error) {
+      return {
+        hasSrc: false,
+        hasBackend: false,
+        hasFrontend: false,
+        hasTests: false,
+        topLevelDirs: [],
+        pattern: 'single-project'
+      };
+    }
+  }
+
+  /**
+   * Find infrastructure files (Docker, Bicep, pipelines)
+   * @param {string} cwd - Current working directory
+   * @returns {Promise<InfraFiles>}
+   */
+  async findInfraFiles(cwd) {
+    try {
+      const [dockerfiles, dockerComposeFiles, bicepFiles, pipelines] = await Promise.all([
+        glob('**/Dockerfile*', { cwd, ignore: ['**/node_modules/**', '**/.git/**'], absolute: false }),
+        glob('**/docker-compose*.yml', { cwd, ignore: ['**/node_modules/**', '**/.git/**'], absolute: false }),
+        glob('**/*.bicep', { cwd, ignore: ['**/node_modules/**', '**/.git/**'], absolute: false }),
+        glob('**/{azure-pipelines.yml,.github/workflows/*.yml,.gitlab-ci.yml}', {
+          cwd,
+          ignore: ['**/node_modules/**'],
+          absolute: false
+        })
+      ]);
+
+      return {
+        dockerfiles,
+        dockerComposeFiles,
+        bicepFiles,
+        pipelines,
+        hasAzure: bicepFiles.length > 0 || pipelines.some(p => p.includes('azure')),
+        hasDocker: dockerfiles.length > 0 || dockerComposeFiles.length > 0,
+        hasDevOps: pipelines.length > 0
+      };
+    } catch (error) {
+      return {
+        dockerfiles: [],
+        dockerComposeFiles: [],
+        bicepFiles: [],
+        pipelines: [],
+        hasAzure: false,
+        hasDocker: false,
+        hasDevOps: false
+      };
+    }
+  }
+
+  /**
+   * Get git remote URL
+   * @param {string} cwd - Current working directory
+   * @returns {Promise<string|null>}
+   */
+  async getGitRemote(cwd) {
+    try {
+      const remote = execSync('git remote get-url origin', {
+        cwd,
+        encoding: 'utf-8',
+        stdio: ['pipe', 'pipe', 'ignore']
+      }).trim();
+
+      return remote || null;
+    } catch (error) {
+      // Not a git repo or no remote
+      return null;
+    }
+  }
+
+  /**
+   * Helper: Read file if it exists
+   * @param {string} filepath - Absolute file path
+   * @returns {Promise<string|null>}
+   */
+  async readFileIfExists(filepath) {
+    try {
+      await access(filepath);
+      const content = await readFile(filepath, 'utf-8');
+      return content;
+    } catch (error) {
+      return null;
+    }
+  }
+}

package/src/ui/diff-display.js

@@ -0,0 +1,91 @@
+/**
+ * @fileoverview Diff Display - Shows diff between current and generated configs
+ * @module morph-spec/ui/diff-display
+ */
+
+import { diffLines } from 'diff';
+import chalk from 'chalk';
+
+/**
+ * Display diff between two text strings
+ * @param {string} oldContent - Original content
+ * @param {string} newContent - New content
+ * @param {string} filename - Filename for display
+ */
+export function displayDiff(oldContent, newContent, filename) {
+  console.log(chalk.bold(`\n📝 Changes in ${filename}:\n`));
+
+  const diff = diffLines(oldContent, newContent);
+
+  diff.forEach(part => {
+    const color = part.added ? chalk.green : part.removed ? chalk.red : chalk.gray;
+    const prefix = part.added ? '+ ' : part.removed ? '- ' : '  ';
+
+    part.value.split('\n').forEach((line, index) => {
+      if (line || index < part.value.split('\n').length - 1) {
+        console.log(color(prefix + line));
+      }
+    });
+  });
+
+  console.log(); // Empty line after diff
+}
+
+/**
+ * Display side-by-side summary of changes
+ * @param {Object} oldConfig - Old config object
+ * @param {Object} newConfig - New config object
+ */
+export function displayConfigSummary(oldConfig, newConfig) {
+  console.log(chalk.bold('\n📊 Configuration Summary:\n'));
+
+  const fields = [
+    { key: 'name', label: 'Project Name' },
+    { key: 'type', label: 'Project Type' },
+    { key: 'description', label: 'Description' },
+    { key: 'stack.backend.tech', label: 'Backend' },
+    { key: 'stack.frontend.tech', label: 'Frontend' },
+    { key: 'stack.database.tech', label: 'Database' },
+    { key: 'architecture', label: 'Architecture' }
+  ];
+
+  fields.forEach(({ key, label }) => {
+    const oldValue = getNestedValue(oldConfig, key) || chalk.gray('(not set)');
+    const newValue = getNestedValue(newConfig, key) || chalk.gray('(not set)');
+
+    const changed = oldValue !== newValue;
+    const color = changed ? chalk.yellow : chalk.white;
+
+    console.log(
+      color(`  ${label.padEnd(20)}: `) +
+      chalk.dim(String(oldValue).padEnd(30)) +
+      chalk.bold(' → ') +
+      color(newValue)
+    );
+  });
+
+  console.log();
+}
+
+/**
+ * Get nested value from object by dot notation key
+ * @param {Object} obj - Object to query
+ * @param {string} key - Dot notation key (e.g., 'stack.backend.tech')
+ * @returns {any} Value or null
+ */
+function getNestedValue(obj, key) {
+  if (!obj) return null;
+
+  const keys = key.split('.');
+  let current = obj;
+
+  for (const k of keys) {
+    if (current && typeof current === 'object' && k in current) {
+      current = current[k];
+    } else {
+      return null;
+    }
+  }
+
+  return current;
+}

package/src/ui/interactive-wizard.js

@@ -0,0 +1,96 @@
+/**
+ * @fileoverview Interactive Wizard - Manual configuration when LLM fails
+ * @module morph-spec/ui/interactive-wizard
+ */
+
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import { getWizardQuestions, mapAnswersToConfig } from './wizard-questions.js';
+
+/**
+ * @typedef {import('../types/index.js').ProjectConfig} ProjectConfig
+ */
+
+/**
+ * InteractiveWizard - Guides user through manual project configuration
+ * @class
+ */
+export class InteractiveWizard {
+  /**
+   * Run interactive wizard to collect project configuration
+   * @returns {Promise<ProjectConfig>}
+   */
+  async run() {
+    console.log(chalk.bold.cyan('\n🧙 Interactive Project Configuration Wizard\n'));
+    console.log(chalk.dim('  Answer 7 questions to configure your project\n'));
+
+    const questions = getWizardQuestions();
+    const answers = await inquirer.prompt(questions);
+
+    // Map answers to ProjectConfig
+    const config = mapAnswersToConfig(answers);
+
+    // Show summary
+    this.displaySummary(config);
+
+    // Confirm before proceeding
+    const { confirmed } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'confirmed',
+        message: 'Is this configuration correct?',
+        default: true
+      }
+    ]);
+
+    if (!confirmed) {
+      console.log(chalk.yellow('\n❌ Configuration canceled. Please run the wizard again.\n'));
+      process.exit(0);
+    }
+
+    return config;
+  }
+
+  /**
+   * Display summary of collected configuration
+   * @param {ProjectConfig} config - Project configuration
+   */
+  displaySummary(config) {
+    console.log(chalk.bold.green('\n✅ Configuration Summary:\n'));
+
+    console.log(chalk.bold('  Name:        ') + chalk.cyan(config.name));
+    console.log(chalk.bold('  Type:        ') + chalk.yellow(config.type));
+    console.log(chalk.bold('  Description: ') + chalk.white(config.description));
+    console.log();
+
+    console.log(chalk.bold('  Stack:'));
+    if (config.stack.frontend) {
+      console.log(chalk.gray('    Frontend:  ') + chalk.white(`${config.stack.frontend.tech} ${config.stack.frontend.version}`));
+    } else {
+      console.log(chalk.gray('    Frontend:  ') + chalk.dim('None (backend-only)'));
+    }
+    console.log(chalk.gray('    Backend:   ') + chalk.white(`${config.stack.backend.tech} ${config.stack.backend.version}`));
+    if (config.stack.database) {
+      console.log(chalk.gray('    Database:  ') + chalk.white(`${config.stack.database.tech} ${config.stack.database.version}`));
+    } else {
+      console.log(chalk.gray('    Database:  ') + chalk.dim('None'));
+    }
+    if (config.stack.hosting) {
+      console.log(chalk.gray('    Hosting:   ') + chalk.white(config.stack.hosting));
+    }
+    console.log();
+
+    console.log(chalk.bold('  Architecture: ') + chalk.magenta(config.architecture));
+    console.log();
+
+    // Infrastructure flags
+    const flags = [];
+    if (config.hasAzure) flags.push(chalk.blue('Azure'));
+    if (config.hasDocker) flags.push(chalk.cyan('Docker'));
+
+    if (flags.length > 0) {
+      console.log(chalk.bold('  Infrastructure: ') + flags.join(' • '));
+      console.log();
+    }
+  }
+}

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
+    };
+  }
+}