@ngxtm/devkit 1.0.0 → 2.0.1

package/cli/config.js

@@ -0,0 +1,261 @@
+/**
+ * Devkit Configuration
+ *
+ * Defines skill categories and minimal skill sets for optimized installation.
+ *
+ * NOTE: Commands (/plan, /brainstorm, /cook, etc.) and Agents are ALWAYS installed
+ * regardless of --minimal or --category options. Only the skills/ directory is filtered.
+ */
+
+// Core skills that are always installed with --minimal
+// Using exact directory names for accurate matching
+const MINIMAL_SKILLS = [
+  // Best practices
+  'react-best-practices',
+  'typescript-expert',
+  'typescript-pro',
+  'postgres-best-practices',
+  'api-security-best-practices',
+  'nodejs-best-practices',
+  // Core workflows
+  'code-review',
+  'debugging',
+  'testing-patterns',
+  'code-refactoring',
+  // Architecture
+  'api-patterns',
+  'architecture',
+  'clean-code',
+  'software-architecture',
+  // Operations
+  'code-documentation',
+  'performance-profiling',
+  // AI/MCP
+  'mcp-management',
+  'sequential-thinking',
+  // Git
+  'git-pushing'
+];
+
+// Skill categories for --category option
+// Using patterns that match actual directory names
+const SKILL_CATEGORIES = {
+  'react': [
+    'react-best-practices',
+    'react-expert',
+    'react-patterns',
+    'react-ui-patterns',
+    'react-native-expert',
+    'react-flow-node',
+    'nextjs-best-practices',
+    'nextjs-developer',
+    'nextjs-supabase-auth',
+    'expo-app-design',
+    'expo-deployment'
+  ],
+  'typescript': [
+    'typescript-expert',
+    'typescript-pro',
+    'javascript-typescript',
+    'javascript-mastery',
+    'javascript-pro'
+  ],
+  'node': [
+    'nodejs-best-practices',
+    'nestjs-expert',
+    'fastapi-expert',
+    'fastapi-router',
+    'prisma-expert',
+    'bullmq-specialist',
+    'bun-development'
+  ],
+  'python': [
+    'python-development',
+    'python-patterns',
+    'python-pro',
+    'django-expert',
+    'fastapi-expert',
+    'pydantic-models',
+    'pandas-pro'
+  ],
+  'database': [
+    'postgres-best-practices',
+    'postgres-pro',
+    'neon-postgres',
+    'database-design',
+    'database-optimizer',
+    'databases',
+    'nosql-expert',
+    'sql-pro'
+  ],
+  'devops': [
+    'docker-expert',
+    'kubernetes-specialist',
+    'terraform-engineer',
+    'github-workflow-automation',
+    'aws-serverless',
+    'aws-cdk-development',
+    'aws-cost-operations',
+    'gcp-cloud-run',
+    'cloudflare-expert',
+    'vercel-deploy',
+    'vercel-deployment',
+    'devops',
+    'devops-engineer'
+  ],
+  'testing': [
+    'testing-patterns',
+    'test-driven-development',
+    'tdd-workflow',
+    'playwright-expert',
+    'playwright-skill',
+    'test-master',
+    'test-fixing',
+    'qa-regression'
+  ],
+  'security': [
+    'api-security-best-practices',
+    'secure-code-guardian',
+    'security-reviewer',
+    'ethical-hacking-methodology',
+    'pentest-checklist',
+    'pentest-commands',
+    'aws-penetration-testing',
+    'cloud-penetration-testing',
+    'top-web-vulnerabilities'
+  ],
+  'ai': [
+    'ai-agents-architect',
+    'ai-product',
+    'ai-multimodal',
+    'mcp-management',
+    'mcp-developer',
+    'mcp-builder',
+    'prompt-engineering',
+    'prompt-engineer',
+    'langgraph',
+    'langfuse',
+    'crewai',
+    'rag-architect',
+    'rag-engineer',
+    'rag-implementation',
+    'llm-application-dev',
+    'llm-app-patterns',
+    'sequential-thinking',
+    'agent-memory-mcp',
+    'agent-memory-systems',
+    'autonomous-agent-patterns'
+  ],
+  'mobile': [
+    'react-native-expert',
+    'flutter-expert',
+    'expo-app-design',
+    'expo-deployment',
+    'mobile-design',
+    'mobile-development',
+    'swift-expert',
+    'kotlin-specialist'
+  ],
+  'frontend': [
+    'frontend-development',
+    'frontend-design',
+    'frontend-dev-guidelines',
+    'tailwind-patterns',
+    'ui-design-system',
+    'ui-styling',
+    'ui-ux-pro-max',
+    'web-design-guidelines',
+    'web-performance-optimization',
+    'threejs',
+    'vue-expert',
+    'angular-architect'
+  ],
+  'backend': [
+    'backend-development',
+    'backend-dev-guidelines',
+    'api-patterns',
+    'api-designer',
+    'microservices-architect',
+    'graphql',
+    'graphql-architect',
+    'websocket-engineer'
+  ],
+  'tools': [
+    'git-pushing',
+    'code-review',
+    'debugging',
+    'debugging-wizard',
+    'code-refactoring',
+    'code-documentation',
+    'repomix',
+    'browser-automation',
+    'cli-developer'
+  ]
+};
+
+// Get all available categories
+function getCategories() {
+  return Object.keys(SKILL_CATEGORIES);
+}
+
+// Get skills for specific categories
+function getSkillsForCategories(categories) {
+  const skills = new Set();
+
+  for (const category of categories) {
+    const categorySkills = SKILL_CATEGORIES[category.toLowerCase()];
+    if (categorySkills) {
+      categorySkills.forEach(skill => skills.add(skill));
+    }
+  }
+
+  return Array.from(skills);
+}
+
+// Check if a skill matches the filter
+function shouldIncludeSkill(skillName, options = {}) {
+  const { minimal, categories, selectedSkills } = options;
+  const lowerSkillName = skillName.toLowerCase();
+
+  // If specific skills are selected, check against that list
+  if (selectedSkills && selectedSkills.length > 0) {
+    return selectedSkills.some(s => {
+      const lowerS = s.toLowerCase();
+      return lowerSkillName === lowerS ||
+             lowerSkillName.includes(lowerS) ||
+             lowerS.includes(lowerSkillName);
+    });
+  }
+
+  // If minimal mode, only include minimal skills
+  if (minimal) {
+    return MINIMAL_SKILLS.some(s => {
+      const lowerS = s.toLowerCase();
+      return lowerSkillName === lowerS ||
+             lowerSkillName.includes(lowerS) ||
+             lowerS.includes(lowerSkillName);
+    });
+  }
+
+  // If categories specified, check against category skills
+  if (categories && categories.length > 0) {
+    const categorySkills = getSkillsForCategories(categories);
+    return categorySkills.some(s => {
+      const lowerS = s.toLowerCase();
+      return lowerSkillName === lowerS ||
+             lowerSkillName.includes(lowerS) ||
+             lowerS.includes(lowerSkillName);
+    });
+  }
+
+  // Default: include all
+  return true;
+}
+
+module.exports = {
+  MINIMAL_SKILLS,
+  SKILL_CATEGORIES,
+  getCategories,
+  getSkillsForCategories,
+  shouldIncludeSkill
+};

package/cli/index.js

@@ -6,69 +6,168 @@
  * Main entry point for the CLI tool.
  */
 
-const { execSync } = require('child_process');
 const path = require('path');
 const fs = require('fs');
 
 const VERSION = require('../package.json').version;
+const {
+  install,
+  uninstall,
+  update,
+  interactiveInstall,
+  listSkills,
+  listCategories
+} = require('./install');
 
-const commands = {
-  install: () => require('./install').install(),
-  update: () => require('./install').update(),
-  list: () => listSkills(),
-  help: () => showHelp(),
-  version: () => console.log(`v${VERSION}`),
-};
+/**
+ * Parse command line arguments
+ */
+function parseArgs(args) {
+  const options = {
+    command: null,
+    tool: null,
+    minimal: false,
+    categories: [],
+    interactive: false,
+    fullSkills: false,
+    indexOnly: true,  // Default: index-only mode
+    help: false
+  };
+
+  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 === '--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.startsWith('--')) {
+      // Unknown flag, ignore
+    } else if (!options.command) {
+      options.command = arg;
+    } else if (!options.tool) {
+      options.tool = arg;
+    }
+  }
+
+  return options;
+}
 
 function showHelp() {
   console.log(`
 Devkit v${VERSION}
 
 USAGE:
-  devkit <command>
+  devkit <command> [tool] [options]
 
 COMMANDS:
-  install     Install skills and rules to AI tools (Claude, Cursor, Copilot)
+  install     Install skills and rules to AI tools
+  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
 
-EXAMPLES:
-  devkit install       # Install to all supported tools
-  devkit install claude # Install to Claude Code only
-  devkit list          # Show available skills
+TOOLS:
+  claude      Claude Code (~/.claude/)
+  cursor      Cursor (~/.cursor/)
+  copilot     GitHub Copilot (~/.copilot/)
+  gemini      Gemini / Antigravity (~/.gemini/)
 
-For more info: https://github.com/ngxtm/devkit
-  `);
-}
+OPTIONS:
+  (default)               Index-only mode - installs skills index file only
+                          Commands and agents are always fully installed
+                          Best for avoiding context limit issues
 
-function listSkills() {
-  const skillsDir = path.join(__dirname, '..', 'skills');
+  --minimal, -m           Install ~20 core skills (instead of index)
 
-  if (!fs.existsSync(skillsDir)) {
-    console.log('No skills directory found.');
-    return;
-  }
+  --category=CATS, -c=    Install specific categories
+                          Example: --category=react,typescript,testing
 
-  const skills = fs.readdirSync(skillsDir)
-    .filter(f => fs.statSync(path.join(skillsDir, f)).isDirectory())
-    .filter(f => !f.startsWith('.'));
+  --full, -f              Install ALL 413+ skills (may cause context limit)
+                          Only use if you need full skill content locally
 
-  console.log(`\nAvailable Skills (${skills.length} total):\n`);
+  --interactive, -i       Interactive mode - choose categories
 
-  skills.forEach(skill => {
-    console.log(`  - ${skill}`);
-  });
+  --help, -h              Show this help
 
-  console.log('\nUse "devkit-agent install" to install these skills.\n');
+EXAMPLES:
+  devkit install                    # Index-only (recommended)
+  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
+
+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
+
+  When you need a specific skill, Claude reads it on-demand from
+  the skills-index.json or loads the full skill file.
+
+  This reduces context usage from ~59MB to ~30KB for skills.
+
+For more info: https://github.com/ngxtm/devkit
+  `);
 }
 
+// Command handlers
+const commands = {
+  install: (options) => {
+    if (options.interactive) {
+      return interactiveInstall(options.tool);
+    }
+    install(options.tool, {
+      minimal: options.minimal,
+      categories: options.categories,
+      fullSkills: options.fullSkills,
+      indexOnly: options.indexOnly
+    });
+  },
+  uninstall: (options) => uninstall(options.tool),
+  update: () => update(),
+  list: () => listSkills(),
+  categories: () => listCategories(),
+  help: () => showHelp(),
+  version: () => console.log(`v${VERSION}`),
+};
+
 // Main execution
-const command = process.argv[2] || 'help';
+const args = process.argv.slice(2);
+const options = parseArgs(args);
+
+// Show help if requested
+if (options.help) {
+  showHelp();
+  process.exit(0);
+}
+
+// Default to help if no command
+const command = options.command || 'help';
 
 if (commands[command]) {
-  commands[command]();
+  const result = commands[command](options);
+  // Handle async commands
+  if (result instanceof Promise) {
+    result.catch(err => {
+      console.error('Error:', err.message);
+      process.exit(1);
+    });
+  }
 } else {
   console.log(`Unknown command: ${command}`);
   showHelp();