kiku-agent 1.3.1 → 1.3.3

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

@@ -0,0 +1,285 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import os from 'node:os';
+import path from 'node:path';
+import { mkdtemp, rm } from 'node:fs/promises';
+
+import {
+  loadDynamicCatalog,
+  saveDynamicCatalog,
+  validateCatalogEntry,
+  addDynamicEntry,
+  getDynamicEntries,
+  clearDynamicCatalog,
+  getDynamicCatalogStats,
+  pruneExpiredEntries
+} from '../dynamicCatalog.js';
+
+import {
+  isTrustedSource,
+  computeEventSimHash,
+  isDuplicateEvent,
+  extractStructuredEvent,
+  ingestRawEvent,
+  runIngestionScan
+} from '../ingestionWorker.js';
+
+import { executeTool } from '../tools.js';
+import { routeCommand } from '../commands.js';
+
+test('Dynamic Catalog: validation and CRUD operations', async (t) => {
+  const tmpDir = await mkdtemp(path.join(os.tmpdir(), 'kiku-dynamic-test-'));
+  const catalogPath = path.join(tmpDir, 'dynamic-catalog.json');
+
+  await t.test('validateCatalogEntry validates categories and required titles', () => {
+    assert.equal(validateCatalogEntry('brands', { brand: 'Lafang' }).valid, true);
+    assert.equal(validateCatalogEntry('invalid_cat', { title: 'Test' }).valid, false);
+    assert.equal(validateCatalogEntry('works', {}).valid, false);
+    assert.equal(validateCatalogEntry('timeline', { title: 'Milestone 2026' }).valid, true);
+  });
+
+  await t.test('addDynamicEntry persists and assigns clean IDs and metadata', () => {
+    const entry = addDynamicEntry('brands', {
+      brand: 'TuTuCare',
+      brandNameEn: 'TuTuCare',
+      brandNameCn: '途途呵护',
+      year: 2024,
+      role: 'Brand Ambassador',
+      highlight: 'Pet and rabbit care ambassador'
+    }, { catalogPath, trustTier: 1, source: 'official_weibo' });
+
+    assert.ok(entry.id.startsWith('dyn-bra-'));
+    assert.equal(entry.brand, 'TuTuCare');
+    assert.equal(entry.trustTier, 1);
+    assert.equal(entry.year, 2024);
+
+    const brands = getDynamicEntries('brands', null, catalogPath);
+    assert.equal(brands.length, 1);
+    assert.equal(brands[0].id, entry.id);
+
+    const stats = getDynamicCatalogStats(catalogPath);
+    assert.equal(stats.totalEntries, 1);
+    assert.equal(stats.brandsCount, 1);
+  });
+
+  await t.test('pruneExpiredEntries removes expired entries and retains valid ones', () => {
+  
+    const eightDaysAgo = new Date(Date.now() - 8 * 24 * 3600 * 1000).toISOString();
+    addDynamicEntry('events', {
+      id: 'old-event-1',
+      title: 'Old Live Stream',
+      createdAt: eightDaysAgo
+    }, { catalogPath });
+
+    const statsBefore = getDynamicCatalogStats(catalogPath);
+    assert.equal(statsBefore.eventsCount, 1);
+
+    const pruned = pruneExpiredEntries({ catalogPath, ttlDays: 7 });
+    assert.equal(pruned.prunedCount, 1);
+
+    const statsAfter = getDynamicCatalogStats(catalogPath);
+    assert.equal(statsAfter.eventsCount, 0);
+  });
+
+  await t.test('clearDynamicCatalog empties all collections', () => {
+    clearDynamicCatalog(catalogPath);
+    const stats = getDynamicCatalogStats(catalogPath);
+    assert.equal(stats.totalEntries, 0);
+  });
+
+  await rm(tmpDir, { recursive: true, force: true });
+});
+
+test('Ingestion Worker: trust tiers, deduplication, and extraction', async (t) => {
+  const tmpDir = await mkdtemp(path.join(os.tmpdir(), 'kiku-ingest-test-'));
+  const catalogPath = path.join(tmpDir, 'dynamic-catalog.json');
+
+  await t.test('isTrustedSource classifies official platforms and press', () => {
+    const douyin = isTrustedSource('douyin');
+    assert.equal(douyin.trusted, true);
+    assert.equal(douyin.tier, 1);
+
+    const weiboUrl = isTrustedSource('https://weibo.com/u/123456');
+    assert.equal(weiboUrl.trusted, true);
+    assert.equal(weiboUrl.tier, 1);
+
+    const press = isTrustedSource('https://www.sohu.com/a/123456');
+    assert.equal(press.trusted, true);
+    assert.equal(press.tier, 2);
+
+    const community = isTrustedSource('https://randomblog.com/post/123');
+    assert.equal(community.trusted, false);
+    assert.equal(community.tier, 3);
+  });
+
+  await t.test('isDuplicateEvent detects identical and near-duplicate entries via SimHash', () => {
+    const existing = [
+      {
+        id: 'item-1',
+        brand: 'Lafang',
+        year: 2026,
+        highlight: 'จวีจิ้งอี ไลฟ์สดแบรนด์ Lafang บน Douyin'
+      }
+    ];
+
+    const exactMatch = { brand: 'Lafang', year: 2026 };
+    assert.equal(isDuplicateEvent(exactMatch, existing), true);
+
+    const simHashMatch = {
+      brand: 'Other',
+      year: 2026,
+      highlight: 'จวีจิ้งอี ไลฟ์สดแบรนด์ Lafang บน Douyin ในลุคนางฟ้า'
+    };
+    assert.equal(isDuplicateEvent(simHashMatch, existing), true);
+
+    const different = {
+      brand: 'FRED Paris',
+      year: 2024,
+      highlight: 'เครื่องประดับชั้นสูงจากฝรั่งเศส'
+    };
+    assert.equal(isDuplicateEvent(different, existing), false);
+  });
+
+  await t.test('extractStructuredEvent correctly parses Thai date and brand entity', async () => {
+    const sample = 'คืนวันที่ 12 กันยายน จวีจิ้งอี ไลฟ์สดงานแบรนด์ Lafang (拉芳) บนแพลตฟอร์ม Douyin ด้วยลุคนางฟ้าดอกไม้';
+    const res = await extractStructuredEvent(sample);
+
+    assert.equal(res.category, 'brands');
+    assert.equal(res.year, 2026);
+    assert.equal(res.date, '2026-09-12');
+    assert.equal(res.brand, 'Lafang');
+    assert.equal(res.brandNameCn, '拉芳');
+  });
+
+  await t.test('ingestRawEvent rejects untrusted source and ingests trusted source', async () => {
+    const text = 'จวีจิ้งอี ร่วมงานอีเวนต์พิเศษ';
+
+
+    const rejected = await ingestRawEvent(text, {
+      source: 'https://unverified-blog.org',
+      catalogPath
+    });
+    assert.equal(rejected.status, 'rejected');
+
+    const success = await ingestRawEvent(text, {
+      source: 'douyin',
+      catalogPath
+    });
+    assert.equal(success.status, 'success');
+
+   
+    const dup = await ingestRawEvent(text, {
+      source: 'douyin',
+      catalogPath
+    });
+    assert.equal(dup.status, 'duplicate');
+  });
+
+  await t.test('runIngestionScan scans and ingests verified candidates', async () => {
+    const mockFetcher = async () => [
+      {
+        title: 'Ju Jingyi attends Luxury Gala',
+        snippet: 'Official appearance at annual fashion gala',
+        url: 'https://weibo.com/detail/999'
+      },
+      {
+        title: 'Ju Jingyi fan forum post',
+        snippet: 'Unverified rumor from forum',
+        url: 'https://randomforum.xyz/topic/1'
+      }
+    ];
+
+    const result = await runIngestionScan({
+      fetcher: mockFetcher,
+      catalogPath,
+      minTrustTier: 2
+    });
+
+    assert.equal(result.totalScanned, 2);
+    assert.equal(result.ingestedCount, 1);
+    assert.equal(result.skippedUntrusted, 1);
+  });
+
+  await rm(tmpDir, { recursive: true, force: true });
+});
+
+test('Core Tools: Dynamic Catalog Overlay integration and record_dynamic_event tool', async () => {
+ 
+  clearDynamicCatalog();
+
+ 
+  const recordRes = await executeTool('record_dynamic_event', {
+    category: 'brands',
+    entry: {
+      brand: 'TestDynamicBrand',
+      brandNameEn: 'TestDynamicBrand',
+      brandNameCn: '测试品牌',
+      year: 2026,
+      category: 'beauty',
+      highlight: 'Special Dynamic Brand Ambassador'
+    },
+    source: 'weibo',
+    trustTier: 1
+  });
+
+  assert.equal(recordRes.status, 'success');
+  assert.equal(recordRes.entry.brand, 'TestDynamicBrand');
+
+ 
+  const brandsRes = await executeTool('get_brand_endorsements', { query: 'TestDynamicBrand' });
+  assert.equal(brandsRes.status, 'success');
+  assert.ok(brandsRes.brands.some(b => b.brand.includes('TestDynamicBrand')));
+
+
+  await executeTool('record_dynamic_event', {
+    category: 'timeline',
+    entry: {
+      title: 'Dynamic Milestone 2026',
+      titleCn: '动态里程碑',
+      year: 2026,
+      summary: 'Special dynamic timeline entry test'
+    }
+  });
+
+  const timelineRes = await executeTool('get_career_timeline', { year: 2026 });
+  assert.equal(timelineRes.status, 'success');
+  assert.ok(timelineRes.milestones.some(m => m.title.includes('Dynamic Milestone 2026')));
+
+
+  await executeTool('record_dynamic_event', {
+    category: 'gallery',
+    entry: {
+      titleTh: 'ภาพพิเศษ 2026',
+      titleCn: '动态写真',
+      category: 'fashion',
+      year: 2026,
+      image: 'https://example.com/dynamic-photo.jpg'
+    }
+  });
+
+  const galleryRes = await executeTool('get_gallery_photos', { year: 2026 });
+  assert.equal(galleryRes.status, 'success');
+  assert.ok(galleryRes.photos.some(p => p.title.includes('ภาพพิเศษ 2026')));
+
+ 
+  clearDynamicCatalog();
+});
+
+test('CLI: /ingest routeCommand handles status, add, and clear', async () => {
+  clearDynamicCatalog();
+
+  const statusRes = await routeCommand('/ingest status', {});
+  assert.equal(statusRes, 'HANDLED');
+
+  const addRes = await routeCommand('/ingest add จวีจิ้งอี ไลฟ์สดงานแบรนด์ Lafang บน Douyin', {});
+  assert.equal(addRes, 'HANDLED');
+
+  const stats = getDynamicCatalogStats();
+  assert.ok(stats.totalEntries >= 1);
+
+  const clearRes = await routeCommand('/ingest clear', {});
+  assert.equal(clearRes, 'HANDLED');
+
+  const statsCleared = getDynamicCatalogStats();
+  assert.equal(statsCleared.totalEntries, 0);
+});

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

@@ -0,0 +1,92 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { resolveQueryEntities, getContextualizedSearchQuery, detectPlatforms, detectPromotionIntent } from '../catalogEntityResolver.js';
+import { DynamicToolRouter } from '../toolRouter.js';
+import { createCatalogMatcher, executeTool } from '../tools.js';
+
+test('catalogEntityResolver resolves entities across languages without rigid keywords', () => {
+  const prsrQuery = 'ค้นหาการโปรโมท PRSR บน bilibili';
+  const prsrRes = resolveQueryEntities(prsrQuery);
+
+  assert.equal(prsrRes.hasBrand, true);
+  assert.ok(prsrRes.primaryBrand);
+  assert.equal(prsrRes.primaryBrand.id, 'prsr');
+  assert.ok(prsrRes.platforms.includes('bilibili'));
+  assert.equal(prsrRes.isPromotion, true);
+  assert.ok(prsrRes.contextualChineseKeywords.includes('帕莎眼镜'));
+
+  const pashaQuery = 'ดูคลิปโฆษณา pasha ใน b站';
+  const pashaRes = resolveQueryEntities(pashaQuery);
+  assert.equal(pashaRes.hasBrand, true);
+  assert.equal(pashaRes.primaryBrand.id, 'prsr');
+  assert.ok(pashaRes.platforms.includes('bilibili'));
+
+  const qixingcaiQuery = 'ผลงานชีซิงไฉ่';
+  const qixingcaiRes = resolveQueryEntities(qixingcaiQuery);
+  assert.equal(qixingcaiRes.hasWork, true);
+  assert.equal(qixingcaiRes.primaryWork.nameCn, '七星彩');
+
+  const inBlossomQuery = 'เพลงประกอบฮวาเจียนลิ่ง';
+  const inBlossomRes = resolveQueryEntities(inBlossomQuery);
+  assert.equal(inBlossomRes.hasWork, true);
+  assert.equal(inBlossomRes.primaryWork.nameCn, '花间令');
+});
+
+test('getContextualizedSearchQuery enriches Chinese queries with artist and brand aliases', () => {
+  const biliPrsr = getContextualizedSearchQuery('PRSR', 'bilibili');
+  assert.ok(biliPrsr.includes('鞠婧祎'), 'Must include artist name in Chinese');
+  assert.ok(biliPrsr.includes('帕莎'), 'Must include Chinese brand name');
+
+  const biliPrompt = getContextualizedSearchQuery('ค้นหาการโปรโมท PRSR บน bilibili', 'bilibili');
+  assert.ok(biliPrompt.includes('鞠婧祎'));
+  assert.ok(biliPrompt.includes('帕莎'));
+  assert.ok(biliPrompt.includes('PRSR'));
+
+  const dramaQuery = getContextualizedSearchQuery('In Blossom', 'bilibili');
+  assert.ok(dramaQuery.includes('鞠婧祎'));
+  assert.ok(dramaQuery.includes('花间令'));
+});
+
+test('DynamicToolRouter routes brand and media tools simultaneously on cross-cutting queries', () => {
+  const router = new DynamicToolRouter();
+
+  const routed = router.routeToolsForQuery('ค้นหาการโปรโมท PRSR บน bilibili');
+  const toolNames = new Set(routed.map(t => t.function.name));
+
+  assert.ok(toolNames.has('get_brand_endorsements'), 'Must include get_brand_endorsements');
+  assert.ok(toolNames.has('search_bilibili'), 'Must include search_bilibili');
+  assert.ok(toolNames.has('get_media_links'), 'Must include get_media_links');
+  assert.ok(routed.length <= 15);
+
+  const fallback = router.routeToolsForQuery('สวัสดีครับ');
+  assert.ok(fallback.length <= 10, 'Fallback tools must not exceed 10');
+  assert.ok(fallback.some(t => t.function.name === 'global_search'));
+  assert.ok(fallback.some(t => t.function.name === 'get_brand_endorsements'));
+});
+
+test('createCatalogMatcher handles promotional query framing without token ratio penalty', () => {
+  const matcher = createCatalogMatcher('ค้นหาการโปรโมท PRSR บน bilibili');
+  assert.equal(matcher('PRSR / Pasha', '帕莎眼镜', 'Global Brand Ambassador'), true);
+
+  const yunxiMatcher = createCatalogMatcher('เพลง Ost Ju Jingyi 2024 Yunxi');
+  assert.equal(yunxiMatcher('ตำนานหยุนซี Legend of Yunxi', 'Yunxi'), true);
+});
+
+test('get_brand_endorsements tool returns bilibiliSearchUrl and handles query filter', async () => {
+  const res = await executeTool('get_brand_endorsements', { query: 'PRSR' });
+  assert.equal(res.status, 'success');
+  assert.ok(res.count >= 1);
+  const prsr = res.brands[0];
+  assert.ok(prsr.brand.includes('PRSR') || prsr.brand.includes('Pasha'));
+  assert.ok(prsr.bilibiliSearchUrl, 'Must include bilibiliSearchUrl');
+  assert.ok(prsr.bilibiliSearchUrl.includes('search.bilibili.com'));
+  assert.ok(prsr.bilibiliSearchUrl.includes(encodeURIComponent('鞠婧祎')));
+});
+
+test('get_media_links tool searches brand commercial links alongside works and music', async () => {
+  const res = await executeTool('get_media_links', { query: 'PRSR' });
+  assert.equal(res.status, 'success');
+  assert.ok(res.results.brands.length >= 1, 'Should find PRSR in brand media results');
+  assert.ok(res.results.brands[0].bilibiliSearchUrl);
+  assert.ok(res.results.brands[0].youtubeCommercialSearch);
+});

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

@@ -0,0 +1,131 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { sanitizeQuery } from '../sanitizer.js';
+import { DynamicToolRouter } from '../toolRouter.js';
+import { executeTool } from '../tools.js';
+import { ContextCompactor } from '../contextCompactor.js';
+import { KikuAgent } from '../agentCore.js';
+import { handleVerifyRoute } from '../../web-chat/routes/verifyRoute.js';
+import { applyFutureEventGuard } from '../../web-chat/core/futureEventGuard.js';
+
+test('Edge Cases Suite: Sanitizer handles empty, whitespace, and extreme length strings gracefully', () => {
+  const emptyRes = sanitizeQuery('');
+  assert.equal(emptyRes.sanitized, '');
+
+  const spaceRes = sanitizeQuery('   \t\n  ');
+  assert.equal(spaceRes.sanitized, '');
+
+  const longText = 'A'.repeat(40000);
+  const longRes = sanitizeQuery(longText);
+  assert.ok(longRes.sanitized.length <= 32768);
+});
+
+test('Edge Cases Suite: DynamicToolRouter returns safe fallback when given empty or strange inputs', () => {
+  const router = new DynamicToolRouter();
+  const nullRouted = router.routeToolsForQuery(null);
+  assert.ok(nullRouted.length > 0);
+
+  const emptyRouted = router.routeToolsForQuery('');
+  assert.ok(emptyRouted.length > 0);
+
+  const weirdRouted = router.routeToolsForQuery('!@#$%^&*()_+~`|}{[]:;?><,./');
+  assert.ok(weirdRouted.length > 0);
+});
+
+test('Edge Cases Suite: Catalog tools return not_found status instead of throwing on unknown records', async () => {
+  const notFoundWork = await executeTool('search_works', { query: 'non_existent_drama_xyz_99999' });
+  assert.equal(notFoundWork.status, 'not_found');
+  assert.equal(notFoundWork.count, 0);
+
+  const notFoundSong = await executeTool('search_discography', { query: 'non_existent_song_xyz_99999' });
+  assert.equal(notFoundSong.status, 'not_found');
+  assert.equal(notFoundSong.count, 0);
+});
+
+test('Edge Cases Suite: ContextCompactor handles empty, malformed, or oversized history arrays', () => {
+  const compactor = new ContextCompactor({ maxTokens: 100, keepRecentMessages: 2 });
+  assert.deepEqual(compactor.compact([]), []);
+  assert.deepEqual(compactor.compact(null), null);
+
+  const singleMsg = [{ role: 'user', content: 'Hello' }];
+  assert.deepEqual(compactor.compact(singleMsg), singleMsg);
+});
+
+test('Edge Cases Suite: KikuAgent immunizes vision limitation statements from refusal interceptor', async () => {
+  let callCount = 0;
+  const fakeClient = {
+    provider: 'lmstudio',
+    model: 'google/gemma-4-e4b',
+    chat: async () => {
+      callCount++;
+      return { role: 'assistant', content: 'ฉันเป็นระบบข้อความ ไม่สามารถดูรูปภาพได้โดยตรง จึงไม่มีข้อมูลของภาพนี้' };
+    }
+  };
+  const agent = new KikuAgent({ client: fakeClient, maxIterations: 2 });
+  const result = await agent.run('ช่วยดูรูปนี้ให้หน่อย จวีจิ้งอี\n\n[USER ATTACHMENT: ผู้ใช้ได้แนบรูปภาพจำนวน 1 รูป: "my_photo.jpg" (image/jpeg)]');
+  assert.equal(callCount, 1);
+  assert.ok(result.includes('ไม่สามารถดูรูปภาพ'));
+});
+
+test('Edge Cases Suite: KikuAgent provides graceful fallback for image attachments instead of raw failure', async () => {
+  const fakeClient = {
+    provider: 'lmstudio',
+    model: 'google/gemma-4-e4b',
+    chat: async () => ({ role: 'assistant', content: '' })
+  };
+  const agent = new KikuAgent({ client: fakeClient, maxIterations: 1 });
+  const result = await agent.run('ดูภาพนี้\n\n[USER ATTACHMENT: ผู้ใช้ได้แนบรูปภาพจำนวน 1 รูป: "unknown.png" (image/png)]');
+  assert.ok(!result.includes('ขออภัยค่ะ ไม่สามารถประมวลผลคำตอบได้'));
+  assert.ok(result.includes('ได้รับรูปภาพเรียบร้อยแล้วค่ะ'));
+});
+
+test('Edge Cases Suite: KikuAgent does not intercept substantive negative answers as refusals', async () => {
+  let callCount = 0;
+  const fakeClient = {
+    provider: 'lmstudio',
+    model: 'google/gemma-4-e4b',
+    chat: async () => {
+      callCount++;
+      return {
+        role: 'assistant',
+        content: 'จากการตรวจสอบข้อมูลและประวัติการทำงานของจวีจิ้งอี ไม่พบว่ามีประวัติการกระทำความผิดกฎหมายหรือเรื่องอื้อฉาวใดๆ ในวงการบันเทิง เธอเป็นศิลปินและนักแสดงที่มีผลงานซีรีส์อย่าง In Blossom และ The Legend of White Snake อย่างต่อเนื่อง'
+      };
+    }
+  };
+  const agent = new KikuAgent({ client: fakeClient, maxIterations: 2 });
+  const result = await agent.run('จวีจิ้งอีเคยมีประวัติด้านลบหรือทำผิดกฎหมายอะไรไหม');
+  assert.equal(callCount, 1);
+  assert.ok(result.includes('ไม่พบว่ามีประวัติการกระทำความผิด'));
+});
+
+test('Edge Cases Suite: handleVerifyRoute verifies natural language claim using token overlap', async () => {
+  let jsonResponse = null;
+  let status = null;
+  const payload = JSON.stringify({ claim: 'Ju Jingyi starred as Yang Caiwei in the 2024 historical drama In Blossom' });
+  const req = {
+    method: 'POST',
+    url: '/api/verify',
+    headers: { 'content-type': 'application/json' },
+    on: (event, cb) => {
+      if (event === 'data') cb(Buffer.from(payload));
+      if (event === 'end') cb();
+      return req;
+    }
+  };
+  const res = {
+    writeHead: (s) => { status = s; },
+    end: (data) => { jsonResponse = JSON.parse(data); }
+  };
+  await handleVerifyRoute(req, res);
+  assert.equal(status, 200);
+  assert.equal(jsonResponse.verdict, 'PARTIALLY_VERIFIED');
+  assert.ok(jsonResponse.evidence.length > 0);
+});
+
+test('Edge Cases Suite: applyFutureEventGuard preserves confirmed 2026 dates when catalog tools are executed', () => {
+  const answer = 'ซีรีส์เรื่อง 《千香》 (The Eternal Fragrance) มีกำหนดออกอากาศในปี 2026';
+  const guarded = applyFutureEventGuard(answer, { tools: [{ name: 'search_works' }], now: new Date('2024-01-01') });
+  assert.ok(guarded.includes('2026'));
+  assert.ok(!guarded.includes('วันที่ในอนาคตที่ยังไม่ยืนยัน'));
+});
+