add-skill-kit 3.2.3 → 3.2.5

package/lib/agent-cli/lib/ui/stats-ui.js

@@ -0,0 +1,123 @@
+/**
+ * Stats UI - Knowledge base statistics display
+ */
+import { ICONS, getKnowledge, line, VERSION } from "./common.js";
+import { showIntro, showInfoNote, showSuccessNote, createSpinner, theme } from "./clack-helpers.js";
+import { signalQueue, getEvolutionStats } from "../evolution-signal.js";
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+
+// ============================================================================
+// STATS DISPLAY
+// ============================================================================
+
+/**
+ * Stats UI - Show knowledge base statistics with cognitive insights
+ */
+export async function runStatsUI() {
+    // Clear terminal và reset cursor về top-left
+    process.stdout.write('\x1Bc'); // Full terminal reset
+
+    showIntro("📊 Knowledge Base Stats");
+
+    const spinner = createSpinner("Loading statistics...");
+
+    try {
+        const db = getKnowledge();
+        const lessons = db.lessons || [];
+
+        // Calculate statistics with cognitive awareness
+        const totalLessons = lessons.length;
+        const mistakes = lessons.filter(l => l.type === 'mistake');
+        const improvements = lessons.filter(l => l.type === 'improvement');
+
+        // Cognitive grouping - Intent
+        const byIntent = lessons.reduce((acc, l) => {
+            const intent = l.intent || 'unknown';
+            acc[intent] = (acc[intent] || 0) + 1;
+            return acc;
+        }, {});
+
+        // Cognitive grouping - Pattern Type
+        const byPatternType = lessons.reduce((acc, l) => {
+            const type = l.patternType || 'general';
+            acc[type] = (acc[type] || 0) + 1;
+            return acc;
+        }, {});
+
+        // Cognitive grouping - Maturity
+        const byMaturity = lessons.reduce((acc, l) => {
+            const maturity = l.cognitive?.maturity || 'learning';
+            acc[maturity] = (acc[maturity] || 0) + 1;
+            return acc;
+        }, {});
+
+        // Top 5 by hit count
+        const topHits = lessons
+            .filter(p => p.hitCount && p.hitCount > 0)
+            .sort((a, b) => b.hitCount - a.hitCount)
+            .slice(0, 5);
+
+        spinner.stopSuccess("Stats loaded");
+
+        // Compact single-line display
+        console.log(`\n${pc.bold('📊 Knowledge Stats')} ${pc.dim(`(${totalLessons} lessons)`)}\n`);
+
+        console.log(
+            `${pc.red('●')} ${mistakes.length} Mistakes  ` +
+            `${pc.green('●')} ${improvements.length} Improvements  ` +
+            `${pc.dim('│')}  ` +
+            `${pc.red('🛡️')} ${byIntent.prevent || 0} Prevent  ` +
+            `${pc.yellow('⚠️')} ${byIntent.warn || 0} Warn  ` +
+            `${pc.green('⚡')} ${byIntent.optimize || 0} Optimize\n`
+        );
+
+        console.log(
+            `${pc.dim('Types:')} ` +
+            `${byPatternType.security ? `🔒${byPatternType.security} ` : ''}` +
+            `${byPatternType.dependency ? `📦${byPatternType.dependency} ` : ''}` +
+            `${byPatternType.structure ? `🏗️${byPatternType.structure} ` : ''}` +
+            `${byPatternType.quality ? `✨${byPatternType.quality} ` : ''}` +
+            `${byPatternType.performance ? `⚡${byPatternType.performance} ` : ''}` +
+            `${byPatternType.general ? pc.dim(`📝${byPatternType.general}`) : ''}\n`
+        );
+
+        console.log(
+            `${pc.dim('Maturity:')} ` +
+            `${pc.green('✓')} ${byMaturity.stable || 0} Stable  ` +
+            `${pc.cyan('📚')} ${byMaturity.learning || 0} Learning\n`
+        );
+
+        // Show top 3 hits in compact format
+        if (topHits.length > 0) {
+            console.log(`${pc.bold('🔥 Top Patterns')}`);
+            topHits.slice(0, 3).forEach((p, i) => {
+                console.log(`  ${i + 1}. ${pc.dim(p.id)} ${pc.bold(p.hitCount)}×`);
+            });
+            console.log('');
+        }
+
+        // Show signal queue summary
+        const signalStats = getEvolutionStats();
+        const pending = signalQueue.getPending();
+
+        console.log(`${pc.bold('📡 Signal Queue')}`);
+        console.log(
+            `  ${pc.yellow('⏳')} ${signalStats.pending} Pending  ` +
+            `${pc.green('✓')} ${signalStats.approved} Approved  ` +
+            `${pc.red('✗')} ${signalStats.rejected} Rejected\n`
+        );
+
+        // User can choose next action
+        await p.select({
+            message: "What's next?",
+            options: [
+                { value: "back", label: "← Back to Main Menu" }
+            ]
+        });
+
+    } catch (error) {
+        spinner.stopError("Failed to load stats");
+        console.error(error);
+    }
+}

package/lib/agent-cli/lib/ui/watch-ui.js

@@ -0,0 +1,236 @@
+/**
+ * Watch UI - Real-Time File Monitoring with Clack UI
+ * 
+ * Watches for file changes and runs recall automatically.
+ * Uses @clack/prompts for consistent terminal UI.
+ */
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import { dirname } from "path";
+import { scanFile, loadKnowledge, saveKnowledge } from "../recall.js";
+import { VERSION } from "../config.js";
+
+// ============================================================================
+// CONFIGURATION
+// ============================================================================
+
+const WATCH_EXTENSIONS = [".js", ".ts", ".tsx", ".jsx", ".mjs"];
+const DEBOUNCE_MS = 300;
+const SKIP_DIRS = ["node_modules", ".git", "dist", "build", ".next", "coverage"];
+
+// ============================================================================
+// WATCHER CLASS
+// ============================================================================
+
+class SmartWatcher {
+    constructor(rootDir) {
+        this.rootDir = path.resolve(rootDir);
+        this.db = loadKnowledge();
+        this.debounceTimers = new Map();
+        this.watchers = [];
+        this.isRunning = false;
+        this.sessionStats = {
+            filesChecked: 0,
+            violationsFound: 0,
+            startTime: Date.now()
+        };
+    }
+
+    /**
+     * Start watching
+     */
+    start() {
+        this.isRunning = true;
+        this.watch(this.rootDir);
+    }
+
+    /**
+     * Stop watching
+     */
+    stop() {
+        this.isRunning = false;
+        // Close all watchers
+        this.watchers.forEach(w => {
+            try { w.close(); } catch (e) { }
+        });
+        this.watchers = [];
+        // Clear debounce timers
+        this.debounceTimers.forEach(timer => clearTimeout(timer));
+        this.debounceTimers.clear();
+    }
+
+    /**
+     * Recursively watch directories
+     */
+    watch(dir) {
+        try {
+            const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+            // Watch current directory
+            const watcher = fs.watch(dir, { persistent: true }, (eventType, filename) => {
+                if (filename && eventType === "change" && this.isRunning) {
+                    this.handleChange(path.join(dir, filename));
+                }
+            });
+            this.watchers.push(watcher);
+
+            // Recurse into subdirs
+            for (const entry of entries) {
+                if (entry.isDirectory() && !SKIP_DIRS.includes(entry.name)) {
+                    this.watch(path.join(dir, entry.name));
+                }
+            }
+        } catch (error) {
+            // Ignore permission errors
+        }
+    }
+
+    /**
+     * Handle file change with debouncing
+     */
+    handleChange(filePath) {
+        const ext = path.extname(filePath);
+        if (!WATCH_EXTENSIONS.includes(ext)) return;
+        if (!fs.existsSync(filePath)) return;
+
+        // Debounce
+        if (this.debounceTimers.has(filePath)) {
+            clearTimeout(this.debounceTimers.get(filePath));
+        }
+
+        this.debounceTimers.set(filePath, setTimeout(() => {
+            const result = this.checkFile(filePath);
+            this.debounceTimers.delete(filePath);
+
+            // Emit event for UI
+            if (this.onFileChange) {
+                this.onFileChange(result);
+            }
+        }, DEBOUNCE_MS));
+    }
+
+    /**
+     * Check a file against memory
+     */
+    checkFile(filePath) {
+        const relativePath = path.relative(this.rootDir, filePath);
+        const result = scanFile(filePath, this.db, true);
+
+        this.sessionStats.filesChecked++;
+
+        if (result.violations.length > 0) {
+            this.sessionStats.violationsFound += result.violations.reduce((sum, v) => sum + v.matches.length, 0);
+            saveKnowledge(this.db);
+        }
+
+        return {
+            path: relativePath,
+            violations: result.violations,
+            hasViolations: result.violations.length > 0
+        };
+    }
+
+    /**
+     * Get session summary
+     */
+    getSummary() {
+        const duration = Math.round((Date.now() - this.sessionStats.startTime) / 1000);
+        return {
+            duration,
+            filesChecked: this.sessionStats.filesChecked,
+            violationsFound: this.sessionStats.violationsFound
+        };
+    }
+}
+
+// ============================================================================
+// WATCH UI
+// ============================================================================
+
+/**
+ * Run Watch UI with Clack
+ * @param {string} targetDir - Directory to watch
+ */
+export async function runWatchUI(targetDir = process.cwd()) {
+    const watcher = new SmartWatcher(targetDir);
+
+    // Show intro
+    p.intro(pc.cyan(`Smart Watcher v${VERSION}`));
+
+    // Show info
+    p.note(
+        `${pc.dim("Directory:")} ${watcher.rootDir}\n` +
+        `${pc.dim("Patterns:")}  ${watcher.db.lessons.length} loaded\n` +
+        `${pc.dim("Extensions:")} ${WATCH_EXTENSIONS.join(", ")}`,
+        "Watch Configuration"
+    );
+
+    // Spinner for starting
+    const s = p.spinner();
+    s.start("Starting file watcher...");
+
+    // Start watcher
+    watcher.start();
+
+    s.stop(pc.green("✓") + " Watching for changes");
+
+    // Setup file change handler
+    watcher.onFileChange = (result) => {
+        if (result.hasViolations) {
+            console.log("");
+            p.log.warn(pc.yellow(result.path));
+            result.violations.forEach(({ lesson, matches }) => {
+                const icon = lesson.severity === "ERROR" ? pc.red("✖") : pc.yellow("⚠");
+                console.log(`  ${icon} ${pc.dim(`[${lesson.id}]`)} ${lesson.message}`);
+                matches.slice(0, 2).forEach(m => {
+                    console.log(`    ${pc.dim(`L${m.line}:`)} ${pc.dim(m.content.substring(0, 60))}`);
+                });
+                if (matches.length > 2) {
+                    console.log(`    ${pc.dim(`... +${matches.length - 2} more`)}`);
+                }
+            });
+        } else {
+            p.log.success(pc.green("✓ ") + pc.dim(result.path));
+        }
+    };
+
+    // Wait for user to press Enter or Ctrl+C
+    console.log("");
+    console.log(pc.dim("  Watching for file changes..."));
+    console.log(pc.dim("  Press Enter to stop\n"));
+
+    // Wait for Enter key
+    await new Promise((resolve) => {
+        const handler = (data) => {
+            if (data.toString().includes("\n") || data.toString().includes("\r")) {
+                process.stdin.removeListener("data", handler);
+                process.stdin.setRawMode?.(false);
+                resolve();
+            }
+        };
+
+        process.stdin.setRawMode?.(true);
+        process.stdin.resume();
+        process.stdin.on("data", handler);
+    });
+
+    // Stop watcher
+    watcher.stop();
+
+    // Show summary
+    const summary = watcher.getSummary();
+
+    p.note(
+        `${pc.dim("Duration:")}   ${summary.duration}s\n` +
+        `${pc.dim("Files:")}      ${summary.filesChecked} checked\n` +
+        `${pc.dim("Violations:")} ${summary.violationsFound} found`,
+        "Session Summary"
+    );
+
+    p.outro(pc.green("Watch session ended"));
+}
+
+export default runWatchUI;

package/lib/agent-cli/lib/verify_all.py

@@ -0,0 +1,327 @@
+#!/usr/bin/env python3
+"""
+Full Verification Suite - Agent Skill Kit
+==========================================
+
+Runs COMPLETE validation including all checks + performance + E2E.
+Use this before deployment or major releases.
+
+Usage:
+    python scripts/verify_all.py . --url <URL>
+
+Includes ALL checks:
+    ✅ Security Scan (OWASP, secrets, dependencies)
+    ✅ Lint & Type Coverage
+    ✅ Schema Validation
+    ✅ Test Suite (unit + integration)
+    ✅ UX Audit (psychology, accessibility)
+    ✅ SEO Check
+    ✅ Lighthouse (Core Web Vitals)
+    ✅ Playwright E2E
+    ✅ Bundle Analysis (if applicable)
+    ✅ Mobile Audit (if applicable)
+"""
+
+import sys
+import subprocess
+import argparse
+from pathlib import Path
+from typing import List, Dict, Optional
+from datetime import datetime
+
+# ANSI colors
+class Colors:
+    HEADER = '\033[95m'
+    BLUE = '\033[94m'
+    CYAN = '\033[96m'
+    GREEN = '\033[92m'
+    YELLOW = '\033[93m'
+    RED = '\033[91m'
+    ENDC = '\033[0m'
+    BOLD = '\033[1m'
+
+def print_header(text: str):
+    print(f"\n{Colors.BOLD}{Colors.CYAN}{'='*70}{Colors.ENDC}")
+    print(f"{Colors.BOLD}{Colors.CYAN}{text.center(70)}{Colors.ENDC}")
+    print(f"{Colors.BOLD}{Colors.CYAN}{'='*70}{Colors.ENDC}\n")
+
+def print_step(text: str):
+    print(f"{Colors.BOLD}{Colors.BLUE}🔄 {text}{Colors.ENDC}")
+
+def print_success(text: str):
+    print(f"{Colors.GREEN}✅ {text}{Colors.ENDC}")
+
+def print_warning(text: str):
+    print(f"{Colors.YELLOW}⚠️  {text}{Colors.ENDC}")
+
+def print_error(text: str):
+    print(f"{Colors.RED}❌ {text}{Colors.ENDC}")
+
+# Complete verification suite
+VERIFICATION_SUITE = [
+    # P0: Security (CRITICAL)
+    {
+        "category": "Security",
+        "checks": [
+            ("Security Scan", ".agent/skills/vulnerability-scanner/scripts/security_scan.py", True),
+            ("Dependency Analysis", ".agent/skills/vulnerability-scanner/scripts/dependency_analyzer.py", False),
+        ]
+    },
+    
+    # P1: Code Quality (CRITICAL)
+    {
+        "category": "Code Quality",
+        "checks": [
+            ("Lint Check", ".agent/skills/lint-and-validate/scripts/lint_runner.py", True),
+            ("Type Coverage", ".agent/skills/lint-and-validate/scripts/type_coverage.py", False),
+        ]
+    },
+    
+    # P2: Data Layer
+    {
+        "category": "Data Layer",
+        "checks": [
+            ("Schema Validation", ".agent/skills/database-design/scripts/schema_validator.py", False),
+        ]
+    },
+    
+    # P3: Testing
+    {
+        "category": "Testing",
+        "checks": [
+            ("Test Suite", ".agent/skills/testing-patterns/scripts/test_runner.py", False),
+        ]
+    },
+    
+    # P4: UX & Accessibility
+    {
+        "category": "UX & Accessibility",
+        "checks": [
+            ("UX Audit", ".agent/skills/frontend-design/scripts/ux_audit.py", False),
+            ("Accessibility Check", ".agent/skills/frontend-design/scripts/accessibility_checker.py", False),
+        ]
+    },
+    
+    # P5: SEO & Content
+    {
+        "category": "SEO & Content",
+        "checks": [
+            ("SEO Check", ".agent/skills/seo-fundamentals/scripts/seo_checker.py", False),
+            ("GEO Check", ".agent/skills/geo-fundamentals/scripts/geo_checker.py", False),
+        ]
+    },
+    
+    # P6: Performance (requires URL)
+    {
+        "category": "Performance",
+        "requires_url": True,
+        "checks": [
+            ("Lighthouse Audit", ".agent/skills/performance-profiling/scripts/lighthouse_audit.py", True),
+            ("Bundle Analysis", ".agent/skills/performance-profiling/scripts/bundle_analyzer.py", False),
+        ]
+    },
+    
+    # P7: E2E Testing (requires URL)
+    {
+        "category": "E2E Testing",
+        "requires_url": True,
+        "checks": [
+            ("Playwright E2E", ".agent/skills/webapp-testing/scripts/playwright_runner.py", False),
+        ]
+    },
+    
+    # P8: Mobile (if applicable)
+    {
+        "category": "Mobile",
+        "checks": [
+            ("Mobile Audit", ".agent/skills/mobile-design/scripts/mobile_audit.py", False),
+        ]
+    },
+    
+    # P9: Internationalization
+    {
+        "category": "Internationalization",
+        "checks": [
+            ("i18n Check", ".agent/skills/i18n-localization/scripts/i18n_checker.py", False),
+        ]
+    },
+]
+
+def run_script(name: str, script_path: Path, project_path: str, url: Optional[str] = None) -> dict:
+    """Run validation script"""
+    if not script_path.exists():
+        print_warning(f"{name}: Script not found, skipping")
+        return {"name": name, "passed": True, "skipped": True, "duration": 0}
+    
+    print_step(f"Running: {name}")
+    start_time = datetime.now()
+    
+    # Build command
+    cmd = ["python", str(script_path), project_path]
+    if url and ("lighthouse" in script_path.name.lower() or "playwright" in script_path.name.lower()):
+        cmd.append(url)
+    
+    # Run
+    try:
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            timeout=600  # 10 minute timeout for slow checks
+        )
+        
+        duration = (datetime.now() - start_time).total_seconds()
+        passed = result.returncode == 0
+        
+        if passed:
+            print_success(f"{name}: PASSED ({duration:.1f}s)")
+        else:
+            print_error(f"{name}: FAILED ({duration:.1f}s)")
+            if result.stderr:
+                print(f"  {result.stderr[:300]}")
+        
+        return {
+            "name": name,
+            "passed": passed,
+            "output": result.stdout,
+            "error": result.stderr,
+            "skipped": False,
+            "duration": duration
+        }
+    
+    except subprocess.TimeoutExpired:
+        duration = (datetime.now() - start_time).total_seconds()
+        print_error(f"{name}: TIMEOUT (>{duration:.0f}s)")
+        return {"name": name, "passed": False, "skipped": False, "duration": duration, "error": "Timeout"}
+    
+    except Exception as e:
+        duration = (datetime.now() - start_time).total_seconds()
+        print_error(f"{name}: ERROR - {str(e)}")
+        return {"name": name, "passed": False, "skipped": False, "duration": duration, "error": str(e)}
+
+def print_final_report(results: List[dict], start_time: datetime):
+    """Print comprehensive final report"""
+    total_duration = (datetime.now() - start_time).total_seconds()
+    
+    print_header("📊 FULL VERIFICATION REPORT")
+    
+    # Statistics
+    total = len(results)
+    passed = sum(1 for r in results if r["passed"] and not r.get("skipped"))
+    failed = sum(1 for r in results if not r["passed"] and not r.get("skipped"))
+    skipped = sum(1 for r in results if r.get("skipped"))
+    
+    print(f"Total Duration: {total_duration:.1f}s")
+    print(f"Total Checks: {total}")
+    print(f"{Colors.GREEN}✅ Passed: {passed}{Colors.ENDC}")
+    print(f"{Colors.RED}❌ Failed: {failed}{Colors.ENDC}")
+    print(f"{Colors.YELLOW}⏭️  Skipped: {skipped}{Colors.ENDC}")
+    print()
+    
+    # Category breakdown
+    print(f"{Colors.BOLD}Results by Category:{Colors.ENDC}")
+    current_category = None
+    for r in results:
+        # Print category header if changed
+        if r.get("category") and r["category"] != current_category:
+            current_category = r["category"]
+            print(f"\n{Colors.BOLD}{Colors.CYAN}{current_category}:{Colors.ENDC}")
+        
+        # Print result
+        if r.get("skipped"):
+            status = f"{Colors.YELLOW}⏭️ {Colors.ENDC}"
+        elif r["passed"]:
+            status = f"{Colors.GREEN}✅{Colors.ENDC}"
+        else:
+            status = f"{Colors.RED}❌{Colors.ENDC}"
+        
+        duration_str = f"({r.get('duration', 0):.1f}s)" if not r.get("skipped") else ""
+        print(f"  {status} {r['name']} {duration_str}")
+    
+    print()
+    
+    # Failed checks detail
+    if failed > 0:
+        print(f"{Colors.BOLD}{Colors.RED}❌ FAILED CHECKS:{Colors.ENDC}")
+        for r in results:
+            if not r["passed"] and not r.get("skipped"):
+                print(f"\n{Colors.RED}✗ {r['name']}{Colors.ENDC}")
+                if r.get("error"):
+                    error_preview = r["error"][:200]
+                    print(f"  Error: {error_preview}")
+        print()
+    
+    # Final verdict
+    if failed > 0:
+        print_error(f"VERIFICATION FAILED - {failed} check(s) need attention")
+        print(f"\n{Colors.YELLOW}💡 Tip: Fix critical (security, lint) issues first{Colors.ENDC}")
+        return False
+    else:
+        print_success("✨ ALL CHECKS PASSED - Ready for deployment! ✨")
+        return True
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Run complete Agent Skill Kit verification suite",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  python scripts/verify_all.py . --url http://localhost:3000
+  python scripts/verify_all.py . --url https://staging.example.com --no-e2e
+        """
+    )
+    parser.add_argument("project", help="Project path to validate")
+    parser.add_argument("--url", required=True, help="URL for performance & E2E checks")
+    parser.add_argument("--no-e2e", action="store_true", help="Skip E2E tests")
+    parser.add_argument("--stop-on-fail", action="store_true", help="Stop on first failure")
+    
+    args = parser.parse_args()
+    
+    project_path = Path(args.project).resolve()
+    
+    if not project_path.exists():
+        print_error(f"Project path does not exist: {project_path}")
+        sys.exit(1)
+    
+    print_header("🚀 AGENT SKILLS KIT - FULL VERIFICATION SUITE")
+    print(f"Project: {project_path}")
+    print(f"URL: {args.url}")
+    print(f"Started: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+    
+    start_time = datetime.now()
+    results = []
+    
+    # Run all verification categories
+    for suite in VERIFICATION_SUITE:
+        category = suite["category"]
+        requires_url = suite.get("requires_url", False)
+        
+        # Skip if requires URL and not provided
+        if requires_url and not args.url:
+            continue
+        
+        # Skip E2E if flag set
+        if args.no_e2e and category == "E2E Testing":
+            continue
+        
+        print_header(f"📋 {category.upper()}")
+        
+        for name, script_path, required in suite["checks"]:
+            script = project_path / script_path
+            result = run_script(name, script, str(project_path), args.url)
+            result["category"] = category
+            results.append(result)
+            
+            # Stop on critical failure if flag set
+            if args.stop_on_fail and required and not result["passed"] and not result.get("skipped"):
+                print_error(f"CRITICAL: {name} failed. Stopping verification.")
+                print_final_report(results, start_time)
+                sys.exit(1)
+    
+    # Print final report
+    all_passed = print_final_report(results, start_time)
+    
+    sys.exit(0 if all_passed else 1)
+
+if __name__ == "__main__":
+    main()