add-skill-kit 3.2.3 → 3.2.5

package/lib/agent-cli/scripts/success_sensor.js

@@ -0,0 +1,500 @@
+#!/usr/bin/env node
+/**
+ * Success Sensor - Detect successful patterns and best practices
+ * 
+ * Part of FAANG-Grade Auto-Learn System
+ * 
+ * Scans for:
+ * - Test successes (all tests pass)
+ * - Lint successes (no errors)
+ * - Build successes (compiled OK)
+ * - Code pattern successes (good practices)
+ * 
+ * Usage:
+ *   node success_sensor.js --scan all
+ *   node success_sensor.js --scan test
+ *   node success_sensor.js --stats
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { execSync } from 'child_process';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Colors
+const c = {
+    reset: '\x1b[0m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    blue: '\x1b[34m',
+    cyan: '\x1b[36m',
+    gray: '\x1b[90m',
+    bold: '\x1b[1m'
+};
+
+// Find project root
+function findProjectRoot() {
+    let current = process.cwd();
+    while (current !== path.dirname(current)) {
+        if (fs.existsSync(path.join(current, '.agent'))) {
+            return current;
+        }
+        current = path.dirname(current);
+    }
+    return process.cwd();
+}
+
+const projectRoot = findProjectRoot();
+const knowledgePath = path.join(projectRoot, '.agent', 'knowledge');
+const successesPath = path.join(knowledgePath, 'successes.json');
+
+// Ensure knowledge directory exists
+if (!fs.existsSync(knowledgePath)) {
+    fs.mkdirSync(knowledgePath, { recursive: true });
+}
+
+// Load existing successes
+function loadSuccesses() {
+    try {
+        if (fs.existsSync(successesPath)) {
+            return JSON.parse(fs.readFileSync(successesPath, 'utf8'));
+        }
+    } catch { }
+    return { successes: [], totalSuccesses: 0, lastScan: null };
+}
+
+// Save successes
+function saveSuccesses(data) {
+    data.lastScan = new Date().toISOString();
+    fs.writeFileSync(successesPath, JSON.stringify(data, null, 2));
+}
+
+// Generate success ID
+function generateSuccessId(type) {
+    const data = loadSuccesses();
+    const count = data.successes.filter(s => s.type === type).length + 1;
+    return `SUCCESS-${type.toUpperCase()}-${String(count).padStart(3, '0')}`;
+}
+
+// ==================== CONTEXT DETECTION ====================
+
+/**
+ * Detect project context
+ */
+function detectProjectContext() {
+    const context = {
+        projectType: 'unknown',
+        framework: null,
+        language: 'javascript'
+    };
+
+    try {
+        const pkgPath = path.join(projectRoot, 'package.json');
+        if (fs.existsSync(pkgPath)) {
+            const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+            const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+
+            if (deps['next']) context.projectType = 'nextjs';
+            else if (deps['react-native'] || deps['expo']) context.projectType = 'react-native';
+            else if (deps['react']) context.projectType = 'react';
+            else if (deps['express']) context.projectType = 'backend';
+
+            if (deps['typescript']) context.language = 'typescript';
+        }
+    } catch { }
+
+    return context;
+}
+
+/**
+ * Detect file context
+ */
+function detectFileContext(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    const relativePath = path.relative(projectRoot, filePath);
+
+    return {
+        fileType: ext,
+        isTypeScript: ext === '.ts' || ext === '.tsx',
+        directory: relativePath.split(path.sep)[0] || 'root',
+        fullPath: relativePath
+    };
+}
+
+// ==================== SUCCESS SENSORS ====================
+
+/**
+ * Scan for test successes
+ */
+function scanTestSuccesses() {
+    const successes = [];
+
+    try {
+        // Try running tests
+        const output = execSync('npm test 2>&1', {
+            encoding: 'utf8',
+            timeout: 60000,
+            cwd: projectRoot
+        });
+
+        // Check for success indicators
+        const successPatterns = [
+            /(\d+) pass/i,
+            /all tests passed/i,
+            /tests?\s+passed/i,
+            /0 failed/i,
+            /✓.*(\d+) tests?/,
+            /PASS\s+/
+        ];
+
+        for (const pattern of successPatterns) {
+            const match = output.match(pattern);
+            if (match) {
+                successes.push({
+                    id: generateSuccessId('test'),
+                    type: 'test',
+                    pattern: 'test-pass',
+                    message: `Tests passed: ${match[0]}`,
+                    source: 'npm test',
+                    severity: 'SUCCESS',
+                    detectedAt: new Date().toISOString()
+                });
+                break;
+            }
+        }
+    } catch (error) {
+        // Test failed or not configured - not a success
+    }
+
+    return successes;
+}
+
+/**
+ * Scan for lint successes
+ */
+function scanLintSuccesses() {
+    const successes = [];
+
+    try {
+        // Try running lint
+        const output = execSync('npm run lint 2>&1', {
+            encoding: 'utf8',
+            timeout: 30000,
+            cwd: projectRoot
+        });
+
+        // Check for success indicators
+        const successPatterns = [
+            /0 errors/i,
+            /no issues found/i,
+            /no problems/i,
+            /all files pass/i,
+            /✓ no issues/i
+        ];
+
+        for (const pattern of successPatterns) {
+            if (pattern.test(output)) {
+                successes.push({
+                    id: generateSuccessId('lint'),
+                    type: 'lint',
+                    pattern: 'lint-clean',
+                    message: 'Lint passed with no errors',
+                    source: 'npm run lint',
+                    severity: 'SUCCESS',
+                    detectedAt: new Date().toISOString()
+                });
+                break;
+            }
+        }
+
+        // Also count as success if no output (many linters silent on success)
+        if (output.trim() === '' || !output.includes('error')) {
+            successes.push({
+                id: generateSuccessId('lint'),
+                type: 'lint',
+                pattern: 'lint-clean',
+                message: 'Lint passed (no output = clean)',
+                source: 'npm run lint',
+                severity: 'SUCCESS',
+                detectedAt: new Date().toISOString()
+            });
+        }
+    } catch (error) {
+        // Lint failed or not configured - not a success
+    }
+
+    return successes;
+}
+
+/**
+ * Scan for code pattern successes
+ */
+function scanCodePatternSuccesses() {
+    const successes = [];
+
+    // Good patterns to detect
+    const goodPatterns = [
+        {
+            name: 'proper-error-handling',
+            pattern: /try\s*\{[\s\S]*?\}\s*catch\s*\([^)]+\)\s*\{[\s\S]*?console\.(error|log)|throw/,
+            message: 'Proper try-catch with error logging/re-throw',
+            fileTypes: ['.js', '.ts', '.jsx', '.tsx']
+        },
+        {
+            name: 'typescript-types',
+            pattern: /:\s*(string|number|boolean|object|\w+\[\]|Promise<|React\.FC|void)/,
+            message: 'TypeScript type annotations used',
+            fileTypes: ['.ts', '.tsx']
+        },
+        {
+            name: 'async-await',
+            pattern: /async\s+function|\basync\s+\(|await\s+/,
+            message: 'Modern async/await pattern used',
+            fileTypes: ['.js', '.ts', '.jsx', '.tsx']
+        },
+        {
+            name: 'destructuring',
+            pattern: /const\s+\{[^}]+\}\s*=|const\s+\[[^\]]+\]\s*=/,
+            message: 'Modern destructuring used',
+            fileTypes: ['.js', '.ts', '.jsx', '.tsx']
+        },
+        {
+            name: 'optional-chaining',
+            pattern: /\?\.\w+|\?\.\[/,
+            message: 'Optional chaining (?.) used for null safety',
+            fileTypes: ['.js', '.ts', '.jsx', '.tsx']
+        },
+        {
+            name: 'nullish-coalescing',
+            pattern: /\?\?/,
+            message: 'Nullish coalescing (??) used',
+            fileTypes: ['.js', '.ts', '.jsx', '.tsx']
+        },
+        {
+            name: 'es6-exports',
+            pattern: /^export\s+(default\s+)?(function|class|const|let|var|async)/m,
+            message: 'ES6 module exports used',
+            fileTypes: ['.js', '.ts', '.jsx', '.tsx']
+        },
+        {
+            name: 'jsdoc-comments',
+            pattern: /\/\*\*[\s\S]*?@(param|returns|type|description)/,
+            message: 'JSDoc documentation present',
+            fileTypes: ['.js', '.ts', '.jsx', '.tsx']
+        }
+    ];
+
+    // Scan source files
+    const srcDirs = ['src', 'lib', 'bin', 'scripts'];
+    const scannedFiles = new Set();
+
+    for (const dir of srcDirs) {
+        const dirPath = path.join(projectRoot, dir);
+        if (!fs.existsSync(dirPath)) continue;
+
+        scanDirectory(dirPath, (filePath) => {
+            if (scannedFiles.has(filePath)) return;
+            scannedFiles.add(filePath);
+
+            const ext = path.extname(filePath);
+            const content = fs.readFileSync(filePath, 'utf8');
+
+            for (const gp of goodPatterns) {
+                if (!gp.fileTypes.includes(ext)) continue;
+
+                const matches = content.match(new RegExp(gp.pattern, 'g'));
+                if (matches && matches.length > 0) {
+                    // Only add if significant (at least 2 occurrences or important pattern)
+                    if (matches.length >= 2 || ['typescript-types', 'jsdoc-comments'].includes(gp.name)) {
+                        successes.push({
+                            id: generateSuccessId('pattern'),
+                            type: 'pattern',
+                            pattern: gp.name,
+                            message: `${gp.message} (${matches.length}x)`,
+                            file: path.relative(projectRoot, filePath),
+                            count: matches.length,
+                            severity: 'SUCCESS',
+                            detectedAt: new Date().toISOString()
+                        });
+                    }
+                }
+            }
+        });
+    }
+
+    return successes;
+}
+
+/**
+ * Helper: Scan directory recursively
+ */
+function scanDirectory(dir, callback) {
+    const items = fs.readdirSync(dir);
+
+    for (const item of items) {
+        if (item.startsWith('.') || item === 'node_modules') continue;
+
+        const fullPath = path.join(dir, item);
+        const stat = fs.statSync(fullPath);
+
+        if (stat.isDirectory()) {
+            scanDirectory(fullPath, callback);
+        } else if (stat.isFile()) {
+            callback(fullPath);
+        }
+    }
+}
+
+// ==================== DEDUPLICATION ====================
+
+function deduplicateSuccesses(newSuccesses, existingSuccesses) {
+    const added = [];
+
+    for (const newS of newSuccesses) {
+        // Check if similar success exists
+        const exists = existingSuccesses.some(existing =>
+            existing.type === newS.type &&
+            existing.pattern === newS.pattern &&
+            existing.file === newS.file
+        );
+
+        if (!exists) {
+            added.push(newS);
+        } else {
+            // Update hit count for existing
+            const existing = existingSuccesses.find(e =>
+                e.type === newS.type && e.pattern === newS.pattern && e.file === newS.file
+            );
+            if (existing) {
+                existing.hitCount = (existing.hitCount || 1) + 1;
+                existing.lastHit = new Date().toISOString();
+            }
+        }
+    }
+
+    return added;
+}
+
+// ==================== MAIN ====================
+
+function runScan(type) {
+    console.log(`${c.green}🎯 Success Sensor - Scanning ${type}...${c.reset}\n`);
+
+    let newSuccesses = [];
+
+    if (type === 'all' || type === 'test') {
+        console.log(`  ${c.cyan}Scanning test results...${c.reset}`);
+        const testSuccesses = scanTestSuccesses();
+        console.log(`    Found ${testSuccesses.length} test successes`);
+        newSuccesses = newSuccesses.concat(testSuccesses);
+    }
+
+    if (type === 'all' || type === 'lint') {
+        console.log(`  ${c.cyan}Scanning lint results...${c.reset}`);
+        const lintSuccesses = scanLintSuccesses();
+        console.log(`    Found ${lintSuccesses.length} lint successes`);
+        newSuccesses = newSuccesses.concat(lintSuccesses);
+    }
+
+    if (type === 'all' || type === 'pattern') {
+        console.log(`  ${c.cyan}Scanning code patterns...${c.reset}`);
+        const patternSuccesses = scanCodePatternSuccesses();
+        console.log(`    Found ${patternSuccesses.length} pattern successes`);
+        newSuccesses = newSuccesses.concat(patternSuccesses);
+    }
+
+    // Load existing and merge
+    const data = loadSuccesses();
+    const added = deduplicateSuccesses(newSuccesses, data.successes);
+    data.successes = [...data.successes, ...added];
+    data.totalSuccesses = data.successes.length;
+
+    // Save
+    saveSuccesses(data);
+
+    console.log(`\n${c.green}════════════════════════════════════════${c.reset}`);
+    console.log(`${c.bold}Scan Complete${c.reset}`);
+    console.log(`  Total detected: ${newSuccesses.length}`);
+    console.log(`  New successes: ${added.length}`);
+    console.log(`${c.gray}Saved to: ${successesPath}${c.reset}`);
+    console.log(`${c.green}════════════════════════════════════════${c.reset}`);
+
+    return { detected: newSuccesses.length, added: added.length };
+}
+
+function showStats() {
+    const data = loadSuccesses();
+
+    console.log(`${c.cyan}╔════════════════════════════════════════╗${c.reset}`);
+    console.log(`${c.cyan}║${c.reset}  ${c.green}🎯 Success Sensor Statistics${c.reset}           ${c.cyan}║${c.reset}`);
+    console.log(`${c.cyan}╚════════════════════════════════════════╝${c.reset}\n`);
+
+    if (data.successes.length === 0) {
+        console.log(`${c.gray}No successes tracked yet.${c.reset}`);
+        console.log(`${c.gray}Run: node success_sensor.js --scan all${c.reset}`);
+        return;
+    }
+
+    // Group by type
+    const byType = {};
+    for (const s of data.successes) {
+        byType[s.type] = (byType[s.type] || 0) + 1;
+    }
+
+    // Group by pattern
+    const byPattern = {};
+    for (const s of data.successes) {
+        byPattern[s.pattern] = (byPattern[s.pattern] || 0) + 1;
+    }
+
+    console.log(`${c.bold}By Type:${c.reset}`);
+    for (const [type, count] of Object.entries(byType)) {
+        console.log(`  ${c.green}${type}${c.reset}: ${count}`);
+    }
+
+    console.log(`\n${c.bold}By Pattern:${c.reset}`);
+    for (const [pattern, count] of Object.entries(byPattern)) {
+        console.log(`  ${c.blue}${pattern}${c.reset}: ${count}`);
+    }
+
+    console.log(`\n${c.bold}Total successes tracked:${c.reset} ${c.green}${data.totalSuccesses}${c.reset}`);
+    if (data.lastScan) {
+        console.log(`${c.gray}Last scan: ${data.lastScan}${c.reset}`);
+    }
+}
+
+// Parse CLI args
+const args = process.argv.slice(2);
+
+if (args.includes('--scan') || args.includes('-s')) {
+    const idx = args.findIndex(a => a === '--scan' || a === '-s');
+    const type = args[idx + 1] || 'all';
+    runScan(type);
+} else if (args.includes('--stats') || args.includes('-t')) {
+    showStats();
+} else {
+    console.log(`${c.green}success_sensor - Detect successful patterns${c.reset}
+
+${c.bold}Usage:${c.reset}
+  node success_sensor.js --scan all       Scan all sources
+  node success_sensor.js --scan test      Scan test results only
+  node success_sensor.js --scan lint      Scan lint results only
+  node success_sensor.js --scan pattern   Scan code patterns only
+  node success_sensor.js --stats          Show statistics
+
+${c.bold}Success Types:${c.reset}
+  test      - Tests passing
+  lint      - Lint clean
+  pattern   - Good code patterns (async/await, types, etc.)
+
+${c.bold}Example:${c.reset}
+  node success_sensor.js --scan all
+  node success_sensor.js --stats
+`);
+}
+
+export { runScan, showStats, scanTestSuccesses, scanLintSuccesses, scanCodePatternSuccesses };