@ngxtm/devkit 1.0.0 → 2.0.0

package/cli/config.js

@@ -0,0 +1,196 @@
+/**
+ * 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
+// These are reference/best-practice skills, not commands
+const MINIMAL_SKILLS = [
+  // Best practices
+  'react-best-practices',
+  'typescript-best-practices',
+  'postgres-best-practices',
+  'api-security-best-practices',
+  // Core workflows
+  'git-commit',
+  'code-review',
+  'debugging',
+  'testing',
+  'refactoring',
+  // Architecture
+  'api-patterns',
+  'architecture',
+  'clean-code',
+  // Operations
+  'documentation',
+  'error-handling',
+  'logging',
+  'performance-optimization',
+  'security-best-practices',
+  // AI/MCP
+  'mcp-management',
+  'sequential-thinking'
+];
+
+// Skill categories for --category option
+const SKILL_CATEGORIES = {
+  'react': [
+    'react-best-practices',
+    'react-native',
+    'nextjs',
+    'remix',
+    'vite-react',
+    'react-query',
+    'react-hooks',
+    'react-testing',
+    'react-performance'
+  ],
+  'typescript': [
+    'typescript-best-practices',
+    'typescript-advanced',
+    'typescript-patterns',
+    'zod-validation'
+  ],
+  'node': [
+    'nodejs',
+    'nestjs',
+    'express',
+    'fastify',
+    'prisma',
+    'drizzle'
+  ],
+  'database': [
+    'postgres-best-practices',
+    'mongodb',
+    'redis',
+    'sql-optimization',
+    'database-design'
+  ],
+  'devops': [
+    'docker',
+    'kubernetes',
+    'ci-cd',
+    'github-actions',
+    'terraform',
+    'aws',
+    'cloudflare-expert'
+  ],
+  'testing': [
+    'testing',
+    'jest',
+    'playwright',
+    'cypress',
+    'vitest',
+    'test-driven-development'
+  ],
+  'security': [
+    'security-best-practices',
+    'api-security-best-practices',
+    'owasp',
+    'authentication',
+    'authorization'
+  ],
+  'ai': [
+    'ai-agents-architect',
+    'ai-product',
+    'mcp-management',
+    'prompt-engineering',
+    'langchain',
+    'openai-integration'
+  ],
+  'mobile': [
+    'react-native',
+    'flutter',
+    'ios-development',
+    'android-development',
+    'mobile-optimization'
+  ],
+  'frontend': [
+    'css-architecture',
+    'tailwindcss',
+    'animation',
+    'accessibility',
+    'responsive-design',
+    'web-performance'
+  ],
+  'backend': [
+    'api-patterns',
+    'microservices',
+    'event-driven',
+    'caching',
+    'queue-systems',
+    'rate-limiting'
+  ],
+  'tools': [
+    'git-commit',
+    'code-review',
+    'debugging',
+    'refactoring',
+    'documentation',
+    'repomix'
+  ]
+};
+
+// 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;
+
+  // If specific skills are selected, check against that list
+  if (selectedSkills && selectedSkills.length > 0) {
+    return selectedSkills.some(s =>
+      skillName.toLowerCase().includes(s.toLowerCase()) ||
+      s.toLowerCase().includes(skillName.toLowerCase())
+    );
+  }
+
+  // If minimal mode, only include minimal skills
+  if (minimal) {
+    return MINIMAL_SKILLS.some(s =>
+      skillName.toLowerCase().includes(s.toLowerCase()) ||
+      s.toLowerCase().includes(skillName.toLowerCase())
+    );
+  }
+
+  // If categories specified, check against category skills
+  if (categories && categories.length > 0) {
+    const categorySkills = getSkillsForCategories(categories);
+    return categorySkills.some(s =>
+      skillName.toLowerCase().includes(s.toLowerCase()) ||
+      s.toLowerCase().includes(skillName.toLowerCase())
+    );
+  }
+
+  // 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();