@ngxtm/devkit 3.4.1 → 3.6.0

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,
@@ -62,10 +65,14 @@ function parseArgs(args) {
       options.clean = true;
     } 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,9 +100,9 @@ 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.
@@ -124,23 +131,34 @@ COMMANDS:
 
 OPTIONS:
   --force, -f     Force overwrite existing installation
+  --all, -a       Install for all supported tools (skip menu)
+  --tools=LIST    Install for specific tools (comma-separated)
+                  Example: --tools=claude,cursor
   --clean, -c     Remove rules for technologies no longer detected (with update)
   --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                 # 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
 
 HOW IT WORKS:
   1. devkit init analyzes your project files:
@@ -181,13 +199,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/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.4.1",
+  "version": "3.6.0",
   "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",

package/skills/learn/SKILL.md

@@ -0,0 +1,476 @@
+---
+name: learn
+description: Interactive step-by-step learning mode. Teaches concepts from basics to advanced while solving real problems. Auto-detects language, verifies code at each step, creates markdown tutorials. Triggers on "/learn [topic]". Features: concept explanation, incremental coding with auto-verify, user checkpoints, optional quiz, saves tutorial to .claude/learn/.
+---
+
+# Learn Mode - Interactive Step-by-Step Learning
+
+> **Version 1.0.0** | Learn by Doing | Verified at Every Step
+
+---
+
+## Overview
+
+Learn Mode helps you understand concepts deeply while solving real problems. Instead of just giving you code, it:
+
+1. Explains concepts from basics to advanced
+2. Guides you through implementation step-by-step
+3. Verifies code actually works at each step
+4. Saves everything to a markdown tutorial for future reference
+
+---
+
+## Activation
+
+User invokes with: `/learn "topic or problem to solve"`
+
+Examples:
+- `/learn "implement debounce function in TypeScript"`
+- `/learn "add JWT authentication to Express API"`
+- `/learn "create custom React hook for form validation"`
+
+---
+
+## Execution Flow
+
+### Phase 0: INIT - Setup & Context Gathering
+
+**Actions:**
+1. Create output directory if not exists: `.claude/learn/`
+2. Generate filename: `YYYY-MM-DD-{topic-slug}.md`
+3. Scan project for language detection:
+   - Check for config files: `tsconfig.json`, `package.json`, `go.mod`, `Cargo.toml`, `requirements.txt`, `pyproject.toml`, `pom.xml`, `composer.json`, `Gemfile`, etc.
+   - Identify primary language(s)
+4. Set verify strategy based on detected language
+5. Read relevant existing code for context
+
+**Language Detection & Verify Strategy:**
+
+| Language | Config Files | Verify Command |
+|----------|--------------|----------------|
+| TypeScript | `tsconfig.json`, `*.ts`, `*.tsx` | `npx tsc --noEmit` |
+| JavaScript | `package.json`, `*.js`, `*.mjs` | `node --check <file>` |
+| Python | `requirements.txt`, `pyproject.toml`, `*.py` | `python -m py_compile <file>` |
+| Go | `go.mod`, `*.go` | `go build ./...` |
+| Rust | `Cargo.toml`, `*.rs` | `cargo check` |
+| Java | `pom.xml`, `build.gradle`, `*.java` | `javac <file>` or `./gradlew compileJava` |
+| C# | `*.csproj`, `*.cs` | `dotnet build --no-restore` |
+| PHP | `composer.json`, `*.php` | `php -l <file>` |
+| Ruby | `Gemfile`, `*.rb` | `ruby -c <file>` |
+| Shell | `*.sh`, `*.bash` | `bash -n <file>` |
+| C/C++ | `Makefile`, `CMakeLists.txt`, `*.c`, `*.cpp` | `make` or `cmake --build .` |
+
+**If multiple languages detected:** Ask user which one to use for this session.
+**If no language detected:** Ask user to specify.
+
+**Markdown Header (write to file):**
+```markdown
+# Learn: {Topic}
+
+> Generated: {YYYY-MM-DD HH:MM}
+> Language: {detected_language}
+> Project: {project_name}
+
+---
+```
+
+---
+
+### Phase 1: CONCEPT - Knowledge Foundation
+
+**Goal:** Explain the underlying concepts before writing any code.
+
+**Actions:**
+1. Break down the topic into fundamental concepts
+2. Explain each concept clearly:
+   - What is it?
+   - Why does it exist? What problem does it solve?
+   - How does it work (high-level)?
+   - Real-world analogies if helpful
+3. Compare with related concepts (if applicable)
+   - e.g., debounce vs throttle
+   - e.g., JWT vs session-based auth
+4. Show simple diagrams using ASCII if helpful
+
+**Write to markdown:**
+```markdown
+## 1. Concepts
+
+### What is {topic}?
+{explanation}
+
+### Why use {topic}?
+{use cases and benefits}
+
+### How it works
+{mechanism explanation}
+
+### Related Concepts
+| Concept A | Concept B |
+|-----------|-----------|
+| ...       | ...       |
+
+---
+```
+
+**User Checkpoint:**
+```
+Phase 1/5: CONCEPT complete.
+
+Do you understand these concepts?
+[ ] Yes, continue to planning
+[ ] Need more explanation (specify what)
+```
+
+**STOP and wait for user response before proceeding.**
+
+---
+
+### Phase 2: PLAN - Implementation Strategy
+
+**Goal:** Create a clear, step-by-step implementation plan.
+
+**Actions:**
+1. Break implementation into small, verifiable steps (3-7 steps typically)
+2. Each step should:
+   - Have a clear goal
+   - Be independently verifiable
+   - Build on previous steps
+3. Identify files to create/modify
+4. Note any dependencies needed
+
+**Write to markdown:**
+```markdown
+## 2. Implementation Plan
+
+### Files
+- `{path/to/file1}` - {purpose}
+- `{path/to/file2}` - {purpose}
+
+### Steps
+1. **{Step 1 title}** - {brief description}
+2. **{Step 2 title}** - {brief description}
+3. **{Step 3 title}** - {brief description}
+...
+
+### Dependencies
+- {dependency 1} - {why needed}
+- {dependency 2} - {why needed}
+
+---
+```
+
+**User Checkpoint:**
+```
+Phase 2/5: PLAN complete.
+
+Ready to start coding?
+[ ] Yes, let's code
+[ ] Modify plan (specify changes)
+```
+
+**STOP and wait for user response before proceeding.**
+
+---
+
+### Phase 3: CODE + VERIFY - Incremental Implementation
+
+**Goal:** Implement each step, verify it works, ensure user understands.
+
+**For each step in the plan:**
+
+#### 3.1 Explain Before Coding
+- What we're about to do
+- Why we're doing it this way
+- Key things to understand
+
+#### 3.2 Write the Code
+- Write complete, working code (no placeholders)
+- Include all necessary imports
+- Add inline comments explaining non-obvious parts
+- Use Edit tool to modify existing files, Write for new files
+
+#### 3.3 Auto-Verify
+Run the appropriate verify command:
+```bash
+# Execute verify command based on language
+{verify_command}
+```
+
+**If verify FAILS:**
+1. Analyze the error
+2. Explain what went wrong (teaching moment)
+3. Fix the code
+4. Re-verify
+5. Repeat until pass
+
+**If verify PASSES:** Continue to user checkpoint.
+
+#### 3.4 Write to Markdown
+```markdown
+### Step {N}: {Title}
+
+**Goal:** {what this step accomplishes}
+
+**Why:** {explanation of approach}
+
+**Code:**
+```{language}
+{code with comments}
+```
+
+**Key Points:**
+- {important thing 1}
+- {important thing 2}
+
+**Verify:** {verify_command} - PASSED
+
+---
+```
+
+#### 3.5 User Checkpoint
+```
+Step {N}/{total} complete and verified.
+
+[ ] Understood, next step
+[ ] Need more explanation
+[ ] Code doesn't work on my machine (paste error)
+```
+
+**If user reports error:**
+1. Ask for the error message
+2. Debug and fix
+3. Re-verify locally
+4. Update the markdown with the fix
+
+**STOP and wait for user response before next step.**
+
+---
+
+### Phase 4: SUMMARY - Knowledge Consolidation
+
+**Goal:** Reinforce learning with summary and best practices.
+
+**Actions:**
+1. Summarize what was built
+2. List key takeaways
+3. Document common mistakes to avoid
+4. Suggest next steps for deeper learning
+
+**Write to markdown:**
+```markdown
+## 4. Summary
+
+### What We Built
+{summary of implementation}
+
+### Key Takeaways
+1. {takeaway 1}
+2. {takeaway 2}
+3. {takeaway 3}
+
+### Common Mistakes to Avoid
+- {mistake 1} - {why it's bad}
+- {mistake 2} - {why it's bad}
+
+### Next Steps
+- {suggestion for further learning 1}
+- {suggestion for further learning 2}
+
+---
+```
+
+**User Checkpoint:**
+```
+Phase 4/5: SUMMARY complete.
+
+Would you like to take a quiz to reinforce learning?
+[ ] Yes, quiz me
+[ ] No, finish up
+```
+
+---
+
+### Phase 5: QUIZ (Optional)
+
+**Goal:** Test understanding with practical questions.
+
+**Only if user opted in.**
+
+**Question Types:**
+1. **Conceptual:** Test understanding of the "why"
+2. **Code Reading:** Given code, predict behavior
+3. **Code Writing:** Small exercise to implement variation
+4. **Debugging:** Find the bug in given code
+
+**Format:**
+```
+QUIZ MODE
+
+Q1 (Conceptual): {question}
+
+Your answer: [wait for user]
+
+---
+
+Correct answer: {answer}
+Explanation: {why}
+
+Score: {X}/4
+```
+
+**Write to markdown:**
+```markdown
+## 5. Quiz
+
+<details>
+<summary>Q1: {question}</summary>
+
+**Answer:** {answer}
+
+**Explanation:** {explanation}
+</details>
+
+<details>
+<summary>Q2: {question}</summary>
+...
+</details>
+
+---
+```
+
+---
+
+### Phase 6: COMPLETE
+
+**Actions:**
+1. Finalize markdown file
+2. Display completion message
+
+**Add to markdown:**
+```markdown
+---
+
+> Tutorial completed: {timestamp}
+> Total steps: {N}
+> All code verified and working
+
+Happy coding!
+```
+
+**Display to user:**
+```
+LEARN MODE COMPLETE
+
+Tutorial saved: .claude/learn/{filename}.md
+You can review this file anytime to refresh your knowledge.
+
+What you learned:
+- {concept 1}
+- {concept 2}
+- {concept 3}
+
+Great job!
+```
+
+---
+
+## Error Handling
+
+### Verify Command Not Available
+If the verify command fails because tool is not installed:
+1. Inform user: "Verify tool not available: {command}"
+2. Ask: "Install it now, or proceed with manual verification?"
+3. If install: run appropriate install command
+4. If manual: ask user to confirm code works after each step
+
+### User Reports Code Doesn't Work
+1. Ask for exact error message
+2. Ask for their environment (OS, versions)
+3. Debug systematically
+4. Update tutorial with fix
+5. Add to "Common Issues" section in markdown
+
+### Language Not Detected
+1. List common languages
+2. Ask user to specify
+3. Set verify strategy accordingly
+
+---
+
+## Principles
+
+1. **No code without understanding** - Always explain before implementing
+2. **Verify everything** - Never assume code works, always test
+3. **Fix before proceed** - Don't move on until current step works
+4. **User controls pace** - Always checkpoint before next phase
+5. **Document for future** - Create reusable tutorial
+6. **Basics to advanced** - Start simple, build up complexity
+7. **Real working code** - No pseudocode, no placeholders
+
+---
+
+## Example Session
+
+```
+User: /learn "implement debounce in TypeScript"
+
+[INIT]
+Detected: TypeScript (tsconfig.json found)
+Verify command: npx tsc --noEmit
+Creating: .claude/learn/2024-02-06-debounce-typescript.md
+
+[CONCEPT]
+Debounce is a technique that delays executing a function until
+after a specified time has passed since the last call...
+[detailed explanation]
+
+Ready to continue? [Yes/Explain more]
+
+User: Yes
+
+[PLAN]
+Step 1: Create utils/debounce.ts with basic structure
+Step 2: Implement core debounce logic
+Step 3: Add TypeScript generics for type safety
+Step 4: Write unit tests
+
+Ready to code? [Yes/Modify plan]
+
+User: Yes
+
+[CODE Step 1/4]
+Creating utils/debounce.ts...
+[code with explanation]
+
+Verifying: npx tsc --noEmit
+PASSED
+
+Understood? [Yes/Explain more/Error on my machine]
+
+User: Yes
+
+[CODE Step 2/4]
+...
+
+[After all steps]
+
+[SUMMARY]
+Key takeaways:
+1. Debounce delays execution until activity stops
+2. clearTimeout prevents stale callbacks
+3. Generics preserve function type signatures
+
+Quiz? [Yes/No]
+
+User: No
+
+COMPLETE
+Tutorial saved: .claude/learn/2024-02-06-debounce-typescript.md
+```
+
+---
+
+## Version History
+
+- **1.0.0** - Initial release with full interactive learning flow