@ngxtm/devkit 2.1.0 → 3.0.0

package/package.json

@@ -1,36 +1,32 @@
 {
   "name": "@ngxtm/devkit",
-  "version": "2.1.0",
-  "description": "Unified multi-agent system with auto-synced skills from multiple sources",
-  "main": "cli/install.js",
+  "version": "3.0.0",
+  "description": "Per-project AI skills with smart tech detection - lightweight and context-optimized",
+  "main": "cli/index.js",
   "bin": {
     "devkit": "cli/index.js"
   },
   "scripts": {
-    "install-global": "node cli/install.js",
+    "build": "npm run merge-commands && npm run organize-rules && npm run generate-index",
+    "merge-commands": "node scripts/merge-commands.js",
+    "organize-rules": "node scripts/organize-rules.js",
     "generate-index": "node scripts/generate-index.js",
+    "test": "node cli/index.js detect",
     "sync": "python scripts/sync_all.py",
-    "validate": "python scripts/validate_skills.py",
-    "update-matrix": "python scripts/update_matrix.py"
+    "validate": "python scripts/validate_skills.py"
   },
   "files": [
     "cli/",
-    "agents/",
-    "agents-claudekit/",
-    "commands/",
-    "commands-claudekit/",
+    "merged-commands/",
+    "templates/",
     "skills/",
-    "matrix-skills/",
-    "rules/",
+    "scripts/merge-commands.js",
+    "scripts/organize-rules.js",
+    "scripts/generate-index.js",
     "hooks/",
-    "output-styles/",
-    "workflows/",
-    "settings.json",
-    "statusline.cjs",
-    "statusline.ps1",
-    "statusline.sh",
-    "SKILLS_INDEX.md",
-    "skills-index.json"
+    "skills-index.json",
+    "rules-index.json",
+    "SKILLS_INDEX.md"
   ],
   "keywords": [
     "ai",

package/rules-index.json

@@ -0,0 +1,76 @@
+{
+  "version": "1.0.0",
+  "generatedAt": "2026-01-28T15:40:42.094Z",
+  "templates": {
+    "dart": {
+      "path": "templates/dart/rules",
+      "rules": [
+        "dart"
+      ],
+      "sizeKB": 4
+    },
+    "flutter": {
+      "path": "templates/flutter/rules",
+      "rules": [
+        "flutter"
+      ],
+      "sizeKB": 89
+    },
+    "golang": {
+      "path": "templates/golang/rules",
+      "rules": [
+        "golang"
+      ],
+      "sizeKB": 141
+    },
+    "java": {
+      "path": "templates/java/rules",
+      "rules": [
+        "java"
+      ],
+      "sizeKB": 150
+    },
+    "javascript": {
+      "path": "templates/javascript/rules",
+      "rules": [
+        "javascript"
+      ],
+      "sizeKB": 12
+    },
+    "nestjs": {
+      "path": "templates/nestjs/rules",
+      "rules": [
+        "nestjs"
+      ],
+      "sizeKB": 105
+    },
+    "nextjs": {
+      "path": "templates/nextjs/rules",
+      "rules": [
+        "nextjs"
+      ],
+      "sizeKB": 74
+    },
+    "react": {
+      "path": "templates/react/rules",
+      "rules": [
+        "react"
+      ],
+      "sizeKB": 34
+    },
+    "rust": {
+      "path": "templates/rust/rules",
+      "rules": [
+        "rust"
+      ],
+      "sizeKB": 134
+    },
+    "typescript": {
+      "path": "templates/typescript/rules",
+      "rules": [
+        "typescript"
+      ],
+      "sizeKB": 17
+    }
+  }
+}

package/scripts/generate-index.js

@@ -0,0 +1,223 @@
+#!/usr/bin/env node
+
+/**
+ * Generate Skills Index
+ *
+ * Scans all skills and creates a single SKILLS_INDEX.md file
+ * containing summaries of all available skills.
+ *
+ * This allows Claude to know what skills exist without loading
+ * all 3500+ files into context.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const SKILLS_DIR = path.join(__dirname, '..', 'skills');
+const OUTPUT_FILE = path.join(__dirname, '..', 'SKILLS_INDEX.md');
+
+/**
+ * Parse YAML frontmatter from markdown file
+ */
+function parseFrontmatter(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) return {};
+
+  const yaml = match[1];
+  const result = {};
+
+  // Simple YAML parser for name/description
+  const lines = yaml.split('\n');
+  for (const line of lines) {
+    const colonIndex = line.indexOf(':');
+    if (colonIndex > 0) {
+      const key = line.slice(0, colonIndex).trim();
+      let value = line.slice(colonIndex + 1).trim();
+      // Remove quotes if present
+      if ((value.startsWith('"') && value.endsWith('"')) ||
+          (value.startsWith("'") && value.endsWith("'"))) {
+        value = value.slice(1, -1);
+      }
+      result[key] = value;
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Get first paragraph after frontmatter as description fallback
+ */
+function getFirstParagraph(content) {
+  // Remove frontmatter
+  const withoutFrontmatter = content.replace(/^---[\s\S]*?---\n*/, '');
+  // Remove title
+  const withoutTitle = withoutFrontmatter.replace(/^#[^\n]*\n*/, '');
+  // Get first non-empty paragraph
+  const paragraphs = withoutTitle.split(/\n\n+/);
+  for (const p of paragraphs) {
+    const trimmed = p.trim();
+    if (trimmed && !trimmed.startsWith('#') && !trimmed.startsWith('```')) {
+      // Limit to 200 chars
+      return trimmed.slice(0, 200) + (trimmed.length > 200 ? '...' : '');
+    }
+  }
+  return '';
+}
+
+/**
+ * Scan a skill directory and extract metadata
+ */
+function scanSkill(skillPath, skillName) {
+  const skillFile = path.join(skillPath, 'SKILL.md');
+  const agentsFile = path.join(skillPath, 'AGENTS.md');
+
+  let content = '';
+  let sourceFile = '';
+
+  if (fs.existsSync(skillFile)) {
+    content = fs.readFileSync(skillFile, 'utf-8');
+    sourceFile = 'SKILL.md';
+  } else if (fs.existsSync(agentsFile)) {
+    content = fs.readFileSync(agentsFile, 'utf-8');
+    sourceFile = 'AGENTS.md';
+  } else {
+    // Try to find any .md file
+    const files = fs.readdirSync(skillPath).filter(f => f.endsWith('.md'));
+    if (files.length > 0) {
+      content = fs.readFileSync(path.join(skillPath, files[0]), 'utf-8');
+      sourceFile = files[0];
+    }
+  }
+
+  if (!content) {
+    return null;
+  }
+
+  const frontmatter = parseFrontmatter(content);
+
+  return {
+    name: frontmatter.name || skillName,
+    description: frontmatter.description || getFirstParagraph(content),
+    path: `skills/${skillName}`,
+    sourceFile
+  };
+}
+
+/**
+ * Categorize skills based on name patterns
+ */
+function categorizeSkill(name) {
+  const lowerName = name.toLowerCase();
+
+  if (/react|next|remix|vue|angular|svelte/.test(lowerName)) return 'Frontend Frameworks';
+  if (/node|express|nest|fastify|hono/.test(lowerName)) return 'Backend/Node.js';
+  if (/python|django|flask|fastapi/.test(lowerName)) return 'Python';
+  if (/database|postgres|mysql|mongo|redis|sql/.test(lowerName)) return 'Databases';
+  if (/docker|kubernetes|k8s|ci|cd|deploy|aws|cloud|terraform/.test(lowerName)) return 'DevOps/Cloud';
+  if (/test|jest|playwright|cypress|vitest/.test(lowerName)) return 'Testing';
+  if (/security|auth|owasp|crypto/.test(lowerName)) return 'Security';
+  if (/ai|agent|llm|mcp|prompt|openai|anthropic/.test(lowerName)) return 'AI/Agents';
+  if (/mobile|react-native|flutter|ios|android/.test(lowerName)) return 'Mobile';
+  if (/git|review|debug|refactor|documentation/.test(lowerName)) return 'Development Tools';
+  if (/api|rest|graphql|grpc/.test(lowerName)) return 'API Design';
+  if (/css|tailwind|style|animation|ui|ux/.test(lowerName)) return 'UI/Styling';
+  if (/typescript|javascript|js|ts/.test(lowerName)) return 'TypeScript/JavaScript';
+
+  return 'Other';
+}
+
+/**
+ * Main function
+ */
+function generateIndex() {
+  console.log('Scanning skills directory...');
+
+  if (!fs.existsSync(SKILLS_DIR)) {
+    console.error('Skills directory not found:', SKILLS_DIR);
+    process.exit(1);
+  }
+
+  const skillDirs = fs.readdirSync(SKILLS_DIR, { withFileTypes: true })
+    .filter(d => d.isDirectory() && !d.name.startsWith('.'))
+    .map(d => d.name)
+    .sort();
+
+  console.log(`Found ${skillDirs.length} skill directories`);
+
+  const skills = [];
+  const categorized = {};
+
+  for (const skillName of skillDirs) {
+    const skillPath = path.join(SKILLS_DIR, skillName);
+    const skillInfo = scanSkill(skillPath, skillName);
+
+    if (skillInfo) {
+      skills.push(skillInfo);
+
+      const category = categorizeSkill(skillName);
+      if (!categorized[category]) {
+        categorized[category] = [];
+      }
+      categorized[category].push(skillInfo);
+    }
+  }
+
+  console.log(`Extracted metadata from ${skills.length} skills`);
+
+  // Generate markdown
+  let output = `# Skills Index
+
+> Auto-generated index of ${skills.length} available skills.
+> Use this to discover skills without loading all files into context.
+>
+> **To use a skill**: Read the full skill at \`~/.claude/skills/<skill-name>/SKILL.md\`
+
+## Quick Reference
+
+| Category | Count |
+|----------|-------|
+`;
+
+  // Sort categories by count
+  const sortedCategories = Object.entries(categorized)
+    .sort((a, b) => b[1].length - a[1].length);
+
+  for (const [category, categorySkills] of sortedCategories) {
+    output += `| ${category} | ${categorySkills.length} |\n`;
+  }
+
+  output += `\n---\n\n`;
+
+  // Output by category
+  for (const [category, categorySkills] of sortedCategories) {
+    output += `## ${category}\n\n`;
+
+    for (const skill of categorySkills) {
+      const desc = skill.description
+        ? skill.description.replace(/\n/g, ' ').slice(0, 150)
+        : 'No description';
+      output += `### ${skill.name}\n`;
+      output += `\`${skill.path}\`\n\n`;
+      output += `${desc}${skill.description && skill.description.length > 150 ? '...' : ''}\n\n`;
+    }
+  }
+
+  // Write output
+  fs.writeFileSync(OUTPUT_FILE, output);
+  console.log(`\nGenerated: ${OUTPUT_FILE}`);
+  console.log(`File size: ${(fs.statSync(OUTPUT_FILE).size / 1024).toFixed(1)} KB`);
+
+  // Also generate a compact JSON version for programmatic use
+  const jsonOutput = path.join(__dirname, '..', 'skills-index.json');
+  const jsonData = skills.map(s => ({
+    name: s.name,
+    path: s.path,
+    description: s.description ? s.description.slice(0, 200) : ''
+  }));
+  fs.writeFileSync(jsonOutput, JSON.stringify(jsonData, null, 2));
+  console.log(`Generated: ${jsonOutput}`);
+}
+
+// Run
+generateIndex();

package/scripts/merge-commands.js

@@ -0,0 +1,290 @@
+#!/usr/bin/env node
+
+/**
+ * Merge Commands Script
+ *
+ * Merges commands from two sources:
+ * - commands/ (agent-assistant style)
+ * - commands-claudekit/ (claudekit style)
+ *
+ * Strategy:
+ * 1. For conflicting commands, prefer claudekit (more sophisticated)
+ * 2. For sub-commands, merge all unique sub-commands from both sources
+ * 3. For unique commands, copy as-is
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const PACKAGE_ROOT = path.join(__dirname, '..');
+const COMMANDS_DIR = path.join(PACKAGE_ROOT, 'commands');
+const COMMANDS_CLAUDEKIT_DIR = path.join(PACKAGE_ROOT, 'commands-claudekit');
+const MERGED_DIR = path.join(PACKAGE_ROOT, 'merged-commands');
+
+/**
+ * Merge strategy for conflicting commands
+ * - 'claudekit': Use claudekit version
+ * - 'agent': Use agent-assistant version
+ * - 'merge': Merge both (claudekit base, add agent sub-commands)
+ */
+const MERGE_STRATEGY = {
+  // Prefer claudekit for these (more sophisticated)
+  'ask.md': 'claudekit',
+  'bootstrap.md': 'claudekit',
+  'ck-help.md': 'claudekit',
+  'coding-level.md': 'claudekit',
+  'debug.md': 'claudekit',
+  'journal.md': 'claudekit',
+  'kanban.md': 'claudekit',
+  'preview.md': 'claudekit',
+  'scout.md': 'claudekit',
+  'use-mcp.md': 'claudekit',
+  'watzup.md': 'claudekit',
+  'worktree.md': 'claudekit',
+
+  // Prefer agent-assistant for these
+  'auto.md': 'agent',
+  'deploy.md': 'agent',
+
+  // Merge both for these (combine sub-commands)
+  'brainstorm.md': 'merge',
+  'code.md': 'merge',
+  'cook.md': 'merge',
+  'design.md': 'merge',
+  'docs.md': 'merge',
+  'fix.md': 'merge',
+  'plan.md': 'merge',
+  'review.md': 'merge',
+  'test.md': 'merge'
+};
+
+/**
+ * For merged commands, which source provides the base .md file
+ */
+const MERGE_BASE = {
+  'brainstorm.md': 'claudekit',
+  'code.md': 'claudekit',
+  'cook.md': 'claudekit',
+  'design.md': 'agent',
+  'docs.md': 'claudekit',
+  'fix.md': 'claudekit',
+  'plan.md': 'claudekit',
+  'review.md': 'agent',
+  'test.md': 'claudekit'
+};
+
+/**
+ * Get all files and directories from a path recursively
+ */
+function getAllEntries(dir, basePath = '') {
+  const entries = { files: [], dirs: [] };
+
+  if (!fs.existsSync(dir)) return entries;
+
+  const items = fs.readdirSync(dir, { withFileTypes: true });
+
+  for (const item of items) {
+    const relativePath = path.join(basePath, item.name);
+
+    if (item.isDirectory()) {
+      entries.dirs.push(relativePath);
+      const subEntries = getAllEntries(path.join(dir, item.name), relativePath);
+      entries.files.push(...subEntries.files);
+      entries.dirs.push(...subEntries.dirs);
+    } else {
+      entries.files.push(relativePath);
+    }
+  }
+
+  return entries;
+}
+
+/**
+ * Copy file with directory creation
+ */
+function copyFile(src, dest) {
+  const destDir = path.dirname(dest);
+  fs.mkdirSync(destDir, { recursive: true });
+  fs.copyFileSync(src, dest);
+}
+
+/**
+ * Copy directory recursively
+ */
+function copyDir(src, dest) {
+  if (!fs.existsSync(src)) return 0;
+
+  fs.mkdirSync(dest, { recursive: true });
+  let count = 0;
+
+  const entries = fs.readdirSync(src, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+
+    if (entry.isDirectory()) {
+      count += copyDir(srcPath, destPath);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+      count++;
+    }
+  }
+
+  return count;
+}
+
+/**
+ * Merge commands from both sources
+ */
+function mergeCommands() {
+  console.log('\n' + '='.repeat(60));
+  console.log('  MERGE COMMANDS');
+  console.log('='.repeat(60));
+
+  // Clean merged directory
+  if (fs.existsSync(MERGED_DIR)) {
+    fs.rmSync(MERGED_DIR, { recursive: true, force: true });
+  }
+  fs.mkdirSync(MERGED_DIR, { recursive: true });
+
+  const agentEntries = getAllEntries(COMMANDS_DIR);
+  const claudekitEntries = getAllEntries(COMMANDS_CLAUDEKIT_DIR);
+
+  // Collect all unique files and dirs
+  const allFiles = new Set([...agentEntries.files, ...claudekitEntries.files]);
+  const processedDirs = new Set();
+
+  let copiedFromAgent = 0;
+  let copiedFromClaudekit = 0;
+  let merged = 0;
+
+  // Process each file
+  for (const relativePath of allFiles) {
+    const fileName = path.basename(relativePath);
+    const dirName = path.dirname(relativePath);
+
+    // Check if this is a root-level command file
+    const isRootCommand = dirName === '.';
+    const commandName = isRootCommand ? fileName : path.basename(dirName) + '.md';
+
+    const agentPath = path.join(COMMANDS_DIR, relativePath);
+    const claudekitPath = path.join(COMMANDS_CLAUDEKIT_DIR, relativePath);
+    const mergedPath = path.join(MERGED_DIR, relativePath);
+
+    const existsInAgent = fs.existsSync(agentPath);
+    const existsInClaudekit = fs.existsSync(claudekitPath);
+
+    // Determine source
+    if (existsInAgent && existsInClaudekit) {
+      // Both have this file - apply strategy
+      const strategy = MERGE_STRATEGY[fileName] || MERGE_STRATEGY[commandName];
+
+      if (strategy === 'agent') {
+        copyFile(agentPath, mergedPath);
+        copiedFromAgent++;
+      } else if (strategy === 'claudekit' || strategy === 'merge' || !strategy) {
+        // Default to claudekit for conflicts
+        copyFile(claudekitPath, mergedPath);
+        copiedFromClaudekit++;
+        if (strategy === 'merge') merged++;
+      }
+    } else if (existsInAgent) {
+      copyFile(agentPath, mergedPath);
+      copiedFromAgent++;
+    } else if (existsInClaudekit) {
+      copyFile(claudekitPath, mergedPath);
+      copiedFromClaudekit++;
+    }
+  }
+
+  // Copy unique subdirectories from both sources
+  const agentDirs = new Set(agentEntries.dirs.map(d => d.split(path.sep)[0]));
+  const claudekitDirs = new Set(claudekitEntries.dirs.map(d => d.split(path.sep)[0]));
+
+  // For directories that exist in both, we need to merge their contents
+  for (const dir of agentDirs) {
+    const agentSubDir = path.join(COMMANDS_DIR, dir);
+    const claudekitSubDir = path.join(COMMANDS_CLAUDEKIT_DIR, dir);
+    const mergedSubDir = path.join(MERGED_DIR, dir);
+
+    if (claudekitDirs.has(dir)) {
+      // Both have this directory - merge contents
+      // Claudekit files already copied above, add agent-only files
+      if (fs.existsSync(agentSubDir)) {
+        const agentFiles = fs.readdirSync(agentSubDir, { withFileTypes: true });
+        for (const entry of agentFiles) {
+          const mergedEntryPath = path.join(mergedSubDir, entry.name);
+          if (!fs.existsSync(mergedEntryPath)) {
+            const agentEntryPath = path.join(agentSubDir, entry.name);
+            if (entry.isDirectory()) {
+              copyDir(agentEntryPath, mergedEntryPath);
+            } else {
+              copyFile(agentEntryPath, mergedEntryPath);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  // Count final files
+  const finalEntries = getAllEntries(MERGED_DIR);
+
+  console.log(`\n  From agent-assistant: ${copiedFromAgent} files`);
+  console.log(`  From claudekit: ${copiedFromClaudekit} files`);
+  console.log(`  Merged conflicts: ${merged} files`);
+  console.log(`  Total merged: ${finalEntries.files.length} files`);
+  console.log('\n' + '='.repeat(60));
+
+  return finalEntries.files.length;
+}
+
+/**
+ * List merged commands
+ */
+function listMergedCommands() {
+  if (!fs.existsSync(MERGED_DIR)) {
+    console.log('No merged commands. Run: npm run merge-commands');
+    return;
+  }
+
+  const entries = getAllEntries(MERGED_DIR);
+  console.log('\nMerged Commands:\n');
+
+  // Get root-level commands
+  const rootCommands = entries.files
+    .filter(f => !f.includes(path.sep))
+    .map(f => f.replace('.md', ''))
+    .sort();
+
+  for (const cmd of rootCommands) {
+    console.log(`  /${cmd}`);
+
+    // Check for sub-commands
+    const subDir = cmd;
+    const subCommands = entries.files
+      .filter(f => f.startsWith(subDir + path.sep))
+      .map(f => f.replace(subDir + path.sep, '').replace('.md', '').replace(/\\/g, ':'))
+      .sort();
+
+    for (const sub of subCommands) {
+      console.log(`    /${cmd}:${sub}`);
+    }
+  }
+
+  console.log(`\nTotal: ${entries.files.length} command files\n`);
+}
+
+// Run if called directly
+if (require.main === module) {
+  const arg = process.argv[2];
+
+  if (arg === 'list') {
+    listMergedCommands();
+  } else {
+    mergeCommands();
+  }
+}
+
+module.exports = { mergeCommands, listMergedCommands };