@nahisaho/shikigami-mcp-server 1.7.0 → 1.10.0

package/src/cache/__tests__/global.test.ts

@@ -0,0 +1,340 @@
+/**
+ * GlobalCacheStore Unit Tests
+ * v1.0.0 - REQ-CACHE-001-03
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import {
+  GlobalCacheStore,
+  DEFAULT_GLOBAL_CACHE_CONFIG,
+  getGlobalCacheStore,
+  resetGlobalCacheStore,
+  createGlobalCacheStore,
+} from '../global.js';
+
+// テスト用一時ディレクトリ
+let TEST_BASE_DIR: string;
+let TEST_PROJECT_DIR: string;
+
+describe('GlobalCacheStore', () => {
+  let globalStore: GlobalCacheStore;
+
+  beforeEach(async () => {
+    const suffix = Date.now() + '-' + Math.random().toString(36).substring(7);
+    TEST_BASE_DIR = `/tmp/shikigami-global-test-${suffix}`;
+    TEST_PROJECT_DIR = `/tmp/shikigami-project-test-${suffix}`;
+
+    globalStore = new GlobalCacheStore({
+      baseDir: TEST_BASE_DIR,
+      enabled: true,
+      preferProjectCache: true,
+    });
+
+    // シングルトンをリセット
+    resetGlobalCacheStore();
+  });
+
+  afterEach(async () => {
+    try {
+      await fs.rm(TEST_BASE_DIR, { recursive: true, force: true });
+      await fs.rm(TEST_PROJECT_DIR, { recursive: true, force: true });
+    } catch {
+      // 無視
+    }
+  });
+
+  describe('constructor', () => {
+    it('should create with default config', () => {
+      const store = new GlobalCacheStore({ baseDir: TEST_BASE_DIR });
+      expect(store).toBeDefined();
+      expect(store.getConfig().enabled).toBe(true);
+    });
+
+    it('should create with custom config', () => {
+      const store = new GlobalCacheStore({
+        baseDir: TEST_BASE_DIR,
+        maxEntries: 1000,
+        preferProjectCache: false,
+      });
+      expect(store.getConfig().maxEntries).toBe(1000);
+      expect(store.getConfig().preferProjectCache).toBe(false);
+    });
+
+    it('should set global cache dir correctly', () => {
+      const store = new GlobalCacheStore({ baseDir: TEST_BASE_DIR });
+      expect(store.getGlobalCacheDir()).toBe(path.join(TEST_BASE_DIR, 'global-cache'));
+    });
+  });
+
+  describe('project store', () => {
+    it('should set project store', () => {
+      expect(globalStore.hasProjectStore()).toBe(false);
+      globalStore.setProjectStore(TEST_PROJECT_DIR);
+      expect(globalStore.hasProjectStore()).toBe(true);
+    });
+
+    it('should clear project store', () => {
+      globalStore.setProjectStore(TEST_PROJECT_DIR);
+      expect(globalStore.hasProjectStore()).toBe(true);
+      globalStore.clearProjectStore();
+      expect(globalStore.hasProjectStore()).toBe(false);
+    });
+
+    it('should get project store', () => {
+      globalStore.setProjectStore(TEST_PROJECT_DIR);
+      const projectStore = globalStore.getProjectStore();
+      expect(projectStore).not.toBeNull();
+    });
+  });
+
+  describe('get/set operations', () => {
+    it('should store and retrieve from global scope', async () => {
+      await globalStore.set('test-key', { data: 'global' }, { scope: 'global' });
+      const result = await globalStore.get<{ data: string }>('test-key');
+
+      expect(result.hit).toBe(true);
+      expect(result.value?.data).toBe('global');
+      expect(result.scope).toBe('global');
+    });
+
+    it('should store and retrieve from project scope', async () => {
+      globalStore.setProjectStore(TEST_PROJECT_DIR);
+
+      await globalStore.set('test-key', { data: 'project' }, { scope: 'project' });
+      const result = await globalStore.get<{ data: string }>('test-key');
+
+      expect(result.hit).toBe(true);
+      expect(result.value?.data).toBe('project');
+      expect(result.scope).toBe('project');
+    });
+
+    it('should prefer project cache when configured', async () => {
+      globalStore.setProjectStore(TEST_PROJECT_DIR);
+
+      // 両方のスコープに保存
+      await globalStore.set('test-key', { data: 'global' }, { scope: 'global' });
+      await globalStore.set('test-key', { data: 'project' }, { scope: 'project' });
+
+      // プロジェクトキャッシュが優先される
+      const result = await globalStore.get<{ data: string }>('test-key');
+      expect(result.value?.data).toBe('project');
+      expect(result.scope).toBe('project');
+    });
+
+    it('should prefer global cache when configured', async () => {
+      globalStore.setPreferProjectCache(false);
+      globalStore.setProjectStore(TEST_PROJECT_DIR);
+
+      // 両方のスコープに保存
+      await globalStore.set('test-key', { data: 'global' }, { scope: 'global' });
+      await globalStore.set('test-key', { data: 'project' }, { scope: 'project' });
+
+      // グローバルキャッシュが優先される
+      const result = await globalStore.get<{ data: string }>('test-key');
+      expect(result.value?.data).toBe('global');
+      expect(result.scope).toBe('global');
+    });
+
+    it('should fallback to global when project cache miss', async () => {
+      globalStore.setProjectStore(TEST_PROJECT_DIR);
+
+      await globalStore.set('test-key', { data: 'global' }, { scope: 'global' });
+
+      const result = await globalStore.get<{ data: string }>('test-key');
+      expect(result.hit).toBe(true);
+      expect(result.value?.data).toBe('global');
+      expect(result.scope).toBe('global');
+    });
+
+    it('should return miss when not found', async () => {
+      const result = await globalStore.get('non-existent');
+      expect(result.hit).toBe(false);
+    });
+
+    it('should not save to global when disabled', async () => {
+      globalStore.setEnabled(false);
+      await globalStore.set('test-key', { data: 'test' }, { scope: 'global' });
+
+      const result = await globalStore.get('test-key');
+      expect(result.hit).toBe(false);
+    });
+  });
+
+  describe('delete', () => {
+    it('should delete from specific scope', async () => {
+      globalStore.setProjectStore(TEST_PROJECT_DIR);
+
+      await globalStore.set('test-key', { data: 'global' }, { scope: 'global' });
+      await globalStore.set('test-key', { data: 'project' }, { scope: 'project' });
+
+      // プロジェクトからのみ削除
+      const deleted = await globalStore.delete('test-key', 'project');
+      expect(deleted).toBe(true);
+
+      // グローバルにはまだ存在
+      globalStore.setPreferProjectCache(false);
+      const result = await globalStore.get<{ data: string }>('test-key');
+      expect(result.hit).toBe(true);
+      expect(result.value?.data).toBe('global');
+    });
+
+    it('should delete from both scopes when no scope specified', async () => {
+      globalStore.setProjectStore(TEST_PROJECT_DIR);
+
+      await globalStore.set('test-key', { data: 'global' }, { scope: 'global' });
+      await globalStore.set('test-key', { data: 'project' }, { scope: 'project' });
+
+      const deleted = await globalStore.delete('test-key');
+      expect(deleted).toBe(true);
+
+      const result = await globalStore.get('test-key');
+      expect(result.hit).toBe(false);
+    });
+  });
+
+  describe('has', () => {
+    it('should check existence in project scope', async () => {
+      globalStore.setProjectStore(TEST_PROJECT_DIR);
+      await globalStore.set('test-key', { data: 'project' }, { scope: 'project' });
+
+      const result = await globalStore.has('test-key');
+      expect(result.exists).toBe(true);
+      expect(result.scope).toBe('project');
+    });
+
+    it('should check existence in global scope', async () => {
+      await globalStore.set('test-key', { data: 'global' }, { scope: 'global' });
+
+      const result = await globalStore.has('test-key');
+      expect(result.exists).toBe(true);
+      expect(result.scope).toBe('global');
+    });
+
+    it('should return false for non-existent key', async () => {
+      const result = await globalStore.has('non-existent');
+      expect(result.exists).toBe(false);
+      expect(result.scope).toBeUndefined();
+    });
+  });
+
+  describe('clear', () => {
+    it('should clear specific scope', async () => {
+      globalStore.setProjectStore(TEST_PROJECT_DIR);
+
+      await globalStore.set('test-key', { data: 'global' }, { scope: 'global' });
+      await globalStore.set('test-key', { data: 'project' }, { scope: 'project' });
+
+      await globalStore.clear('project');
+
+      // プロジェクトはクリアされた
+      const projectStore = globalStore.getProjectStore()!;
+      const projectStats = await projectStore.getStats();
+      expect(projectStats.totalEntries).toBe(0);
+
+      // グローバルは残っている
+      const globalStats = await globalStore.getGlobalStore().getStats();
+      expect(globalStats.totalEntries).toBe(1);
+    });
+
+    it('should clear all scopes when no scope specified', async () => {
+      globalStore.setProjectStore(TEST_PROJECT_DIR);
+
+      await globalStore.set('test-key', { data: 'global' }, { scope: 'global' });
+      await globalStore.set('test-key', { data: 'project' }, { scope: 'project' });
+
+      await globalStore.clear();
+
+      const result = await globalStore.get('test-key');
+      expect(result.hit).toBe(false);
+    });
+  });
+
+  describe('getStats', () => {
+    it('should return global stats', async () => {
+      await globalStore.set('test-key', { data: 'global' }, { scope: 'global' });
+
+      const stats = await globalStore.getStats('global');
+      expect(stats.global).toBeDefined();
+      expect(stats.global!.totalEntries).toBe(1);
+      expect(stats.project).toBeUndefined();
+    });
+
+    it('should return project stats', async () => {
+      globalStore.setProjectStore(TEST_PROJECT_DIR);
+      await globalStore.set('test-key', { data: 'project' }, { scope: 'project' });
+
+      const stats = await globalStore.getStats('project');
+      expect(stats.project).toBeDefined();
+      expect(stats.project!.totalEntries).toBe(1);
+      expect(stats.global).toBeUndefined();
+    });
+
+    it('should return combined stats', async () => {
+      globalStore.setProjectStore(TEST_PROJECT_DIR);
+      await globalStore.set('key1', { data: 'global' }, { scope: 'global' });
+      await globalStore.set('key2', { data: 'project' }, { scope: 'project' });
+
+      const stats = await globalStore.getStats();
+      expect(stats.global).toBeDefined();
+      expect(stats.project).toBeDefined();
+      expect(stats.combined).toBeDefined();
+      expect(stats.combined!.totalEntries).toBe(2);
+    });
+  });
+
+  describe('evictExpired', () => {
+    it('should evict expired entries from both scopes', async () => {
+      globalStore.setProjectStore(TEST_PROJECT_DIR);
+
+      // 短いTTLで保存
+      await globalStore.set('global-key', { data: 'global' }, { scope: 'global', ttlSeconds: 1 });
+      await globalStore.set('project-key', { data: 'project' }, { scope: 'project', ttlSeconds: 1 });
+
+      // TTL期限後
+      await new Promise((resolve) => setTimeout(resolve, 1200));
+
+      const result = await globalStore.evictExpired();
+      expect(result.global).toBeGreaterThanOrEqual(0);
+      expect(result.project).toBeGreaterThanOrEqual(0);
+    });
+  });
+
+  describe('configuration', () => {
+    it('should toggle enabled state', () => {
+      expect(globalStore.getConfig().enabled).toBe(true);
+      globalStore.setEnabled(false);
+      expect(globalStore.getConfig().enabled).toBe(false);
+    });
+
+    it('should toggle preferProjectCache', () => {
+      expect(globalStore.getConfig().preferProjectCache).toBe(true);
+      globalStore.setPreferProjectCache(false);
+      expect(globalStore.getConfig().preferProjectCache).toBe(false);
+    });
+  });
+
+  describe('singleton', () => {
+    it('should return singleton instance', () => {
+      const store1 = getGlobalCacheStore({ baseDir: TEST_BASE_DIR });
+      const store2 = getGlobalCacheStore({ baseDir: TEST_BASE_DIR });
+      expect(store1).toBe(store2);
+    });
+
+    it('should reset singleton', () => {
+      const store1 = getGlobalCacheStore({ baseDir: TEST_BASE_DIR });
+      resetGlobalCacheStore();
+      const store2 = getGlobalCacheStore({ baseDir: TEST_BASE_DIR });
+      expect(store1).not.toBe(store2);
+    });
+  });
+
+  describe('createGlobalCacheStore', () => {
+    it('should create new instance', () => {
+      const store1 = createGlobalCacheStore({ baseDir: TEST_BASE_DIR });
+      const store2 = createGlobalCacheStore({ baseDir: TEST_BASE_DIR });
+      expect(store1).not.toBe(store2);
+    });
+  });
+});

package/src/cache/__tests__/manager.test.ts

@@ -0,0 +1,353 @@
+/**
+ * QueryCacheManager Unit Tests
+ * v1.0.0 - REQ-CACHE-001-01
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs/promises';
+import {
+  QueryCacheManager,
+  createCacheManager,
+  getDefaultCacheManager,
+  SearchCacheKeyParams,
+  VisitCacheKeyParams,
+  EmbeddingCacheKeyParams,
+} from '../manager.js';
+
+// テスト用一時ディレクトリ
+const TEST_CACHE_DIR = '/tmp/shikigami-manager-test-' + Date.now();
+
+describe('QueryCacheManager', () => {
+  let manager: QueryCacheManager;
+
+  beforeEach(async () => {
+    manager = new QueryCacheManager({
+      cacheDir: TEST_CACHE_DIR,
+      maxEntries: 100,
+      defaultTtlSeconds: 3600,
+    });
+  });
+
+  afterEach(async () => {
+    manager.stopMaintenanceTasks();
+    try {
+      await fs.rm(TEST_CACHE_DIR, { recursive: true, force: true });
+    } catch {
+      // 無視
+    }
+  });
+
+  describe('generateSearchKey', () => {
+    it('should generate key with query only', () => {
+      const key = QueryCacheManager.generateSearchKey({ query: 'test query' });
+      expect(key).toBe('search:default:test query');
+    });
+
+    it('should generate key with engine', () => {
+      const key = QueryCacheManager.generateSearchKey({
+        query: 'test query',
+        engine: 'google',
+      });
+      expect(key).toBe('search:google:test query');
+    });
+
+    it('should generate key with options', () => {
+      const key = QueryCacheManager.generateSearchKey({
+        query: 'test query',
+        engine: 'google',
+        options: { lang: 'ja', safe: true },
+      });
+      expect(key).toContain('search:google:test query');
+      expect(key).toContain('lang');
+    });
+  });
+
+  describe('generateVisitKey', () => {
+    it('should generate key with URL only', () => {
+      const key = QueryCacheManager.generateVisitKey({
+        url: 'https://example.com/page',
+      });
+      expect(key).toBe('visit:https://example.com/page');
+    });
+
+    it('should generate key with options', () => {
+      const key = QueryCacheManager.generateVisitKey({
+        url: 'https://example.com/page',
+        options: { extractImages: true },
+      });
+      expect(key).toContain('visit:https://example.com/page');
+      expect(key).toContain('extractImages');
+    });
+  });
+
+  describe('generateEmbeddingKey', () => {
+    it('should generate key with short text', () => {
+      const key = QueryCacheManager.generateEmbeddingKey({
+        text: 'short text',
+      });
+      expect(key).toBe('embedding:default:short text');
+    });
+
+    it('should generate key with model', () => {
+      const key = QueryCacheManager.generateEmbeddingKey({
+        text: 'test',
+        model: 'ada-002',
+      });
+      expect(key).toBe('embedding:ada-002:test');
+    });
+
+    it('should hash long text', () => {
+      const longText = 'a'.repeat(200);
+      const key = QueryCacheManager.generateEmbeddingKey({ text: longText });
+      expect(key).toContain('embedding:default:');
+      expect(key.length).toBeLessThan(50); // ハッシュ化されている
+    });
+  });
+
+  describe('search cache', () => {
+    it('should cache and retrieve search results', async () => {
+      const params: SearchCacheKeyParams = {
+        query: 'AI trends 2026',
+        engine: 'google',
+      };
+      const value = {
+        results: [
+          { title: 'AI in 2026', url: 'https://example.com/ai' },
+        ],
+      };
+
+      await manager.setSearchResult(params, value);
+      const result = await manager.getSearchResult(params);
+
+      expect(result.hit).toBe(true);
+      expect(result.value).toEqual(value);
+    });
+
+    it('should return miss for uncached search', async () => {
+      const result = await manager.getSearchResult({
+        query: 'uncached query',
+      });
+      expect(result.hit).toBe(false);
+    });
+
+    it('should set source to search', async () => {
+      const params: SearchCacheKeyParams = { query: 'test' };
+      await manager.setSearchResult(params, { data: 'test' });
+      const result = await manager.getSearchResult(params);
+
+      expect(result.meta?.source).toBe('search');
+    });
+  });
+
+  describe('visit cache', () => {
+    it('should cache and retrieve visit results', async () => {
+      const params: VisitCacheKeyParams = {
+        url: 'https://example.com/article',
+      };
+      const value = {
+        title: 'Article Title',
+        content: 'Article content...',
+      };
+
+      await manager.setVisitResult(params, value);
+      const result = await manager.getVisitResult(params);
+
+      expect(result.hit).toBe(true);
+      expect(result.value).toEqual(value);
+    });
+
+    it('should return miss for uncached visit', async () => {
+      const result = await manager.getVisitResult({
+        url: 'https://uncached.com/page',
+      });
+      expect(result.hit).toBe(false);
+    });
+
+    it('should set source to visit', async () => {
+      const params: VisitCacheKeyParams = { url: 'https://example.com' };
+      await manager.setVisitResult(params, { data: 'test' });
+      const result = await manager.getVisitResult(params);
+
+      expect(result.meta?.source).toBe('visit');
+    });
+  });
+
+  describe('embedding cache', () => {
+    it('should cache and retrieve embeddings', async () => {
+      const params: EmbeddingCacheKeyParams = {
+        text: 'Hello world',
+        model: 'ada-002',
+      };
+      const value = {
+        embedding: [0.1, 0.2, 0.3, 0.4],
+      };
+
+      await manager.setEmbedding(params, value);
+      const result = await manager.getEmbedding(params);
+
+      expect(result.hit).toBe(true);
+      expect(result.value).toEqual(value);
+    });
+
+    it('should return miss for uncached embedding', async () => {
+      const result = await manager.getEmbedding({
+        text: 'uncached text',
+      });
+      expect(result.hit).toBe(false);
+    });
+
+    it('should set source to embedding', async () => {
+      const params: EmbeddingCacheKeyParams = { text: 'test' };
+      await manager.setEmbedding(params, { vector: [0.1] });
+      const result = await manager.getEmbedding(params);
+
+      expect(result.meta?.source).toBe('embedding');
+    });
+  });
+
+  describe('generic cache', () => {
+    it('should cache and retrieve generic data', async () => {
+      const key = 'custom:analysis:report-001';
+      const value = { score: 85, details: 'Good' };
+
+      await manager.set(key, value, { source: 'analysis' });
+      const result = await manager.get(key);
+
+      expect(result.hit).toBe(true);
+      expect(result.value).toEqual(value);
+    });
+  });
+
+  describe('delete', () => {
+    it('should delete a cached entry', async () => {
+      const params: SearchCacheKeyParams = { query: 'to delete' };
+      await manager.setSearchResult(params, { data: 'test' });
+
+      const key = QueryCacheManager.generateSearchKey(params);
+      const deleted = await manager.delete(key);
+
+      expect(deleted).toBe(true);
+
+      const result = await manager.getSearchResult(params);
+      expect(result.hit).toBe(false);
+    });
+  });
+
+  describe('invalidateUrl', () => {
+    it('should invalidate URL-related caches', async () => {
+      const url = 'https://example.com/page';
+      await manager.setVisitResult({ url }, { content: 'test' });
+
+      const deletedCount = await manager.invalidateUrl(url);
+
+      expect(deletedCount).toBeGreaterThanOrEqual(1);
+
+      const result = await manager.getVisitResult({ url });
+      expect(result.hit).toBe(false);
+    });
+  });
+
+  describe('invalidateBySource', () => {
+    it('should invalidate all entries of a source', async () => {
+      await manager.setSearchResult({ query: 'q1' }, { data: '1' });
+      await manager.setSearchResult({ query: 'q2' }, { data: '2' });
+      await manager.setVisitResult({ url: 'https://example.com' }, { data: '3' });
+
+      const deletedCount = await manager.invalidateBySource('search');
+
+      expect(deletedCount).toBe(2);
+
+      const r1 = await manager.getSearchResult({ query: 'q1' });
+      const r2 = await manager.getSearchResult({ query: 'q2' });
+      const r3 = await manager.getVisitResult({ url: 'https://example.com' });
+
+      expect(r1.hit).toBe(false);
+      expect(r2.hit).toBe(false);
+      expect(r3.hit).toBe(true);
+    });
+  });
+
+  describe('clear', () => {
+    it('should clear all cached entries', async () => {
+      await manager.setSearchResult({ query: 'q1' }, { data: '1' });
+      await manager.setVisitResult({ url: 'https://example.com' }, { data: '2' });
+      await manager.setEmbedding({ text: 'test' }, { vector: [0.1] });
+
+      await manager.clear();
+
+      const r1 = await manager.getSearchResult({ query: 'q1' });
+      const r2 = await manager.getVisitResult({ url: 'https://example.com' });
+      const r3 = await manager.getEmbedding({ text: 'test' });
+
+      expect(r1.hit).toBe(false);
+      expect(r2.hit).toBe(false);
+      expect(r3.hit).toBe(false);
+    });
+  });
+
+  describe('getStats', () => {
+    it('should return cache statistics', async () => {
+      await manager.setSearchResult({ query: 'q1' }, { data: '1' });
+      await manager.getSearchResult({ query: 'q1' }); // hit
+      await manager.getSearchResult({ query: 'q2' }); // miss
+
+      const stats = await manager.getStats();
+
+      expect(stats.totalEntries).toBe(1);
+      expect(stats.hits).toBeGreaterThanOrEqual(1);
+      expect(stats.misses).toBeGreaterThanOrEqual(1);
+    });
+  });
+
+  describe('getSummary', () => {
+    it('should return formatted summary string', async () => {
+      await manager.setSearchResult({ query: 'test' }, { data: 'value' });
+      await manager.getSearchResult({ query: 'test' });
+
+      const summary = await manager.getSummary();
+
+      expect(summary).toContain('Cache Summary:');
+      expect(summary).toContain('Entries:');
+      expect(summary).toContain('Size:');
+      expect(summary).toContain('Hit Rate:');
+    });
+  });
+
+  describe('maintenance tasks', () => {
+    it('should start and stop maintenance tasks', () => {
+      manager.startMaintenanceTasks();
+      // タイマーが設定されていることを確認
+      expect(() => manager.stopMaintenanceTasks()).not.toThrow();
+    });
+  });
+
+  describe('getStore', () => {
+    it('should return the underlying store', () => {
+      const store = manager.getStore();
+      expect(store).toBeDefined();
+    });
+  });
+});
+
+describe('createCacheManager', () => {
+  it('should create a new QueryCacheManager instance', () => {
+    const manager = createCacheManager();
+    expect(manager).toBeInstanceOf(QueryCacheManager);
+  });
+
+  it('should accept custom config', () => {
+    const manager = createCacheManager({
+      maxEntries: 500,
+      defaultTtlSeconds: 7200,
+    });
+    expect(manager).toBeInstanceOf(QueryCacheManager);
+  });
+});
+
+describe('getDefaultCacheManager', () => {
+  it('should return a singleton instance', () => {
+    const manager1 = getDefaultCacheManager();
+    const manager2 = getDefaultCacheManager();
+    expect(manager1).toBe(manager2);
+  });
+});