pikakit 1.0.8 → 1.0.10

package/lib/agent-cli/dashboard/dashboard_server.js

@@ -1,340 +0,0 @@
-#!/usr/bin/env node
-/**
- * Dashboard Server - Local web server for Auto-Learn Dashboard
- * 
- * Bundled with PikaKit CLI
- * 
- * Serves:
- * - Static dashboard HTML
- * - API endpoints for data
- * 
- * Usage:
- *   node dashboard_server.js --port 3030
- */
-
-import fs from 'fs';
-import path from 'path';
-import http from 'http';
-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',
-    cyan: '\x1b[36m',
-    gray: '\x1b[90m',
-    bold: '\x1b[1m'
-};
-
-// Find project root (where .agent folder exists)
-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();
-}
-
-// Find knowledge path - check multiple locations
-function findKnowledgePath() {
-    const projectRoot = findProjectRoot();
-    const possiblePaths = [
-        path.join(projectRoot, '.agent', 'knowledge'),
-        path.join(projectRoot, '.agent', 'agentskillskit', '.agent', 'knowledge'),
-    ];
-
-    for (const p of possiblePaths) {
-        if (fs.existsSync(p)) {
-            return p;
-        }
-    }
-
-    // Create default if none exists
-    const defaultPath = path.join(projectRoot, '.agent', 'knowledge');
-    fs.mkdirSync(defaultPath, { recursive: true });
-    return defaultPath;
-}
-
-const knowledgePath = findKnowledgePath();
-// Dashboard is in same directory as this server
-const dashboardPath = __dirname;
-
-// Load JSON files
-function loadJson(filename) {
-    const filePath = path.join(knowledgePath, filename);
-    try {
-        if (fs.existsSync(filePath)) {
-            return JSON.parse(fs.readFileSync(filePath, 'utf8'));
-        }
-    } catch { }
-    return null;
-}
-
-// API handlers
-const api = {
-    '/api/errors': () => {
-        const data = loadJson('detected-errors.json');
-        return data || { errors: [], totalErrors: 0 };
-    },
-
-    '/api/corrections': () => {
-        const data = loadJson('user-corrections.json');
-        return data || { corrections: [], totalCorrections: 0 };
-    },
-
-    '/api/lessons': () => {
-        const data = loadJson('lessons-learned.json');
-        return data || { lessons: [] };
-    },
-
-    '/api/patterns': () => {
-        const data = loadJson('patterns.json');
-        return data || { errors: {}, corrections: {}, highFrequency: [] };
-    },
-
-    '/api/successes': () => {
-        const data = loadJson('successes.json');
-        return data || { successes: [], totalSuccesses: 0 };
-    },
-
-    '/api/summary': () => {
-        const errors = loadJson('detected-errors.json');
-        const corrections = loadJson('user-corrections.json');
-        const lessons = loadJson('lessons-learned.json');
-        const patterns = loadJson('patterns.json');
-        const successes = loadJson('successes.json');
-
-        // Calculate success/failure ratio
-        const totalErrors = errors?.errors?.length || 0;
-        const totalCorrections = corrections?.corrections?.length || 0;
-        const totalSuccesses = successes?.successes?.length || 0;
-        const totalFailures = totalErrors + totalCorrections;
-        const total = totalFailures + totalSuccesses;
-
-        let ratio = 0;
-        let status = 'NO_DATA';
-        if (total > 0) {
-            ratio = Math.round((totalSuccesses / total) * 100) / 100;
-            if (ratio > 0.7) status = 'EXCELLENT';
-            else if (ratio > 0.5) status = 'GOOD';
-            else if (ratio > 0.3) status = 'LEARNING';
-            else status = 'NEEDS_ATTENTION';
-        }
-
-        // Group successes by pattern
-        const successesByPattern = {};
-        for (const s of (successes?.successes || [])) {
-            successesByPattern[s.pattern] = (successesByPattern[s.pattern] || 0) + 1;
-        }
-
-        return {
-            errors: {
-                total: totalErrors,
-                byType: patterns?.errors?.byType || {},
-                bySeverity: patterns?.errors?.bySeverity || {}
-            },
-            corrections: {
-                total: totalCorrections,
-                byCategory: patterns?.corrections?.byCategory || {}
-            },
-            successes: {
-                total: totalSuccesses,
-                byPattern: successesByPattern
-            },
-            balance: {
-                ratio,
-                status,
-                failures: totalFailures,
-                successes: totalSuccesses
-            },
-            lessons: lessons?.lessons?.length || 0,
-            highFrequency: patterns?.highFrequency || [],
-            lastUpdated: patterns?.analyzedAt || null,
-            knowledgePath: knowledgePath
-        };
-    },
-
-    '/api/trends': () => {
-        const errors = loadJson('detected-errors.json');
-        const successes = loadJson('successes.json');
-
-        const errorList = errors?.errors || [];
-        const successList = successes?.successes || [];
-
-        // Calculate trends
-        const now = new Date();
-        const oneWeekAgo = new Date(now - 7 * 24 * 60 * 60 * 1000);
-        const twoWeeksAgo = new Date(now - 14 * 24 * 60 * 60 * 1000);
-
-        const thisWeekErrors = errorList.filter(e => new Date(e.timestamp) > oneWeekAgo).length;
-        const lastWeekErrors = errorList.filter(e => {
-            const d = new Date(e.timestamp);
-            return d > twoWeeksAgo && d <= oneWeekAgo;
-        }).length;
-
-        const thisWeekSuccesses = successList.filter(s => {
-            const d = new Date(s.detectedAt || s.timestamp);
-            return d > oneWeekAgo;
-        }).length;
-
-        // Daily breakdown (last 7 days)
-        const daily = [];
-        for (let i = 6; i >= 0; i--) {
-            const date = new Date(now - i * 24 * 60 * 60 * 1000);
-            const dateStr = date.toISOString().split('T')[0];
-
-            const dayErrors = errorList.filter(e =>
-                e.timestamp && e.timestamp.startsWith(dateStr)
-            ).length;
-
-            const daySuccesses = successList.filter(s =>
-                (s.detectedAt || s.timestamp || '').startsWith(dateStr)
-            ).length;
-
-            daily.push({ date: dateStr, errors: dayErrors, successes: daySuccesses });
-        }
-
-        const errorTrend = lastWeekErrors > 0
-            ? Math.round(((thisWeekErrors - lastWeekErrors) / lastWeekErrors) * 100)
-            : 0;
-
-        let healthStatus = 'STABLE';
-        if (errorTrend < 0) healthStatus = 'IMPROVING';
-        else if (errorTrend > 20) healthStatus = 'DECLINING';
-
-        return {
-            thisWeek: { errors: thisWeekErrors, successes: thisWeekSuccesses },
-            lastWeek: { errors: lastWeekErrors },
-            trends: { errorChange: errorTrend },
-            healthStatus,
-            daily
-        };
-    }
-};
-
-// MIME types
-const mimeTypes = {
-    '.html': 'text/html',
-    '.css': 'text/css',
-    '.js': 'application/javascript',
-    '.json': 'application/json',
-    '.png': 'image/png',
-    '.jpg': 'image/jpeg',
-    '.svg': 'image/svg+xml'
-};
-
-// Create server
-function createServer(port) {
-    const server = http.createServer((req, res) => {
-        const url = req.url.split('?')[0];
-
-        // CORS headers for local development
-        res.setHeader('Access-Control-Allow-Origin', '*');
-        res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
-        res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
-
-        // Handle API requests
-        if (url.startsWith('/api/')) {
-            const handler = api[url];
-            if (handler) {
-                res.setHeader('Content-Type', 'application/json');
-                res.writeHead(200);
-                res.end(JSON.stringify(handler()));
-            } else {
-                res.writeHead(404);
-                res.end(JSON.stringify({ error: 'Not found' }));
-            }
-            return;
-        }
-
-        // Serve static files
-        let filePath = url === '/' ? '/index.html' : url;
-        filePath = path.join(dashboardPath, filePath);
-
-        if (fs.existsSync(filePath)) {
-            const ext = path.extname(filePath);
-            const mimeType = mimeTypes[ext] || 'text/plain';
-
-            res.setHeader('Content-Type', mimeType);
-            res.writeHead(200);
-            res.end(fs.readFileSync(filePath));
-        } else {
-            res.writeHead(404);
-            res.end('Not found');
-        }
-    });
-
-    return server;
-}
-
-function startServer(port = 3030) {
-    const server = createServer(port);
-
-    server.listen(port, () => {
-        console.log(`${c.cyan}╔════════════════════════════════════════╗${c.reset}`);
-        console.log(`${c.cyan}║${c.reset}  🧠 Auto-Learn Dashboard Server         ${c.cyan}║${c.reset}`);
-        console.log(`${c.cyan}╚════════════════════════════════════════╝${c.reset}\n`);
-        console.log(`${c.green}✓ Server running at:${c.reset}`);
-        console.log(`  ${c.bold}http://localhost:${port}${c.reset}\n`);
-        console.log(`${c.gray}API Endpoints:${c.reset}`);
-        console.log(`  GET /api/errors       - Detected errors`);
-        console.log(`  GET /api/corrections  - User corrections`);
-        console.log(`  GET /api/lessons      - Lessons learned`);
-        console.log(`  GET /api/patterns     - Pattern analysis`);
-        console.log(`  GET /api/summary      - Dashboard summary\n`);
-        console.log(`${c.yellow}Press Ctrl+C to stop${c.reset}`);
-    });
-
-    server.on('error', (err) => {
-        if (err.code === 'EADDRINUSE') {
-            console.log(`${c.red}Error: Port ${port} is already in use${c.reset}`);
-            console.log(`${c.gray}Try: node dashboard_server.js --port ${port + 1}${c.reset}`);
-        } else {
-            console.error(`${c.red}Server error:${c.reset}`, err);
-        }
-        process.exit(1);
-    });
-
-    return server;
-}
-
-// Parse CLI args
-const args = process.argv.slice(2);
-
-if (args.includes('--start') || args.includes('-s') || args.length === 0 || args.includes('--port') || args.includes('-p')) {
-    let port = 3030;
-    const portIdx = args.findIndex(a => a === '--port' || a === '-p');
-    if (portIdx >= 0 && args[portIdx + 1]) {
-        port = parseInt(args[portIdx + 1], 10);
-    }
-    startServer(port);
-} else if (args.includes('--help') || args.includes('-h')) {
-    console.log(`${c.cyan}dashboard_server - Auto-Learn Dashboard Web Server${c.reset}
-
-${c.bold}Usage:${c.reset}
-  node dashboard_server.js                  Start server (default port 3030)
-  node dashboard_server.js --port 8080      Start on custom port
-  node dashboard_server.js --help           Show this help
-
-${c.bold}API Endpoints:${c.reset}
-  GET /api/errors       - All detected errors
-  GET /api/corrections  - All user corrections
-  GET /api/lessons      - All lessons learned
-  GET /api/patterns     - Pattern analysis results
-  GET /api/summary      - Dashboard summary data
-
-${c.bold}Example:${c.reset}
-  node dashboard_server.js --port 3030
-  # Open http://localhost:3030 in browser
-`);
-}
-
-export { createServer, startServer };

package/lib/agent-cli/lib/auto-learn.js

@@ -1,319 +0,0 @@
-#!/usr/bin/env node
-/**
- * Smart Auto-Learn - True Self-Learning Engine
- * 
- * Automatically learns from:
- * 1. ESLint output (runs ESLint and parses)
- * 2. Test failures (runs tests and parses)
- * 3. TypeScript errors (runs tsc and parses)
- * 
- * Usage:
- *   agent auto-learn              # Run all
- *   agent auto-learn --eslint     # ESLint only
- *   agent auto-learn --test       # Test failures only
- *   agent auto-learn --typescript # TypeScript only
- */
-
-import fs from "fs";
-import path from "path";
-import { execSync, spawnSync } from "child_process";
-import { loadKnowledge, saveKnowledge } from "./recall.js";
-import { VERSION } from "./config.js";
-
-// ============================================================================
-// ESLINT AUTO-LEARN
-// ============================================================================
-
-const ESLINT_PATTERN_MAP = {
-    "no-console": { pattern: "console\\.(log|warn|error|info|debug)", message: "Avoid console statements in production" },
-    "no-debugger": { pattern: "\\bdebugger\\b", message: "Remove debugger statements" },
-    "no-var": { pattern: "\\bvar\\s+\\w", message: "Use const/let instead of var" },
-    "eqeqeq": { pattern: "[^!=]==[^=]", message: "Use === instead of ==" },
-    "no-eval": { pattern: "\\beval\\s*\\(", message: "Avoid eval() for security" },
-    "no-alert": { pattern: "\\balert\\s*\\(", message: "Avoid alert() in production" },
-    "no-implicit-globals": { pattern: "^(?!const|let|var|function|class|import|export)", message: "Avoid implicit globals" },
-    "prefer-const": { pattern: "\\blet\\s+\\w+\\s*=\\s*[^;]+;(?![\\s\\S]*\\1\\s*=)", message: "Use const for variables that are never reassigned" },
-    "no-unused-expressions": { pattern: "^\\s*['\"`]use strict['\"`];?\\s*$", message: "Remove unused expressions" },
-    "semi": { pattern: "[^;{}]\\s*$", message: "Missing semicolon" },
-    "quotes": { pattern: '(?<![\\w])"(?![^"]*"[,\\]\\}\\)])', message: "Prefer single quotes" },
-    "no-empty": { pattern: "\\{\\s*\\}", message: "Empty block statement" },
-    "no-extra-semi": { pattern: ";;", message: "Unnecessary semicolon" },
-    "no-unreachable": { pattern: "(?:return|throw|break|continue)[^}]*[\\n\\r]+[^}]+", message: "Unreachable code" }
-};
-
-function runEslintAutoLearn(projectRoot) {
-    console.log("\n🔍 Running ESLint analysis...\n");
-
-    try {
-        // Try to run ESLint with JSON output
-        const result = spawnSync("npx", ["eslint", ".", "--format", "json", "--no-error-on-unmatched-pattern"], {
-            cwd: projectRoot,
-            encoding: "utf8",
-            shell: true,
-            timeout: 60000
-        });
-
-        if (!result.stdout) {
-            console.log("   ℹ️  ESLint not configured or no files to lint.");
-            return [];
-        }
-
-        const eslintResults = JSON.parse(result.stdout);
-        const ruleViolations = {};
-
-        eslintResults.forEach(file => {
-            if (!file.messages) return;
-            file.messages.forEach(msg => {
-                if (!msg.ruleId) return;
-                if (!ruleViolations[msg.ruleId]) {
-                    ruleViolations[msg.ruleId] = {
-                        rule: msg.ruleId,
-                        count: 0,
-                        severity: msg.severity === 2 ? "ERROR" : "WARNING",
-                        sample: msg.message
-                    };
-                }
-                ruleViolations[msg.ruleId].count++;
-            });
-        });
-
-        return Object.values(ruleViolations).sort((a, b) => b.count - a.count);
-    } catch (e) {
-        console.log("   ⚠️  ESLint analysis skipped:", e.message);
-        return [];
-    }
-}
-
-// ============================================================================
-// TEST FAILURE AUTO-LEARN
-// ============================================================================
-
-const TEST_PATTERN_MAP = {
-    "undefined is not a function": { pattern: "\\w+\\s*\\(", message: "Function may be undefined before call" },
-    "cannot read property": { pattern: "\\w+\\.\\w+", message: "Object property access may fail if undefined" },
-    "null is not an object": { pattern: "\\.\\w+", message: "Null check needed before property access" },
-    "expected.*to equal": { pattern: "expect\\s*\\(", message: "Assertion expectation mismatch" },
-    "timeout": { pattern: "async|await|Promise", message: "Async operation may need longer timeout" },
-    "not defined": { pattern: "\\b\\w+\\b", message: "Variable may not be defined in scope" }
-};
-
-function runTestAutoLearn(projectRoot) {
-    console.log("\n🧪 Running test analysis...\n");
-
-    try {
-        // Try common test runners
-        const testCommands = [
-            { cmd: "npm", args: ["test", "--", "--json", "--passWithNoTests"], name: "npm test" },
-            { cmd: "npx", args: ["vitest", "run", "--reporter=json"], name: "vitest" },
-            { cmd: "npx", args: ["jest", "--json", "--passWithNoTests"], name: "jest" }
-        ];
-
-        for (const tc of testCommands) {
-            const result = spawnSync(tc.cmd, tc.args, {
-                cwd: projectRoot,
-                encoding: "utf8",
-                shell: true,
-                timeout: 120000
-            });
-
-            // Look for test failures in output
-            const output = result.stdout + result.stderr;
-            const failures = [];
-
-            // Parse failure messages
-            const failurePatterns = [
-                /FAIL\s+(.+)/g,
-                /✕\s+(.+)/g,
-                /Error:\s+(.+)/g,
-                /AssertionError:\s+(.+)/g
-            ];
-
-            failurePatterns.forEach(regex => {
-                let match;
-                while ((match = regex.exec(output)) !== null) {
-                    failures.push(match[1].trim());
-                }
-            });
-
-            if (failures.length > 0) {
-                console.log(`   Found ${failures.length} test failure(s) from ${tc.name}`);
-                return failures.map(f => ({ message: f, source: tc.name }));
-            }
-        }
-
-        console.log("   ✅ All tests passing or no tests found.");
-        return [];
-    } catch (e) {
-        console.log("   ⚠️  Test analysis skipped:", e.message);
-        return [];
-    }
-}
-
-// ============================================================================
-// TYPESCRIPT ERROR AUTO-LEARN
-// ============================================================================
-
-const TS_PATTERN_MAP = {
-    "TS2304": { pattern: "\\b\\w+\\b", message: "TypeScript: Cannot find name" },
-    "TS2322": { pattern: ":\\s*\\w+", message: "TypeScript: Type mismatch" },
-    "TS2345": { pattern: "\\(.*\\)", message: "TypeScript: Argument type mismatch" },
-    "TS2339": { pattern: "\\.\\w+", message: "TypeScript: Property does not exist" },
-    "TS7006": { pattern: "\\(\\w+\\)", message: "TypeScript: Parameter implicitly has 'any' type" },
-    "TS2531": { pattern: "\\w+\\.", message: "TypeScript: Object is possibly 'null'" },
-    "TS2532": { pattern: "\\w+\\.", message: "TypeScript: Object is possibly 'undefined'" }
-};
-
-function runTypescriptAutoLearn(projectRoot) {
-    console.log("\n📘 Running TypeScript analysis...\n");
-
-    try {
-        const result = spawnSync("npx", ["tsc", "--noEmit", "--pretty", "false"], {
-            cwd: projectRoot,
-            encoding: "utf8",
-            shell: true,
-            timeout: 60000
-        });
-
-        const output = result.stdout + result.stderr;
-        const errors = {};
-
-        // Parse TS errors: file(line,col): error TS1234: message
-        const tsErrorRegex = /error (TS\d+):\s*(.+)/g;
-        let match;
-
-        while ((match = tsErrorRegex.exec(output)) !== null) {
-            const code = match[1];
-            const message = match[2];
-
-            if (!errors[code]) {
-                errors[code] = { code, message, count: 0 };
-            }
-            errors[code].count++;
-        }
-
-        const errorList = Object.values(errors).sort((a, b) => b.count - a.count);
-
-        if (errorList.length > 0) {
-            console.log(`   Found ${errorList.length} unique TypeScript error type(s)`);
-        } else {
-            console.log("   ✅ No TypeScript errors found.");
-        }
-
-        return errorList;
-    } catch (e) {
-        console.log("   ⚠️  TypeScript analysis skipped:", e.message);
-        return [];
-    }
-}
-
-// ============================================================================
-// MAIN AUTO-LEARN ENGINE
-// ============================================================================
-
-function autoLearn(projectRoot, options = {}) {
-    console.log(`\n🧠 Smart Auto-Learn Engine v${VERSION}`);
-    console.log(`📂 Project: ${projectRoot}\n`);
-    console.log("─".repeat(50));
-
-    const db = loadKnowledge();
-    let totalAdded = 0;
-
-    // ESLint
-    if (!options.onlyTest && !options.onlyTypescript) {
-        const eslintViolations = runEslintAutoLearn(projectRoot);
-
-        eslintViolations.forEach(v => {
-            const mapping = ESLINT_PATTERN_MAP[v.rule];
-            if (!mapping) return;
-
-            // Check if already exists
-            if (db.lessons.some(l => l.pattern === mapping.pattern)) return;
-
-            const id = `AUTO-${String(db.lessons.length + 1).padStart(3, "0")}`;
-            db.lessons.push({
-                id,
-                pattern: mapping.pattern,
-                message: `${mapping.message} (ESLint: ${v.rule})`,
-                severity: v.severity,
-                source: "auto-eslint",
-                hitCount: v.count,
-                autoEscalated: false,
-                addedAt: new Date().toISOString()
-            });
-            totalAdded++;
-            console.log(`   ✅ Auto-learned: [${id}] ${v.rule} (${v.count} occurrences)`);
-        });
-    }
-
-    // TypeScript
-    if (!options.onlyEslint && !options.onlyTest) {
-        const tsErrors = runTypescriptAutoLearn(projectRoot);
-
-        tsErrors.slice(0, 5).forEach(e => { // Top 5 only
-            const mapping = TS_PATTERN_MAP[e.code];
-            if (!mapping) return;
-
-            if (db.lessons.some(l => l.message.includes(e.code))) return;
-
-            const id = `AUTO-${String(db.lessons.length + 1).padStart(3, "0")}`;
-            db.lessons.push({
-                id,
-                pattern: mapping.pattern,
-                message: `${mapping.message} (${e.code})`,
-                severity: "WARNING",
-                source: "auto-typescript",
-                hitCount: e.count,
-                autoEscalated: false,
-                addedAt: new Date().toISOString()
-            });
-            totalAdded++;
-            console.log(`   ✅ Auto-learned: [${id}] ${e.code} (${e.count} occurrences)`);
-        });
-    }
-
-    // Summary
-    console.log("\n" + "─".repeat(50));
-
-    if (totalAdded > 0) {
-        saveKnowledge(db);
-        console.log(`\n🎓 Auto-learned ${totalAdded} new pattern(s)!`);
-        console.log(`📊 Total lessons in memory: ${db.lessons.length}\n`);
-    } else {
-        console.log("\n✅ No new patterns discovered. Code looks clean!\n");
-    }
-
-    return totalAdded;
-}
-
-// ============================================================================
-// CLI
-// ============================================================================
-
-const args = process.argv.slice(2);
-const projectRoot = process.cwd();
-
-if (args.includes("--help")) {
-    console.log(`
-🧠 Smart Auto-Learn - True Self-Learning Engine
-
-Usage:
-  agent auto-learn              Run all analyzers
-  agent auto-learn --eslint     ESLint only
-  agent auto-learn --typescript TypeScript only
-  agent auto-learn --test       Test failures only
-
-The engine automatically:
-  1. Runs ESLint and learns from violations
-  2. Runs TypeScript and learns from type errors
-  3. Runs tests and learns from failures
-
-Patterns are automatically added to knowledge base!
-`);
-    process.exit(0);
-}
-
-autoLearn(projectRoot, {
-    onlyEslint: args.includes("--eslint"),
-    onlyTypescript: args.includes("--typescript"),
-    onlyTest: args.includes("--test")
-});