add-skill-kit 3.2.3 → 3.2.5

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

@@ -0,0 +1,222 @@
+/**
+ * Dashboard UI - Launch Auto-Learn Dashboard in browser
+ */
+import * as p from "@clack/prompts";
+import { spawn, exec } from "child_process";
+import path from "path";
+import fs from "fs";
+import http from "http";
+
+// Track running server globally
+let runningServer = null;
+let runningPort = null;
+
+/**
+ * Check if a port is already in use by our dashboard
+ * Uses /api/summary to verify it's actually our dashboard server
+ */
+async function checkPortInUse(port) {
+    return new Promise((resolve) => {
+        const req = http.get(`http://localhost:${port}/api/summary`, (res) => {
+            // If we get 200 response from /api/summary, it's our dashboard
+            if (res.statusCode === 200) {
+                resolve(true);
+            } else {
+                resolve(false);
+            }
+            req.destroy();
+        });
+        req.on('error', () => {
+            resolve(false);
+        });
+        // Faster timeout - 500ms is enough for localhost
+        req.setTimeout(500, () => {
+            req.destroy();
+            resolve(false);
+        });
+    });
+}
+
+/**
+ * Find existing dashboard server on ports 3030-3040
+ */
+async function findExistingServer() {
+    // Check ports in parallel for faster detection
+    const portChecks = [];
+    for (let port = 3030; port <= 3040; port++) {
+        portChecks.push(checkPortInUse(port).then(inUse => inUse ? port : null));
+    }
+
+    const results = await Promise.all(portChecks);
+    const existingPort = results.find(port => port !== null);
+    return existingPort || null;
+}
+
+/**
+ * Find an available port
+ */
+async function findAvailablePort(startPort = 3030) {
+    return new Promise((resolve) => {
+        const server = http.createServer();
+        server.listen(startPort, () => {
+            server.close(() => resolve(startPort));
+        });
+        server.on("error", () => {
+            resolve(findAvailablePort(startPort + 1));
+        });
+    });
+}
+
+/**
+ * Find dashboard server script
+ */
+function findDashboardScript() {
+    // Get the directory where this module is located
+    const moduleDir = path.dirname(new URL(import.meta.url).pathname.replace(/^\/([A-Z]:)/i, '$1'));
+    const cliRoot = path.resolve(moduleDir, '..', '..');
+
+    // User home directory
+    const homeDir = process.env.USERPROFILE || process.env.HOME || '';
+
+    const possiblePaths = [
+        // PRIORITY 1: Bundled with CLI package (always available)
+        path.join(cliRoot, "dashboard", "dashboard_server.js"),
+        // PRIORITY 2: Current project paths
+        path.join(process.cwd(), ".agent", "skills", "auto-learner", "scripts", "dashboard_server.js"),
+        path.join(process.cwd(), ".agent", "agentskillskit", ".agent", "skills", "auto-learner", "scripts", "dashboard_server.js"),
+        // PRIORITY 3: Fallback user paths (Windows Desktop)
+        path.join(homeDir, "Desktop", "agent-skill-kit", ".agent", "skills", "auto-learner", "scripts", "dashboard_server.js"),
+    ];
+
+    for (const searchPath of possiblePaths) {
+        if (fs.existsSync(searchPath)) {
+            return searchPath;
+        }
+    }
+    return null;
+}
+
+/**
+ * Open URL in default browser
+ */
+function openBrowser(url) {
+    const platform = process.platform;
+    let command;
+
+    if (platform === "win32") {
+        command = `start "" "${url}"`;
+    } else if (platform === "darwin") {
+        command = `open "${url}"`;
+    } else {
+        command = `xdg-open "${url}"`;
+    }
+
+    exec(command, (err) => {
+        if (err) {
+            p.log.warn(`Could not open browser automatically. Visit: ${url}`);
+        }
+    });
+}
+
+/**
+ * Run Dashboard UI
+ */
+export async function runDashboardUI() {
+    const spinner = p.spinner();
+
+    // Check if there's already a server running
+    spinner.start("Checking for existing dashboard server...");
+    const existingPort = await findExistingServer();
+
+    if (existingPort) {
+        spinner.stop(`Found existing server on port ${existingPort}`);
+        const url = `http://localhost:${existingPort}`;
+
+        p.log.success(`Dashboard already running at: ${url}`);
+        openBrowser(url);
+
+        p.note(`Server running on port ${existingPort}\nUsing existing server`, "📊 Auto-Learn Dashboard");
+
+        const action = await p.select({
+            message: "Dashboard is running. What would you like to do?",
+            options: [
+                { value: "keep", label: "🏠 Back to menu", hint: "Keep server running" },
+                { value: "stop", label: "🛑 Stop server", hint: "Shutdown dashboard" }
+            ]
+        });
+
+        if (action === "stop") {
+            // Kill all node processes on that port
+            p.log.info("Stopping existing server...");
+            if (process.platform === "win32") {
+                exec(`for /f "tokens=5" %a in ('netstat -aon ^| findstr :${existingPort}') do taskkill /F /PID %a`, () => { });
+            } else {
+                exec(`lsof -ti:${existingPort} | xargs kill -9`, () => { });
+            }
+            await new Promise(r => setTimeout(r, 1000));
+            p.log.success("Dashboard server stopped");
+        }
+        return;
+    }
+
+    spinner.stop("No existing server found");
+
+    // Find dashboard script
+    const scriptPath = findDashboardScript();
+
+    if (!scriptPath) {
+        p.log.error("Dashboard script not found!");
+        p.log.info("Install auto-learner skill first or check .agent/skills/auto-learner/scripts/");
+        return;
+    }
+
+    // Find available port
+    spinner.start("Finding available port...");
+    const port = await findAvailablePort(3030);
+    runningPort = port;
+    spinner.stop(`Using port ${port}`);
+
+    // Start dashboard server
+    spinner.start("Starting dashboard server...");
+
+    const child = spawn("node", [scriptPath, "--port", String(port)], {
+        stdio: ["ignore", "pipe", "pipe"],
+        detached: false
+    });
+
+    runningServer = child;
+
+    // Wait for server to start
+    await new Promise((resolve) => setTimeout(resolve, 1500));
+
+    spinner.stop("Dashboard server started!");
+
+    const url = `http://localhost:${port}`;
+
+    // Open browser
+    p.log.success(`Dashboard running at: ${url}`);
+    openBrowser(url);
+
+    p.log.info("Dashboard opened in browser");
+    p.note(`Server running on port ${port}\nPress Ctrl+C in terminal to stop`, "📊 Auto-Learn Dashboard");
+
+    // Keep server running and wait for user
+    const action = await p.select({
+        message: "Dashboard is running. What would you like to do?",
+        options: [
+            { value: "keep", label: "🏠 Back to menu", hint: "Keep server running" },
+            { value: "stop", label: "🛑 Stop server", hint: "Shutdown dashboard" }
+        ]
+    });
+
+    if (action === "stop" || p.isCancel(action)) {
+        child.kill();
+        runningServer = null;
+        runningPort = null;
+        p.log.info("Dashboard server stopped");
+    } else {
+        p.log.info(`Dashboard still running at ${url}`);
+    }
+}
+
+export default runDashboardUI;

package/lib/agent-cli/lib/ui/evolution-signals-ui.js

@@ -0,0 +1,107 @@
+/**
+ * Evolution Signals UI - View and manage pending evolution signals
+ */
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+import { signalQueue, getEvolutionStats, reviewGate } from "../evolution-signal.js";
+import { loadKnowledge } from "../recall.js";
+import { loadSettings } from "../settings.js";
+
+/**
+ * Show pending evolution signals
+ */
+export async function runEvolutionSignalsUI() {
+    p.intro("📡 Evolution Signals");
+
+    const pending = signalQueue.getPending();
+    const stats = getEvolutionStats();
+
+    // Show summary
+    p.note(
+        `Pending: ${pc.yellow(stats.pending)}\n` +
+        `Approved: ${pc.green(stats.approved)}\n` +
+        `Rejected: ${pc.red(stats.rejected)}\n` +
+        `Executed: ${pc.cyan(stats.executed)}`,
+        "📊 Signal Queue Status"
+    );
+
+    if (pending.length === 0) {
+        p.note(pc.dim("No pending evolution signals"), "✅ All Clear");
+        return;
+    }
+
+    // Load lessons for context
+    const db = loadKnowledge();
+    const settings = loadSettings();
+
+    // Display pending signals with details
+    const signalChoices = pending.map(signal => {
+        const lesson = db.lessons.find(l => l.id === signal.lessonId);
+        const lessonName = lesson ? lesson.id : signal.lessonId;
+        const gate = reviewGate(signal, {
+            autoUpdating: settings.autoUpdating,
+            confidenceThreshold: 0.8
+        });
+
+        return {
+            value: signal.id,
+            label: `${pc.yellow('●')} ${lessonName}`,
+            hint: `${signal.reason} · confidence: ${(signal.confidence * 100).toFixed(0)}% ${gate.shouldAuto ? pc.green('(auto-eligible)') : pc.dim('(review)')}`
+        };
+    });
+
+    const action = await p.select({
+        message: "Pending Evolution Signals",
+        options: [
+            ...signalChoices,
+            { value: "back", label: "← Back" }
+        ]
+    });
+
+    if (p.isCancel(action) || action === "back") {
+        return;
+    }
+
+    // Show signal details
+    const signal = pending.find(s => s.id === action);
+    if (!signal) return;
+
+    const lesson = db.lessons.find(l => l.id === signal.lessonId);
+
+    p.note(
+        `${pc.bold('Lesson:')} ${signal.lessonId}\n` +
+        `${pc.bold('Reason:')} ${signal.reason}\n` +
+        `${pc.bold('Confidence:')} ${(signal.confidence * 100).toFixed(0)}%\n` +
+        `${pc.bold('Created:')} ${new Date(signal.createdAt).toLocaleString()}\n\n` +
+        `${pc.bold('Current Stats:')}\n` +
+        `  Hit Count: ${lesson?.hitCount || 0}\n` +
+        `  Maturity: ${lesson?.cognitive?.maturity || 'unknown'}\n` +
+        `  Intent: ${lesson?.intent || 'unknown'}\n\n` +
+        `${pc.bold('Metadata:')}\n` +
+        `  Trigger: ${signal.metadata.triggerEvent}\n` +
+        `  File: ${signal.metadata.file || 'N/A'}`,
+        "🔍 Signal Details"
+    );
+
+    // Action options
+    const signalAction = await p.select({
+        message: "What would you like to do?",
+        options: [
+            { value: "approve", label: "✅ Approve", hint: "Mark for evolution" },
+            { value: "reject", label: "❌ Reject", hint: "Dismiss this signal" },
+            { value: "back", label: "← Back" }
+        ]
+    });
+
+    if (p.isCancel(signalAction) || signalAction === "back") {
+        return;
+    }
+
+    if (signalAction === "approve") {
+        signalQueue.approve(signal.id);
+        p.note(pc.green(`✅ Signal approved for [${signal.lessonId}]`));
+    } else if (signalAction === "reject") {
+        signalQueue.reject(signal.id);
+        p.note(pc.red(`❌ Signal rejected for [${signal.lessonId}]`));
+    }
+}

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

@@ -0,0 +1,94 @@
+/**
+ * Export/Import UI - Share settings between projects
+ */
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+import path from "path";
+import { cwd } from "../config.js";
+import { exportData, importData } from "../export.js";
+
+/**
+ * Interactive export/import menu
+ */
+export async function runExportUI() {
+    p.intro("Export & Import (Press ESC to exit)");
+
+    while (true) {
+
+        const action = await p.select({
+            message: "What would you like to do?",
+            options: [
+                { value: "export", label: "Export", hint: "Export lessons to file" },
+                { value: "import", label: "Import", hint: "Import lessons from file" },
+                { value: "back", label: "← Back", hint: "Return to main menu" }
+            ]
+        });
+
+        if (p.isCancel(action) || action === "back") {
+            return;
+        }
+
+        switch (action) {
+            case "export": {
+                const filename = await p.text({
+                    message: "Export filename:",
+                    placeholder: "agent-skills-export.json",
+                    initialValue: "agent-skills-export.json"
+                });
+
+                if (p.isCancel(filename)) break;
+
+                const outputPath = path.join(cwd, filename);
+                const success = exportData(outputPath);
+
+                if (success) {
+                    p.note(
+                        `Exported to:\n${pc.dim(outputPath)}`,
+                        pc.green("Success")
+                    );
+                } else {
+                    p.note("Failed to export", pc.red("Error"));
+                }
+                break;
+            }
+
+            case "import": {
+                const filename = await p.text({
+                    message: "Import filename:",
+                    placeholder: "agent-skills-export.json",
+                    validate: (v) => {
+                        if (!v) return "Filename required";
+                    }
+                });
+
+                if (p.isCancel(filename)) break;
+
+                const mode = await p.select({
+                    message: "Import mode:",
+                    options: [
+                        { value: "merge", label: "Merge", hint: "Add new, keep existing" },
+                        { value: "replace", label: "Replace", hint: "Overwrite all data" }
+                    ]
+                });
+
+                if (p.isCancel(mode)) break;
+
+                const inputPath = path.join(cwd, filename);
+                const result = importData(inputPath, mode);
+
+                if (result.success) {
+                    p.note(
+                        `Imported ${result.lessonsCount} lesson(s)\n` +
+                        `Settings: ${result.hasSettings ? "Yes" : "No"}`,
+                        pc.green("Success")
+                    );
+                } else {
+                    p.note("Failed to import. Check file exists and is valid JSON.", pc.red("Error"));
+                }
+                break;
+            }
+        }
+    }
+}
+
+export default runExportUI;

package/lib/agent-cli/lib/ui/fix-all-ui.js

@@ -0,0 +1,191 @@
+/**
+ * Fix All UI - Agent Coding Handoff (Smart Version)
+ * Instead of brittle regex auto-fix, generates AI-friendly prompts
+ */
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+import path from "path";
+import fs from "fs";
+import { execSync } from "child_process";
+import { showIntro, createSpinner, showSuccessNote, showErrorNote, theme } from "./clack-helpers.js";
+import { loadMostRecentScan, loadScanResult } from "../recall.js";
+
+/**
+ * Fix All UI - Generate Agent handoff prompts
+ */
+export async function runFixAllUI(scanId = null) {
+    showIntro('🔧 Fix All - Agent Handoff');
+
+    // 1. Get scan results
+    let scanResult;
+    const spinner = createSpinner('Loading scan results...');
+
+    if (!scanId) {
+        scanResult = loadMostRecentScan();
+    } else {
+        scanResult = loadScanResult(scanId);
+    }
+
+    spinner.stop();
+
+    if (!scanResult) {
+        showErrorNote(
+            'No scan results found.\\n\\n' +
+            'Run "Scan All" first to generate scan data.',
+            '✗ No Scan Results'
+        );
+        return;
+    }
+
+    // 2. Show summary
+    console.log(`\\n${theme.primary(scanResult.totalIssues)} violations found\\n`);
+
+    // 3. Offer handoff options
+    const choice = await p.select({
+        message: "How would you like to fix these violations?",
+        options: [
+            { value: "agent", label: "🤖 Hand off to Agent", hint: "Generate AI fix request" },
+            { value: "skip", label: "← Skip", hint: "Return to menu" }
+        ]
+    });
+
+    if (p.isCancel(choice) || choice === "skip") {
+        p.cancel('Cancelled');
+        return;
+    }
+
+    // 4. Generate fix prompt
+    const fixPrompt = generateAgentFixPrompt(scanResult);
+
+    // 5. Ask where to send
+    const outputChoice = await p.select({
+        message: "Where to send the fix request?",
+        options: [
+            { value: "clipboard", label: "📋 Copy to Clipboard", hint: "Paste into AI chat" },
+            { value: "file", label: "💾 Save to File", hint: ".agent/fix-request.md" },
+            { value: "both", label: "✨ Both", hint: "Copy and save" }
+        ]
+    });
+
+    if (p.isCancel(outputChoice)) {
+        p.cancel('Cancelled');
+        return;
+    }
+
+    // 6. Execute handoff
+    let copied = false;
+    let saved = false;
+
+    if (outputChoice === "clipboard" || outputChoice === "both") {
+        copied = copyToClipboard(fixPrompt);
+    }
+
+    if (outputChoice === "file" || outputChoice === "both") {
+        saved = saveFixRequest(fixPrompt);
+    }
+
+    // 7. Show success
+    let message = '';
+    if (copied && saved) {
+        message = '✓ Copied to clipboard\\n✓ Saved to .agent/fix-request.md\\n\\nPaste into your AI coding assistant!';
+    } else if (copied) {
+        message = '✓ Copied to clipboard\\n\\nPaste into your AI coding assistant!';
+    } else if (saved) {
+        message = '✓ Saved to .agent/fix-request.md\\n\\nOpen file and copy into your AI coding assistant!';
+    } else {
+        message = 'Failed to copy or save. Check console for errors.';
+    }
+
+    p.note(message, '🎉 Fix Request Ready');
+}
+
+/**
+ * Generate AI-friendly fix prompt from scan results
+ */
+function generateAgentFixPrompt(scanResult) {
+    // Group by file
+    const byFile = {};
+    scanResult.issues.forEach(issue => {
+        const file = path.relative(process.cwd(), issue.file);
+        if (!byFile[file]) byFile[file] = [];
+        byFile[file].push(issue);
+    });
+
+    const fileList = Object.entries(byFile).sort((a, b) => b[1].length - a[1].length);
+
+    let prompt = '# Code Violation Fix Request\\n\\n## Summary\\n';
+    prompt += `- **Total violations**: ${scanResult.totalIssues}\\n`;
+    prompt += `- **Files affected**: ${fileList.length}\\n`;
+    prompt += `- **Errors**: ${scanResult.summary.errors}\\n`;
+    prompt += `- **Warnings**: ${scanResult.summary.warnings}\\n\\n`;
+    prompt += '## Violations by File\\n\\n';
+
+    fileList.forEach(([file, issues]) => {
+        prompt += `### 📁 \`${file}\`\\n\\n`;
+        issues.forEach(issue => {
+            const icon = issue.severity === 'ERROR' ? '🔴' : '⚠️';
+            prompt += `${icon} **Line ${issue.line}** - ${issue.severity}\\n`;
+            prompt += `- **Issue**: ${issue.message}\\n`;
+            if (issue.pattern) {
+                prompt += `- **Pattern**: \`${issue.pattern}\`\\n`;
+            }
+            prompt += '\\n';
+        });
+        prompt += '\\n';
+    });
+
+    prompt += '## Instructions\\n\\n';
+    prompt += 'Please fix all violations following these guidelines:\\n\\n';
+    prompt += '1. **Understand Context**: Read the entire file before making changes\\n';
+    prompt += '2. **Fix Correctly**: Address the root cause, not just the symptom\\n';
+    prompt += '3. **Maintain Style**: Keep existing code style and formatting\\n';
+    prompt += '4. **Test Changes**: Ensure no functionality is broken\\n';
+    prompt += '5. **Verify**: Check that all violations are resolved\\n\\n';
+    prompt += '**Important**: Some violations may be false positives. Use your judgment and skip if the code is actually correct.\\n\\n';
+    prompt += 'Ready to proceed with fixing these violations?\\n';
+
+    return prompt;
+}
+
+/**
+ * Copy text to clipboard (cross-platform)
+ */
+function copyToClipboard(text) {
+    try {
+        if (process.platform === 'win32') {
+            execSync('clip', { input: text });
+            return true;
+        } else if (process.platform === 'darwin') {
+            execSync('pbcopy', { input: text });
+            return true;
+        } else {
+            execSync('xclip -selection clipboard', { input: text });
+            return true;
+        }
+    } catch (e) {
+        console.error(`Clipboard error: ${e.message}`);
+        return false;
+    }
+}
+
+/**
+ * Save fix request to file
+ */
+function saveFixRequest(text) {
+    try {
+        const fixRequestPath = path.join('.agent', 'fix-request.md');
+        const dir = path.dirname(fixRequestPath);
+
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+
+        fs.writeFileSync(fixRequestPath, text, 'utf8');
+        return true;
+    } catch (e) {
+        console.error(`Save error: ${e.message}`);
+        return false;
+    }
+}
+
+export default runFixAllUI;

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

@@ -0,0 +1,49 @@
+/**
+ * Help/Guide UI - Compact Visual Guide
+ */
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+
+/**
+ * Show compact visual guide (fits in one screen)
+ */
+export async function runHelpUI() {
+  // Clear terminal và reset cursor về top-left
+  process.stdout.write('\x1Bc'); // Full terminal reset
+
+  p.intro(pc.cyan("📖 Agent Skill Kit - Quick Guide"));
+
+  console.log(`
+${pc.bold(pc.yellow("🎯 HOW IT WORKS"))}
+  ${pc.green("Write Code")} → ${pc.yellow("Agent Scans")} → ${pc.blue("Learns Patterns")} → ${pc.magenta("Auto Warns")}
+
+${pc.bold(pc.yellow("🔧 MENU OPTIONS"))}
+  ${pc.cyan("🔎 Scan All")}     - Check violations + option to auto-fix
+  ${pc.cyan("📝 Learn")}        - Teach agent new patterns (manual mode only)
+  ${pc.cyan("📚 Knowledge")}    - View lessons & review pending patterns
+  ${pc.cyan("📊 Stats")}        - Project metrics & insights
+  ${pc.cyan("⚙️  Settings")}    - Configure auto-learning, API keys
+  ${pc.cyan("💾 Backup")}       - Manage knowledge backups
+
+${pc.bold(pc.yellow("🚀 QUICK START"))}
+  ${pc.bold("1.")} ${pc.cyan("Scan All")} ${pc.dim("→ See current violations")}
+  ${pc.bold("2.")} ${pc.cyan("Fix All")} ${pc.dim("→ Auto-fix simple issues")}
+  ${pc.bold("3.")} ${pc.cyan("Knowledge")} ${pc.dim("→ Review what agent learned")}
+
+${pc.green("✓")} Agent learns from your code automatically
+${pc.green("✓")} All fixes are backed up safely
+${pc.green("✓")} The more you use it, the smarter it gets!
+`);
+
+  // User selects next action
+  const action = await p.select({
+    message: "What's next?",
+    options: [
+      { value: "back", label: "← Back to Main Menu" }
+    ]
+  });
+
+  if (!p.isCancel(action)) {
+    p.outro(pc.cyan("👋 Returning to menu"));
+  }
+}