@ngxtm/devkit 2.1.0 → 3.0.1

package/hooks/lib/__tests__/statusline-integration.test.cjs

@@ -4,7 +4,7 @@
 /**
  * Integration Tests for Statusline Main Script
  * Tests the complete statusline.cjs with sample JSON input
- * Run: node .claude/hooks/lib/__tests__/statusline-integration.test.cjs
+ * Run: node hooks/lib/__tests__/statusline-integration.test.cjs
  */
 
 const fs = require('fs');
@@ -12,6 +12,12 @@ const path = require('path');
 const os = require('os');
 const { execSync } = require('child_process');
 
+// Determine the correct statusline.cjs path (at project root)
+const statuslinePath = path.resolve(__dirname, '..', '..', '..', 'statusline.cjs');
+
+// Check if running on Windows
+const isWindows = process.platform === 'win32';
+
 let passed = 0;
 let failed = 0;
 const failures = [];
@@ -47,6 +53,29 @@ function assertContains(actual, search, msg = '') {
   }
 }
 
+/**
+ * Cross-platform helper to run statusline with JSON input
+ * Uses temp file approach to avoid shell quoting issues on Windows
+ */
+function runStatusline(jsonInput, extraEnv = {}, options = {}) {
+  const tmpFile = path.join(os.tmpdir(), `statusline-test-${Date.now()}-${Math.random().toString(36).substring(7)}.json`);
+  try {
+    fs.writeFileSync(tmpFile, jsonInput);
+    const cmd = isWindows
+      ? `type "${tmpFile}" | node "${statuslinePath}"`
+      : `cat "${tmpFile}" | node "${statuslinePath}"`;
+    return execSync(cmd, {
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+      env: { ...process.env, ...extraEnv },
+      shell: true,
+      ...options
+    });
+  } finally {
+    try { fs.unlinkSync(tmpFile); } catch {}
+  }
+}
+
 console.log('\n═══════════════════════════════════════════════════════');
 console.log('STATUSLINE INTEGRATION TESTS');
 console.log('═══════════════════════════════════════════════════════\n');
@@ -64,10 +93,7 @@ const minimalInput = JSON.stringify({
 });
 
 try {
-  const result = execSync(`echo '${minimalInput.replace(/'/g, "'\\''")}'  | node .claude/statusline.cjs`, {
-    encoding: 'utf8',
-    stdio: ['pipe', 'pipe', 'pipe']
-  });
+  const result = runStatusline(minimalInput);
 
   test('Minimal input produces output', () => {
     assertTrue(result.length > 0, 'Should produce some output');
@@ -109,11 +135,7 @@ try {
     context_window: { context_window_size: 200000 }
   });
 
-  const gitResult = execSync(`echo '${gitInput.replace(/'/g, "'\\''")}'  | node .claude/statusline.cjs`, {
-    encoding: 'utf8',
-    cwd: tmpDir,
-    stdio: ['pipe', 'pipe', 'pipe']
-  });
+  const gitResult = runStatusline(gitInput);
 
   test('Git input processed without error', () => {
     assertTrue(gitResult.length > 0, 'Should produce output for git repo');
@@ -153,10 +175,7 @@ const contextInput = JSON.stringify({
 });
 
 try {
-  const contextResult = execSync(`echo '${contextInput.replace(/'/g, "'\\''")}'  | node .claude/statusline.cjs`, {
-    encoding: 'utf8',
-    stdio: ['pipe', 'pipe', 'pipe']
-  });
+  const contextResult = runStatusline(contextInput);
 
   test('Context window data processed', () => {
     assertTrue(contextResult.length > 0, 'Should process context window data');
@@ -180,8 +199,6 @@ try {
 
 console.log('\nTEST 4: JSON with Cost Info\n');
 
-process.env.CLAUDE_BILLING_MODE = 'api';
-
 const costInput = JSON.stringify({
   model: { display_name: 'Claude' },
   workspace: { current_dir: '/home/user' },
@@ -194,11 +211,7 @@ const costInput = JSON.stringify({
 });
 
 try {
-  const costResult = execSync(`echo '${costInput.replace(/'/g, "'\\''")}'  | CLAUDE_BILLING_MODE=api node .claude/statusline.cjs`, {
-    encoding: 'utf8',
-    stdio: ['pipe', 'pipe', 'pipe'],
-    env: { ...process.env, CLAUDE_BILLING_MODE: 'api' }
-  });
+  const costResult = runStatusline(costInput, { CLAUDE_BILLING_MODE: 'api' });
 
   test('Cost info displayed in API mode', () => {
     assertTrue(costResult.length > 0, 'Should display cost info');
@@ -222,10 +235,7 @@ try {
 console.log('\nTEST 5: Invalid JSON Handling\n');
 
 try {
-  const invalidResult = execSync(`echo 'not valid json'  | node .claude/statusline.cjs`, {
-    encoding: 'utf8',
-    stdio: ['pipe', 'pipe', 'pipe']
-  });
+  const invalidResult = runStatusline('not valid json');
 
   test('Invalid JSON produces fallback output', () => {
     assertTrue(invalidResult.length > 0, 'Should produce fallback output');
@@ -247,10 +257,7 @@ try {
 console.log('\nTEST 6: Empty Input Handling\n');
 
 try {
-  const emptyResult = execSync(`echo '' | node .claude/statusline.cjs`, {
-    encoding: 'utf8',
-    stdio: ['pipe', 'pipe', 'pipe']
-  });
+  const emptyResult = runStatusline('');
 
   test('Empty input handled', () => {
     // Should either error gracefully or produce fallback
@@ -281,10 +288,7 @@ const multilineInput = JSON.stringify({
 });
 
 try {
-  const multilineResult = execSync(`echo '${multilineInput.replace(/'/g, "'\\''")}'  | node .claude/statusline.cjs`, {
-    encoding: 'utf8',
-    stdio: ['pipe', 'pipe', 'pipe']
-  });
+  const multilineResult = runStatusline(multilineInput);
 
   test('Multi-line output generates content', () => {
     assertTrue(multilineResult.length > 0, 'Should generate output');
@@ -322,10 +326,7 @@ const expandInput = JSON.stringify({
 });
 
 try {
-  const expandResult = execSync(`echo '${expandInput.replace(/'/g, "'\\''")}'  | node .claude/statusline.cjs`, {
-    encoding: 'utf8',
-    stdio: ['pipe', 'pipe', 'pipe']
-  });
+  const expandResult = runStatusline(expandInput);
 
   test('Home directory expanded to tilde', () => {
     assertTrue(expandResult.includes('~') || expandResult.includes('projects'), 'Should expand or contain path');
@@ -352,11 +353,7 @@ const colorInput = JSON.stringify({
 
 try {
   // Test with NO_COLOR=1
-  const noColorResult = execSync(`echo '${colorInput.replace(/'/g, "'\\''")}'  | NO_COLOR=1 node .claude/statusline.cjs`, {
-    encoding: 'utf8',
-    stdio: ['pipe', 'pipe', 'pipe'],
-    env: { ...process.env, NO_COLOR: '1' }
-  });
+  const noColorResult = runStatusline(colorInput, { NO_COLOR: '1' });
 
   test('NO_COLOR=1 produces output', () => {
     assertTrue(noColorResult.length > 0, 'Should produce output with NO_COLOR=1');
@@ -390,11 +387,7 @@ const wideInput = JSON.stringify({
 
 let wideLines = 0;
 try {
-  const wideResult = execSync(`echo '${wideInput.replace(/'/g, "'\\''")}'  | COLUMNS=160 node .claude/statusline.cjs`, {
-    encoding: 'utf8',
-    stdio: ['pipe', 'pipe', 'pipe'],
-    env: { ...process.env, COLUMNS: '160' }
-  });
+  const wideResult = runStatusline(wideInput, { COLUMNS: '160' });
   wideLines = wideResult.trim().split('\n').length;
 
   test('Wide terminal (160 cols) produces output', () => {
@@ -425,11 +418,7 @@ const narrowInput = JSON.stringify({
 });
 
 try {
-  const narrowResult = execSync(`echo '${narrowInput.replace(/'/g, "'\\''")}'  | COLUMNS=80 node .claude/statusline.cjs`, {
-    encoding: 'utf8',
-    stdio: ['pipe', 'pipe', 'pipe'],
-    env: { ...process.env, COLUMNS: '80' }
-  });
+  const narrowResult = runStatusline(narrowInput, { COLUMNS: '80' });
   const narrowLines = narrowResult.trim().split('\n').length;
 
   test('Narrow terminal (80 cols) produces output', () => {
@@ -463,11 +452,7 @@ const longPathInput = JSON.stringify({
 });
 
 try {
-  const longPathResult = execSync(`echo '${longPathInput.replace(/'/g, "'\\''")}'  | COLUMNS=100 node .claude/statusline.cjs`, {
-    encoding: 'utf8',
-    stdio: ['pipe', 'pipe', 'pipe'],
-    env: { ...process.env, COLUMNS: '100' }
-  });
+  const longPathResult = runStatusline(longPathInput, { COLUMNS: '100' });
 
   test('Long path produces output without crash', () => {
     assertTrue(longPathResult.length > 0, 'Should produce output');
@@ -497,11 +482,7 @@ const longModelInput = JSON.stringify({
 });
 
 try {
-  const longModelResult = execSync(`echo '${longModelInput.replace(/'/g, "'\\''")}'  | COLUMNS=100 node .claude/statusline.cjs`, {
-    encoding: 'utf8',
-    stdio: ['pipe', 'pipe', 'pipe'],
-    env: { ...process.env, COLUMNS: '100' }
-  });
+  const longModelResult = runStatusline(longModelInput, { COLUMNS: '100' });
 
   test('Long model name produces output', () => {
     assertTrue(longModelResult.length > 0, 'Should produce output');
@@ -580,10 +561,7 @@ const agentTodoInput = JSON.stringify({
 });
 
 try {
-  const agentTodoResult = execSync(`echo '${agentTodoInput.replace(/'/g, "'\\''")}'  | node .claude/statusline.cjs`, {
-    encoding: 'utf8',
-    stdio: ['pipe', 'pipe', 'pipe']
-  });
+  const agentTodoResult = runStatusline(agentTodoInput);
 
   test('Agent/Todo tracking produces output', () => {
     assertTrue(agentTodoResult.length > 0, 'Should produce output');
@@ -624,10 +602,7 @@ const zeroContextInput = JSON.stringify({
 });
 
 try {
-  const zeroResult = execSync(`echo '${zeroContextInput.replace(/'/g, "'\\''")}'  | node .claude/statusline.cjs`, {
-    encoding: 'utf8',
-    stdio: ['pipe', 'pipe', 'pipe']
-  });
+  const zeroResult = runStatusline(zeroContextInput);
 
   test('Zero context produces output', () => {
     assertTrue(zeroResult.length > 0, 'Should produce output');
@@ -638,11 +613,7 @@ try {
 
 // Test with very small terminal
 try {
-  const tinyResult = execSync(`echo '${wideInput.replace(/'/g, "'\\''")}'  | COLUMNS=40 node .claude/statusline.cjs`, {
-    encoding: 'utf8',
-    stdio: ['pipe', 'pipe', 'pipe'],
-    env: { ...process.env, COLUMNS: '40' }
-  });
+  const tinyResult = runStatusline(wideInput, { COLUMNS: '40' });
 
   test('Very narrow terminal (40 cols) handles gracefully', () => {
     assertTrue(tinyResult.length > 0, 'Should produce output even at 40 cols');

package/hooks/scout-block/tests/test-monorepo-scenarios.cjs

@@ -138,9 +138,9 @@ const scenarios = [
     desc: 'Grep in src'
   },
   {
-    input: { tool_name: 'Glob', tool_input: { pattern: '**/*.ts' } },
+    input: { tool_name: 'Glob', tool_input: { pattern: 'src/**/*.ts' } },
     expected: 'ALLOWED',
-    desc: 'Glob all .ts files'
+    desc: 'Glob scoped .ts files in src'
   },
   {
     input: { tool_name: 'Bash', tool_input: { command: 'find packages -name "*.json" | head' } },

package/hooks/tests/test-ckignore.cjs

@@ -9,7 +9,7 @@ const { execSync } = require('child_process');
 const fs = require('fs');
 const path = require('path');
 
-const scriptPath = path.join(__dirname, '..', 'scout-block', 'scout-block.sh');
+const scriptPath = path.join(__dirname, '..', 'scout-block.cjs');
 const ckignorePath = path.join(__dirname, '..', '..', '.ckignore');
 const ckignoreBackupPath = ckignorePath + '.backup';
 
@@ -23,7 +23,7 @@ if (fs.existsSync(ckignorePath)) {
 function runTest(name, input, expected) {
   try {
     const inputJson = JSON.stringify(input);
-    execSync(`bash "${scriptPath}"`, {
+    execSync(`node "${scriptPath}"`, {
       input: inputJson,
       encoding: 'utf-8',
       stdio: ['pipe', 'pipe', 'pipe']
@@ -48,6 +48,11 @@ function restoreCkignore() {
     if (fs.existsSync(ckignoreBackupPath)) {
       fs.unlinkSync(ckignoreBackupPath);
     }
+  } else {
+    // If there was no original .ckignore, remove the test-created one
+    if (fs.existsSync(ckignorePath)) {
+      fs.unlinkSync(ckignorePath);
+    }
   }
 }
 

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.1",
+  "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();