drt-method 1.0.0

package/tools/installer/ide/manager.js

@@ -0,0 +1,324 @@
+const { DRT_FOLDER_NAME } = require('./shared/path-utils');
+const prompts = require('../prompts');
+
+/**
+ * IDE Manager - handles IDE-specific setup
+ * Dynamically discovers and loads IDE handlers
+ *
+ * Loading strategy:
+ * All platforms are config-driven from platform-codes.yaml.
+ */
+class IdeManager {
+  constructor() {
+    this.handlers = new Map();
+    this._initialized = false;
+    this.drtFolderName = DRT_FOLDER_NAME; // Default, can be overridden
+  }
+
+  /**
+   * Set the drt folder name for all IDE handlers
+   * @param {string} drtFolderName - The drt folder name
+   */
+  setDrtFolderName(drtFolderName) {
+    this.drtFolderName = drtFolderName;
+    // Update all loaded handlers
+    for (const handler of this.handlers.values()) {
+      if (typeof handler.setDrtFolderName === 'function') {
+        handler.setDrtFolderName(drtFolderName);
+      }
+    }
+  }
+
+  /**
+   * Ensure handlers are loaded (lazy loading)
+   */
+  async ensureInitialized() {
+    if (!this._initialized) {
+      await this.loadHandlers();
+      this._initialized = true;
+    }
+  }
+
+  /**
+   * Dynamically load all IDE handlers from platform-codes.yaml
+   */
+  async loadHandlers() {
+    await this.loadConfigDrivenHandlers();
+  }
+
+  /**
+   * Load config-driven handlers from platform-codes.yaml
+   * This creates ConfigDrivenIdeSetup instances for platforms with installer config
+   */
+  async loadConfigDrivenHandlers() {
+    const { loadPlatformCodes } = require('./platform-codes');
+    const platformConfig = await loadPlatformCodes();
+
+    const { ConfigDrivenIdeSetup } = require('./_config-driven');
+
+    for (const [platformCode, platformInfo] of Object.entries(platformConfig.platforms)) {
+      // Skip if no installer config (platform may not need installation)
+      if (!platformInfo.installer) continue;
+
+      const handler = new ConfigDrivenIdeSetup(platformCode, platformInfo);
+      if (typeof handler.setDrtFolderName === 'function') {
+        handler.setDrtFolderName(this.drtFolderName);
+      }
+      this.handlers.set(platformCode, handler);
+    }
+  }
+
+  /**
+   * Get all available IDEs with their metadata
+   * @returns {Array} Array of IDE information objects
+   */
+  getAvailableIdes() {
+    const ides = [];
+
+    for (const [key, handler] of this.handlers) {
+      // Skip handlers without valid names
+      const name = handler.displayName || handler.name || key;
+
+      // Filter out invalid entries (undefined name, empty key, etc.)
+      if (!key || !name || typeof key !== 'string' || typeof name !== 'string') {
+        continue;
+      }
+
+      // Skip suspended platforms (e.g., IDE doesn't support skills yet)
+      if (handler.platformConfig?.suspended) {
+        continue;
+      }
+
+      ides.push({
+        value: key,
+        name: name,
+        preferred: handler.preferred || false,
+      });
+    }
+
+    // Sort: preferred first, then alphabetical
+    ides.sort((a, b) => {
+      if (a.preferred && !b.preferred) return -1;
+      if (!a.preferred && b.preferred) return 1;
+      return a.name.localeCompare(b.name);
+    });
+
+    return ides;
+  }
+
+  /**
+   * Get preferred IDEs
+   * @returns {Array} Array of preferred IDE information
+   */
+  getPreferredIdes() {
+    return this.getAvailableIdes().filter((ide) => ide.preferred);
+  }
+
+  /**
+   * Get non-preferred IDEs
+   * @returns {Array} Array of non-preferred IDE information
+   */
+  getOtherIdes() {
+    return this.getAvailableIdes().filter((ide) => !ide.preferred);
+  }
+
+  /**
+   * Setup IDE configuration
+   * @param {string} ideName - Name of the IDE
+   * @param {string} projectDir - Project directory
+   * @param {string} drtDir - DRT installation directory
+   * @param {Object} options - Setup options
+   */
+  async setup(ideName, projectDir, drtDir, options = {}) {
+    const handler = this.handlers.get(ideName.toLowerCase());
+
+    if (!handler) {
+      await prompts.log.warn(`IDE '${ideName}' is not yet supported`);
+      await prompts.log.message(`Supported IDEs: ${[...this.handlers.keys()].join(', ')}`);
+      return { success: false, ide: ideName, error: 'unsupported IDE' };
+    }
+
+    // Block suspended platforms — clean up legacy files but don't install
+    if (handler.platformConfig?.suspended) {
+      if (!options.silent) {
+        await prompts.log.warn(`${handler.displayName || ideName}: ${handler.platformConfig.suspended}`);
+      }
+      // Still clean up legacy artifacts so old broken configs don't linger
+      if (typeof handler.cleanup === 'function') {
+        try {
+          await handler.cleanup(projectDir, { silent: true });
+        } catch {
+          // Best-effort cleanup — don't let stale files block the suspended result
+        }
+      }
+      return { success: false, ide: ideName, error: 'suspended' };
+    }
+
+    try {
+      const handlerResult = await handler.setup(projectDir, drtDir, options);
+      // Build detail string from handler-returned data
+      let detail = '';
+      if (handlerResult && handlerResult.results) {
+        const r = handlerResult.results;
+        let count = r.skillDirectories || r.skills || 0;
+        // Dedup'd platform: report the count its peer wrote so the user sees
+        // a consistent picture across all platforms sharing the dir.
+        if (count === 0 && r.sharedTargetHandledByPeer && options.sharedSkillCount) {
+          count = options.sharedSkillCount;
+        }
+        const targetDir = handler.installerConfig?.target_dir || null;
+        if (count > 0 && targetDir) {
+          detail = `${count} skills → ${targetDir}`;
+        } else if (count > 0) {
+          detail = `${count} skills`;
+        }
+      }
+      // Propagate handler's success status (default true for backward compat)
+      const success = handlerResult?.success !== false;
+      return { success, ide: ideName, detail, error: handlerResult?.error, handlerResult };
+    } catch (error) {
+      await prompts.log.error(`Failed to setup ${ideName}: ${error.message}`);
+      return { success: false, ide: ideName, error: error.message };
+    }
+  }
+
+  /**
+   * Run setup for multiple IDEs as a single batch.
+   * Dedupes work when several selected platforms share the same target_dir:
+   * the first platform owns the directory write, peers skip it.
+   * @param {Array<string>} ideList - IDE names to set up
+   * @param {string} projectDir
+   * @param {string} drtDir
+   * @param {Object} [options] - Forwarded to each handler.setup
+   * @returns {Promise<Array>} Per-IDE results
+   */
+  async setupBatch(ideList, projectDir, drtDir, options = {}) {
+    await this.ensureInitialized();
+    const results = [];
+    // target_dir → { firstIde, skillCount } from the platform that actually wrote it
+    const claimedTargets = new Map();
+
+    for (const ideName of ideList) {
+      const handler = this.handlers.get(ideName.toLowerCase());
+      if (!handler) {
+        results.push(await this.setup(ideName, projectDir, drtDir, options));
+        continue;
+      }
+
+      const target = handler.installerConfig?.target_dir || null;
+      const claim = target ? claimedTargets.get(target) : null;
+      const skipTarget = !!claim;
+
+      const result = await this.setup(ideName, projectDir, drtDir, {
+        ...options,
+        skipTarget,
+        sharedWith: claim?.firstIde || null,
+        sharedTarget: target,
+        sharedSkillCount: claim?.skillCount || 0,
+      });
+
+      if (target && !claim) {
+        const writtenCount = result.handlerResult?.results?.skillDirectories || result.handlerResult?.results?.skills || 0;
+        // Only claim the target when the install actually succeeded and wrote skills.
+        // If the first platform fails (ancestor conflict, exception, etc.), leave the
+        // dir unclaimed so the next peer becomes the new first writer instead of
+        // silently skipping into a broken/empty target_dir.
+        if (result.success && writtenCount > 0) {
+          claimedTargets.set(target, { firstIde: ideName, skillCount: writtenCount });
+        }
+      }
+      results.push(result);
+    }
+
+    return results;
+  }
+
+  /**
+   * Cleanup IDE configurations
+   * @param {string} projectDir - Project directory
+   * @param {Object} [options] - Cleanup options passed through to handlers
+   */
+  async cleanup(projectDir, options = {}) {
+    const results = [];
+
+    for (const [name, handler] of this.handlers) {
+      try {
+        await handler.cleanup(projectDir, options);
+        results.push({ ide: name, success: true });
+      } catch (error) {
+        results.push({ ide: name, success: false, error: error.message });
+      }
+    }
+
+    return results;
+  }
+
+  /**
+   * Cleanup only the IDEs in the provided list
+   * Falls back to cleanup() (all handlers) if ideList is empty or undefined
+   * @param {string} projectDir - Project directory
+   * @param {Array<string>} ideList - List of IDE names to clean up
+   * @param {Object} [options] - Cleanup options passed through to handlers
+   *   options.remainingIdes - IDE names still installed after this cleanup; used
+   *     to skip target_dir wipe when a co-installed platform shares the dir.
+   * @returns {Array} Results array
+   */
+  async cleanupByList(projectDir, ideList, options = {}) {
+    if (!ideList || ideList.length === 0) {
+      return this.cleanup(projectDir, options);
+    }
+
+    await this.ensureInitialized();
+    const results = [];
+
+    // Build lowercase lookup for case-insensitive matching
+    const lowercaseHandlers = new Map([...this.handlers.entries()].map(([k, v]) => [k.toLowerCase(), v]));
+
+    // Resolve target_dirs for IDEs that will remain installed after this cleanup
+    const remainingTargets = new Set();
+    if (Array.isArray(options.remainingIdes)) {
+      for (const remaining of options.remainingIdes) {
+        const h = lowercaseHandlers.get(String(remaining).toLowerCase());
+        const t = h?.installerConfig?.target_dir;
+        if (t) remainingTargets.add(t);
+      }
+    }
+
+    for (const ideName of ideList) {
+      const handler = lowercaseHandlers.get(ideName.toLowerCase());
+      if (!handler) continue;
+
+      const target = handler.installerConfig?.target_dir || null;
+      const skipTarget = target && remainingTargets.has(target);
+      const cleanupOptions = skipTarget ? { ...options, skipTarget: true } : options;
+
+      try {
+        await handler.cleanup(projectDir, cleanupOptions);
+        results.push({ ide: ideName, success: true, skippedTarget: !!skipTarget });
+      } catch (error) {
+        results.push({ ide: ideName, success: false, error: error.message });
+      }
+    }
+
+    return results;
+  }
+
+  /**
+   * Detect installed IDEs
+   * @param {string} projectDir - Project directory
+   * @returns {Array} List of detected IDEs
+   */
+  async detectInstalledIdes(projectDir) {
+    const detected = [];
+
+    for (const [name, handler] of this.handlers) {
+      if (typeof handler.detect === 'function' && (await handler.detect(projectDir))) {
+        detected.push(name);
+      }
+    }
+
+    return detected;
+  }
+}
+
+module.exports = { IdeManager };

package/tools/installer/ide/platform-codes.js

@@ -0,0 +1,80 @@
+const fs = require('../fs-native');
+const path = require('node:path');
+const yaml = require('yaml');
+
+const PLATFORM_CODES_PATH = path.join(__dirname, 'platform-codes.yaml');
+
+let _cachedPlatformCodes = null;
+
+/**
+ * Load the platform codes configuration from YAML
+ * @returns {Object} Platform codes configuration
+ */
+async function loadPlatformCodes() {
+  if (_cachedPlatformCodes) {
+    return _cachedPlatformCodes;
+  }
+
+  if (!(await fs.pathExists(PLATFORM_CODES_PATH))) {
+    throw new Error(`Platform codes configuration not found at: ${PLATFORM_CODES_PATH}`);
+  }
+
+  const content = await fs.readFile(PLATFORM_CODES_PATH, 'utf8');
+  _cachedPlatformCodes = yaml.parse(content);
+  return _cachedPlatformCodes;
+}
+
+/**
+ * Clear the cached platform codes (useful for testing)
+ */
+function clearCache() {
+  _cachedPlatformCodes = null;
+}
+
+/**
+ * Format the installable platform list for human-readable output (used by --list-tools).
+ * Sourced from IdeManager so this view matches what --tools accepts at install time
+ * (suspended platforms excluded).
+ * @returns {Promise<string>} Formatted multi-line string with id, name, target_dir, preferred flag.
+ */
+async function formatPlatformList() {
+  const { IdeManager } = require('./manager');
+  const ideManager = new IdeManager();
+  await ideManager.ensureInitialized();
+
+  const entries = ideManager.getAvailableIdes().map((ide) => {
+    const handler = ideManager.handlers.get(ide.value);
+    return {
+      id: ide.value,
+      name: ide.name,
+      targetDir: handler?.installerConfig?.target_dir || '',
+      preferred: ide.preferred,
+    };
+  });
+
+  const idWidth = Math.max(...entries.map((e) => e.id.length), 'ID'.length);
+  const nameWidth = Math.max(...entries.map((e) => e.name.length), 'Name'.length);
+
+  const pad = (s, w) => s + ' '.repeat(Math.max(0, w - s.length));
+  const lines = [
+    `Supported tool IDs (pass via --tools <id>[,<id>...]):`,
+    '',
+    `  ${pad('ID', idWidth)}  ${pad('Name', nameWidth)}  Target dir`,
+    `  ${pad('-'.repeat(idWidth), idWidth)}  ${pad('-'.repeat(nameWidth), nameWidth)}  ${'-'.repeat(10)}`,
+  ];
+
+  for (const e of entries) {
+    const star = e.preferred ? ' *' : '  ';
+    lines.push(`${star}${pad(e.id, idWidth)}  ${pad(e.name, nameWidth)}  ${e.targetDir}`);
+  }
+
+  lines.push('', '* = recommended / preferred', '', 'Example: drt-method install --modules drt --tools claude-code');
+
+  return lines.join('\n');
+}
+
+module.exports = {
+  loadPlatformCodes,
+  clearCache,
+  formatPlatformList,
+};