@ngxtm/devkit 2.1.0 → 3.0.0

package/cli/detect.js

@@ -0,0 +1,292 @@
+/**
+ * Project Type Detection
+ *
+ * Detects the technology stack of a project by analyzing:
+ * - Configuration files (package.json, pubspec.yaml, go.mod, etc.)
+ * - Dependencies
+ * - File patterns
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Detection rules for different technology stacks
+ * Each rule can have:
+ * - files: Array of files that indicate this tech (any match)
+ * - dependencies: Array of npm dependencies (any match)
+ * - devDependencies: Array of npm devDependencies (any match)
+ * - rules: Array of rule directories to install
+ */
+const DETECTION_RULES = {
+  // Flutter/Dart
+  flutter: {
+    files: ['pubspec.yaml', 'pubspec.lock'],
+    rules: ['flutter', 'dart']
+  },
+
+  // React (standalone)
+  react: {
+    dependencies: ['react', 'react-dom'],
+    excludeIf: ['next'], // Don't detect if Next.js is present
+    rules: ['react', 'typescript']
+  },
+
+  // Next.js (includes React rules)
+  nextjs: {
+    files: ['next.config.js', 'next.config.mjs', 'next.config.ts'],
+    dependencies: ['next'],
+    rules: ['nextjs', 'react', 'typescript']
+  },
+
+  // NestJS
+  nestjs: {
+    files: ['nest-cli.json'],
+    dependencies: ['@nestjs/core', '@nestjs/common'],
+    rules: ['nestjs', 'typescript']
+  },
+
+  // Golang
+  golang: {
+    files: ['go.mod', 'go.sum'],
+    rules: ['golang']
+  },
+
+  // Python
+  python: {
+    files: ['pyproject.toml', 'requirements.txt', 'Pipfile', 'setup.py', 'poetry.lock'],
+    rules: ['python']
+  },
+
+  // Rust
+  rust: {
+    files: ['Cargo.toml', 'Cargo.lock'],
+    rules: ['rust']
+  },
+
+  // Java/Kotlin
+  java: {
+    files: ['pom.xml', 'build.gradle', 'build.gradle.kts'],
+    rules: ['java']
+  },
+
+  // TypeScript (generic, if not covered by framework)
+  typescript: {
+    files: ['tsconfig.json'],
+    devDependencies: ['typescript'],
+    rules: ['typescript']
+  },
+
+  // Prisma ORM
+  prisma: {
+    files: ['prisma/schema.prisma'],
+    dependencies: ['@prisma/client'],
+    devDependencies: ['prisma'],
+    rules: ['prisma']
+  },
+
+  // Supabase
+  supabase: {
+    files: ['supabase/config.toml'],
+    dependencies: ['@supabase/supabase-js'],
+    rules: ['supabase']
+  },
+
+  // Vue.js
+  vue: {
+    dependencies: ['vue'],
+    files: ['vue.config.js', 'vite.config.ts', 'vite.config.js'],
+    rules: ['vue', 'typescript']
+  },
+
+  // Angular
+  angular: {
+    files: ['angular.json'],
+    dependencies: ['@angular/core'],
+    rules: ['angular', 'typescript']
+  },
+
+  // Svelte/SvelteKit
+  svelte: {
+    files: ['svelte.config.js'],
+    dependencies: ['svelte', '@sveltejs/kit'],
+    rules: ['svelte', 'typescript']
+  },
+
+  // Express.js
+  express: {
+    dependencies: ['express'],
+    rules: ['express', 'nodejs']
+  },
+
+  // Fastify
+  fastify: {
+    dependencies: ['fastify'],
+    rules: ['fastify', 'nodejs']
+  },
+
+  // Hono
+  hono: {
+    dependencies: ['hono'],
+    rules: ['hono', 'typescript']
+  },
+
+  // Tailwind CSS
+  tailwind: {
+    files: ['tailwind.config.js', 'tailwind.config.ts', 'tailwind.config.cjs'],
+    devDependencies: ['tailwindcss'],
+    rules: ['tailwind']
+  },
+
+  // Docker
+  docker: {
+    files: ['Dockerfile', 'docker-compose.yml', 'docker-compose.yaml'],
+    rules: ['docker']
+  }
+};
+
+/**
+ * Parse package.json and extract dependencies
+ */
+function parsePackageJson(projectDir) {
+  const pkgPath = path.join(projectDir, 'package.json');
+
+  if (!fs.existsSync(pkgPath)) {
+    return { dependencies: {}, devDependencies: {} };
+  }
+
+  try {
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+    return {
+      dependencies: pkg.dependencies || {},
+      devDependencies: pkg.devDependencies || {}
+    };
+  } catch (e) {
+    return { dependencies: {}, devDependencies: {} };
+  }
+}
+
+/**
+ * Check if any file from the list exists in the project
+ */
+function hasAnyFile(projectDir, files) {
+  return files.some(file => fs.existsSync(path.join(projectDir, file)));
+}
+
+/**
+ * Check if any dependency from the list exists
+ */
+function hasAnyDependency(deps, targetDeps) {
+  return targetDeps.some(dep => dep in deps);
+}
+
+/**
+ * Detect project types based on rules
+ * @param {string} projectDir - Project directory to analyze
+ * @returns {string[]} - Array of detected technology types
+ */
+function detectProjectType(projectDir = process.cwd()) {
+  const detected = new Set();
+  const { dependencies, devDependencies } = parsePackageJson(projectDir);
+  const allDeps = { ...dependencies, ...devDependencies };
+
+  // First pass: detect all matching rules
+  const matches = [];
+
+  for (const [type, config] of Object.entries(DETECTION_RULES)) {
+    let isMatch = false;
+
+    // Check files
+    if (config.files && hasAnyFile(projectDir, config.files)) {
+      isMatch = true;
+    }
+
+    // Check dependencies
+    if (config.dependencies && hasAnyDependency(allDeps, config.dependencies)) {
+      isMatch = true;
+    }
+
+    // Check devDependencies specifically
+    if (config.devDependencies && hasAnyDependency(devDependencies, config.devDependencies)) {
+      isMatch = true;
+    }
+
+    if (isMatch) {
+      // Check exclusions
+      if (config.excludeIf) {
+        const shouldExclude = config.excludeIf.some(excludeType => {
+          const excludeConfig = DETECTION_RULES[excludeType];
+          if (!excludeConfig) return false;
+
+          if (excludeConfig.files && hasAnyFile(projectDir, excludeConfig.files)) return true;
+          if (excludeConfig.dependencies && hasAnyDependency(allDeps, excludeConfig.dependencies)) return true;
+          return false;
+        });
+
+        if (shouldExclude) continue;
+      }
+
+      matches.push({ type, rules: config.rules });
+    }
+  }
+
+  // Collect unique rules from all matches
+  for (const match of matches) {
+    detected.add(match.type);
+  }
+
+  return Array.from(detected);
+}
+
+/**
+ * Get all rules that should be installed for detected types
+ * @param {string[]} detectedTypes - Array of detected technology types
+ * @returns {string[]} - Array of unique rule directories to install
+ */
+function getRulesForTypes(detectedTypes) {
+  const rules = new Set();
+
+  for (const type of detectedTypes) {
+    const config = DETECTION_RULES[type];
+    if (config && config.rules) {
+      config.rules.forEach(rule => rules.add(rule));
+    }
+  }
+
+  return Array.from(rules);
+}
+
+/**
+ * Print detection results
+ */
+function printDetectionResults(projectDir = process.cwd()) {
+  const detected = detectProjectType(projectDir);
+  const rules = getRulesForTypes(detected);
+
+  console.log('\n' + '='.repeat(50));
+  console.log('  PROJECT DETECTION RESULTS');
+  console.log('='.repeat(50));
+  console.log(`\nDirectory: ${projectDir}`);
+
+  if (detected.length === 0) {
+    console.log('\nNo specific technology detected.');
+    console.log('Will install base commands only.\n');
+    return;
+  }
+
+  console.log('\nDetected Technologies:');
+  detected.forEach(tech => console.log(`  - ${tech}`));
+
+  console.log('\nRules to Install:');
+  rules.forEach(rule => console.log(`  - ${rule}`));
+
+  console.log('');
+}
+
+module.exports = {
+  DETECTION_RULES,
+  detectProjectType,
+  getRulesForTypes,
+  printDetectionResults,
+  parsePackageJson
+};

package/cli/index.js

@@ -1,8 +1,9 @@
 #!/usr/bin/env node
 
 /**
- * Devkit Agent Assistant CLI
+ * Devkit CLI v3
  *
+ * Per-project installation with smart tech detection.
  * Main entry point for the CLI tool.
  */
 
@@ -10,15 +11,21 @@ const path = require('path');
 const fs = require('fs');
 
 const VERSION = require('../package.json').version;
-const {
-  install,
-  uninstall,
-  update,
-  interactiveInstall,
-  listSkills,
-  listCategories,
-  initProject
-} = require('./install');
+
+// New modular imports
+const { initProject, uninstallProject } = require('./init');
+const { updateProject, showStatus } = require('./update');
+const { detectProjectType, getRulesForTypes, printDetectionResults } = require('./detect');
+const { validatePath } = require('./utils');
+
+// Legacy imports for backwards compatibility (will be deprecated)
+let legacyInstall = null;
+try {
+  const legacy = require('./install');
+  legacyInstall = legacy;
+} catch (e) {
+  // Legacy install not available, that's fine
+}
 
 /**
  * Parse command line arguments
@@ -26,40 +33,53 @@ const {
 function parseArgs(args) {
   const options = {
     command: null,
+    path: null,
+    force: false,
+    update: false,
+    clean: false,
+    help: false,
+    // Legacy options (deprecated)
     tool: null,
     minimal: false,
-    lite: false,      // New: commands only, no skills/rules/hooks
+    lite: false,
     categories: [],
     interactive: false,
     fullSkills: false,
-    indexOnly: true,  // Default: index-only mode
-    help: false
+    indexOnly: true
   };
 
   for (const arg of args) {
     if (arg === '--help' || arg === '-h') {
       options.help = true;
-    } else if (arg === '--minimal' || arg === '-m') {
-      options.minimal = true;
-      options.indexOnly = false;
-    } else if (arg === '--lite' || arg === '-l') {
-      options.lite = true;
-      options.indexOnly = false;
-    } else if (arg === '--interactive' || arg === '-i') {
-      options.interactive = true;
-    } else if (arg === '--full' || arg === '-f') {
-      options.fullSkills = true;
-      options.indexOnly = false;
-    } else if (arg.startsWith('--category=') || arg.startsWith('-c=')) {
-      const cats = arg.split('=')[1].split(',').map(c => c.trim());
-      options.categories.push(...cats);
-      options.indexOnly = false;
+    } else if (arg === '--force' || arg === '-f') {
+      options.force = true;
+    } else if (arg === '--update' || arg === '-u') {
+      options.update = true;
+    } else if (arg === '--clean' || arg === '-c') {
+      options.clean = true;
+    } else if (arg === '--status' || arg === '-s') {
+      options.command = 'status';
+    } else if (arg.startsWith('--path=')) {
+      options.path = arg.split('=')[1];
     } else if (arg.startsWith('--')) {
-      // Unknown flag, ignore
+      // Handle legacy options for backwards compatibility
+      if (arg === '--minimal' || arg === '-m') options.minimal = true;
+      if (arg === '--lite' || arg === '-l') options.lite = true;
+      if (arg === '--interactive' || arg === '-i') options.interactive = true;
+      if (arg === '--full') options.fullSkills = true;
+      if (arg.startsWith('--category=')) {
+        const cats = arg.split('=')[1].split(',').map(c => c.trim());
+        options.categories.push(...cats);
+      }
     } else if (!options.command) {
       options.command = arg;
-    } else if (!options.tool) {
-      options.tool = arg;
+    } else if (!options.path && !options.tool) {
+      // Could be a path or a tool name (legacy)
+      if (['claude', 'cursor', 'copilot', 'gemini'].includes(arg)) {
+        options.tool = arg;
+      } else {
+        options.path = arg;
+      }
     }
   }
 
@@ -68,95 +88,187 @@ function parseArgs(args) {
 
 function showHelp() {
   console.log(`
-Devkit v${VERSION}
+Devkit v${VERSION} - Per-Project AI Skills
 
 USAGE:
-  devkit <command> [tool] [options]
+  devkit <command> [options]
 
 COMMANDS:
-  install     Install skills and rules to AI tools (global ~/.claude/)
-  init        Initialize devkit in current project (.claude/ folder)
-  uninstall   Remove all installed skills and rules
-  update      Check for updates and reinstall
-  list        List all available skills
-  categories  List available skill categories
-  version     Show version
-  help        Show this help
-
-TOOLS:
-  claude      Claude Code (~/.claude/)
-  cursor      Cursor (~/.cursor/)
-  copilot     GitHub Copilot (~/.copilot/)
-  gemini      Gemini / Antigravity (~/.gemini/)
+  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.
 
-OPTIONS:
-  --lite, -l              LITE mode - commands only, no skills/rules/hooks
-                          Best for avoiding context limit issues
-                          Installs: /brainstorm, /plan, /fix, /code, etc.
+  update        Update existing installation
+                Re-detects project type and updates rules accordingly.
+
+  detect        Show detected technologies for current project
+                Useful to see what devkit will install.
 
-  (default)               Index-only mode - installs skills index file only
-                          Commands and agents are always fully installed
-                          May still cause context issues with some models
+  status        Show installation status
 
-  --minimal, -m           Install ~20 core skills (instead of index)
+  uninstall     Remove devkit from current project
 
-  --category=CATS, -c=    Install specific categories
-                          Example: --category=react,typescript,testing
+  list          List all available skills
 
-  --full, -f              Install ALL 413+ skills (may cause context limit)
-                          Only use if you need full skill content locally
+  help          Show this help
 
-  --interactive, -i       Interactive mode - choose categories
+  version       Show version
 
-  --help, -h              Show this help
+OPTIONS:
+  --force, -f   Force overwrite existing installation
+  --clean, -c   Remove rules for technologies no longer detected (with update)
+  --path=DIR    Specify project directory (default: current directory)
+  --help, -h    Show this help
 
 EXAMPLES:
-  devkit install --lite             # Commands only (recommended for context limit)
-  devkit install                    # Index-only (default)
-  devkit install claude             # Index-only to Claude Code
-  devkit install --minimal          # Install ~20 core skills
-  devkit install --category=react   # Install React-related skills
-  devkit install --full             # Install all skills (large)
-  devkit install --interactive      # Choose interactively
-  devkit uninstall                  # Remove from all tools
+  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 status               # Show current installation
+  devkit uninstall            # Remove from current project
 
 HOW IT WORKS:
-  By default, devkit installs:
-  - SKILLS_INDEX.md (29KB summary of 411 skills)
-  - All commands (/plan, /cook, /brainstorm, etc.)
-  - All agents (planner, debugger, reviewer, etc.)
-  - Hooks, rules, output-styles
+  1. devkit init analyzes your project files:
+     - package.json → React, Next.js, NestJS, etc.
+     - pubspec.yaml → Flutter
+     - go.mod → Golang
+     - pyproject.toml → Python
 
-  When you need a specific skill, Claude reads it on-demand from
-  the skills-index.json or loads the full skill file.
+  2. Installs ONLY relevant content:
+     - Merged commands (~100 commands, ~150KB)
+     - Tech-specific rules (based on detection)
+     - Skills index (for on-demand loading)
+     - Essential hooks
 
-  This reduces context usage from ~59MB to ~30KB for skills.
+  3. Total size: ~300-500KB (vs 59MB for global install)
+
+  This ensures best practices for your tech stack without
+  overwhelming Claude with irrelevant rules.
 
 For more info: https://github.com/ngxtm/devkit
   `);
 }
 
+function showDeprecationWarning(cmd) {
+  console.log(`
+⚠️  DEPRECATION WARNING
+========================
+The 'devkit ${cmd}' command is deprecated in v3.
+
+Global installation caused context limit issues (~59MB).
+Use per-project installation instead:
+
+  devkit init    # Initialize in current project (~300-500KB)
+
+This auto-detects your tech stack and installs only relevant rules.
+  `);
+}
+
 // Command handlers
 const commands = {
-  install: (options) => {
-    if (options.interactive) {
-      return interactiveInstall(options.tool);
-    }
-    install(options.tool, {
-      minimal: options.minimal,
-      lite: options.lite,
-      categories: options.categories,
-      fullSkills: options.fullSkills,
-      indexOnly: options.indexOnly
+  // Primary command - per-project init
+  init: (options) => {
+    const projectPath = validatePath(options.path) || process.cwd();
+    return initProject({
+      path: projectPath,
+      force: options.force,
+      update: options.update
     });
   },
-  init: (options) => initProject(options),
-  uninstall: (options) => uninstall(options.tool),
-  update: () => update(),
-  list: () => listSkills(),
-  categories: () => listCategories(),
+
+  // Update existing installation
+  update: (options) => {
+    const projectPath = validatePath(options.path) || process.cwd();
+    return updateProject({
+      path: projectPath,
+      force: options.force,
+      clean: options.clean
+    });
+  },
+
+  // Detect project type
+  detect: (options) => {
+    const projectDir = validatePath(options.path) || process.cwd();
+    printDetectionResults(projectDir);
+    return { success: true };
+  },
+
+  // Show status
+  status: (options) => {
+    const projectPath = validatePath(options.path) || process.cwd();
+    return showStatus({
+      path: projectPath
+    });
+  },
+
+  // Uninstall
+  uninstall: (options) => {
+    const projectPath = validatePath(options.path) || process.cwd();
+    return uninstallProject({
+      path: projectPath
+    });
+  },
+
+  // List skills (from skills-index.json)
+  list: () => {
+    const indexPath = path.join(__dirname, '..', 'skills-index.json');
+    if (!fs.existsSync(indexPath)) {
+      console.log('Skills index not found.');
+      return;
+    }
+
+    const index = JSON.parse(fs.readFileSync(indexPath, 'utf-8'));
+    console.log(`\nAvailable Skills (${index.skills?.length || 0} total):\n`);
+
+    // Group by category
+    const categories = {};
+    for (const skill of (index.skills || [])) {
+      const cat = skill.category || 'other';
+      categories[cat] = categories[cat] || [];
+      categories[cat].push(skill.name);
+    }
+
+    for (const [cat, skills] of Object.entries(categories).sort()) {
+      console.log(`  ${cat} (${skills.length}):`);
+      skills.slice(0, 5).forEach(s => console.log(`    - ${s}`));
+      if (skills.length > 5) {
+        console.log(`    ... and ${skills.length - 5} more`);
+      }
+      console.log('');
+    }
+  },
+
+  // Help
   help: () => showHelp(),
+
+  // Version
   version: () => console.log(`v${VERSION}`),
+
+  // Legacy commands (deprecated) - redirect with warning
+  install: (options) => {
+    showDeprecationWarning('install');
+
+    // Still try to run if legacy module available
+    if (legacyInstall && legacyInstall.install) {
+      console.log('Running legacy install anyway...\n');
+      return legacyInstall.install(options.tool, {
+        minimal: options.minimal,
+        lite: options.lite,
+        categories: options.categories,
+        fullSkills: options.fullSkills,
+        indexOnly: options.indexOnly
+      });
+    }
+  },
+
+  categories: () => {
+    if (legacyInstall && legacyInstall.listCategories) {
+      return legacyInstall.listCategories();
+    }
+    console.log('Use: devkit list');
+  }
 };
 
 // Main execution