kiku-agent 1.3.1 → 1.3.3

package/server/agent/tests/commands.test.js

@@ -0,0 +1,506 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { COMMAND_NAMES } from '../commandRegistry.js';
+import { handlers, routeCommand } from '../commands.js';
+import { getThemeName } from '../theme.js';
+
+const HIDDEN_LEGACY_HANDLERS = [];
+
+test('every canonical slash command has exactly one handler', () => {
+  assert.equal(new Set(COMMAND_NAMES).size, COMMAND_NAMES.length);
+  for (const name of COMMAND_NAMES) {
+    assert.equal(typeof handlers[name], 'function', `${name} must have a handler`);
+  }
+  const hidden = Object.keys(handlers).filter(name => !COMMAND_NAMES.includes(name)).sort();
+  assert.deepEqual(hidden, HIDDEN_LEGACY_HANDLERS, 'hidden legacy handlers must stay minimal');
+});
+
+test('/ads receives the router context and displays one sponsor card', async () => {
+  let calls = 0;
+  const result = await routeCommand('/ads', {
+    printAd() { calls += 1; },
+  });
+
+  assert.equal(result, 'HANDLED');
+  assert.equal(calls, 1);
+});
+
+test('/gallery displays an image through the managed TUI callback and aliases work', async () => {
+  let calls = 0;
+  const ctx = {
+    showTerminalImage() { calls += 1; return true; },
+  };
+
+  assert.equal(await routeCommand('/gallery', ctx), 'HANDLED');
+  assert.equal(await routeCommand('/image', ctx), 'HANDLED');
+  assert.equal(await routeCommand('/photo', ctx), 'HANDLED');
+  assert.equal(calls, 3);
+});
+
+test('/quiz retries the current question after a wrong managed-TUI answer', async () => {
+  const originalFetch = global.fetch;
+  const originalRandom = Math.random;
+  const originalLog = console.log;
+  const prompts = [];
+  const output = [];
+  const preferences = {};
+  let claimBody = null;
+
+  global.fetch = async (_url, options = {}) => {
+    if (!options.method) {
+      return {
+        ok: true,
+        json: async () => ({ data: { challengeToken: 'kiku_chal_test' } }),
+      };
+    }
+    claimBody = JSON.parse(options.body);
+    return {
+      json: async () => ({ status: 'success', data: { apiKey: 'kiku_vip_sk_server_test' } }),
+    };
+  };
+  Math.random = () => 0;
+  console.log = (...args) => output.push(args.join(' '));
+
+  try {
+    const result = await routeCommand('/quiz lang en', {
+      sub: 'lang',
+      extra: 'en',
+      readInput: async options => {
+        prompts.push(options);
+        return prompts.length === 1 ? 'a' : 'd';
+      },
+      agent: {
+        memory: {
+          preferences,
+          setPreference(key, value) { preferences[key] = value; },
+        },
+      },
+    });
+
+    assert.equal(result, 'HANDLED');
+    assert.equal(prompts.length, 16);
+    assert.ok(prompts.every(prompt => prompt.prompt === 'Answer ❯ '));
+    assert.ok(prompts.every(prompt => prompt.history === false && prompt.cancelValue === 'q'));
+    assert.match(output.join('\n'), /Incorrect, try again!/);
+    assert.match(output.join('\n'), /Perfect Score!/);
+    assert.equal(preferences.vipKey, 'kiku_vip_sk_server_test');
+    assert.equal(claimBody.challengeToken, 'kiku_chal_test');
+    assert.equal(claimBody.answers.length, 15);
+    assert.ok(claimBody.answers.every(answer => answer.answerIndex === 0));
+  } finally {
+    global.fetch = originalFetch;
+    Math.random = originalRandom;
+    console.log = originalLog;
+  }
+});
+
+test('/quiz can be cancelled through the managed TUI input row', async () => {
+  const originalFetch = global.fetch;
+  const originalLog = console.log;
+  const output = [];
+
+  global.fetch = async () => ({ ok: false });
+  console.log = (...args) => output.push(args.join(' '));
+
+  try {
+    const result = await routeCommand('/quiz lang en', {
+      sub: 'lang',
+      extra: 'en',
+      readInput: async () => 'q',
+      agent: { memory: { preferences: {} } },
+    });
+
+    assert.equal(result, 'HANDLED');
+    assert.match(output.join('\n'), /Quiz cancelled/);
+  } finally {
+    global.fetch = originalFetch;
+    console.log = originalLog;
+  }
+});
+
+test('/skill list and learn commands update user skills', async () => {
+  const skills = [];
+  const preferences = { userSkills: skills, skillsEnabled: true };
+  const mockMemory = {
+    preferences,
+    addUserSkill(instruction) {
+      const skill = { id: 's_test', instruction, createdAt: Date.now() };
+      skills.push(skill);
+      return skill;
+    },
+    removeUserSkill(id) {
+      const idx = skills.findIndex(s => s.id === id);
+      if (idx !== -1) { skills.splice(idx, 1); return true; }
+      return false;
+    },
+    clearUserSkills() { skills.length = 0; },
+    setPreference(key, val) { preferences[key] = val; }
+  };
+
+  const agent = { memory: mockMemory };
+  assert.equal(await routeCommand('/skill list', { agent }), 'HANDLED');
+  assert.equal(await routeCommand('/skill learn always be kind', { agent, sub: 'learn', extra: 'always be kind' }), 'HANDLED');
+  assert.equal(skills.length, 1);
+  assert.equal(await routeCommand('/skill off', { agent, sub: 'off' }), 'HANDLED');
+  assert.equal(preferences.skillsEnabled, false);
+});
+
+test('/subagent status returns gracefully when no previous run', async () => {
+  const agent = {};
+  assert.equal(await routeCommand('/subagent status', { agent, sub: 'status' }), 'HANDLED');
+});
+
+test('/research status and sources return gracefully', async () => {
+  const agent = {
+    getResearchStatus() { return { state: 'idle', question: '', workers: [], lastResult: null }; }
+  };
+  assert.equal(await routeCommand('/research status', { agent, sub: 'status' }), 'HANDLED');
+  assert.equal(await routeCommand('/research sources', { agent, sub: 'sources' }), 'HANDLED');
+});
+
+test('/clear resets TUI viewport without appending duplicate banners', async () => {
+  let ended = false;
+  const agent = { endSession: async () => { ended = true; } };
+  const mockTuiPrompt = {
+    viewportLines: ['line1', 'line2'],
+    scrollOffset: 5,
+    rendered: false,
+    addViewportLines(line) { this.viewportLines.push(line); },
+    render() { this.rendered = true; }
+  };
+
+  const res = await routeCommand('/clear', { agent, tuiPrompt: mockTuiPrompt });
+  assert.equal(res, 'HANDLED');
+  assert.equal(ended, true);
+  assert.equal(mockTuiPrompt.scrollOffset, 0);
+  assert.ok(mockTuiPrompt.viewportLines.length > 0);
+});
+
+test('/gpu and /system return handled status and display hardware information', async () => {
+  assert.equal(await routeCommand('/gpu', {}), 'HANDLED');
+  assert.equal(await routeCommand('/vram', {}), 'HANDLED');
+  assert.equal(await routeCommand('/system', {}), 'HANDLED');
+});
+
+test('/mcp status includes every connected tool command in one panel output', async () => {
+  const tools = Array.from({ length: 18 }, (_, index) => ({
+    function: {
+      name: `mcp_kiku_tool_${index + 1}`,
+      description: `Tool ${index + 1}`,
+      parameters: { type: 'object', properties: {} },
+    },
+  }));
+  const agent = {
+    mcpManager: {
+      getStatus() {
+        return {
+          activeServersCount: 1,
+          totalToolsCount: tools.length,
+          servers: [{ name: 'kiku', type: 'streamable-http', toolsCount: tools.length, resourcesCount: 5 }],
+        };
+      },
+      getToolsSchema() { return tools; },
+    },
+  };
+  const originalLog = console.log;
+  const output = [];
+  console.log = (...args) => output.push(args.join(' '));
+  try {
+    assert.equal(await routeCommand('/mcp', { agent }), 'HANDLED');
+  } finally {
+    console.log = originalLog;
+  }
+  const rendered = output.join('\n');
+  for (const tool of tools) assert.match(rendered, new RegExp(`@${tool.function.name}`));
+  assert.equal(output.length, 1, 'the panel should be emitted as one TUI batch');
+});
+
+test('/update is no longer registered or routed', async () => {
+  const originalLog = console.log;
+  console.log = () => {};
+  try {
+    assert.equal(COMMAND_NAMES.includes('/update'), false);
+    assert.equal(await routeCommand('/update check', {}), 'UNKNOWN');
+  } finally {
+    console.log = originalLog;
+  }
+});
+
+test('audioPlayer tracks playback offset and resumes from saved position', async () => {
+  const { audioPlayer } = await import('../audioPlayer.js');
+  const originalCreateStream = audioPlayer._createStream;
+  audioPlayer._createStream = async () => {};
+  try {
+    audioPlayer.isPlaying = true;
+    audioPlayer.isPaused = false;
+    audioPlayer.currentTrack = 'Test Track';
+    audioPlayer._playbackStartedAt = Date.now() - 35000;
+    audioPlayer._currentOffsetSeconds = 10;
+
+    const pauseMsg = audioPlayer.pause();
+    assert.ok(pauseMsg.includes('Paused: Test Track'));
+    assert.ok(pauseMsg.includes('0:45'));
+    assert.equal(audioPlayer.isPaused, true);
+    assert.equal(audioPlayer._playbackStartedAt, 0);
+    assert.ok(audioPlayer._currentOffsetSeconds >= 44 && audioPlayer._currentOffsetSeconds <= 46);
+
+    const resumeMsg = audioPlayer.resume();
+    assert.ok(resumeMsg.includes('Resumed: Test Track'));
+    assert.ok(resumeMsg.includes('from 0:45'));
+    assert.equal(audioPlayer.isPaused, false);
+    assert.ok(audioPlayer._playbackStartedAt > 0);
+
+    audioPlayer.stop();
+    assert.equal(audioPlayer._currentOffsetSeconds, 0);
+    assert.equal(audioPlayer._playbackStartedAt, 0);
+  } finally {
+    audioPlayer._createStream = originalCreateStream;
+    audioPlayer.stop();
+  }
+});
+
+test('getCommandDetails returns structured metadata, subcommands, and examples', async () => {
+  const { getCommandDetails } = await import('../commandRegistry.js');
+
+  const suggestionDetails = getCommandDetails('/suggestion');
+  assert.ok(suggestionDetails, 'Should have details for /suggestion');
+  assert.ok(suggestionDetails.subcommands.length >= 4);
+  assert.ok(suggestionDetails.subcommands.some(s => s.cmd === 'list'));
+  assert.ok(suggestionDetails.subcommands.some(s => s.cmd.startsWith('run')));
+  assert.ok(suggestionDetails.subcommands.some(s => s.cmd.startsWith('topic')));
+  assert.ok(suggestionDetails.examples.length >= 3);
+
+  const mcpDetails = getCommandDetails('mcp');
+  assert.ok(mcpDetails, 'Should normalize command without leading slash');
+  assert.ok(mcpDetails.subcommands.some(s => s.cmd.startsWith('connect')));
+  assert.ok(mcpDetails.subcommands.some(s => s.cmd.startsWith('save')));
+  assert.ok(mcpDetails.subcommands.some(s => s.cmd.startsWith('remove')));
+
+  const providerDetails = getCommandDetails('/provider');
+  assert.ok(providerDetails);
+  assert.ok(providerDetails.subcommands.some(s => s.cmd.startsWith('use')));
+});
+
+test('/<cmd> help and /help <cmd> route to help handler with subcommands', async () => {
+  let printedCmd = null;
+  const ctx = {
+    printHelp(cmd) { printedCmd = cmd; },
+  };
+
+  assert.equal(await routeCommand('/help suggestion', ctx), 'HANDLED');
+  assert.equal(printedCmd, 'suggestion');
+
+  assert.equal(await routeCommand('/suggestion help', ctx), 'HANDLED');
+  assert.equal(printedCmd, '/suggestion');
+});
+
+test('/cancel command aborts running query and returns handled', async () => {
+  let cancelled = false;
+  const ctx = {
+    cancelActiveQuery: () => {
+      cancelled = true;
+      return true;
+    },
+  };
+
+  assert.equal(await routeCommand('/cancel', ctx), 'HANDLED');
+  assert.equal(cancelled, true);
+
+  assert.equal(await routeCommand('/abort', ctx), 'HANDLED');
+  assert.equal(cancelled, true);
+});
+
+test('/copy command routes to copyQueryDetails context method and aliases work', async () => {
+  let copiedRef = null;
+  const ctx = {
+    copyQueryDetails: (ref) => {
+      copiedRef = ref;
+      return true;
+    },
+  };
+
+  assert.equal(await routeCommand('/copy', ctx), 'HANDLED');
+  assert.equal(copiedRef, '');
+
+  assert.equal(await routeCommand('/copy thinking', ctx), 'HANDLED');
+  assert.equal(copiedRef, 'thinking');
+
+  assert.equal(await routeCommand('/cp Q2 answer', ctx), 'HANDLED');
+  assert.equal(copiedRef, 'Q2 answer');
+
+  assert.equal(await routeCommand('/clipboard tool 1', ctx), 'HANDLED');
+  assert.equal(copiedRef, 'tool 1');
+});
+
+test('/stats renders an AI insight when a chat client is available', async () => {
+  const originalLog = console.log;
+  const output = [];
+  console.log = (...args) => output.push(args.join(' '));
+  const ctx = {
+    agent: {
+      memory: { preferences: { language: null } },
+      client: { chat: async () => ({ content: 'Dramas dominate the catalog.' }) },
+    },
+  };
+  try {
+    assert.equal(await routeCommand('/stats', ctx), 'HANDLED');
+  } finally {
+    console.log = originalLog;
+  }
+  const text = output.join('\n');
+  assert.match(text, /Database Overview/);
+  assert.match(text, /Dramas dominate the catalog/);
+});
+
+test('/stats falls back gracefully when no chat client is available', async () => {
+  const originalLog = console.log;
+  const output = [];
+  console.log = (...args) => output.push(args.join(' '));
+  try {
+    assert.equal(await routeCommand('/stats', {}), 'HANDLED');
+  } finally {
+    console.log = originalLog;
+  }
+  const text = output.join('\n');
+  assert.match(text, /Database Overview/);
+  assert.doesNotMatch(text, /STATS ERROR/);
+});
+
+test('/theme next cycles to next theme and renders tuiPrompt if available', async () => {
+  let rendered = false;
+  const mockTuiPrompt = { render() { rendered = true; } };
+  const current = getThemeName();
+  assert.equal(await routeCommand('/theme next', { tuiPrompt: mockTuiPrompt }), 'HANDLED');
+  assert.equal(rendered, true);
+  assert.notEqual(getThemeName(), current);
+
+
+  assert.equal(await routeCommand('/theme prev', { tuiPrompt: mockTuiPrompt }), 'HANDLED');
+  assert.equal(getThemeName(), current);
+});
+
+test('all hotkey target commands are routeable and handled', async () => {
+  const dummyCtx = {
+    agent: {
+      session: {
+        setThinkingMode() {},
+        toggleThinkingMode() { return 'show'; },
+        exportToMarkdown: async () => ({ filePath: 'export.md' }),
+      },
+      getAllToolsSchema: () => [],
+    },
+    client: {},
+    printHelp: () => {},
+    printQueryDetails: () => {},
+    copyQueryDetails: () => ({ error: null }),
+    showTerminalImage: () => true,
+    lastQuery: 'test query',
+  };
+
+
+  assert.equal(await routeCommand('/help', dummyCtx), 'HANDLED');
+  assert.equal(await routeCommand('/details', dummyCtx), 'HANDLED');
+  assert.equal(await routeCommand('/details thinking', dummyCtx), 'HANDLED');
+  assert.equal(await routeCommand('/details tools', dummyCtx), 'HANDLED');
+  assert.equal(await routeCommand('/copy', dummyCtx), 'HANDLED');
+  assert.equal(await routeCommand('/gallery', dummyCtx), 'HANDLED');
+  assert.equal(await routeCommand('/theme next', { ...dummyCtx, tuiPrompt: { render() {} } }), 'HANDLED');
+  assert.equal(await routeCommand('/stats', dummyCtx), 'HANDLED');
+  assert.equal(await routeCommand('/provider', dummyCtx), 'HANDLED');
+  assert.equal(await routeCommand('/mcp list', dummyCtx), 'HANDLED');
+  assert.equal(await routeCommand('/thinking toggle', dummyCtx), 'HANDLED');
+  assert.equal(await routeCommand('/retry', dummyCtx), 'RETRY');
+  assert.equal(await routeCommand('/save', dummyCtx), 'HANDLED');
+  assert.equal(await routeCommand('/mcp-key', dummyCtx), 'HANDLED');
+});
+
+test('/quiz mcp completes 12 questions and claims MCP key', async () => {
+  const originalFetch = global.fetch;
+  const originalRandom = Math.random;
+  const originalLog = console.log;
+  const prompts = [];
+  const output = [];
+  const preferences = {};
+  let claimBody = null;
+  let challengeUrl = null;
+  let claimUrl = null;
+
+  global.fetch = async (url, options = {}) => {
+    if (!options.method) {
+      challengeUrl = url;
+      return {
+        ok: true,
+        json: async () => ({ data: { challengeToken: 'kiku_mcp_chal_test' } }),
+      };
+    }
+    claimUrl = url;
+    claimBody = JSON.parse(options.body);
+    return {
+      json: async () => ({ status: 'success', data: { apiKey: 'kiku_mcp_sk_test_token' } }),
+    };
+  };
+  Math.random = () => 0;
+  console.log = (...args) => output.push(args.join(' '));
+
+  try {
+    const result = await routeCommand('/quiz mcp', {
+      sub: 'mcp',
+      extra: '',
+      readInput: async options => {
+        prompts.push(options);
+        return 'd';
+      },
+      agent: {
+        memory: {
+          preferences,
+          setPreference(key, value) { preferences[key] = value; },
+        },
+      },
+    });
+
+    assert.equal(result, 'HANDLED');
+    assert.equal(prompts.length, 12);
+    assert.match(challengeUrl, /\/api\/v1\/mcp\/quiz\/challenge/);
+    assert.match(claimUrl, /\/api\/v1\/mcp\/keys\/claim/);
+    assert.equal(claimBody.challengeToken, 'kiku_mcp_chal_test');
+    assert.equal(claimBody.answers.length, 12);
+    assert.equal(preferences.mcpKey, 'kiku_mcp_sk_test_token');
+  } finally {
+    global.fetch = originalFetch;
+    Math.random = originalRandom;
+    console.log = originalLog;
+  }
+});
+
+test('/mcp-key manages MCP API key preferences', async () => {
+  const originalLog = console.log;
+  const output = [];
+  console.log = (...args) => output.push(args.join(' '));
+  const preferences = {};
+  const mem = {
+    preferences,
+    setPreference(k, v) { preferences[k] = v; },
+  };
+
+  try {
+    await routeCommand('/mcp-key', { sub: '', extra: '', agent: { memory: mem } });
+    assert.match(output.join('\n'), /No MCP API Key stored/);
+
+    await routeCommand('/mcp-key apply kiku_mcp_sk_my_key', { sub: 'apply', extra: 'kiku_mcp_sk_my_key', agent: { memory: mem } });
+    assert.equal(preferences.mcpKey, 'kiku_mcp_sk_my_key');
+
+    output.length = 0;
+    await routeCommand('/mcp-key config', { sub: 'config', extra: '', agent: { memory: mem } });
+    assert.match(output.join('\n'), /Claude Desktop & Cursor Config/);
+    assert.match(output.join('\n'), /kiku_mcp_sk_my_key/);
+
+    output.length = 0;
+    await routeCommand('/mcp-key clear', { sub: 'clear', extra: '', agent: { memory: mem } });
+    assert.equal(preferences.mcpKey, null);
+    assert.match(output.join('\n'), /MCP API Key cleared/);
+  } finally {
+    console.log = originalLog;
+  }
+});
+