@ngxtm/devkit 3.9.0 → 3.10.1

package/cli/init.js

@@ -85,18 +85,22 @@ function installForTool(toolId, tool, projectDir, options = {}) {
   let totalFiles = 0;
   const stats = {};
 
-  // 1. Install commands (if tool supports it)
+  // 1. Install core commands (if tool supports it) - optimized size ~400KB
   if (tool.commandsPath) {
-    const mergedCommandsDir = path.join(PACKAGE_ROOT, 'merged-commands');
+    const coreCommandsDir = path.join(PACKAGE_ROOT, 'core-commands');
     const commandsDir = path.join(targetDir, tool.commandsPath);
 
-    if (fs.existsSync(mergedCommandsDir)) {
-      const count = copyDir(mergedCommandsDir, commandsDir);
+    if (fs.existsSync(coreCommandsDir)) {
+      const count = copyDir(coreCommandsDir, commandsDir);
       stats.commands = count;
       totalFiles += count;
     }
   }
 
+  // Note: Skills are loaded on-demand from skills-compact.json
+  // Full skills are NOT copied to reduce installation size
+  // User can run "devkit add-skills" to install specific skill packs
+
   // 2. Install rules
   if (tool.rulesPath && options.rules && options.rules.length > 0) {
     const rulesDir = path.join(targetDir, tool.rulesPath);
@@ -136,19 +140,11 @@ function installForTool(toolId, tool, projectDir, options = {}) {
     }
   }
 
-  // 4. Install skills index files (for auto-skill detection)
-  const indexFiles = [
-    'skills-index.json',
-    'skills-keywords.json',
-    'skills-categories.json',
-    'skills-triggers.json'
-  ];
-  for (const indexFile of indexFiles) {
-    const src = path.join(PACKAGE_ROOT, indexFile);
-    if (fs.existsSync(src)) {
-      fs.copyFileSync(src, path.join(targetDir, indexFile));
-      totalFiles++;
-    }
+  // 4. Install compact skill index (for auto-detection, ~20KB only)
+  const compactIndex = path.join(PACKAGE_ROOT, 'skills-compact.json');
+  if (fs.existsSync(compactIndex)) {
+    fs.copyFileSync(compactIndex, path.join(targetDir, 'skills-compact.json'));
+    totalFiles++;
   }
 
   // 5. Install base rules (including auto-skill detection)
@@ -366,12 +362,19 @@ if (require.main === module) {
   const toolsArg = args.find(a => a.startsWith('--tools='));
   const tools = toolsArg ? toolsArg.split('=')[1].split(',') : [];
 
+  // Parse --path=value format
+  const pathArg = args.find(a => a.startsWith('--path='));
+  const pathValue = pathArg ? pathArg.split('=')[1] : null;
+
+  // Fallback to positional argument (first non-flag argument)
+  const positionalPath = args.find(a => !a.startsWith('-') && !a.includes('='));
+
   const options = {
     force: args.includes('--force') || args.includes('-f'),
     update: args.includes('--update') || args.includes('-u'),
     all: args.includes('--all') || args.includes('-a'),
     tools: tools,
-    path: args.find(a => !a.startsWith('-') && !a.includes('=')) || process.cwd()
+    path: pathValue || positionalPath || process.cwd()
   };
 
   if (args.includes('--uninstall')) {

package/cli/update.js

@@ -56,15 +56,17 @@ function updateToolInstallation(toolId, tool, projectDir, options = {}) {
 
   let updatedCount = 0;
 
-  // 1. Update commands (if tool supports it)
+  // 1. Update core commands (if tool supports it) - optimized size ~400KB
   if (tool.commandsPath) {
-    const mergedCommandsDir = path.join(PACKAGE_ROOT, 'merged-commands');
+    const coreCommandsDir = path.join(PACKAGE_ROOT, 'core-commands');
     const commandsDir = path.join(targetDir, tool.commandsPath);
-    if (fs.existsSync(mergedCommandsDir)) {
-      updatedCount += copyDir(mergedCommandsDir, commandsDir);
+    if (fs.existsSync(coreCommandsDir)) {
+      updatedCount += copyDir(coreCommandsDir, commandsDir);
     }
   }
 
+  // Note: Skills are loaded on-demand, not copied to project
+
   // 2. Update rules
   if (tool.rulesPath && options.rules && options.rules.length > 0) {
     const rulesDir = path.join(targetDir, tool.rulesPath);
@@ -97,19 +99,11 @@ function updateToolInstallation(toolId, tool, projectDir, options = {}) {
     }
   }
 
-  // 5. Update skills index files
-  const indexFiles = [
-    'skills-index.json',
-    'skills-keywords.json',
-    'skills-categories.json',
-    'skills-triggers.json'
-  ];
-  for (const indexFile of indexFiles) {
-    const src = path.join(PACKAGE_ROOT, indexFile);
-    if (fs.existsSync(src)) {
-      fs.copyFileSync(src, path.join(targetDir, indexFile));
-      updatedCount++;
-    }
+  // 5. Update compact skill index (for auto-detection, ~20KB only)
+  const compactIndex = path.join(PACKAGE_ROOT, 'skills-compact.json');
+  if (fs.existsSync(compactIndex)) {
+    fs.copyFileSync(compactIndex, path.join(targetDir, 'skills-compact.json'));
+    updatedCount++;
   }
 
   // 6. Update base rules (including auto-skill detection)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ngxtm/devkit",
-  "version": "3.9.0",
+  "version": "3.10.1",
   "description": "Per-project AI skills with smart tech detection - lightweight and context-optimized",
   "main": "cli/index.js",
   "bin": {

package/templates/base/rules/auto-skill.md

@@ -4,128 +4,136 @@
 
 ## When to Activate
 
-Before starting ANY coding task, you MUST check if a relevant skill exists:
+Before starting ANY coding task, you SHOULD check if a relevant skill exists:
 
 1. **Analyze the user's request** - Extract key technologies, patterns, or domains
-2. **Quick keyword match** - Check `skills-keywords.json` for exact matches
-3. **Category browse** - If no exact match, check `skills-categories.json` for relevant category
-4. **Suggest to user** - Present top 1-3 matching skills with brief descriptions
+2. **Check compact index** - Read `skills-compact.json` (~20KB) for skill names and categories
+3. **Suggest to user** - Present top 1-3 matching skills
+4. **Load on-demand** - When user confirms, read full skill from `skills/{name}/SKILL.md`
+
+## Quick Reference: Skill Categories
+
+| Code | Category | Examples |
+|------|----------|----------|
+| `fe` | Frontend | react, vue, nextjs, tailwind, ui/ux |
+| `be` | Backend | node, express, nestjs, fastapi, api |
+| `db` | Database | postgres, mysql, mongodb, redis, prisma |
+| `ai` | AI/ML | llm, agents, rag, mcp, embeddings |
+| `ops` | DevOps | docker, k8s, ci/cd, aws, terraform |
+| `test` | Testing | jest, playwright, tdd, e2e |
+| `sec` | Security | auth, oauth, jwt, owasp, pentest |
+| `git` | Git/Workflow | pr, review, commit, branching |
+| `mob` | Mobile | react-native, flutter, ios, android |
+| `py` | Python | django, flask, fastapi, pandas |
+| `go` | Golang | gin, echo, fiber, concurrency |
 
 ## Detection Flow
 
 ```
-User Request → Extract Keywords → Match in skills-keywords.json
-                                          ↓
-                              Found? → Suggest: "I found /skill-name that matches your task"
-                                ↓ No
-                         Check skills-categories.json → Browse category
-                                          ↓
-                              Found? → Suggest: "These skills in [category] might help: ..."
-                                ↓ No
-                         Proceed without skill
+User Request → Extract keywords (react, auth, test, etc.)
+                    ↓
+            Read skills-compact.json
+                    ↓
+            Match skill names containing keywords
+                    ↓
+            Found? → Suggest: "I found /skill-name. Use it?"
+              ↓ No
+            Check category (fe, be, ai, etc.)
+                    ↓
+            Suggest skills in that category
 ```
 
 ## How to Search
 
-### Step 1: Extract Keywords
-From user request, identify:
-- **Technologies**: react, python, docker, postgres, etc.
-- **Patterns**: authentication, caching, testing, deployment
-- **Domains**: ai, security, mobile, devops
+### Step 1: Read Compact Index
+```
+Read: .claude/skills-compact.json
+Format: { "_categories": {...}, "skills": { "skill-name": "category-code" } }
+```
 
-### Step 2: Keyword Lookup
+### Step 2: Match by Name/Keyword
+Look for skills whose name contains user's keywords:
+- User says "react" → find skills with "react" in name
+- User says "authentication" → find "auth" skills
+- User says "docker" → find "docker" skills
+
+### Step 3: Load Full Skill
+When user confirms, read the full skill:
 ```
-Read: .claude/skills-keywords.json
-Find: keywords from user request
-Result: List of matching skill names
+Read: .claude/skills/{skill-name}/SKILL.md
 ```
 
-### Step 3: Category Fallback
-If keywords don't match, check categories:
-- `frontend` - React, Vue, UI/UX, CSS
-- `backend` - Node, API, REST, GraphQL
-- `database` - SQL, Postgres, MongoDB, Redis
-- `ai-ml` - LLM, Agents, RAG, Embeddings
-- `devops` - Docker, K8s, CI/CD, Cloud
-- `testing` - Jest, Playwright, TDD
-- `security` - Auth, OAuth, OWASP
-- `mobile` - React Native, Flutter, iOS
-- `git-workflow` - PR, Code Review, Branching
-
-### Step 4: Suggest
-
-**Format for suggestion:**
+## Suggestion Format
+
+**Single match:**
 ```
-I found a skill that might help with your task:
+I found a skill that might help:
 
-📌 /skill-name - Brief description
+📌 /skill-name - [category]
 
-Would you like me to use this skill? (It will load specific patterns and best practices for [domain])
+Load this skill? It has specialized patterns for your task.
 ```
 
-**For multiple matches:**
+**Multiple matches (max 3):**
 ```
-I found several skills that might help:
+I found skills that might help:
 
-1. /skill-1 - Description
-2. /skill-2 - Description
-3. /skill-3 - Description
+1. /skill-1 - [category]
+2. /skill-2 - [category]
+3. /skill-3 - [category]
 
-Which one should I use? (or say "none" to proceed without)
+Which one should I use? (or "none" to proceed without)
 ```
 
 ## Auto-Activate Triggers
 
-Some skills should auto-activate based on patterns:
+Some patterns should auto-suggest specific skills:
 
-| Pattern | Auto-load Skill |
-|---------|----------------|
-| "create PR", "pull request" | /pr-description |
+| User says... | Suggest skill |
+|--------------|---------------|
+| "create PR", "pull request" | /git-advanced-workflows |
 | "code review" | /code-review |
 | "write tests", "add tests" | /test-master |
 | "fix bug", "debug" | /systematic-debugging |
-| "deploy", "deployment" | Check devops category |
-| "authenticate", "auth" | /auth-patterns |
+| "learn", "teach me" | /learn |
+| "react component" | /react-expert |
+| "nextjs", "next.js" | /nextjs-best-practices |
+| "docker", "container" | /docker-expert |
+| "api design" | /api-design-principles |
 | "database schema" | /database-design |
+| "authentication", "auth" | /auth-implementation-patterns |
+| "mcp server" | /mcp-developer |
 
 ## Important Rules
 
-1. **Don't overwhelm** - Max 3 suggestions at a time
-2. **Be concise** - One-line descriptions only
-3. **Ask permission** - Always ask before loading a skill
+1. **Don't auto-load** - Always ask before loading a skill
+2. **Max 3 suggestions** - Don't overwhelm user
+3. **Be concise** - One-line per skill
 4. **Remember context** - If user said "none", don't suggest again for same task
-5. **Skill stacking** - Multiple skills can be used together if relevant
+5. **On-demand loading** - Only read full SKILL.md when user confirms
+6. **Core commands available** - /learn, /react-expert, /docker-expert, etc. are pre-loaded
 
-## Files Reference
+## File Locations
 
 | File | Purpose | Size |
 |------|---------|------|
-| `skills-keywords.json` | Keyword → Skills mapping | ~330KB |
-| `skills-categories.json` | Category-based index | ~108KB |
-| `skills-triggers.json` | Trigger patterns | ~205KB |
-| `skills-index.json` | Full skill list | ~200KB |
+| `skills-compact.json` | Quick lookup index | ~20KB |
+| `skills/{name}/SKILL.md` | Full skill content | varies |
+| `commands/*.md` | Core commands (pre-loaded) | ~400KB |
 
-## Example Interactions
+## Example Interaction
 
-**User:** "Add JWT authentication to my Express API"
+**User:** "Help me add JWT authentication to my Express API"
 
-**Claude:**
+**Claude:** (reads skills-compact.json, finds "auth-implementation-patterns")
 ```
-I found skills that match your task:
+I found a skill that matches your task:
 
-📌 /auth-patterns - JWT, OAuth2, session management patterns
-📌 /express-expert - Express.js best practices and middleware
+📌 /auth-implementation-patterns - security
 
-Should I use these? They'll help ensure secure auth implementation.
+This skill has JWT, OAuth2, and session patterns. Load it?
 ```
 
-**User:** "Optimize my React app performance"
+**User:** "yes"
 
-**Claude:**
-```
-I found a relevant skill:
-
-📌 /react-performance - React optimization patterns, memo, lazy loading, profiling
-
-Want me to apply these optimization patterns?
-```
+**Claude:** (reads skills/auth-implementation-patterns/SKILL.md and applies it)