kiku-agent 1.3.0 → 1.3.2

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

@@ -0,0 +1,152 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  DEFAULT_LOCAL_ENDPOINTS,
+  getProviderBaseUrl,
+  savePersistedProviderBaseUrl,
+  setActiveProvider,
+  getUnifiedProviderCatalog,
+  config
+} from '../config.js';
+import { LLMClient } from '../llmClient.js';
+import { routeCommand } from '../commands.js';
+import { handleProviderGetRoute, handleProviderUpdateRoute } from '../../web-chat/routes/providerRoute.js';
+
+test('DEFAULT_LOCAL_ENDPOINTS exposes canonical local endpoints', () => {
+  assert.equal(DEFAULT_LOCAL_ENDPOINTS.lmstudio, 'http://127.0.0.1:1234/v1');
+  assert.equal(DEFAULT_LOCAL_ENDPOINTS.vllm, 'http://127.0.0.1:8000/v1');
+});
+
+test('getProviderBaseUrl resolves local engines and custom endpoints correctly', () => {
+  const lmUrl = getProviderBaseUrl('lmstudio');
+  assert.ok(lmUrl.includes(':1234') || lmUrl.startsWith('http://127.0.0.1:1234'));
+
+  const vllmUrl = getProviderBaseUrl('vllm');
+  assert.ok(vllmUrl.includes(':8000') || vllmUrl.startsWith('http://127.0.0.1:8000'));
+
+  const customTestUrl = 'http://127.0.0.1:8888/v1';
+  savePersistedProviderBaseUrl('vllm', customTestUrl);
+  assert.equal(getProviderBaseUrl('vllm'), customTestUrl);
+
+
+  savePersistedProviderBaseUrl('vllm', DEFAULT_LOCAL_ENDPOINTS.vllm);
+  assert.equal(getProviderBaseUrl('vllm'), DEFAULT_LOCAL_ENDPOINTS.vllm);
+});
+
+test('setActiveProvider updates active provider and in-memory configuration', () => {
+  const infoVllm = setActiveProvider('vllm');
+  assert.equal(infoVllm.provider, 'vllm');
+  assert.equal(config.activeProvider, 'vllm');
+  assert.equal(config.lmStudio.baseUrl, getProviderBaseUrl('vllm'));
+
+  const catalog = getUnifiedProviderCatalog();
+  assert.equal(catalog.activeProvider, 'vllm');
+  assert.equal(catalog.localEndpoints.vllm.isActive, true);
+  assert.equal(catalog.localEndpoints.lmstudio.isActive, false);
+
+  const infoLm = setActiveProvider('lmstudio');
+  assert.equal(infoLm.provider, 'lmstudio');
+  assert.equal(config.activeProvider, 'lmstudio');
+  assert.equal(config.lmStudio.baseUrl, getProviderBaseUrl('lmstudio'));
+
+  const catalogLm = getUnifiedProviderCatalog();
+  assert.equal(catalogLm.activeProvider, 'lmstudio');
+  assert.equal(catalogLm.localEndpoints.lmstudio.isActive, true);
+  assert.equal(catalogLm.localEndpoints.vllm.isActive, false);
+});
+
+test('LLMClient respects unified baseUrl for vLLM and LM Studio', () => {
+  const vllmClient = new LLMClient({ provider: 'vllm' });
+  assert.equal(vllmClient.provider, 'vllm');
+  assert.equal(vllmClient.baseUrl, getProviderBaseUrl('vllm'));
+  assert.equal(vllmClient._buildHeaders()['Authorization'], 'Bearer token-kiku');
+
+  vllmClient.setBaseUrl('http://127.0.0.1:8008/v1');
+  assert.equal(vllmClient.baseUrl, 'http://127.0.0.1:8008/v1');
+  assert.equal(getProviderBaseUrl('vllm'), 'http://127.0.0.1:8008/v1');
+
+  vllmClient.setBaseUrl(DEFAULT_LOCAL_ENDPOINTS.vllm);
+  assert.equal(vllmClient.baseUrl, DEFAULT_LOCAL_ENDPOINTS.vllm);
+
+  const lmClient = new LLMClient({ provider: 'lmstudio' });
+  assert.equal(lmClient.provider, 'lmstudio');
+  assert.equal(lmClient.baseUrl, getProviderBaseUrl('lmstudio'));
+  assert.equal(lmClient._buildHeaders()['Authorization'], 'Bearer lm-studio');
+});
+
+test('CLI routeCommand handles /provider url, /url, and /endpoint', async () => {
+  const fakeContext = {
+    client: new LLMClient({ provider: 'vllm' }),
+    agent: null,
+    parts: ['/provider', 'url'],
+    sub: 'url',
+    extra: '',
+  };
+
+  const res1 = await routeCommand('/provider url', fakeContext);
+  assert.equal(res1, 'HANDLED');
+
+  const res2 = await routeCommand('/url', fakeContext);
+  assert.equal(res2, 'HANDLED');
+
+  const res3 = await routeCommand('/endpoint', fakeContext);
+  assert.equal(res3, 'HANDLED');
+
+  const res4 = await routeCommand('/provider url vllm http://127.0.0.1:8000/v1', {
+    ...fakeContext,
+    parts: ['/provider', 'url', 'vllm', 'http://127.0.0.1:8000/v1'],
+    sub: 'url'
+  });
+  assert.equal(res4, 'HANDLED');
+});
+
+import { Readable } from 'node:stream';
+
+test('Web Chat /api/provider GET and POST routes work as unified manager', async () => {
+  let resStatus = null;
+  let resPayload = null;
+
+  const mockRes = {
+    writeHead(status, headers) {
+      resStatus = status;
+    },
+    end(content) {
+      if (content) resPayload = JSON.parse(content);
+    },
+    setHeader() {}
+  };
+
+  await handleProviderGetRoute({}, mockRes);
+  assert.equal(resStatus, 200);
+  assert.ok(resPayload);
+  assert.equal(resPayload.status, 'ok');
+  assert.ok(resPayload.localEndpoints.lmstudio);
+  assert.ok(resPayload.localEndpoints.vllm);
+
+
+  const updateReq = Readable.from([
+    Buffer.from(JSON.stringify({
+      provider: 'vllm',
+      baseUrl: 'http://127.0.0.1:8000/v1'
+    }))
+  ]);
+
+  let postStatus = null;
+  let postPayload = null;
+  const mockPostRes = {
+    writeHead(status, headers) {
+      postStatus = status;
+    },
+    end(content) {
+      if (content) postPayload = JSON.parse(content);
+    },
+    setHeader() {}
+  };
+
+  await handleProviderUpdateRoute(updateReq, mockPostRes);
+  assert.equal(postStatus, 200);
+  assert.equal(postPayload.activeProvider, 'vllm');
+  assert.equal(postPayload.activeBaseUrl, 'http://127.0.0.1:8000/v1');
+
+  setActiveProvider('lmstudio');
+});

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

@@ -0,0 +1,262 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { DebateOrchestrator } from '../debate.js';
+import { AgentMemory } from '../memory.js';
+import { AgentSession } from '../session.js';
+import { promptDefinitions, getPrompt } from '../../mcp/prompts.js';
+import { routeCommand } from '../commands.js';
+import { formatCareerTimelineGraphic, formatDebateMatrix } from '../ui.js';
+import { timelineData } from '../../../src/data/timelineData.js';
+
+test('DebateOrchestrator generates structured adversarial truth matrix', async () => {
+  const mockClient = {
+    chat: async ({ messages }) => {
+      const userText = messages[messages.length - 1]?.content || '';
+      if (userText.includes('ADVOCATE')) {
+        return { message: { content: 'Verified in SNH48 Senbatsu archives and official press.' } };
+      }
+      if (userText.includes('CRITIC')) {
+        return { message: { content: 'Debunked common misconceptions regarding timeline dates.' } };
+      }
+      return { message: { content: 'NEUTRAL VERDICT: Claim verified with primary catalog records.' } };
+    }
+  };
+
+  const orchestrator = new DebateOrchestrator({
+    client: mockClient,
+    executeTool: async () => ({ status: 'ok' })
+  });
+
+  const result = await orchestrator.run('Did Ju Jingyi win SNH48 General Elections?');
+  assert.ok(result.topic);
+  assert.ok(result.advocate);
+  assert.ok(result.critic);
+  assert.ok(result.verdict);
+});
+
+test('Smart Memory 2.0 calculates relevance with TF-IDF keyword scoring and recency decay', async () => {
+  const memory = new AgentMemory();
+  const fact1 = {
+    id: 'f1',
+    content: 'Ju Jingyi starred as Yang Caiwei in In Blossom (2024)',
+    category: 'drama',
+    tags: ['in-blossom', 'yang-caiwei'],
+    confidence: 'high',
+    createdAt: new Date(),
+    accessCount: 2,
+  };
+  const fact2 = {
+    id: 'f2',
+    content: 'Ju Jingyi released Everyday solo single in Spain',
+    category: 'music',
+    tags: ['everyday', 'single'],
+    confidence: 'high',
+    createdAt: new Date(Date.now() - 1000 * 60 * 60 * 24 * 10),
+    accessCount: 0,
+  };
+
+  const scoreDrama = memory.scoreFactRelevance(fact1, ['caiwei', 'blossom']);
+  const scoreMusic = memory.scoreFactRelevance(fact2, ['caiwei', 'blossom']);
+
+  assert.ok(scoreDrama > scoreMusic, 'Drama fact should score significantly higher for drama keywords');
+});
+
+test('AgentSession exports beautiful single-file HTML transcript', async () => {
+  const session = new AgentSession();
+  session.createUserMessage('Tell me about Ju Jingyi.');
+  session.messages.push({
+    id: 'msg_a1',
+    role: 'assistant',
+    parts: [
+      { type: 'reasoning', content: 'Searching catalog...', durationMs: 120 },
+      { type: 'tool', name: 'search_works', args: { query: 'In Blossom' }, result: { count: 1 }, status: 'ok', durationMs: 45 },
+      { type: 'text', content: 'Ju Jingyi is a celebrated Chinese singer and actress.' }
+    ]
+  });
+
+  const html = session.getTranscriptHtml();
+  assert.ok(html.includes('<!DOCTYPE html>'));
+  assert.ok(html.includes('Kiku AI Agent — Session Transcript'));
+  assert.ok(html.includes('search_works'));
+  assert.ok(html.includes('Tell me about Ju Jingyi.'));
+});
+
+test('MCP prompts expose draft_fan_fiction, analyze_drama_rating, and compare_discography_era', async () => {
+  const promptNames = promptDefinitions.map(p => p.name);
+  assert.ok(promptNames.includes('draft_fan_fiction'));
+  assert.ok(promptNames.includes('analyze_drama_rating'));
+  assert.ok(promptNames.includes('compare_discography_era'));
+
+  const fiction = await getPrompt('draft_fan_fiction', { character: 'Yang Caiwei' });
+  assert.ok(fiction.messages[0].content.text.includes('Yang Caiwei'));
+
+  const dramaAnalysis = await getPrompt('analyze_drama_rating', { title: 'In Blossom' });
+  assert.ok(dramaAnalysis.messages[0].content.text.includes('Drama Critical Analysis'));
+
+  const compareEra = await getPrompt('compare_discography_era', {});
+  assert.ok(compareEra.messages[0].content.text.includes('Discography Era Comparison'));
+});
+
+test('formatCareerTimelineGraphic renders clean ASCII branch timeline', () => {
+  const lines = formatCareerTimelineGraphic(timelineData.slice(0, 3), 80);
+  assert.ok(lines.length > 0);
+  assert.ok(lines[0].includes('CAREER MILESTONES TIMELINE'));
+});
+
+test('formatDebateMatrix renders structured truth matrix', () => {
+  const lines = formatDebateMatrix({
+    topic: 'Test topic',
+    advocate: 'Advocate arguments',
+    critic: 'Critic counterpoints',
+    verdict: 'Final judge synthesis',
+  }, 80);
+  assert.ok(lines.length > 0);
+  assert.ok(lines[0].includes('DEBATE MATRIX'));
+});
+
+test('Standalone webChatServer starts, exposes endpoints, and stops cleanly on port 3001', async () => {
+  const { startWebChatServer, stopWebChatServer, getWebChatServerStatus } = await import('../../webChatServer.js');
+  
+  const serverInfo = await startWebChatServer({ port: 3309 });
+  assert.equal(serverInfo.port, 3309);
+  assert.equal(serverInfo.url, 'http://localhost:3309');
+
+  const status = getWebChatServerStatus();
+  assert.equal(status.running, true);
+  assert.equal(status.port, 3309);
+
+  const res = await fetch('http://localhost:3309/api/status');
+  const data = await res.json();
+  assert.equal(data.status, 'ok');
+  assert.equal(data.server, 'Kiku Web Chatbot');
+
+  const timelineRes = await fetch('http://localhost:3309/api/v1/timeline');
+  assert.equal(timelineRes.status, 200);
+  const timelinePayload = await timelineRes.json();
+  assert.equal(timelinePayload.status, 'success');
+  assert.ok(Array.isArray(timelinePayload.data));
+  assert.ok(timelinePayload.data.length > 0);
+
+
+  const sampleHistory = [
+    { role: 'user', text: 'เล่าประวัติจวีจิ้งอี' },
+    { role: 'assistant', text: 'จวีจิ้งอี เกิดวันที่ 18 มิถุนายน 1994' }
+  ];
+
+  const exportJsonRes = await fetch('http://localhost:3309/api/export', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ format: 'json', history: sampleHistory, sessionId: 'test_sess' })
+  });
+  assert.equal(exportJsonRes.status, 200);
+  const exportJson = await exportJsonRes.json();
+  assert.equal(exportJson.sessionId, 'test_sess');
+  assert.equal(exportJson.messages.length, 2);
+
+  const exportMdRes = await fetch('http://localhost:3309/api/export', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ format: 'markdown', history: sampleHistory, sessionId: 'test_sess' })
+  });
+  assert.equal(exportMdRes.status, 200);
+  const exportMd = await exportMdRes.text();
+  assert.ok(exportMd.includes('# 🌸 Kiku AI Chat Export'));
+  assert.ok(exportMd.includes('เล่าประวัติจวีจิ้งอี'));
+
+  const exportHtmlRes = await fetch('http://localhost:3309/api/export', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ format: 'html', history: sampleHistory, sessionId: 'test_sess' })
+  });
+  assert.equal(exportHtmlRes.status, 200);
+  const exportHtml = await exportHtmlRes.text();
+  assert.ok(exportHtml.includes('<!DOCTYPE html>'));
+  assert.ok(exportHtml.includes('Kiku AI Chat Export'));
+
+
+  const suggestRes = await fetch('http://localhost:3309/api/ai-suggest', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ topic: 'drama' })
+  });
+  assert.equal(suggestRes.status, 200);
+  const suggestData = await suggestRes.json();
+  assert.equal(suggestData.status, 'ok');
+  assert.ok(Array.isArray(suggestData.suggestions));
+  assert.ok(suggestData.suggestions.length > 0);
+
+
+  const verifyRes = await fetch('http://localhost:3309/api/verify', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ claim: 'จวีจิ้งอีเป็น Brand Ambassador ของ Versace' })
+  });
+  assert.equal(verifyRes.status, 200);
+  const verifyData = await verifyRes.json();
+  assert.equal(verifyData.status, 'ok');
+  assert.ok(verifyData.verdict);
+
+ 
+  const newsRes = await fetch('http://localhost:3309/api/news', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ query: 'จวีจิ้งอี' })
+  });
+  assert.equal(newsRes.status, 200);
+  const newsData = await newsRes.json();
+  assert.equal(newsData.status, 'ok');
+  assert.ok(Array.isArray(newsData.items));
+
+
+  const compareRes = await fetch('http://localhost:3309/api/compare', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ itemA: 'In Blossom', itemB: 'Legend of Yunxi' })
+  });
+  assert.equal(compareRes.status, 200);
+  const compareData = await compareRes.json();
+  assert.equal(compareData.status, 'ok');
+  assert.ok(compareData.comparison?.itemA);
+  assert.ok(compareData.comparison?.itemB);
+
+  const stopped = await stopWebChatServer();
+  assert.equal(stopped, true);
+  assert.equal(getWebChatServerStatus().running, false);
+});
+
+test('System Prompt encapsulates MULTI-ANGLE RETRIEVAL & SMART MULTI-TOOL PARALLELISM across broad domains and single-hop guard', async () => {
+  const { buildSystemPrompt } = await import('../prompts.js');
+  const { config } = await import('../config.js');
+  const { KikuAgent } = await import('../agentCore.js');
+
+  const prompt = buildSystemPrompt();
+
+  assert.ok(prompt.includes('2A. MULTI-ANGLE RETRIEVAL & SMART MULTI-TOOL PARALLELISM:'));
+  assert.ok(prompt.includes('Dramas / Series / Characters / Acting'));
+  assert.ok(prompt.includes('Music / Singles / OST / Discography'));
+  assert.ok(prompt.includes('News / Recent Activities / Current Events / Trends'));
+  assert.ok(prompt.includes('Commercial Endorsements / Brand Styling / Fashion'));
+  assert.ok(prompt.includes('Awards / Honors / Music Chart Recognition'));
+  assert.ok(prompt.includes('Comprehensive Overview / Introduction for New Fans'));
+  assert.ok(prompt.includes('Fact-Checking / Rumors / Verification / Controversies'));
+  assert.ok(prompt.includes('SINGLE-HOP PRECISION GUARD (ANTI-OVERFETCH)'));
+  assert.ok(prompt.includes('PARALLEL EXECUTION:'));
+
+  
+  assert.ok(prompt.includes('Action: search_works({"query": "花间令"})'));
+  assert.ok(prompt.includes('Action: get_gallery_photos({"query": "花间令"})'));
+  assert.ok(prompt.includes('Action: search_discography({"query": "恋爱告急"})'));
+  assert.ok(prompt.includes('Action: get_music_videos({"query": "恋爱告急"})'));
+
+
+  assert.ok(config.agent.systemPersona.includes('MULTI-ANGLE RETRIEVAL & SMART MULTI-TOOL PARALLELISM:'));
+
+
+  const agent = Object.create(KikuAgent.prototype);
+  agent.getAllToolsSchema = () => [];
+  const agentPrompt = agent.buildSystemPrompt();
+  assert.ok(agentPrompt.includes('MULTI-ANGLE RETRIEVAL & SMART MULTI-TOOL PARALLELISM:'));
+  assert.ok(agentPrompt.includes('search_works({"query": "花间令"})'));
+  assert.ok(agentPrompt.includes('get_gallery_photos({"query": "花间令"})'));
+});
+

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

@@ -0,0 +1,69 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { writeFileSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { bumpVersion, findStaleVersionReferences } from '../../../bump_version.js';
+import { PACKAGE_VERSION } from '../version.js';
+
+const REPO_ROOT = fileURLToPath(new URL('../../../', import.meta.url));
+
+test('bumpVersion accurately calculates patch, minor, and major increments in dry-run mode', () => {
+  const patchRes = bumpVersion({ target: 'patch', dryRun: true });
+  assert.equal(patchRes.currentVersion, PACKAGE_VERSION);
+  assert.ok(patchRes.nextVersion);
+  assert.equal(patchRes.changes.length, 3);
+  assert.ok(Array.isArray(patchRes.staleReferences));
+
+  const minorRes = bumpVersion({ target: 'minor', dryRun: true });
+  assert.ok(minorRes.nextVersion);
+
+  const majorRes = bumpVersion({ target: 'major', dryRun: true });
+  assert.ok(majorRes.nextVersion);
+
+  const preRes = bumpVersion({ target: 'prerelease', preId: 'beta', dryRun: true });
+  assert.ok(preRes.nextVersion.includes('-beta.'));
+});
+
+test('bumpVersion handles explicit semver strings and validates ordering', () => {
+  // Hardcoding the next version here would expire on every release; derive a
+  // valid future version from the current package version instead.
+  const [major, minor, patch] = PACKAGE_VERSION.split('.').map(Number);
+  const explicitNext = `${major}.${minor}.${patch + 1}`;
+  const explicitRes = bumpVersion({ target: explicitNext, channel: 'beta', dryRun: true });
+  assert.equal(explicitRes.nextVersion, explicitNext);
+  assert.equal(explicitRes.changes[0].file, 'package.json');
+
+
+  assert.throws(() => {
+    bumpVersion({ target: 'invalid_version', dryRun: true });
+  }, /Unknown bump type or invalid version/);
+
+
+  assert.throws(() => {
+    bumpVersion({ target: '1.0.0', dryRun: true });
+  }, /must be greater than current version/);
+
+
+  const forceRes = bumpVersion({ target: '1.0.0', force: true, dryRun: true });
+  assert.equal(forceRes.nextVersion, '1.0.0');
+});
+
+test('stale version audit surfaces hardcoded pins and stays clean for the release', () => {
+  const fixturePath = join(REPO_ROOT, 'audit-fixture.tmp.md');
+  try {
+    writeFileSync(fixturePath, `metadata pinned at ${PACKAGE_VERSION}\n`, 'utf8');
+    const hits = findStaleVersionReferences(PACKAGE_VERSION);
+    assert.equal(hits.length, 1);
+    assert.equal(hits[0].file, 'audit-fixture.tmp.md');
+    assert.match(hits[0].snippet, new RegExp(PACKAGE_VERSION.replace(/\./g, '\.')));
+  } finally {
+    rmSync(fixturePath, { force: true });
+  }
+
+  // Once the fixture is gone, nothing outside package.json/package-lock.json/
+  // the README tarball line may pin the released version — this is the drift
+  // guard that keeps badges and export metadata on dynamic lookups.
+  assert.deepEqual(findStaleVersionReferences(PACKAGE_VERSION), []);
+});