kiku-agent 1.0.0

package/server/agent/commands.js

@@ -0,0 +1,788 @@
+import { toolsSchema, executeTool } from './tools.js';
+import { audioPlayer } from './audioPlayer.js';
+import { ensureYouTubeCookies, resetCookieCheck, getCookieStatus } from './youtubeAuth.js';
+import { AgentMemory } from './memory.js';
+import { C, UI_ICONS, printSolidPanel, randomFanName } from './ui.js';
+import { COMMAND_NAMES } from './commandRegistry.js';
+import { THEMES, THEME_NAMES, ansiBackground, ansiForeground, getThemeName, setTheme } from './theme.js';
+
+function levenshteinDistance(a, b) {
+  const matrix = Array.from({ length: a.length + 1 }, () => Array(b.length + 1).fill(0));
+  for (let i = 0; i <= a.length; i++) matrix[i][0] = i;
+  for (let j = 0; j <= b.length; j++) matrix[0][j] = j;
+  for (let i = 1; i <= a.length; i++) {
+    for (let j = 1; j <= b.length; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      matrix[i][j] = Math.min(
+        matrix[i - 1][j] + 1,
+        matrix[i][j - 1] + 1,
+        matrix[i - 1][j - 1] + cost
+      );
+    }
+  }
+  return matrix[a.length][b.length];
+}
+
+const VALID_COMMANDS = [...COMMAND_NAMES, '/export'];
+
+export function findClosestCommand(cmd) {
+  let closest = null;
+  let minDistance = Infinity;
+  for (const vc of VALID_COMMANDS) {
+    const dist = levenshteinDistance(cmd.toLowerCase(), vc);
+    if (dist < minDistance) {
+      minDistance = dist;
+      closest = vc;
+    }
+  }
+  return minDistance <= 3 ? closest : null;
+}
+
+export function fuzzyMatchTools(query) {
+  if (!query) return toolsSchema.map(t => ({ tool: t, score: 10 }));
+  const q = query.toLowerCase();
+  const qWords = q.split(/\s+/).filter(Boolean);
+
+  const scored = toolsSchema.map(t => {
+    const name = t.function.name.toLowerCase();
+    const desc = (t.function.description || '').toLowerCase();
+    let score = 0;
+
+    if (name === q) score = 200;
+    else if (name.startsWith(q)) score = 150;
+    else if (name.includes(q)) score = 100;
+    else if (qWords.every(w => name.includes(w))) score = 80;
+    else if (qWords.some(w => name.includes(w))) score = 65;
+    else if (qWords.every(w => desc.includes(w))) score = 50;
+    else if (qWords.some(w => desc.includes(w))) score = 40;
+    else {
+      const dist = levenshteinDistance(q, name);
+      const threshold = Math.floor(Math.min(q.length, name.length) * 0.4);
+      if (dist <= threshold && dist <= 6) score = 30 - dist * 3;
+      if (score === 0) {
+        for (const word of name.split('_')) {
+          const wd = levenshteinDistance(q, word);
+          const wThreshold = Math.floor(Math.min(q.length, word.length) * 0.4);
+          if (wd <= wThreshold && wd <= 4) {
+            score = Math.max(score, 35 - wd * 5);
+          }
+        }
+      }
+    }
+
+    return { tool: t, score };
+  });
+
+  return scored
+    .filter(s => s.score > 0)
+    .sort((a, b) => b.score - a.score);
+}
+
+export const handlers = {
+  '/exit': async (ctx) => {
+    try { await ctx.agent.endSession(); } catch {}
+    console.log(`\n  ${C.sakura}Session archived. Thank you for supporting Ju Jingyi. Goodbye. (鞠躬 ~ 谢谢!)${C.reset}\n`);
+    return 'EXIT';
+  },
+
+  '/help': async (ctx) => {
+    const sub = ctx.extra || '';
+    ctx.printHelp(sub);
+    return 'HANDLED';
+  },
+
+  '/details': async (ctx) => {
+    ctx.printQueryDetails(ctx.sub || '');
+    return 'HANDLED';
+  },
+
+  '/history': async (ctx) => {
+    const { agent, sub, extra } = ctx;
+    if (sub === 'clear') {
+      agent.session.messages = [];
+      agent.conversationHistory = [agent.conversationHistory[0]];
+      await agent.session.clearDisk().catch(() => {});
+      console.log(`\n  ${C.emerald}[OK] Chat history cleared.${C.reset}\n`);
+      return 'HANDLED';
+    }
+
+    if (sub === 'search' && extra) {
+      const q = extra.toLowerCase().trim();
+      const matches = [];
+      for (const msg of agent.session.messages) {
+        const textPart = msg.parts.find(p => p.type === 'text');
+        if (textPart && textPart.content.toLowerCase().includes(q)) {
+          matches.push({ role: msg.role, text: textPart.content, createdAt: msg.createdAt });
+        }
+      }
+      printSolidPanel({
+        title: `History Search Results for "${extra}" (${matches.length} matches)`,
+        lines: matches.length === 0
+          ? [`${C.dim}No messages found matching "${extra}".${C.reset}`]
+          : matches.map(m => {
+            const prefix = m.role === 'user' ? `${C.roseGlow}User` : `${C.cyberCyan}Kiku`;
+            return `${prefix}:${C.reset} ${C.white}${m.text.slice(0, 80)}${m.text.length > 80 ? '...' : ''}${C.reset}`;
+          }),
+        headerBg: '\x1b[48;2;48;54;70m',
+        bg: '\x1b[48;2;36;40;52m'
+      });
+      return 'HANDLED';
+    }
+
+    let count = 10;
+    if (sub && !isNaN(parseInt(sub))) count = Math.min(parseInt(sub), 50);
+
+    const recentMessages = agent.session.messages.slice(-count);
+    if (recentMessages.length === 0) {
+      console.log(`\n  ${C.dim}No conversation history yet.${C.reset}\n`);
+      return 'HANDLED';
+    }
+
+    const lines = [];
+    for (const msg of recentMessages) {
+      if (msg.role === 'user') {
+        const textPart = msg.parts.find(p => p.type === 'text');
+        if (textPart) {
+          lines.push(`${C.roseGlow}${C.bold}${randomFanName()}:${C.reset} ${C.white}${textPart.content}${C.reset}`);
+        }
+      } else if (msg.role === 'assistant') {
+        const textPart = msg.parts.find(p => p.type === 'text');
+        if (textPart) {
+          const preview = textPart.content.length > 120 ? textPart.content.slice(0, 120) + '…' : textPart.content;
+          lines.push(`${C.cyberCyan}${C.bold}Kiku:${C.reset} ${C.white}${preview.replace(/\n/g, ' ')}${C.reset}`);
+        }
+      }
+    }
+    printSolidPanel({
+      title: `Conversation History (last ${recentMessages.length} messages)`,
+      lines,
+      headerBg: '\x1b[48;2;48;54;70m',
+      bg: '\x1b[48;2;36;40;52m'
+    });
+    return 'HANDLED';
+  },
+
+  '/session': async (ctx) => {
+    const { agent, sub } = ctx;
+    const sess = agent.session;
+    const action = (sub || 'info').toLowerCase();
+
+    if (action === 'info' || !action) {
+      const msgCount = sess.messages.length;
+      const userMsgs = sess.messages.filter(m => m.role === 'user').length;
+      const assistantMsgs = sess.messages.filter(m => m.role === 'assistant').length;
+      const toolCalls = sess.stats.totalToolCalls || 0;
+      const totalDur = ((sess.stats.totalDurationMs || 0) / 1000).toFixed(1);
+      const createdAt = sess.createdAt ? sess.createdAt.toLocaleString() : 'unknown';
+
+      printSolidPanel({
+        title: `Active Session Details`,
+        lines: [
+          `${C.gold}Session ID:${C.reset}      ${C.white}${sess.id}${C.reset}`,
+          `${C.gold}Created At:${C.reset}      ${C.white}${createdAt}${C.reset}`,
+          `${C.gold}Total Messages:${C.reset}  ${C.cyberCyan}${msgCount}${C.reset} total ${C.dim}(${userMsgs} user, ${assistantMsgs} assistant)${C.reset}`,
+          `${C.gold}Total Queries:${C.reset}   ${C.cyberCyan}${sess.stats.totalQueries}${C.reset}`,
+          `${C.gold}Tool Calls:${C.reset}      ${C.cyberCyan}${toolCalls}${C.reset}`,
+          `${C.gold}Total Duration:${C.reset}  ${C.cyberCyan}${totalDur}s${C.reset}`,
+          `${C.gold}Thinking Mode:${C.reset}   ${C.bold}${C.gold}${sess.thinkingMode.toUpperCase()}${C.reset}`
+        ],
+        headerBg: '\x1b[48;2;48;54;70m',
+        bg: '\x1b[48;2;36;40;52m'
+      });
+      return 'HANDLED';
+    }
+
+    if (action === 'list') {
+      const sessions = agent.memory.getArchivedSessions(15);
+      printSolidPanel({
+        title: `Archived Sessions (Total: ${sessions.length})`,
+        lines: sessions.length === 0
+          ? [`${C.dim}No archived sessions found.${C.reset}`]
+          : sessions.map(s => {
+            const date = new Date(s.createdAt).toLocaleString();
+            const dur = ((s.stats?.totalDurationMs || 0) / 1000).toFixed(1);
+            return `${C.gold}${s.id}${C.reset} ${C.dim}(${date})${C.reset} — ${s.messageCount} msgs, ${dur}s`;
+          }),
+        headerBg: '\x1b[48;2;48;54;70m',
+        bg: '\x1b[48;2;36;40;52m'
+      });
+      return 'HANDLED';
+    }
+
+    if (action === 'export') {
+      const exported = await agent.session.exportToMarkdown();
+      console.log(`\n  ${C.emerald}[OK] Session transcript exported.${C.reset}`);
+      console.log(`  ${C.slate}• File:${C.reset} ${C.white}${exported.filePath}${C.reset}\n`);
+      return 'HANDLED';
+    }
+
+    if (action === 'clear' || action === 'new' || action === 'reset') {
+      await agent.endSession();
+      console.log(`\n  ${C.emerald}[OK] Previous session archived. Started fresh.${C.reset}\n`);
+      return 'HANDLED';
+    }
+
+    console.log(`\n  ${C.amber}Unknown session action: "${sub}". Use /session [info|list|export|clear]${C.reset}\n`);
+    return 'HANDLED';
+  },
+
+  '/thinking': async (ctx) => {
+    const { agent, sub } = ctx;
+    const targetMode = (sub || '').toLowerCase();
+    if (targetMode === 'show' || targetMode === 'hide') {
+      agent.session.setThinkingMode(targetMode);
+      console.log(`\n  ${C.emerald}[OK] Thinking mode set to ${C.bold}${targetMode.toUpperCase()}${C.reset}\n`);
+    } else {
+      const current = agent.session.toggleThinkingMode();
+      console.log(`\n  ${C.emerald}[OK] Thinking mode toggled to ${C.bold}${current.toUpperCase()}${C.reset}\n`);
+    }
+    return 'HANDLED';
+  },
+
+  '/lang': async (ctx) => {
+    const { agent, sub } = ctx;
+    const langArg = (sub || '').toLowerCase();
+    if (langArg === 'th' || langArg === 'zh' || langArg === 'en' || langArg === 'auto') {
+      agent.memory.setPreference('language', langArg === 'auto' ? null : langArg);
+      const langNames = { th: 'Thai', zh: 'Chinese', en: 'English', auto: 'Auto-detect' };
+      console.log(`\n  ${C.emerald}[OK] Language updated to:${C.reset} ${C.bold}${C.white}${langNames[langArg]}${C.reset}\n`);
+    } else {
+      const current = agent.memory.preferences.language || 'auto';
+      printSolidPanel({
+        title: `Language Preference`,
+        lines: [`${C.gold}Current:${C.reset} ${C.bold}${C.white}${current.toUpperCase()}${C.reset}`, `${C.dim}Usage: /lang [th|zh|en|auto]${C.reset}`],
+        headerBg: '\x1b[48;2;48;54;70m', bg: '\x1b[48;2;36;40;52m'
+      });
+    }
+    return 'HANDLED';
+  },
+
+  '/theme': async (ctx) => {
+    const action = (ctx.sub || 'current').toLowerCase();
+    const current = getThemeName();
+
+    if (action === 'list') {
+      printSolidPanel({
+        title: `Themes (${THEME_NAMES.length})`,
+        lines: THEME_NAMES.map(name => {
+          const theme = THEMES[name];
+          const marker = name === current ? '[x]' : '[ ]';
+          const sample = ansiForeground(theme.colors.primary);
+          const preview = `${ansiBackground(theme.colors.panel)}${ansiForeground(theme.colors.text)}${C.bold} Aa ${C.reset}`;
+          return `${marker} ${preview} ${sample}${C.bold}${name.padEnd(12)}${C.reset} ${C.dim}${theme.description}${C.reset}`;
+        }),
+      });
+      return 'HANDLED';
+    }
+
+    if (action === 'current') {
+      const theme = THEMES[current];
+      printSolidPanel({
+        title: 'Theme',
+        lines: [
+          `${C.gold}Current:${C.reset} ${C.bold}${C.white}${theme.label} (${current})${C.reset}`,
+          `${C.dim}${theme.description}${C.reset}`,
+          `${C.sakura}Primary${C.reset}  ${C.roseGlow}Accent${C.reset}  ${C.cyberCyan}Info${C.reset}  ${C.emerald}Success${C.reset}  ${C.amber}Warning${C.reset}  ${C.red}Error${C.reset}`,
+          `${C.dim}Usage: /theme list or /theme <name>${C.reset}`,
+        ],
+      });
+      return 'HANDLED';
+    }
+
+    const requested = action === 'reset' ? 'sakura' : action;
+    const theme = setTheme(requested);
+    if (!theme) {
+      console.log(`\n  ${C.amber}Unknown theme: "${action}".${C.reset}`);
+      console.log(`  ${C.dim}Available: ${THEME_NAMES.join(', ')}${C.reset}\n`);
+      return 'HANDLED';
+    }
+
+    printSolidPanel({
+      title: 'Theme Updated',
+      lines: [
+        `${C.emerald}[OK] Active theme: ${C.bold}${theme.label} (${requested})${C.reset}`,
+        `${C.dim}${theme.description}${C.reset}`,
+        `${C.sakura}Primary${C.reset}  ${C.roseGlow}Accent${C.reset}  ${C.cyberCyan}Info${C.reset}  ${C.emerald}Success${C.reset}  ${C.amber}Warning${C.reset}  ${C.red}Error${C.reset}`,
+        `${C.dim}Saved for future Kiku Agent sessions.${C.reset}`,
+      ],
+    });
+    return 'HANDLED';
+  },
+
+  '/tool': async (ctx) => {
+    const { sub, extra } = ctx;
+    const toolName = sub;
+    const rawArgs = extra || '';
+
+    if (!toolName) {
+      console.log(`\n  ${C.amber}Usage: /tool <tool_name> [args]${C.reset}\n`);
+      return 'HANDLED';
+    }
+
+    const schema = toolsSchema.find(t => t.function.name.toLowerCase() === toolName.toLowerCase());
+    if (!schema) {
+      console.log(`\n  ${C.red}Unknown tool: "${toolName}". Use /tools to view all.${C.reset}\n`);
+      return 'HANDLED';
+    }
+
+    const actualToolName = schema.function.name;
+
+    if (!rawArgs || !rawArgs.trim()) {
+      const props = schema.function.parameters?.properties || {};
+      const required = schema.function.parameters?.required || [];
+      console.log(`\n  ${C.gold}Tool:${C.reset} ${C.bold}${C.cyberCyan}${actualToolName}${C.reset}`);
+      console.log(`  ${C.gold}Description:${C.reset} ${C.white}${schema.function.description}${C.reset}`);
+      for (const [pName, pMeta] of Object.entries(props)) {
+        const reqStr = required.includes(pName) ? `${C.red}[required]${C.reset}` : `${C.dim}[optional]${C.reset}`;
+        console.log(`    • ${C.bold}${pName}${C.reset} (${pMeta.type || 'any'}) ${reqStr}: ${pMeta.description || ''}`);
+      }
+      console.log(`\n`);
+      return 'HANDLED';
+    }
+
+    let parsedArgs = {};
+    if (rawArgs.startsWith('{') && rawArgs.endsWith('}')) {
+      try { parsedArgs = JSON.parse(rawArgs); } catch { parsedArgs = { query: rawArgs }; }
+    } else {
+      const props = schema.function.parameters?.properties || {};
+      const firstProp = Object.keys(props)[0] || 'query';
+      parsedArgs = { [firstProp]: rawArgs };
+    }
+
+    console.log(`\n  ${C.cyberCyan}[RUNNING] ${C.bold}${actualToolName}${C.reset}...`);
+    const start = Date.now();
+    try {
+      const result = await executeTool(actualToolName, parsedArgs);
+      const dur = ((Date.now() - start) / 1000).toFixed(2);
+      console.log(`  ${C.emerald}[OK] Completed in ${dur}s${C.reset}`);
+      console.log(JSON.stringify(result, null, 2));
+      console.log('');
+    } catch (err) {
+      console.log(`  ${C.red}[ERROR] ${err.message}${C.reset}\n`);
+    }
+    return 'HANDLED';
+  },
+
+  '/tools': async (ctx) => {
+    const filter = (ctx.sub || '').toLowerCase().trim();
+    const filtered = filter
+      ? toolsSchema.filter(t => t.function.name.toLowerCase().includes(filter) || t.function.description.toLowerCase().includes(filter))
+      : toolsSchema;
+
+    console.log(`\n  ${C.bold}${C.sakura}Registered Tools (${filtered.length}/${toolsSchema.length})${C.reset}\n`);
+    for (const [idx, t] of filtered.entries()) {
+      const f = t.function;
+      const params = Object.keys(f.parameters?.properties || {}).join(', ');
+      console.log(`  ${C.gold}${String(idx + 1).padStart(2)}. ${C.bold}${C.cyberCyan}${f.name}${C.reset}${C.slate}(${params})${C.reset}`);
+      console.log(`      ${C.dim}${C.roseGlow}${f.description}${C.reset}`);
+    }
+    console.log(`\n`);
+    return 'HANDLED';
+  },
+
+  '/mem': async (ctx) => {
+    const { agent, sub, extra, parts } = ctx;
+    const memAction = (sub || '').toLowerCase();
+
+    if (memAction === 'add') {
+      const factText = (parts || []).slice(2).join(' ').trim();
+      if (!factText) {
+        console.log(`\n  ${C.amber}Usage: /mem add <fact>${C.reset}\n`);
+      } else {
+        const entry = agent.memory.addFact(factText, { source: 'user' });
+        console.log(`\n  ${C.emerald}[OK] Saved:${C.reset} ${C.white}${factText.slice(0, 80)}${C.reset} (ID: ${entry.id})\n`);
+      }
+      return 'HANDLED';
+    }
+
+    if (memAction === 'del' || memAction === 'rm') {
+      const factId = (parts || [])[2]?.trim();
+      if (!factId) {
+        console.log(`\n  ${C.amber}Usage: /mem del <fact_id>${C.reset}\n`);
+      } else if (agent.memory.removeFact(factId)) {
+        console.log(`\n  ${C.emerald}[OK] Removed [${factId}]${C.reset}\n`);
+      } else {
+        console.log(`\n  ${C.red}Not found [${factId}]${C.reset}\n`);
+      }
+      return 'HANDLED';
+    }
+
+    if (memAction === 'search') {
+      const query = (parts || []).slice(2).join(' ').trim();
+      if (!query) {
+        console.log(`\n  ${C.amber}Usage: /mem search <keyword>${C.reset}\n`);
+      } else {
+        const results = agent.memory.searchFacts(query);
+        printSolidPanel({
+          title: `Memory Search: "${query}" (${results.length})`,
+          lines: results.map(fact => `${C.white}${fact.content.slice(0, 65)}${C.reset} ${C.dim}(${fact.id})${C.reset}`),
+        });
+      }
+      return 'HANDLED';
+    }
+
+    if (memAction === 'list') {
+      const grouped = agent.memory.getFactsByCategory();
+      const factLines = [];
+      for (const [cat, facts] of Object.entries(grouped)) {
+        factLines.push(`${C.bold}${C.cyberCyan}${cat.toUpperCase()}${C.reset} (${facts.length})`);
+        for (const fact of facts.slice(0, 6)) {
+          factLines.push(` • ${C.white}${fact.content.slice(0, 65)}${C.reset}`);
+        }
+      }
+      printSolidPanel({ title: 'Stored Facts', lines: factLines });
+      return 'HANDLED';
+    }
+
+    if (memAction === 'topics') {
+      const topics = agent.memory.getTopTopics(10);
+      printSolidPanel({
+        title: 'Topic Profile',
+        lines: topics.map(t => {
+        const bar = '█'.repeat(Math.min(t.count, 15));
+          return `${C.gold}${t.topic.padEnd(14)}${C.reset} ${C.cyberCyan}${bar}${C.reset} ${C.dim}(${t.count}x)${C.reset}`;
+        }),
+      });
+      return 'HANDLED';
+    }
+
+    if (memAction === 'export') {
+      const exported = await agent.memory.exportToJSON();
+      console.log(`\n  ${C.emerald}[OK] Memory exported.${C.reset} ${C.white}${exported.filePath}${C.reset}\n`);
+      return 'HANDLED';
+    }
+
+    if (memAction === 'import') {
+      const filePath = (parts || []).slice(2).join(' ').trim();
+      if (!filePath) {
+        console.log(`\n  ${C.amber}Usage: /mem import <path>${C.reset}\n`);
+      } else {
+        const result = await agent.memory.importFromJSON(filePath);
+        if (result.success) {
+          console.log(`\n  ${C.emerald}[OK] Imported ${result.factsImported} facts.${C.reset}\n`);
+        } else {
+          console.log(`\n  ${C.red}[ERROR] ${result.message}${C.reset}\n`);
+        }
+      }
+      return 'HANDLED';
+    }
+
+    if (memAction === 'clear') {
+      await agent.memory.clearAll();
+      console.log(`\n  ${C.emerald}[OK] Memory cleared.${C.reset}\n`);
+      return 'HANDLED';
+    }
+
+    const memStatus = agent.memory.getStatus();
+    printSolidPanel({
+      title: 'Memory Status',
+      lines: [`${C.gold}Facts:${C.reset} ${C.cyberCyan}${memStatus.factsCount}${C.reset}  ${C.gold}Sessions:${C.reset} ${C.cyberCyan}${memStatus.sessionsCount}${C.reset}`],
+    });
+    return 'HANDLED';
+  },
+
+  '/play': async (ctx) => {
+    const songName = ctx.extra || '';
+    if (!songName) {
+      console.log(`\n  ${C.amber}Usage: /play <song name>${C.reset}\n`);
+    } else {
+      await audioPlayer.play(songName);
+      console.log(`\n  ${C.emerald}[OK] Playing: ${C.white}${songName}${C.reset}\n`);
+    }
+    return 'HANDLED';
+  },
+
+  '/stop': async () => { await audioPlayer.stop(); console.log(`\n  ${C.emerald}[OK] Stopped${C.reset}\n`); return 'HANDLED'; },
+  '/pause': async () => { const r = await audioPlayer.pause(); console.log(`\n  ${C.emerald}${r}${C.reset}\n`); return 'HANDLED'; },
+  '/resume': async () => { const r = await audioPlayer.resume(); console.log(`\n  ${C.emerald}${r}${C.reset}\n`); return 'HANDLED'; },
+  '/next': async () => { const r = await audioPlayer.next(); console.log(`\n  ${C.emerald}${r}${C.reset}\n`); return 'HANDLED'; },
+  '/prev': async () => { const r = await audioPlayer.prev(); console.log(`\n  ${C.emerald}${r}${C.reset}\n`); return 'HANDLED'; },
+  '/mute': async () => { const r = await audioPlayer.mute(); console.log(`\n  ${C.emerald}${r}${C.reset}\n`); return 'HANDLED'; },
+  '/unmute': async () => { const r = await audioPlayer.unmute(); console.log(`\n  ${C.emerald}${r}${C.reset}\n`); return 'HANDLED'; },
+
+  '/add': async (ctx) => {
+    const song = ctx.extra || '';
+    if (!song) { console.log(`\n  ${C.amber}Usage: /add <song>${C.reset}\n`); }
+    else { const r = await audioPlayer.addToQueue(song); console.log(`\n  ${C.emerald}${r}${C.reset}\n`); }
+    return 'HANDLED';
+  },
+
+  '/remove': async (ctx) => {
+    const index = parseInt(ctx.sub, 10);
+    if (isNaN(index)) { console.log(`\n  ${C.amber}Usage: /remove <index>${C.reset}\n`); }
+    else { const r = await audioPlayer.removeFromQueue(index); console.log(`\n  ${C.emerald}${r}${C.reset}\n`); }
+    return 'HANDLED';
+  },
+
+  '/clearqueue': async () => { const r = await audioPlayer.clearQueue(); console.log(`\n  ${C.emerald}${r}${C.reset}\n`); return 'HANDLED'; },
+
+  '/search': async (ctx) => {
+    const q = ctx.extra || '';
+    if (!q) { console.log(`\n  ${C.amber}Usage: /search <query>${C.reset}\n`); return 'HANDLED'; }
+    try {
+      const results = await audioPlayer.searchYouTube(q);
+      if (results.length === 0) { console.log(`\n  ${C.amber}No results for "${q}"${C.reset}\n`); }
+      else {
+        printSolidPanel({
+          title: `YouTube: "${q}" (${results.length})`,
+          lines: results.map((r, i) => `${C.gold}${i + 1}.${C.reset} ${C.white}${r.title}${C.reset} ${C.dim}(${r.duration})${C.reset}`),
+          headerBg: '\x1b[48;2;48;54;70m', bg: '\x1b[48;2;36;40;52m'
+        });
+      }
+    } catch (err) { console.log(`\n  ${C.red}${err.message}${C.reset}\n`); }
+    return 'HANDLED';
+  },
+
+  '/current': async () => {
+    const state = audioPlayer.getFullState();
+    if (!state.isPlaying && !state.isPaused) {
+      console.log(`\n  ${C.slate}No music playing.${C.reset}\n`);
+    } else {
+      printSolidPanel({
+        title: `${UI_ICONS.music} Current Track`,
+        lines: [
+          `${C.gold}Track:${C.reset} ${C.white}${state.currentTrack}${C.reset}`,
+          `${C.gold}Status:${C.reset} ${state.isPaused ? C.amber + 'Paused' : C.emerald + 'Playing'}${C.reset}`,
+          `${C.gold}Queue:${C.reset} ${C.cyberCyan}${state.queueLength} songs${C.reset}`
+        ],
+        headerBg: '\x1b[48;2;48;54;70m', bg: '\x1b[48;2;36;40;52m'
+      });
+    }
+    return 'HANDLED';
+  },
+
+  '/retry': async (ctx) => {
+    if (!ctx.lastQuery) {
+      console.log(`\n  ${C.amber}No previous query.${C.reset}\n`);
+      return 'HANDLED';
+    }
+    return 'RETRY';
+  },
+
+  '/clear': async (ctx) => {
+    try { await ctx.agent.endSession(); } catch {}
+    console.clear();
+    ctx.printWelcome();
+    console.log(`  ${C.emerald}[OK] Fresh start.${C.reset}\n`);
+    return 'HANDLED';
+  },
+
+  '/save': async (ctx) => {
+    const exported = await ctx.agent.session.exportToMarkdown();
+    console.log(`\n  ${C.emerald}[OK] Exported.${C.reset} ${C.white}${exported.filePath}${C.reset}\n`);
+    return 'HANDLED';
+  },
+
+  '/model': async (ctx) => {
+    const liveCheck = await ctx.client.checkConnection();
+    printSolidPanel({
+      title: `LM Studio Diagnostics`,
+      lines: [
+        `${C.gold}Status:${C.reset} ${liveCheck.connected ? C.emerald + '● Online' : C.red + '○ Offline'}${C.reset}`,
+        `${C.gold}Model:${C.reset}  ${C.bold}${C.white}${liveCheck.activeModel || 'None'}${C.reset}`,
+        `${C.gold}URL:${C.reset}   ${C.cyberCyan}${ctx.baseUrl}${C.reset}`
+      ],
+      headerBg: '\x1b[48;2;48;54;70m', bg: '\x1b[48;2;36;40;52m'
+    });
+    return 'HANDLED';
+  },
+
+  '/ping': async (ctx) => {
+    const start = Date.now();
+    const check = await ctx.client.checkConnection();
+    const ms = Date.now() - start;
+    if (check.connected) {
+      console.log(`\n  ${C.emerald}● Connected${C.reset} ${C.dim}(${ms}ms)${C.reset} — ${C.white}${check.activeModel}${C.reset}\n`);
+    } else {
+      console.log(`\n  ${C.red}● Disconnected${C.reset} ${C.dim}(${ms}ms)${C.reset}\n`);
+    }
+    return 'HANDLED';
+  },
+
+  '/config': async (ctx) => {
+    const { config } = await import('./config.js');
+    printSolidPanel({
+      title: `Configuration`,
+      lines: [
+        `${C.gold}URL:${C.reset}      ${C.cyberCyan}${ctx.baseUrl}${C.reset}`,
+        `${C.gold}Model:${C.reset}     ${C.white}${config.lmStudio.model}${C.reset}`,
+        `${C.gold}Theme:${C.reset}     ${C.white}${getThemeName()}${C.reset}`,
+        `${C.gold}Max Iters:${C.reset} ${C.white}${ctx.agent.maxIterations}${C.reset}`,
+        `${C.gold}Window:${C.reset}    ${C.white}${ctx.agent.slidingWindowSize}${C.reset}`,
+        `${C.gold}Tools:${C.reset}     ${C.cyberCyan}${toolsSchema.length}${C.reset}`
+      ],
+      headerBg: '\x1b[48;2;48;54;70m', bg: '\x1b[48;2;36;40;52m'
+    });
+    return 'HANDLED';
+  },
+
+  '/version': async () => {
+    printSolidPanel({
+      title: 'Version',
+      lines: [
+        `${C.gold}Version:${C.reset} ${C.white}1.0.0${C.reset}`,
+        `${C.gold}Node:${C.reset}    ${C.white}${process.version}${C.reset}`,
+        `${C.gold}Platform:${C.reset} ${C.white}${process.platform} ${process.arch}${C.reset}`,
+      ],
+    });
+    return 'HANDLED';
+  },
+
+  '/system': async () => {
+    const os = await import('node:os');
+    const mem = process.memoryUsage();
+    printSolidPanel({
+      title: 'System',
+      lines: [
+        `${C.gold}OS:${C.reset}   ${C.white}${os.default.platform()} ${os.default.release()}${C.reset}`,
+        `${C.gold}CPU:${C.reset}  ${C.white}${os.default.cpus().length} cores${C.reset}`,
+        `${C.gold}RAM:${C.reset}  ${C.white}${(os.default.totalmem() / 1073741824).toFixed(1)} GB${C.reset}`,
+        `${C.gold}Heap:${C.reset} ${C.white}${(mem.heapUsed / 1048576).toFixed(1)} MB${C.reset}`,
+      ],
+    });
+    return 'HANDLED';
+  },
+
+  '/about': async () => {
+    printSolidPanel({
+      title: 'About Kiku AI Agent',
+      lines: [
+        `${C.white}Intelligent assistant for Ju Jingyi (鞠婧祎)${C.reset}`,
+        `${C.gold}Engine:${C.reset} ${C.white}LM Studio + Gemma 4${C.reset}`,
+        `${C.gold}Tools:${C.reset} ${C.white}${toolsSchema.length} registered${C.reset}`,
+        `${C.gold}Languages:${C.reset} ${C.white}TH, ZH, EN (auto)${C.reset}`,
+      ],
+    });
+    return 'HANDLED';
+  },
+
+  '/login': async (ctx) => {
+    console.log(`\n  ${C.cyberCyan}YouTube Login${C.reset}\n`);
+    resetCookieCheck();
+    const result = await ensureYouTubeCookies({ timeout: 180000 });
+    if (result.ok) {
+      console.log(`  ${C.emerald}[OK] Session active (${result.source}).${C.reset}\n`);
+    } else {
+      console.log(`  ${C.red}[ERROR] Not available: ${result.reason}${C.reset}\n`);
+    }
+    return 'HANDLED';
+  },
+
+  '/ytstatus': async () => {
+    const status = getCookieStatus();
+    const ensured = status.ensured;
+    printSolidPanel({
+      title: 'YouTube Status',
+      lines: [
+        `${C.gold}Browser:${C.reset} ${status.envBrowser ? C.emerald + status.envBrowser : C.dim + 'n/a'}${C.reset}`,
+        `${C.gold}Cookies:${C.reset} ${status.envCookies ? C.emerald + status.envCookies : C.dim + 'n/a'}${C.reset}`,
+        `${C.gold}Status:${C.reset}  ${ensured ? (ensured.ok ? C.emerald + '[OK]' : C.red + '[ERROR] Failed') : C.dim + 'Unchecked'}${C.reset}`
+      ],
+      headerBg: '\x1b[48;2;48;54;70m', bg: '\x1b[48;2;36;40;52m'
+    });
+    return 'HANDLED';
+  },
+
+  '/queue': async (ctx) => {
+    const { sub } = ctx;
+    if (sub === 'clear') {
+      if (audioPlayer.isPlaying || audioPlayer.queue.length > 0) {
+        console.log(`\n  ${C.emerald}${await audioPlayer.clearQueue()}${C.reset}\n`);
+      } else {
+        ctx.clearQueryQueue();
+        console.log(`\n  ${C.emerald}[OK] Execution queue cleared.${C.reset}\n`);
+      }
+    } else if (audioPlayer.isPlaying || audioPlayer.queue.length > 0) {
+      const queue = audioPlayer.getQueue();
+      printSolidPanel({
+        title: `${UI_ICONS.music} Queue (${queue.length})`,
+        lines: queue.map((item, idx) => `${item.isCurrent ? C.gold + '[PLAYING]' : C.dim + (idx + 1)} ${C.white}${item.title}${C.reset}`),
+        headerBg: '\x1b[48;2;48;54;70m', bg: '\x1b[48;2;36;40;52m'
+      });
+    } else {
+      const qLen = ctx.getQueryQueueLength();
+      console.log(`\n  ${C.slate}Execution queue: ${qLen} items${C.reset}\n`);
+    }
+    return 'HANDLED';
+  },
+
+  '/stats': async () => {
+    const result = await executeTool('get_system_stats', {});
+    const s = result.stats;
+    printSolidPanel({
+      title: `Database Overview`,
+      lines: [
+        `${C.gold}Works:${C.reset}     ${C.cyberCyan}${s.totalWorks}${C.reset}`,
+        `${C.gold}Songs:${C.reset}     ${C.cyberCyan}${s.totalUniqueSongs}${C.reset}`,
+        `${C.gold}Brands:${C.reset}    ${C.cyberCyan}${s.brandEndorsements}${C.reset}`,
+        `${C.gold}Awards:${C.reset}    ${C.cyberCyan}${s.totalAwards}${C.reset}`,
+        `${C.gold}Timeline:${C.reset}  ${C.cyberCyan}${s.timelineMilestones}${C.reset}`
+      ],
+      headerBg: '\x1b[48;2;48;54;70m', bg: '\x1b[48;2;36;40;52m'
+    });
+    return 'HANDLED';
+  },
+
+  '/prompt': async (ctx) => {
+    const { config } = await import('./config.js');
+    const lines = config.agent.systemPersona.split('\n').slice(0, 20).map(l => `${C.dim}${C.white}${l}${C.reset}`);
+    printSolidPanel({ title: `System Prompt`, lines, headerBg: '\x1b[48;2;48;54;70m', bg: '\x1b[48;2;36;40;52m' });
+    return 'HANDLED';
+  },
+
+  '/ads': async (ctx) => {
+    ctx.printAd();
+    return 'HANDLED';
+  },
+};
+
+const ALIASES = {
+  '/quit': '/exit', '/q': '/exit',
+  '/?': '/help', '/commands': '/help', '/menu': '/help',
+  '/hist': '/history', '/h': '/history',
+  '/sess': '/session', '/sessions': '/session',
+  '/think': '/thinking', '/th': '/thinking',
+  '/detail': '/details', '/d': '/details',
+  '/language': '/lang',
+  '/themes': '/theme',
+  '/exec': '/tool', '/call': '/tool',
+  '/toollist': '/tools',
+  '/metrics': '/stats', '/catalog': '/stats',
+  '/llm': '/model', '/engine': '/model',
+  '/health': '/ping',
+  '/settings': '/config', '/conf': '/config',
+  '/persona': '/prompt', '/sysprompt': '/prompt',
+  '/ver': '/version', '/v': '/version',
+  '/sys': '/system', '/os': '/system',
+  '/info': '/about',
+  '/sponsor': '/ads', '/ad': '/ads',
+  '/cls': '/clear', '/reset': '/clear',
+  '/export': '/save',
+  '/r': '/retry',
+};
+
+export async function routeCommand(rawInput, ctx) {
+  const trimmed = rawInput.trim();
+  if (!trimmed.startsWith('/')) return 'UNKNOWN';
+
+  const parts = trimmed.split(/\s+/);
+  let rawCmd = parts[0].toLowerCase();
+  const sub = parts[1] || '';
+  const extra = parts.slice(2).join(' ');
+
+  if (ALIASES[rawCmd]) rawCmd = ALIASES[rawCmd];
+
+  const handler = handlers[rawCmd];
+  if (!handler) {
+    const suggestion = findClosestCommand(rawCmd);
+    console.log(`\n  ${C.amber}Unknown command: "${rawCmd}"${C.reset}`);
+    if (suggestion) {
+      console.log(`  ${C.dim}Did you mean ${C.bold}${C.cyberCyan}${suggestion}${C.reset}${C.dim}?${C.reset}\n`);
+    } else {
+      console.log(`  ${C.dim}Type ${C.emerald}/help${C.reset}${C.dim} for available commands.${C.reset}\n`);
+    }
+    return 'UNKNOWN';
+  }
+
+  return await handler({ ...ctx, sub, extra, parts });
+}