myaidev-method 0.2.23 → 0.2.24-2

package/src/lib/installation-detector.js

@@ -0,0 +1,266 @@
+/**
+ * Installation Detection Utility
+ *
+ * Detects the current installation state of MyAIDev Method:
+ * - Legacy installation (npx-based file copying)
+ * - Plugin installation (Claude Code plugin system)
+ * - Both (dual installation)
+ * - None (not installed)
+ *
+ * This utility ensures backward compatibility during migration to plugin architecture.
+ */
+
+import fs from 'fs-extra';
+import path from 'path';
+
+/**
+ * Installation types enum
+ */
+export const InstallationType = {
+  NONE: 'none',
+  LEGACY: 'legacy',
+  PLUGIN: 'plugin',
+  BOTH: 'both'
+};
+
+/**
+ * Detect the current installation state of MyAIDev Method
+ *
+ * @param {string} projectRoot - The project root directory
+ * @returns {Promise<Object>} Installation detection result
+ */
+export async function detectInstallation(projectRoot = process.cwd()) {
+  const checks = {
+    // Legacy installation indicators
+    hasClaudeDir: await fs.pathExists(path.join(projectRoot, '.claude')),
+    hasClaudeCommands: await fs.pathExists(path.join(projectRoot, '.claude', 'commands')),
+    hasClaudeAgents: await fs.pathExists(path.join(projectRoot, '.claude', 'agents')),
+    hasManifest: await fs.pathExists(path.join(projectRoot, '.myaidev-manifest.json')),
+
+    // Plugin installation indicators
+    hasPluginDir: await fs.pathExists(path.join(projectRoot, '.claude-plugin')),
+    hasPluginJson: await fs.pathExists(path.join(projectRoot, '.claude-plugin', 'plugin.json')),
+
+    // Skills-based installation
+    hasSkills: await fs.pathExists(path.join(projectRoot, 'skills')),
+
+    // Check for myaidev-specific files
+    hasMyAIDevCommands: false,
+    hasMyAIDevAgents: false
+  };
+
+  // Check for myaidev-specific commands
+  if (checks.hasClaudeCommands) {
+    const commandsDir = path.join(projectRoot, '.claude', 'commands');
+    try {
+      const files = await fs.readdir(commandsDir);
+      checks.hasMyAIDevCommands = files.some(f => f.startsWith('myai-'));
+    } catch (e) {
+      // Directory doesn't exist or not readable
+    }
+  }
+
+  // Check for myaidev-specific agents
+  if (checks.hasClaudeAgents) {
+    const agentsDir = path.join(projectRoot, '.claude', 'agents');
+    try {
+      const files = await fs.readdir(agentsDir);
+      checks.hasMyAIDevAgents = files.some(f =>
+        f.includes('content-writer') ||
+        f.includes('visual') ||
+        f.includes('wordpress')
+      );
+    } catch (e) {
+      // Directory doesn't exist or not readable
+    }
+  }
+
+  // Determine installation type
+  const hasLegacy = checks.hasManifest || (checks.hasMyAIDevCommands || checks.hasMyAIDevAgents);
+  const hasPlugin = checks.hasPluginJson;
+
+  let installationType;
+  if (hasLegacy && hasPlugin) {
+    installationType = InstallationType.BOTH;
+  } else if (hasLegacy) {
+    installationType = InstallationType.LEGACY;
+  } else if (hasPlugin) {
+    installationType = InstallationType.PLUGIN;
+  } else {
+    installationType = InstallationType.NONE;
+  }
+
+  // Get version info if available
+  let legacyVersion = null;
+  let pluginVersion = null;
+
+  if (checks.hasManifest) {
+    try {
+      const manifest = await fs.readJson(path.join(projectRoot, '.myaidev-manifest.json'));
+      legacyVersion = manifest.version || '1.0.0';
+    } catch (e) {
+      // Manifest unreadable
+    }
+  }
+
+  if (checks.hasPluginJson) {
+    try {
+      const pluginJson = await fs.readJson(path.join(projectRoot, '.claude-plugin', 'plugin.json'));
+      pluginVersion = pluginJson.version;
+    } catch (e) {
+      // Plugin json unreadable
+    }
+  }
+
+  // Get installed workflows from manifest
+  let installedWorkflows = [];
+  if (checks.hasManifest) {
+    try {
+      const manifest = await fs.readJson(path.join(projectRoot, '.myaidev-manifest.json'));
+      installedWorkflows = manifest.installedWorkflows || [];
+    } catch (e) {
+      // Manifest unreadable
+    }
+  }
+
+  return {
+    installationType,
+    hasLegacy,
+    hasPlugin,
+    canUpgrade: hasLegacy && !hasPlugin,
+    canCoexist: true, // Both installation methods can coexist
+    checks,
+    versions: {
+      legacy: legacyVersion,
+      plugin: pluginVersion
+    },
+    installedWorkflows,
+    recommendations: getRecommendations(installationType, checks)
+  };
+}
+
+/**
+ * Get recommendations based on installation state
+ *
+ * @param {string} installationType - Current installation type
+ * @param {Object} checks - Detection checks
+ * @returns {string[]} Array of recommendation strings
+ */
+function getRecommendations(installationType, checks) {
+  const recommendations = [];
+
+  switch (installationType) {
+    case InstallationType.NONE:
+      recommendations.push('Run "npx myaidev-method init --claude" to install via npx');
+      recommendations.push('Or use "/plugin install myaidev-method" for plugin installation');
+      break;
+
+    case InstallationType.LEGACY:
+      recommendations.push('Legacy installation detected - all existing commands will continue to work');
+      recommendations.push('Consider upgrading to plugin installation for automatic updates');
+      recommendations.push('Use "/plugin install myaidev-method" to add plugin capabilities');
+      break;
+
+    case InstallationType.PLUGIN:
+      recommendations.push('Plugin installation detected - skills are auto-discovered');
+      recommendations.push('Use "/myaidev-method:*" commands or legacy "/myai-*" aliases');
+      break;
+
+    case InstallationType.BOTH:
+      recommendations.push('Both legacy and plugin installations detected - all features available');
+      recommendations.push('You can use both "/myai-*" and "/myaidev-method:*" command formats');
+      break;
+  }
+
+  return recommendations;
+}
+
+/**
+ * Get a human-readable status message for the installation
+ *
+ * @param {string} projectRoot - The project root directory
+ * @returns {Promise<string>} Status message
+ */
+export async function getInstallationStatus(projectRoot = process.cwd()) {
+  const detection = await detectInstallation(projectRoot);
+
+  let status = '\n📦 MyAIDev Method Installation Status\n';
+  status += '════════════════════════════════════════\n\n';
+
+  switch (detection.installationType) {
+    case InstallationType.NONE:
+      status += '❌ Not Installed\n\n';
+      break;
+    case InstallationType.LEGACY:
+      status += '✅ Legacy Installation (npx)\n';
+      if (detection.versions.legacy) {
+        status += `   Version: ${detection.versions.legacy}\n`;
+      }
+      if (detection.installedWorkflows.length > 0) {
+        status += `   Workflows: ${detection.installedWorkflows.join(', ')}\n`;
+      }
+      status += '\n';
+      break;
+    case InstallationType.PLUGIN:
+      status += '✅ Plugin Installation\n';
+      if (detection.versions.plugin) {
+        status += `   Version: ${detection.versions.plugin}\n`;
+      }
+      status += '\n';
+      break;
+    case InstallationType.BOTH:
+      status += '✅ Dual Installation (Legacy + Plugin)\n';
+      if (detection.versions.legacy) {
+        status += `   Legacy Version: ${detection.versions.legacy}\n`;
+      }
+      if (detection.versions.plugin) {
+        status += `   Plugin Version: ${detection.versions.plugin}\n`;
+      }
+      if (detection.installedWorkflows.length > 0) {
+        status += `   Workflows: ${detection.installedWorkflows.join(', ')}\n`;
+      }
+      status += '\n';
+      break;
+  }
+
+  status += '📋 Recommendations:\n';
+  for (const rec of detection.recommendations) {
+    status += `   • ${rec}\n`;
+  }
+
+  return status;
+}
+
+/**
+ * Check if upgrade from legacy to plugin is available
+ *
+ * @param {string} projectRoot - The project root directory
+ * @returns {Promise<Object>} Upgrade availability info
+ */
+export async function checkUpgradeAvailability(projectRoot = process.cwd()) {
+  const detection = await detectInstallation(projectRoot);
+
+  return {
+    canUpgrade: detection.canUpgrade,
+    currentType: detection.installationType,
+    upgradeBenefits: [
+      'Automatic skill discovery',
+      'Namespaced commands (/myaidev-method:*)',
+      'Plugin marketplace updates',
+      'Cross-platform support preparation'
+    ],
+    preservedFeatures: [
+      'All existing /myai-* commands',
+      'Installed workflows and agents',
+      'Configuration and environment variables',
+      '.myaidev-manifest.json tracking'
+    ]
+  };
+}
+
+export default {
+  detectInstallation,
+  getInstallationStatus,
+  checkUpgradeAvailability,
+  InstallationType
+};