add-skill-kit 3.2.3 → 3.2.5

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

@@ -0,0 +1,325 @@
+/**
+ * @fileoverview Intelligent Routing UI for Agent Skill Kit
+ * FAANG-level professional agent display with Clack UI
+ */
+
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+
+// ============================================================================
+// CLACK SYMBOLS
+// ============================================================================
+
+const S = {
+    BAR: "│",
+    BAR_END: "└",
+    CORNER_TOP_RIGHT: "╮",
+    CORNER_BOTTOM_RIGHT: "╯",
+    STEP_ACTIVE: "◆",
+    STEP_SUBMIT: "◇",
+    RADIO_ACTIVE: "●",
+    RADIO_INACTIVE: "○",
+    CONNECT_LEFT: "├",
+    H_LINE: "─"
+};
+
+// ============================================================================
+// AGENT BRANDING
+// ============================================================================
+
+const AGENT_EMOJI = "🤖";
+
+const COMPLEXITY_CONFIG = {
+    "SIMPLE": {
+        color: pc.green,
+        icon: S.RADIO_ACTIVE,
+        label: "Focused",
+        description: "Single specialist engaged"
+    },
+    "MODERATE": {
+        color: pc.yellow,
+        icon: `${S.RADIO_ACTIVE}${S.RADIO_ACTIVE}`,
+        label: "Collaborative",
+        description: "Multi-specialist coordination"
+    },
+    "COMPLEX": {
+        color: pc.red,
+        icon: `${S.RADIO_ACTIVE}${S.RADIO_ACTIVE}${S.RADIO_ACTIVE}`,
+        label: "Full Stack",
+        description: "Complete team mobilized"
+    }
+};
+
+// FAANG-level professional messages
+const ROUTING_MESSAGES = {
+    simple: [
+        "Specialist locked in",
+        "Expert matched to your task",
+        "Best-fit agent selected",
+        "Precision routing complete"
+    ],
+    moderate: [
+        "Cross-functional team assembled",
+        "Specialists synchronized",
+        "Multi-domain expertise activated",
+        "Collaborative intelligence engaged"
+    ],
+    complex: [
+        "Full engineering squad deployed",
+        "Maximum capability unlocked",
+        "Enterprise-grade orchestration",
+        "Complete specialist coverage"
+    ]
+};
+
+// ============================================================================
+// CORE FUNCTIONS
+// ============================================================================
+
+/**
+ * Get icon for an agent
+ * @param {string} agentName 
+ * @param {boolean} isMain - Is this the main/first agent?
+ * @returns {string}
+ */
+function getAgentIcon(agentName, isMain = false) {
+    if (isMain || agentName === "orchestrator") {
+        return S.STEP_ACTIVE;
+    }
+    return S.STEP_SUBMIT;
+}
+
+/**
+ * Format agent names with professional styling
+ * @param {string[]} agents - List of agent names
+ * @returns {string}
+ */
+function formatAgents(agents) {
+    if (!agents || agents.length === 0) return pc.dim("analyzing...");
+
+    return agents
+        .map((agent, index) => {
+            const icon = getAgentIcon(agent, index === 0);
+            const name = `@${agent}`;
+            const colorFn = index === 0 ? pc.cyan : pc.blue;
+            return `${colorFn(icon)} ${pc.bold(colorFn(name))}`;
+        })
+        .join(pc.dim("  →  "));
+}
+
+/**
+ * Format domains with professional styling
+ * @param {string[]} domains 
+ * @returns {string}
+ */
+function formatDomains(domains) {
+    if (!domains || domains.length === 0) return pc.dim("general");
+    return domains.map(d => pc.magenta(d)).join(pc.dim(" · "));
+}
+
+/**
+ * Get random message from array
+ * @param {string[]} messages 
+ * @returns {string}
+ */
+function getRandomMessage(messages) {
+    return messages[Math.floor(Math.random() * messages.length)];
+}
+
+/**
+ * Show routing result using Clack native styling
+ * @param {object} routing - Routing result object
+ */
+export function showRoutingResult(routing) {
+    const { selectedAgents = [], domains = [], complexity = "SIMPLE", reasoning } = routing;
+
+    const config = COMPLEXITY_CONFIG[complexity] || COMPLEXITY_CONFIG.SIMPLE;
+
+    // Build content lines
+    const lines = [];
+    lines.push(`${pc.dim("Agents")}     ${formatAgents(selectedAgents)}`);
+    lines.push(`${pc.dim("Domains")}    ${formatDomains(domains)}`);
+    lines.push(`${pc.dim("Mode")}       ${config.color(config.icon)} ${config.color(config.label)}`);
+
+    if (reasoning) {
+        lines.push("");
+        lines.push(`${pc.dim("→")} ${pc.italic(reasoning)}`);
+    }
+
+    // Use Clack's native note for consistent styling
+    p.note(lines.join("\n"), `${AGENT_EMOJI} Agent Routing`);
+}
+
+/**
+ * Show compact inline routing info
+ * @param {string[]} selectedAgents 
+ */
+export function showRoutingInline(selectedAgents) {
+    const formatted = selectedAgents
+        .map((agent, i) => `${getAgentIcon(agent, i === 0)} ${pc.cyan(`@${agent}`)}`)
+        .join(pc.dim("  →  "));
+
+    console.log("");
+    console.log(`${pc.gray(S.BAR)}`);
+    console.log(`${pc.cyan(S.STEP_ACTIVE)}  ${AGENT_EMOJI} ${pc.bold("Engaging")} ${formatted}`);
+}
+
+/**
+ * Show routing with Clack log message style
+ * @param {object} routing 
+ */
+export function showRoutingLog(routing) {
+    const { selectedAgents = [], complexity = "SIMPLE" } = routing;
+    const config = COMPLEXITY_CONFIG[complexity] || COMPLEXITY_CONFIG.SIMPLE;
+
+    const agentList = selectedAgents
+        .map((a, i) => `${getAgentIcon(a, i === 0)} @${a}`)
+        .join(" → ");
+
+    p.log.info(`${AGENT_EMOJI} ${pc.bold("Routing:")} ${pc.cyan(agentList)} ${config.color(`[${config.label}]`)}`);
+}
+
+/**
+ * Show routing step (for multi-step flows)
+ * @param {string} agent - Agent name
+ * @param {string} status - active | complete | pending
+ */
+export function showRoutingStep(agent, status = "active") {
+    const icons = {
+        active: pc.cyan(S.STEP_ACTIVE),
+        complete: pc.green(S.STEP_SUBMIT),
+        pending: pc.dim(S.RADIO_INACTIVE)
+    };
+
+    const labels = {
+        active: pc.cyan("working"),
+        complete: pc.green("done"),
+        pending: pc.dim("queued")
+    };
+
+    const icon = icons[status] || icons.pending;
+    const label = labels[status] || labels.pending;
+    const name = status === "active" ? pc.bold(pc.cyan(`@${agent}`)) : pc.dim(`@${agent}`);
+
+    console.log(`${pc.gray(S.BAR)}  ${icon}  ${name} ${pc.dim("·")} ${label}`);
+}
+
+/**
+ * Analyze request and show routing decision
+ * @param {string} userRequest - The user's request text
+ * @returns {object} - The routing decision
+ */
+export function analyzeAndShowRouting(userRequest) {
+    // Domain detection patterns
+    const patterns = {
+        "security": /auth|login|password|jwt|token|vulnerability|security|encrypt/i,
+        "frontend": /component|react|vue|css|html|tailwind|button|layout|style|ui/i,
+        "backend": /api|endpoint|server|express|route|post|get|database/i,
+        "mobile": /react native|flutter|ios|android|mobile|expo|screen/i,
+        "database": /prisma|sql|mongodb|schema|migration|table|query/i,
+        "testing": /test|jest|vitest|playwright|coverage|e2e/i,
+        "debug": /error|bug|crash|not working|broken|fix/i,
+        "performance": /slow|optimize|performance|speed|cache/i,
+        "analysis": /analyze|review|refactor|clean|improve|upgrade/i
+    };
+
+    // Detect domains
+    const domains = [];
+    for (const [domain, pattern] of Object.entries(patterns)) {
+        if (pattern.test(userRequest)) {
+            domains.push(domain);
+        }
+    }
+
+    // Determine complexity
+    let complexity = "SIMPLE";
+    let messagePool = ROUTING_MESSAGES.simple;
+
+    if (domains.length >= 3) {
+        complexity = "COMPLEX";
+        messagePool = ROUTING_MESSAGES.complex;
+    } else if (domains.length === 2) {
+        complexity = "MODERATE";
+        messagePool = ROUTING_MESSAGES.moderate;
+    }
+
+    // Select agents based on domains (FAANG-style short names)
+    const agentMap = {
+        "security": "security",
+        "frontend": "frontend",
+        "backend": "backend",
+        "mobile": "mobile",
+        "database": "database",
+        "testing": "testing",
+        "debug": "debug",
+        "performance": "perf",
+        "analysis": "analyst"
+    };
+
+    let selectedAgents = domains.map(d => agentMap[d] || "lead");
+
+    // If complex or no agents, add lead
+    if (complexity === "COMPLEX" || selectedAgents.length === 0) {
+        selectedAgents = ["lead", ...selectedAgents];
+    }
+
+    // Remove duplicates
+    selectedAgents = [...new Set(selectedAgents)];
+
+    const routing = {
+        selectedAgents,
+        domains,
+        complexity,
+        reasoning: getRandomMessage(messagePool)
+    };
+
+    // Show the routing result
+    showRoutingResult(routing);
+
+    return routing;
+}
+
+/**
+ * Show agent intro message
+ * @param {string} message - Custom message
+ */
+export function showAgentIntro(message = "Ready to assist") {
+    p.intro(`${AGENT_EMOJI} ${pc.bold(message)}`);
+}
+
+/**
+ * Show agent outro message
+ * @param {string} message - Custom message
+ */
+export function showAgentOutro(message = "Task complete") {
+    p.outro(`${AGENT_EMOJI} ${pc.green(message)}`);
+}
+
+/**
+ * Show agent thinking indicator
+ * @param {string} action - What the agent is doing
+ */
+export function showAgentThinking(action = "Analyzing") {
+    console.log(`${pc.gray(S.BAR)}`);
+    console.log(`${pc.cyan(S.STEP_ACTIVE)}  ${AGENT_EMOJI} ${pc.dim(action)}...`);
+}
+
+// ============================================================================
+// EXPORTS
+// ============================================================================
+
+export default {
+    showRoutingResult,
+    showRoutingInline,
+    showRoutingLog,
+    showRoutingStep,
+    analyzeAndShowRouting,
+    showAgentIntro,
+    showAgentOutro,
+    showAgentThinking,
+    getAgentIcon,
+    AGENT_EMOJI,
+    S,
+    COMPLEXITY_CONFIG,
+    ROUTING_MESSAGES
+};

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

@@ -0,0 +1,381 @@
+/**
+ * Settings UI - Interactive settings configuration
+ */
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+import {
+    loadSettings,
+    saveSettings,
+    toggleAutoLearning,
+    toggleAutoUpdating,
+    setApiKey,
+    getApiKey,
+    removeApiKey
+} from "../settings.js";
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+// ============================================================================
+// HELPERS
+// ============================================================================
+
+/**
+ * Mask API key for display (show first 4 and last 4 chars)
+ */
+function maskApiKey(key) {
+    if (!key) return pc.dim("[Not Set]");
+    if (key.length < 12) return "***...***";
+    return `${key.substring(0, 4)}...${key.substring(key.length - 4)}`;
+}
+
+/**
+ * Get Antigravity OAuth credentials (if available)
+ * @returns {{accessToken: string, expiryDate: number} | null}
+ */
+function getAntigravityOAuthToken() {
+    try {
+        const credPath = path.join(os.homedir(), '.gemini', 'oauth_creds.json');
+
+        if (!fs.existsSync(credPath)) return null;
+
+        const creds = JSON.parse(fs.readFileSync(credPath, 'utf8'));
+
+        // Check if token is still valid
+        if (creds.access_token && creds.expiry_date) {
+            const now = Date.now();
+            if (now < creds.expiry_date) {
+                return {
+                    accessToken: creds.access_token,
+                    expiryDate: creds.expiry_date
+                };
+            }
+        }
+
+        return null;
+    } catch (e) {
+        return null;
+    }
+}
+
+/**
+ * Detect which API key Agent is actively using (from environment)
+ * Checks multiple sources in priority order:
+ * 1. Current process environment
+ * 2. Exported Settings API key
+ * 3. SelfEvolution .env file
+ * @returns {'gemini' | 'claude' | null}
+ */
+function getActiveApiKey() {
+    // Priority 1: Current process environment (Agent session)
+    if (process.env.GEMINI_API_KEY) return 'gemini';
+    if (process.env.CLAUDE_API_KEY || process.env.ANTHROPIC_API_KEY) return 'claude';
+
+    // Priority 2: Check if we have exported keys from Settings
+    const geminiKey = getApiKey('gemini');
+    const claudeKey = getApiKey('claude');
+
+    // If Settings has a key configured, consider it "active"
+    // (because we auto-export to SelfEvolution)
+    if (geminiKey) return 'gemini';
+    if (claudeKey) return 'claude';
+
+    // Priority 3: Check Antigravity OAuth credentials
+    const oauthCreds = getAntigravityOAuthToken();
+    if (oauthCreds) return 'gemini'; // Antigravity uses Google OAuth
+
+    return null;
+}
+
+/**
+ * Format API key status (ON if active, OFF if not)
+ */
+function formatApiKeyStatus(provider, storedKey) {
+    const activeKey = getActiveApiKey();
+    const isActive = activeKey === provider;
+
+    if (!storedKey) {
+        return pc.dim("[Not Set]");
+    }
+
+    if (isActive) {
+        return `${pc.green("[ON]")} ${maskApiKey(storedKey)}`;
+    } else {
+        return `${pc.dim("[OFF]")} ${maskApiKey(storedKey)}`;
+    }
+}
+
+// ============================================================================
+// SETTINGS MENU
+// ============================================================================
+
+/**
+ * Interactive settings menu with Clack icons
+ */
+export async function runSettingsUI() {
+    // No intro - go straight to settings menu
+
+    // Display active API key info ONCE at the start
+    const geminiKey = getApiKey('gemini');
+    const claudeKey = getApiKey('claude');
+
+    let bannerMsg;
+
+    // Priority 1: Check if running in Antigravity (check for oauth_creds.json)
+    try {
+        const credPath = path.join(os.homedir(), '.gemini', 'oauth_creds.json');
+        if (fs.existsSync(credPath)) {
+            // Running in Antigravity - always show this message
+            bannerMsg = pc.green(
+                `✓ Agent Coding is using system credentials\n` +
+                `  Source: Antigravity Session (in-memory)\n` +
+                `  → Configure permanent API key below for SelfEvolution features`
+            );
+        } else {
+            // Not in Antigravity, check for configured keys
+            if (geminiKey) {
+                bannerMsg = pc.green(`✓ Using Gemini API Key (Configured)\n  → SelfEvolution features enabled`);
+            } else if (claudeKey) {
+                bannerMsg = pc.green(`✓ Using Claude API Key (Configured)\n  → SelfEvolution features enabled`);
+            } else {
+                bannerMsg = pc.yellow(`⚠ No API Key Configured\n  → Set up API key below to enable SelfEvolution features`);
+            }
+        }
+    } catch (e) {
+        // Fallback: check configured keys
+        if (geminiKey) {
+            bannerMsg = pc.green(`✓ Using Gemini API Key (Configured)\n  → SelfEvolution features enabled`);
+        } else if (claudeKey) {
+            bannerMsg = pc.green(`✓ Using Claude API Key (Configured)\n  → SelfEvolution features enabled`);
+        } else {
+            bannerMsg = pc.yellow(`⚠ No API Key Configured\n  → Set up API key below to enable SelfEvolution features`);
+        }
+    }
+
+    p.note(bannerMsg, "🔑 Active API Key");
+
+    while (true) {
+        const settings = loadSettings();
+
+        const action = await p.select({
+            message: "⚙️  Settings",
+            options: [
+                // AI BEHAVIOR GROUP
+                {
+                    value: "autoLearn",
+                    label: `🤖 Auto-Learning: ${settings.autoLearning ? pc.green("[ON]") : pc.dim("[OFF]")}`,
+                    hint: "Learn from mistakes"
+                },
+                {
+                    value: "autoUpdate",
+                    label: `🔄 Auto-Updating: ${settings.autoUpdating ? pc.green("[ON]") : pc.dim("[OFF]")}`,
+                    hint: "Update threshold hits"
+                },
+                {
+                    value: "threshold",
+                    label: `📈 Update Threshold: ${pc.cyan(settings.updateThreshold)}`,
+                    hint: "Hits before update"
+                },
+
+                // API CONFIGURATION GROUP
+                {
+                    value: "geminiKey",
+                    label: `🔑 Gemini API: ${formatApiKeyStatus('gemini', getApiKey('gemini'))}`,
+                    hint: "For agent coding"
+                },
+                {
+                    value: "claudeKey",
+                    label: `🔑 Claude API: ${formatApiKeyStatus('claude', getApiKey('claude'))}`,
+                    hint: "Alternative AI provider"
+                },
+                {
+                    value: "testOptimization",
+                    label: "🧪 Test AI Optimization",
+                    hint: "Verify SelfEvolution integration"
+                },
+                { value: "back", label: "← Back", hint: "Return to main menu" }
+            ]
+        });
+
+        if (p.isCancel(action) || action === "back") {
+            return;
+        }
+
+        switch (action) {
+            case "autoLearn": {
+                const newValue = toggleAutoLearning();
+                p.note(
+                    `Auto-Learning is now ${newValue ? pc.green("ON") : pc.red("OFF")}`,
+                    "Setting Updated"
+                );
+                break; // Continue loop to show menu again
+            }
+            case "autoUpdate": {
+                const newValue = toggleAutoUpdating();
+                if (newValue) {
+                    p.note(
+                        `Auto-Updating is now ${pc.green("ON")}\n\n` +
+                        `When patterns become valuable, Agent will:\n` +
+                        `• Analyze learned lessons\n` +
+                        `• Generate update proposals\n` +
+                        `• Notify you for approval`,
+                        "Setting Updated"
+                    );
+                } else {
+                    p.note(
+                        `Auto-Updating is now ${pc.red("OFF")}`,
+                        "Setting Updated"
+                    );
+                }
+                break; // Continue loop
+            }
+            case "threshold": {
+                const newThreshold = await p.text({
+                    message: "Set new threshold (1-20):",
+                    placeholder: "5",
+                    initialValue: String(settings.updateThreshold),
+                    validate: (value) => {
+                        const num = parseInt(value);
+                        if (isNaN(num) || num < 1 || num > 20) {
+                            return "Please enter a number between 1 and 20";
+                        }
+                    }
+                });
+
+                if (!p.isCancel(newThreshold)) {
+                    settings.updateThreshold = parseInt(newThreshold);
+                    saveSettings(settings);
+                    p.note(
+                        `Update threshold set to ${settings.updateThreshold}`,
+                        "Setting Updated"
+                    );
+                }
+                break; // Continue loop
+            }
+            case "geminiKey":
+            case "claudeKey": {
+                const provider = action === "geminiKey" ? "gemini" : "claude";
+                const providerName = provider.charAt(0).toUpperCase() + provider.slice(1);
+                const currentKey = getApiKey(provider);
+
+                // Ask user action
+                const keyAction = await p.select({
+                    message: `${providerName} API Key:`,
+                    options: [
+                        { value: "set", label: "Set/Update Key", hint: "Configure API key" },
+                        ...(currentKey ? [{ value: "remove", label: "Remove Key", hint: "Clear stored key" }] : []),
+                        { value: "cancel", label: "Cancel", hint: "Go back" }
+                    ]
+                });
+
+                if (p.isCancel(keyAction) || keyAction === "cancel") {
+                    break; // Return to settings menu
+                }
+
+                if (keyAction === "set") {
+                    const apiKey = await p.password({
+                        message: `Enter ${providerName} API Key:`,
+                        mask: "*",
+                        validate: (value) => {
+                            if (!value || value.length < 10) {
+                                return "API key must be at least 10 characters";
+                            }
+                        }
+                    });
+
+                    if (!p.isCancel(apiKey)) {
+                        const success = setApiKey(provider, apiKey);
+                        if (success) {
+                            p.note(
+                                `${providerName} API key ${currentKey ? 'updated' : 'set'} successfully!\n\n` +
+                                `Key: ${maskApiKey(apiKey)}\n` +
+                                `Stored in: .agent/knowledge/settings.yaml`,
+                                pc.green("✓ API Key Saved")
+                            );
+                        } else {
+                            p.note(
+                                `Failed to save ${providerName} API key`,
+                                pc.red("✗ Error")
+                            );
+                        }
+                    }
+                } else if (keyAction === "remove") {
+                    const confirm = await p.confirm({
+                        message: `Remove ${providerName} API key?`,
+                    });
+
+                    if (confirm && !p.isCancel(confirm)) {
+                        removeApiKey(provider);
+                        p.note(
+                            `${providerName} API key removed`,
+                            "Key Removed"
+                        );
+                    }
+                }
+                break;
+            }
+            case "testOptimization": {
+                const { exportApiKeysToSelfEvolution, verifySelfEvolutionAccess } =
+                    await import('../selfevolution-bridge.js');
+
+                // Step 1: Export keys
+                const spinner = p.spinner();
+                spinner.start('Exporting API keys to SelfEvolution...');
+
+                const exportResult = exportApiKeysToSelfEvolution();
+
+                if (!exportResult.success) {
+                    spinner.stop('Export failed');
+                    p.note(
+                        `❌ No API keys configured\n\n` +
+                        `Please set Gemini or Claude API key first.\n\n` +
+                        `Reason: ${exportResult.reason}`,
+                        pc.red('✗ Cannot Test')
+                    );
+                    break;
+                }
+
+                spinner.message('Keys exported. Verifying Python access...');
+
+                // Step 2: Verify Python can access
+                const verifyResult = await verifySelfEvolutionAccess();
+
+                if (verifyResult.success && verifyResult.keyDetected) {
+                    spinner.stop('Verification complete');
+
+                    const exportedKeys = [];
+                    if (exportResult.exported.gemini) exportedKeys.push('Gemini');
+                    if (exportResult.exported.claude) exportedKeys.push('Claude');
+
+                    p.note(
+                        `✅ **API Key Integration Working!**\n\n` +
+                        `Exported: ${exportedKeys.join(', ')}\n` +
+                        `Location: ${exportResult.path}\n\n` +
+                        `SelfEvolution can now:\n` +
+                        `• Auto-learn from mistakes\n` +
+                        `• AI-powered lesson optimization\n` +
+                        `• Self-improve knowledge base\n\n` +
+                        `${pc.dim('Python Output:')}\n${pc.dim(verifyResult.output)}`,
+                        pc.green('✓ Optimization Ready')
+                    );
+                } else {
+                    spinner.stop('Verification failed');
+                    p.note(
+                        `⚠️ **Export OK, but verification failed**\n\n` +
+                        `Keys exported to: ${exportResult.path}\n` +
+                        `But Python script couldn't detect them.\n\n` +
+                        `Error: ${verifyResult.error || 'Unknown'}\n\n` +
+                        `Possible causes:\n` +
+                        `• Python not installed\n` +
+                        `• SelfEvolution scripts missing\n` +
+                        `• Environment variable issue`,
+                        pc.yellow('⚠ Partial Success')
+                    );
+                }
+                break;
+            }
+        }
+    }
+}
+
+export default runSettingsUI;