@ngxtm/devkit 3.5.0 → 3.6.1

package/cli/index.js

@@ -41,6 +41,9 @@ function parseArgs(args) {
     help: false,
     installed: false,
     ruleArgs: [],
+    // New v3.6 options
+    all: false,
+    tools: [],
     // Legacy options (deprecated)
     tool: null,
     minimal: false,
@@ -60,12 +63,18 @@ function parseArgs(args) {
       options.update = true;
     } else if (arg === '--clean' || arg === '-c') {
       options.clean = true;
+    } else if (arg === '--no-clean') {
+      options.clean = false;
     } else if (arg === '--installed' || arg === '-i') {
       options.installed = true;
+    } else if (arg === '--all' || arg === '-a') {
+      options.all = true;
     } else if (arg === '--status' || arg === '-s') {
       options.command = 'status';
     } else if (arg.startsWith('--path=')) {
       options.path = arg.split('=')[1];
+    } else if (arg.startsWith('--tools=')) {
+      options.tools = arg.split('=')[1].split(',').map(t => t.trim());
     } else if (arg.startsWith('--')) {
       // Handle legacy options for backwards compatibility
       if (arg === '--minimal' || arg === '-m') options.minimal = true;
@@ -93,12 +102,12 @@ USAGE:
   devkit <command> [options]
 
 COMMANDS:
-  init          Initialize devkit in current project (.claude/ folder)
-                Auto-detects tech stack and installs relevant rules only.
-                This is the PRIMARY command - use this for new projects.
+  init          Initialize devkit in current project
+                Shows interactive tool selection menu.
+                Auto-detects tech stack and installs relevant rules.
 
   update        Update existing installation
-                Re-detects project type and updates rules accordingly.
+                Re-detects project, updates commands, and cleans old rules.
 
   detect        Show detected technologies for current project
                 Useful to see what devkit will install.
@@ -124,23 +133,34 @@ COMMANDS:
 
 OPTIONS:
   --force, -f     Force overwrite existing installation
-  --clean, -c     Remove rules for technologies no longer detected (with update)
+  --all, -a       Install for all supported tools (skip menu)
+  --tools=LIST    Install for specific tools (comma-separated)
+                  Example: --tools=claude,cursor
+  --no-clean      Skip removing rules for technologies no longer detected
   --installed, -i Show only installed rules (with rules command)
   --path=DIR      Specify project directory (default: current directory)
   --help, -h      Show this help
 
+SUPPORTED TOOLS:
+  claude        Claude Code
+  cursor        Cursor
+  copilot       GitHub Copilot
+  gemini        Gemini CLI
+
 EXAMPLES:
-  devkit init                 # Initialize in current project
-  devkit init --force         # Overwrite existing installation
-  devkit update               # Update and re-detect technologies
-  devkit update --clean       # Update and remove old rules
-  devkit detect               # Show what would be detected
-  devkit rules                # List all available rules
-  devkit rules --installed    # Show installed rules
-  devkit add golang docker    # Add golang and docker rules
-  devkit remove flutter       # Remove flutter rule
-  devkit status               # Show current installation
-  devkit uninstall            # Remove from current project
+  devkit init                   # Interactive tool selection
+  devkit init --all             # Install for all tools
+  devkit init --tools=claude,cursor  # Install for specific tools
+  devkit init --force           # Overwrite existing installation
+  devkit update                 # Full update (commands + clean old rules)
+  devkit update --no-clean      # Update without removing old rules
+  devkit detect                 # Show what would be detected
+  devkit rules                  # List all available rules
+  devkit rules --installed      # Show installed rules
+  devkit add golang docker      # Add golang and docker rules
+  devkit remove flutter         # Remove flutter rule
+  devkit status                 # Show current installation
+  devkit uninstall              # Remove from current project
 
 HOW IT WORKS:
   1. devkit init analyzes your project files:
@@ -181,13 +201,15 @@ This auto-detects your tech stack and installs only relevant rules.
 
 // Command handlers
 const commands = {
-  // Primary command - per-project init
-  init: (options) => {
+  // Primary command - per-project init (now async with tool selection)
+  init: async (options) => {
     const projectPath = validatePath(options.path) || process.cwd();
     return initProject({
       path: projectPath,
       force: options.force,
-      update: options.update
+      update: options.update,
+      all: options.all,
+      tools: options.tools
     });
   },
 

package/cli/init.js

@@ -3,167 +3,280 @@
 /**
  * Devkit Init - Per-Project Installation
  *
- * Installs devkit to the current project's .claude/ directory with:
- * - Merged commands (from both agent-assistant and claudekit)
+ * Installs devkit to the current project with support for multiple AI tools:
+ * - Claude Code, Cursor, GitHub Copilot, Gemini CLI
+ * - Interactive tool selection with auto-detection
  * - Tech-specific rules (based on project detection)
- * - Skills index (for on-demand loading)
- * - Essential hooks
+ * - Merged commands and essential hooks
  */
 
 const fs = require('fs');
 const path = require('path');
 
-const { detectProjectType, getRulesForTypes, printDetectionResults } = require('./detect');
-const { copyDir, getDirSize, validatePath } = require('./utils');
+const { detectProjectType, getRulesForTypes } = require('./detect');
+const { copyDir, getDirSize, detectInstalledTools, TOOLS } = require('./utils');
 
 const VERSION = require('../package.json').version;
 const PACKAGE_ROOT = path.join(__dirname, '..');
 
 /**
- * Initialize devkit in a project directory
+ * Show interactive tool selection menu
+ * @param {Object} detectedTools - Results from detectInstalledTools()
+ * @returns {Promise<string[]>} - Array of selected tool ids
  */
-function initProject(options = {}) {
-  const projectDir = options.path || process.cwd();
-  const claudeDir = path.join(projectDir, '.claude');
-  const isUpdate = options.update || false;
-
-  console.log('\n' + '='.repeat(60));
-  console.log('  DEVKIT v' + VERSION + (isUpdate ? ' - UPDATE' : ' - INIT'));
-  console.log('='.repeat(60));
+async function showToolSelectionMenu(detectedTools) {
+  // Dynamic import for inquirer (ES module)
+  const inquirer = (await import('inquirer')).default;
+
+  console.log('\n  Detecting installed AI tools...\n');
+
+  const choices = Object.entries(TOOLS).map(([id, tool]) => {
+    const detected = detectedTools[id]?.detected;
+    const status = detected ? '(detected)' : '(not detected)';
+    return {
+      name: `${tool.name} ${status}`,
+      value: id,
+      checked: detected // Pre-select detected tools
+    };
+  });
+
+  const { selectedTools } = await inquirer.prompt([
+    {
+      type: 'checkbox',
+      name: 'selectedTools',
+      message: 'Select AI tools to install devkit for:',
+      choices,
+      validate: (answer) => {
+        if (answer.length === 0) {
+          return 'Please select at least one tool.';
+        }
+        return true;
+      }
+    }
+  ]);
 
-  // Check if .claude already exists
-  if (fs.existsSync(claudeDir) && !isUpdate && !options.force) {
-    console.log(`\n  .claude/ folder already exists.`);
-    console.log('  Use --force to overwrite or --update to update.\n');
-    return { success: false, reason: 'exists' };
-  }
+  return selectedTools;
+}
 
-  // 1. Detect project type
-  console.log('\n  Detecting project type...');
-  const detectedTypes = detectProjectType(projectDir);
-  const rulesToInstall = getRulesForTypes(detectedTypes);
+/**
+ * Install devkit for a single tool
+ * @param {string} toolId - Tool identifier
+ * @param {Object} tool - Tool configuration
+ * @param {string} projectDir - Project directory
+ * @param {Object} options - Install options
+ * @returns {Object} - Installation result
+ */
+function installForTool(toolId, tool, projectDir, options = {}) {
+  const targetDir = path.join(projectDir, tool.projectPath);
+  const isUpdate = options.update || false;
 
-  if (detectedTypes.length > 0) {
-    console.log(`  Detected: ${detectedTypes.join(', ')}`);
-    console.log(`  Rules: ${rulesToInstall.join(', ')}`);
-  } else {
-    console.log('  No specific technology detected.');
-    console.log('  Installing base commands only.');
+  // Check if already exists
+  if (fs.existsSync(targetDir) && !isUpdate && !options.force) {
+    return {
+      success: false,
+      reason: 'exists',
+      message: `${tool.projectPath}/ already exists`
+    };
   }
 
-  // Create .claude directory
-  fs.mkdirSync(claudeDir, { recursive: true });
+  // Create target directory
+  fs.mkdirSync(targetDir, { recursive: true });
 
   let totalFiles = 0;
   const stats = {};
 
-  // 2. Install merged commands
-  console.log('\n  Installing components...');
-  const mergedCommandsDir = path.join(PACKAGE_ROOT, 'merged-commands');
-  const commandsDir = path.join(claudeDir, 'commands');
-
-  if (fs.existsSync(mergedCommandsDir)) {
-    const count = copyDir(mergedCommandsDir, commandsDir);
-    stats.commands = count;
-    totalFiles += count;
-    console.log(`    Commands: ${count} files`);
-  } else {
-    // Fallback to commands-claudekit if merged not available
-    const fallbackDir = path.join(PACKAGE_ROOT, 'commands-claudekit');
-    if (fs.existsSync(fallbackDir)) {
-      const count = copyDir(fallbackDir, commandsDir);
+  // 1. Install commands (if tool supports it)
+  if (tool.commandsPath) {
+    const mergedCommandsDir = path.join(PACKAGE_ROOT, 'merged-commands');
+    const commandsDir = path.join(targetDir, tool.commandsPath);
+
+    if (fs.existsSync(mergedCommandsDir)) {
+      const count = copyDir(mergedCommandsDir, commandsDir);
       stats.commands = count;
       totalFiles += count;
-      console.log(`    Commands (claudekit): ${count} files`);
     }
   }
 
-  // 3. Install tech-specific rules
-  const rulesDir = path.join(claudeDir, 'rules');
-  let rulesCount = 0;
-
-  for (const ruleType of rulesToInstall) {
-    const srcRulesDir = path.join(PACKAGE_ROOT, 'templates', ruleType, 'rules');
-    if (fs.existsSync(srcRulesDir)) {
-      const destRulesDir = path.join(rulesDir, ruleType);
-      const count = copyDir(srcRulesDir, destRulesDir);
-      rulesCount += count;
+  // 2. Install rules
+  if (tool.rulesPath && options.rules && options.rules.length > 0) {
+    const rulesDir = path.join(targetDir, tool.rulesPath);
+    let rulesCount = 0;
+
+    for (const ruleType of options.rules) {
+      const srcRulesDir = path.join(PACKAGE_ROOT, 'templates', ruleType, 'rules');
+      if (fs.existsSync(srcRulesDir)) {
+        const destRulesDir = path.join(rulesDir, ruleType);
+        const count = copyDir(srcRulesDir, destRulesDir);
+        rulesCount += count;
+      }
     }
-  }
 
-  if (rulesCount > 0) {
-    stats.rules = rulesCount;
-    totalFiles += rulesCount;
-    console.log(`    Rules: ${rulesCount} files (${rulesToInstall.join(', ')})`);
+    if (rulesCount > 0) {
+      stats.rules = rulesCount;
+      totalFiles += rulesCount;
+    }
   }
 
-  // 4. Install essential hooks
-  const srcHooksDir = path.join(PACKAGE_ROOT, 'templates', 'base', 'hooks');
-  const hooksDir = path.join(claudeDir, 'hooks');
+  // 3. Install hooks (if tool supports it)
+  if (tool.supportsHooks && tool.hooksPath) {
+    const srcHooksDir = path.join(PACKAGE_ROOT, 'templates', 'base', 'hooks');
+    const hooksDir = path.join(targetDir, tool.hooksPath);
 
-  if (fs.existsSync(srcHooksDir)) {
-    const count = copyDir(srcHooksDir, hooksDir);
-    stats.hooks = count;
-    totalFiles += count;
-    console.log(`    Hooks: ${count} files`);
-  } else {
-    // Fallback to main hooks directory (essential only)
-    const fallbackHooks = path.join(PACKAGE_ROOT, 'hooks');
-    if (fs.existsSync(fallbackHooks)) {
-      const count = copyDir(fallbackHooks, hooksDir);
+    if (fs.existsSync(srcHooksDir)) {
+      const count = copyDir(srcHooksDir, hooksDir);
       stats.hooks = count;
       totalFiles += count;
-      console.log(`    Hooks: ${count} files`);
+    } else {
+      const fallbackHooks = path.join(PACKAGE_ROOT, 'hooks');
+      if (fs.existsSync(fallbackHooks)) {
+        const count = copyDir(fallbackHooks, hooksDir);
+        stats.hooks = count;
+        totalFiles += count;
+      }
     }
   }
 
-  // 5. Install skills index
+  // 4. Install skills index
   const skillsIndexSrc = path.join(PACKAGE_ROOT, 'skills-index.json');
-  const skillsIndexDest = path.join(claudeDir, 'skills-index.json');
-
   if (fs.existsSync(skillsIndexSrc)) {
-    fs.copyFileSync(skillsIndexSrc, skillsIndexDest);
+    fs.copyFileSync(skillsIndexSrc, path.join(targetDir, 'skills-index.json'));
     totalFiles++;
-    console.log(`    Skills Index: 1 file`);
   }
 
-  // 6. Create devkit.json tracking file
+  // 5. Create devkit.json tracking file
   const devkitConfig = {
     version: VERSION,
-    detectedTypes: detectedTypes,
-    installedRules: rulesToInstall,
+    tool: toolId,
+    toolName: tool.name,
+    detectedTypes: options.detectedTypes || [],
+    installedRules: options.rules || [],
     installedAt: new Date().toISOString(),
     updatedAt: isUpdate ? new Date().toISOString() : null,
     stats: {
       totalFiles: totalFiles,
-      sizeKB: Math.round(getDirSize(claudeDir) / 1024)
+      sizeKB: Math.round(getDirSize(targetDir) / 1024)
     }
   };
 
   fs.writeFileSync(
-    path.join(claudeDir, 'devkit.json'),
+    path.join(targetDir, 'devkit.json'),
     JSON.stringify(devkitConfig, null, 2)
   );
   totalFiles++;
 
-  // 7. Create settings.json if not exists
-  const settingsPath = path.join(claudeDir, 'settings.json');
-  if (!fs.existsSync(settingsPath)) {
-    const settings = {
-      includeCoAuthoredBy: false
-    };
-    fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
-    totalFiles++;
+  // 6. Create settings.json if not exists (for tools that use it)
+  if (toolId === 'claude') {
+    const settingsPath = path.join(targetDir, 'settings.json');
+    if (!fs.existsSync(settingsPath)) {
+      const settings = { includeCoAuthoredBy: false };
+      fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+      totalFiles++;
+    }
   }
 
-  // Calculate total size
-  const totalSizeKB = Math.round(getDirSize(claudeDir) / 1024);
+  return {
+    success: true,
+    tool: toolId,
+    toolName: tool.name,
+    path: targetDir,
+    stats: {
+      files: totalFiles,
+      sizeKB: Math.round(getDirSize(targetDir) / 1024),
+      ...stats
+    }
+  };
+}
+
+/**
+ * Initialize devkit in a project directory
+ * @param {Object} options - Installation options
+ */
+async function initProject(options = {}) {
+  const projectDir = options.path || process.cwd();
+  const isUpdate = options.update || false;
+
+  console.log('\n' + '='.repeat(60));
+  console.log('  DEVKIT v' + VERSION + (isUpdate ? ' - UPDATE' : ' - INIT'));
+  console.log('='.repeat(60));
+
+  // Determine which tools to install
+  let selectedTools = [];
+
+  if (options.all) {
+    // --all flag: install for all tools
+    selectedTools = Object.keys(TOOLS);
+    console.log('\n  Installing for all tools...');
+  } else if (options.tools && options.tools.length > 0) {
+    // Specific tools via --tools flag
+    selectedTools = options.tools;
+  } else {
+    // Interactive mode: show selection menu
+    const detectedTools = detectInstalledTools();
+    selectedTools = await showToolSelectionMenu(detectedTools);
+  }
+
+  if (selectedTools.length === 0) {
+    console.log('\n  No tools selected. Exiting.\n');
+    return { success: false, reason: 'no_selection' };
+  }
+
+  // Detect project type
+  console.log('\n  Detecting project type...');
+  const detectedTypes = detectProjectType(projectDir);
+  const rulesToInstall = getRulesForTypes(detectedTypes);
+
+  if (detectedTypes.length > 0) {
+    console.log(`  Detected: ${detectedTypes.join(', ')}`);
+    console.log(`  Rules: ${rulesToInstall.join(', ')}`);
+  } else {
+    console.log('  No specific technology detected.');
+    console.log('  Installing base commands only.');
+  }
+
+  // Install for each selected tool
+  console.log('\n  Installing components...');
+  const results = [];
+
+  for (const toolId of selectedTools) {
+    const tool = TOOLS[toolId];
+    if (!tool) {
+      console.log(`    [!] Unknown tool: ${toolId}`);
+      continue;
+    }
+
+    const result = installForTool(toolId, tool, projectDir, {
+      ...options,
+      detectedTypes,
+      rules: rulesToInstall
+    });
+
+    if (result.success) {
+      console.log(`    [+] ${tool.name}: ${result.stats.files} files (${result.stats.sizeKB} KB)`);
+    } else {
+      console.log(`    [-] ${tool.name}: ${result.message || result.reason}`);
+    }
+
+    results.push(result);
+  }
+
+  // Summary
+  const successCount = results.filter(r => r.success).length;
+  const totalFiles = results.reduce((sum, r) => sum + (r.stats?.files || 0), 0);
+  const totalSize = results.reduce((sum, r) => sum + (r.stats?.sizeKB || 0), 0);
 
   console.log('\n' + '='.repeat(60));
   console.log('  INSTALLATION COMPLETE');
   console.log('='.repeat(60));
-  console.log(`\n  Total: ${totalFiles} files (${totalSizeKB} KB)`);
-  console.log(`  Location: ${claudeDir}`);
+  console.log(`\n  Tools: ${successCount}/${selectedTools.length} installed`);
+  console.log(`  Total: ${totalFiles} files (${totalSize} KB)`);
+
+  // Show installed locations
+  console.log('\n  Installed to:');
+  for (const result of results) {
+    if (result.success) {
+      console.log(`    - ${result.path}`);
+    }
+  }
 
   console.log('\n  Available commands:');
   console.log('    /plan        - Plan implementation');
@@ -176,15 +289,16 @@ function initProject(options = {}) {
     console.log(`\n  Tech-specific rules loaded for: ${detectedTypes.join(', ')}`);
   }
 
-  console.log('\n  Restart Claude Code to use the new skills.\n');
+  console.log('\n  Restart your AI tool to use the new skills.\n');
 
   return {
-    success: true,
+    success: successCount > 0,
+    tools: results,
     detected: detectedTypes,
     rules: rulesToInstall,
     stats: {
       files: totalFiles,
-      sizeKB: totalSizeKB
+      sizeKB: totalSize
     }
   };
 }
@@ -194,52 +308,62 @@ function initProject(options = {}) {
  */
 function uninstallProject(options = {}) {
   const projectDir = options.path || process.cwd();
-  const claudeDir = path.join(projectDir, '.claude');
 
   console.log('\n' + '='.repeat(60));
   console.log('  DEVKIT - UNINSTALL');
   console.log('='.repeat(60));
 
-  if (!fs.existsSync(claudeDir)) {
-    console.log('\n  No .claude/ folder found.\n');
-    return { success: false, reason: 'not_found' };
-  }
+  let removedCount = 0;
+
+  for (const [toolId, tool] of Object.entries(TOOLS)) {
+    const targetDir = path.join(projectDir, tool.projectPath);
+    const devkitConfig = path.join(targetDir, 'devkit.json');
 
-  // Check if it's a devkit installation
-  const devkitConfig = path.join(claudeDir, 'devkit.json');
-  if (!fs.existsSync(devkitConfig)) {
-    console.log('\n  .claude/ exists but is not a devkit installation.');
-    console.log('  Remove manually if needed.\n');
-    return { success: false, reason: 'not_devkit' };
+    if (fs.existsSync(devkitConfig)) {
+      fs.rmSync(targetDir, { recursive: true, force: true });
+      console.log(`  Removed: ${targetDir}`);
+      removedCount++;
+    }
   }
 
-  // Remove the directory
-  fs.rmSync(claudeDir, { recursive: true, force: true });
-  console.log(`\n  Removed: ${claudeDir}`);
-  console.log('  Devkit uninstalled successfully.\n');
+  if (removedCount === 0) {
+    console.log('\n  No devkit installations found.\n');
+    return { success: false, reason: 'not_found' };
+  }
 
-  return { success: true };
+  console.log(`\n  Uninstalled ${removedCount} tool(s) successfully.\n`);
+  return { success: true, removed: removedCount };
 }
 
 module.exports = {
   initProject,
   uninstallProject,
-  copyDir,
-  getDirSize
+  installForTool,
+  showToolSelectionMenu
 };
 
 // Run if called directly
 if (require.main === module) {
   const args = process.argv.slice(2);
+
+  // Parse --tools=claude,cursor format
+  const toolsArg = args.find(a => a.startsWith('--tools='));
+  const tools = toolsArg ? toolsArg.split('=')[1].split(',') : [];
+
   const options = {
     force: args.includes('--force') || args.includes('-f'),
     update: args.includes('--update') || args.includes('-u'),
-    path: args.find(a => !a.startsWith('-')) || process.cwd()
+    all: args.includes('--all') || args.includes('-a'),
+    tools: tools,
+    path: args.find(a => !a.startsWith('-') && !a.includes('=')) || process.cwd()
   };
 
   if (args.includes('--uninstall')) {
     uninstallProject(options);
   } else {
-    initProject(options);
+    initProject(options).catch(err => {
+      console.error('Error:', err.message);
+      process.exit(1);
+    });
   }
 }

package/cli/update.js

@@ -99,8 +99,8 @@ function updateProject(options = {}) {
     console.log('  No changes in detected technologies.');
   }
 
-  // Update rules if needed
-  if (added.length > 0 || options.force) {
+  // Update rules if needed (always update by default)
+  if (added.length > 0 || options.force !== false) {
     const newRules = getRulesForTypes(added);
     const rulesDir = path.join(claudeDir, 'rules');
 
@@ -116,8 +116,8 @@ function updateProject(options = {}) {
     }
   }
 
-  // Remove old rules if needed and user agrees
-  if (removed.length > 0 && options.clean) {
+  // Remove old rules (enabled by default, use --no-clean to skip)
+  if (removed.length > 0 && options.clean !== false) {
     const rulesDir = path.join(claudeDir, 'rules');
 
     console.log('\n  Removing old rules...');
@@ -131,26 +131,17 @@ function updateProject(options = {}) {
     }
   }
 
-  // Update commands if --force
-  if (options.force) {
+  // Update commands (enabled by default)
+  if (options.force !== false) {
     console.log('\n  Updating commands...');
     const mergedCommandsDir = path.join(PACKAGE_ROOT, 'merged-commands');
     const commandsDir = path.join(claudeDir, 'commands');
 
     if (fs.existsSync(mergedCommandsDir)) {
-      // Backup existing
-      const backupDir = path.join(claudeDir, 'commands.backup');
-      if (fs.existsSync(commandsDir)) {
-        fs.renameSync(commandsDir, backupDir);
-      }
-
+      // Copy directly - copyDir will overwrite existing files
+      // No need for backup/rename which fails on Windows when files are open
       const count = copyDir(mergedCommandsDir, commandsDir);
       console.log(`    Commands: ${count} files`);
-
-      // Remove backup
-      if (fs.existsSync(backupDir)) {
-        fs.rmSync(backupDir, { recursive: true, force: true });
-      }
     }
   }
 

package/cli/utils.js

@@ -6,6 +6,112 @@
 
 const fs = require('fs');
 const path = require('path');
+const os = require('os');
+const { execSync } = require('child_process');
+
+const HOME = os.homedir();
+
+/**
+ * Supported AI tools configuration
+ */
+const TOOLS = {
+  'claude': {
+    id: 'claude',
+    name: 'Claude Code',
+    basePath: path.join(HOME, '.claude'),
+    projectPath: '.claude',
+    skillsPath: 'skills',
+    rulesPath: 'rules',
+    hooksPath: 'hooks',
+    commandsPath: 'commands',
+    supportsHooks: true,
+    configFile: 'CLAUDE.md',
+    detectCmd: 'claude --version',
+    detectFolder: path.join(HOME, '.claude')
+  },
+  'cursor': {
+    id: 'cursor',
+    name: 'Cursor',
+    basePath: path.join(HOME, '.cursor'),
+    projectPath: '.cursor',
+    skillsPath: 'skills',
+    rulesPath: 'rules',
+    hooksPath: 'hooks',
+    commandsPath: 'commands',
+    supportsHooks: false,
+    configFile: 'CURSOR.md',
+    detectCmd: null,
+    detectFolder: path.join(HOME, '.cursor')
+  },
+  'copilot': {
+    id: 'copilot',
+    name: 'GitHub Copilot',
+    basePath: path.join(HOME, '.copilot'),
+    projectPath: '.github',
+    skillsPath: 'skills',
+    rulesPath: 'rules',
+    hooksPath: null,
+    commandsPath: null,
+    supportsHooks: false,
+    configFile: null,
+    detectCmd: 'gh copilot --version',
+    detectFolder: path.join(HOME, '.copilot')
+  },
+  'gemini': {
+    id: 'gemini',
+    name: 'Gemini CLI',
+    basePath: path.join(HOME, '.gemini'),
+    projectPath: '.gemini',
+    skillsPath: 'skills',
+    rulesPath: 'rules',
+    hooksPath: null,
+    commandsPath: null,
+    supportsHooks: false,
+    configFile: 'GEMINI.md',
+    detectCmd: 'gemini --version',
+    detectFolder: path.join(HOME, '.gemini')
+  }
+};
+
+/**
+ * Detect which AI tools are installed on the system
+ * @returns {Object} - Object with tool ids as keys and detection status
+ */
+function detectInstalledTools() {
+  const results = {};
+
+  for (const [toolId, tool] of Object.entries(TOOLS)) {
+    let detected = false;
+    let method = null;
+
+    // Try command detection first
+    if (tool.detectCmd) {
+      try {
+        execSync(tool.detectCmd, { stdio: 'pipe' });
+        detected = true;
+        method = 'cli';
+      } catch (e) {
+        // Command not found
+      }
+    }
+
+    // Fallback to folder detection
+    if (!detected && tool.detectFolder) {
+      if (fs.existsSync(tool.detectFolder)) {
+        detected = true;
+        method = 'folder';
+      }
+    }
+
+    results[toolId] = {
+      ...tool,
+      detected,
+      method
+    };
+  }
+
+  return results;
+}
 
 /**
  * Copy directory recursively
@@ -191,5 +297,8 @@ module.exports = {
   getDirSize,
   parseJsonFile,
   validatePath,
-  getAllEntries
+  getAllEntries,
+  detectInstalledTools,
+  TOOLS,
+  HOME
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ngxtm/devkit",
-  "version": "3.5.0",
+  "version": "3.6.1",
   "description": "Per-project AI skills with smart tech detection - lightweight and context-optimized",
   "main": "cli/index.js",
   "bin": {
@@ -47,6 +47,9 @@
     "type": "git",
     "url": "git+https://github.com/ngxtm/devkit.git"
   },
+  "dependencies": {
+    "inquirer": "^9.2.12"
+  },
   "devDependencies": {
     "@semantic-release/changelog": "^6.0.3",
     "@semantic-release/commit-analyzer": "^11.1.0",