test: add BM25 Unicode, graph migration, version conflict, relation events, Unicode content tests

prih · prih · commit be32a57c8979 · 2026-03-30T02:02:53.000+01:00
New test suites:
- bm25: Cyrillic/CJK/Arabic tokenization + BM25 Cyrillic search (6 tests)
- graph-migration: preserves user data on version/embedding change (5 tests)
- version-conflict: optimistic locking for notes and tasks (7 tests)
- relation-events: emit events on create/delete relations for all 3 graphs (7 tests)
- unicode-content: Cyrillic/CJK/mixed content via MCP tools (8 tests)

Total: 1879 tests across 51 suites.
diff --git a/src/tests/bm25.test.ts b/src/tests/bm25.test.ts
@@ -50,6 +50,37 @@ describe('tokenize', () => {
   it('handles single word', () => {
     expect(tokenize('jwt')).toEqual(['jwt']);
   });
+
+  // Unicode support
+  it('tokenizes Cyrillic text', () => {
+    expect(tokenize('Создать задачу')).toEqual(['создать', 'задачу']);
+  });
+
+  it('tokenizes mixed Latin + Cyrillic', () => {
+    expect(tokenize('Mixed русский text')).toEqual(['mixed', 'русский', 'text']);
+  });
+
+  it('tokenizes CJK text', () => {
+    const tokens = tokenize('データ分析');
+    expect(tokens.length).toBeGreaterThan(0);
+    expect(tokens[0]).toContain('データ');
+  });
+
+  it('tokenizes Arabic text', () => {
+    const tokens = tokenize('مرحبا بالعالم');
+    expect(tokens.length).toBe(2);
+  });
+
+  it('BM25 finds Cyrillic documents', () => {
+    type Doc = { text: string };
+    const idx = new BM25Index<Doc>((d) => d.text);
+    idx.addDocument('d1', { text: 'Создать новую задачу' });
+    idx.addDocument('d2', { text: 'English only document' });
+
+    const scores = idx.score('задачу');
+    expect(scores.has('d1')).toBe(true);
+    expect(scores.has('d2')).toBe(false);
+  });
 });
 
 describe('BM25Index', () => {
diff --git a/src/tests/graph-migration.test.ts b/src/tests/graph-migration.test.ts
@@ -0,0 +1,123 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { loadKnowledgeGraph, saveKnowledgeGraph, createKnowledgeGraph } from '@/graphs/knowledge';
+import { loadTaskGraph, saveTaskGraph, createTaskGraph } from '@/graphs/task';
+import { loadSkillGraph, saveSkillGraph, createSkillGraph } from '@/graphs/skill';
+import { GRAPH_DATA_VERSION } from '@/lib/defaults';
+
+function tmpDir(): string {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'gm-migration-'));
+  return dir;
+}
+
+describe('Graph migration — preserves user data on version/embedding change', () => {
+  describe('Knowledge graph', () => {
+    it('preserves notes when data version changes', () => {
+      const dir = tmpDir();
+
+      // Create and save a graph with a note
+      const graph = createKnowledgeGraph();
+      graph.addNode('test-note', {
+        title: 'My Note', content: 'Important data', tags: ['keep'],
+        embedding: [1, 2, 3], createdAt: 1000, updatedAt: 2000, version: 1,
+        attachments: [],
+      });
+      saveKnowledgeGraph(graph, dir, 'model-v1');
+
+      // Tamper version in saved file to simulate old version
+      const file = path.join(dir, 'knowledge.json');
+      const data = JSON.parse(fs.readFileSync(file, 'utf-8'));
+      data.version = GRAPH_DATA_VERSION - 1;
+      fs.writeFileSync(file, JSON.stringify(data));
+
+      // Load — should preserve data but clear embeddings
+      const loaded = loadKnowledgeGraph(dir, false, 'model-v1');
+      expect(loaded.hasNode('test-note')).toBe(true);
+      expect(loaded.getNodeAttribute('test-note', 'title')).toBe('My Note');
+      expect(loaded.getNodeAttribute('test-note', 'content')).toBe('Important data');
+      expect(loaded.getNodeAttribute('test-note', 'embedding')).toEqual([]);
+    });
+
+    it('preserves notes when embedding model changes', () => {
+      const dir = tmpDir();
+
+      const graph = createKnowledgeGraph();
+      graph.addNode('note-2', {
+        title: 'Note 2', content: 'Data', tags: [],
+        embedding: [4, 5, 6], createdAt: 1000, updatedAt: 2000, version: 1,
+        attachments: [],
+      });
+      saveKnowledgeGraph(graph, dir, 'old-model');
+
+      // Load with different embedding fingerprint
+      const loaded = loadKnowledgeGraph(dir, false, 'new-model');
+      expect(loaded.hasNode('note-2')).toBe(true);
+      expect(loaded.getNodeAttribute('note-2', 'title')).toBe('Note 2');
+      expect(loaded.getNodeAttribute('note-2', 'embedding')).toEqual([]);
+    });
+
+    it('keeps embeddings when nothing changed', () => {
+      const dir = tmpDir();
+
+      const graph = createKnowledgeGraph();
+      graph.addNode('note-3', {
+        title: 'Note 3', content: 'Data', tags: [],
+        embedding: [7, 8, 9], createdAt: 1000, updatedAt: 2000, version: 1,
+        attachments: [],
+      });
+      saveKnowledgeGraph(graph, dir, 'same-model');
+
+      const loaded = loadKnowledgeGraph(dir, false, 'same-model');
+      expect(loaded.getNodeAttribute('note-3', 'embedding')).toEqual([7, 8, 9]);
+    });
+  });
+
+  describe('Task graph', () => {
+    it('preserves tasks when data version changes', () => {
+      const dir = tmpDir();
+
+      const graph = createTaskGraph();
+      graph.addNode('test-task', {
+        title: 'My Task', description: 'Do something', status: 'todo',
+        priority: 'high', tags: [], embedding: [1, 2],
+        dueDate: null, estimate: null, completedAt: null, assignee: null,
+        order: 0, nodeType: 'task',
+        createdAt: 1000, updatedAt: 2000, version: 1, attachments: [],
+      });
+      saveTaskGraph(graph, dir, 'model-v1');
+
+      const file = path.join(dir, 'tasks.json');
+      const data = JSON.parse(fs.readFileSync(file, 'utf-8'));
+      data.version = GRAPH_DATA_VERSION - 1;
+      fs.writeFileSync(file, JSON.stringify(data));
+
+      const loaded = loadTaskGraph(dir, false, 'model-v1');
+      expect(loaded.hasNode('test-task')).toBe(true);
+      expect(loaded.getNodeAttribute('test-task', 'title')).toBe('My Task');
+      expect(loaded.getNodeAttribute('test-task', 'embedding')).toEqual([]);
+    });
+  });
+
+  describe('Skill graph', () => {
+    it('preserves skills when embedding model changes', () => {
+      const dir = tmpDir();
+
+      const graph = createSkillGraph();
+      graph.addNode('test-skill', {
+        title: 'Deploy', description: 'How to deploy', tags: [],
+        steps: ['step1'], triggers: ['deploy'], inputHints: [], filePatterns: [],
+        source: 'user', confidence: 1, usageCount: 0, lastUsedAt: null,
+        embedding: [1, 2], createdAt: 1000, updatedAt: 2000, version: 1,
+        attachments: [],
+      });
+      saveSkillGraph(graph, dir, 'old-model');
+
+      const loaded = loadSkillGraph(dir, false, 'new-model');
+      expect(loaded.hasNode('test-skill')).toBe(true);
+      expect(loaded.getNodeAttribute('test-skill', 'title')).toBe('Deploy');
+      expect(loaded.getNodeAttribute('test-skill', 'steps')).toEqual(['step1']);
+      expect(loaded.getNodeAttribute('test-skill', 'embedding')).toEqual([]);
+    });
+  });
+});
diff --git a/src/tests/relation-events.test.ts b/src/tests/relation-events.test.ts
@@ -0,0 +1,127 @@
+import { createKnowledgeGraph } from '@/graphs/knowledge-types';
+import { KnowledgeGraphManager } from '@/graphs/knowledge';
+import { createTaskGraph } from '@/graphs/task-types';
+import { TaskGraphManager } from '@/graphs/task';
+import { createSkillGraph } from '@/graphs/skill-types';
+import { SkillGraphManager } from '@/graphs/skill';
+import { unitVec, DIM } from '@/tests/helpers';
+
+const fakeEmbed = async () => unitVec(0, DIM);
+const embedFns = { document: fakeEmbed, query: fakeEmbed };
+
+function makeCtx() {
+  const events: Array<[string, any]> = [];
+  return {
+    markDirty: () => {},
+    emit: (event: string, data: any) => { events.push([event, data]); },
+    projectId: 'test',
+    events,
+  } as any;
+}
+
+describe('Relation events', () => {
+  describe('Knowledge graph', () => {
+    let mgr: KnowledgeGraphManager;
+    let ctx: ReturnType<typeof makeCtx>;
+    let idA: string, idB: string;
+
+    beforeEach(async () => {
+      ctx = makeCtx();
+      const graph = createKnowledgeGraph();
+      mgr = new KnowledgeGraphManager(graph, embedFns, ctx);
+      idA = await mgr.createNote('Note A', 'content a');
+      idB = await mgr.createNote('Note B', 'content b');
+      ctx.events.length = 0; // clear creation events
+    });
+
+    it('emits note:relation:added on createRelation', () => {
+      const ok = mgr.createRelation(idA, idB, 'depends_on');
+      expect(ok).toBe(true);
+      const ev = ctx.events.find(([e]: [string, any]) => e === 'note:relation:added');
+      expect(ev).toBeDefined();
+      expect(ev![1]).toMatchObject({ noteId: idA, toId: idB, kind: 'depends_on' });
+    });
+
+    it('emits note:relation:deleted on deleteRelation', () => {
+      mgr.createRelation(idA, idB, 'depends_on');
+      ctx.events.length = 0;
+
+      const ok = mgr.deleteRelation(idA, idB);
+      expect(ok).toBe(true);
+      const ev = ctx.events.find(([e]: [string, any]) => e === 'note:relation:deleted');
+      expect(ev).toBeDefined();
+      expect(ev![1]).toMatchObject({ noteId: idA, toId: idB });
+    });
+
+    it('does not emit on failed createRelation', () => {
+      mgr.createRelation('nonexistent', idB, 'refs');
+      expect(ctx.events.find(([e]: [string, any]) => e === 'note:relation:added')).toBeUndefined();
+    });
+  });
+
+  describe('Task graph', () => {
+    let mgr: TaskGraphManager;
+    let ctx: ReturnType<typeof makeCtx>;
+    let idA: string, idB: string;
+
+    beforeEach(async () => {
+      ctx = makeCtx();
+      const graph = createTaskGraph();
+      mgr = new TaskGraphManager(graph, embedFns, ctx);
+      idA = await mgr.createTask('Task A', 'desc', 'todo', 'medium');
+      idB = await mgr.createTask('Task B', 'desc', 'todo', 'medium');
+      ctx.events.length = 0;
+    });
+
+    it('emits task:relation:added on linkTasks', () => {
+      const ok = mgr.linkTasks(idA, idB, 'blocks');
+      expect(ok).toBe(true);
+      const ev = ctx.events.find(([e]: [string, any]) => e === 'task:relation:added');
+      expect(ev).toBeDefined();
+      expect(ev![1]).toMatchObject({ taskId: idA, toId: idB, kind: 'blocks' });
+    });
+
+    it('emits task:relation:deleted on deleteTaskLink', () => {
+      mgr.linkTasks(idA, idB, 'blocks');
+      ctx.events.length = 0;
+
+      const ok = mgr.deleteTaskLink(idA, idB);
+      expect(ok).toBe(true);
+      const ev = ctx.events.find(([e]: [string, any]) => e === 'task:relation:deleted');
+      expect(ev).toBeDefined();
+    });
+  });
+
+  describe('Skill graph', () => {
+    let mgr: SkillGraphManager;
+    let ctx: ReturnType<typeof makeCtx>;
+    let idA: string, idB: string;
+
+    beforeEach(async () => {
+      ctx = makeCtx();
+      const graph = createSkillGraph();
+      mgr = new SkillGraphManager(graph, embedFns, ctx);
+      idA = await mgr.createSkill('Skill A', 'desc');
+      idB = await mgr.createSkill('Skill B', 'desc');
+      ctx.events.length = 0;
+    });
+
+    it('emits skill:relation:added on linkSkills', () => {
+      const ok = mgr.linkSkills(idA, idB, 'related_to');
+      expect(ok).toBe(true);
+      const ev = ctx.events.find(([e]: [string, any]) => e === 'skill:relation:added');
+      expect(ev).toBeDefined();
+      expect(ev![1]).toMatchObject({ skillId: idA, toId: idB, kind: 'related_to' });
+    });
+
+    it('emits skill:relation:deleted on deleteSkillLink', () => {
+      mgr.linkSkills(idA, idB, 'related_to');
+      ctx.events.length = 0;
+
+      const ok = mgr.deleteSkillLink(idA, idB);
+      expect(ok).toBe(true);
+      const ev = ctx.events.find(([e]: [string, any]) => e === 'skill:relation:deleted');
+      expect(ev).toBeDefined();
+    });
+  });
+});
diff --git a/src/tests/unicode-content.test.ts b/src/tests/unicode-content.test.ts
@@ -0,0 +1,86 @@
+import { createTaskGraph } from '@/graphs/task-types';
+import { createKnowledgeGraph } from '@/graphs/knowledge-types';
+import {
+  setupMcpClient, createFakeEmbed, json, jsonList,
+  type McpTestContext,
+} from '@/tests/helpers';
+
+describe('Unicode content — Cyrillic, CJK, emoji', () => {
+  let ctx: McpTestContext;
+
+  beforeAll(async () => {
+    const embedFn = createFakeEmbed([['задача', 1], ['ノート', 2], ['deploy', 3]]);
+    const taskGraph = createTaskGraph();
+    const knowledgeGraph = createKnowledgeGraph();
+    ctx = await setupMcpClient({ taskGraph, knowledgeGraph, embedFn });
+  });
+
+  afterAll(async () => { await ctx.close(); });
+
+  let cyrillicNoteId: string;
+
+  it('creates a note with Cyrillic title and content', async () => {
+    const r = json<{ noteId: string }>(await ctx.call('notes_create', {
+      title: 'Архитектура системы',
+      content: 'Описание архитектуры на русском языке',
+      tags: ['архитектура', 'документация'],
+    }));
+    expect(r.noteId).toBeTruthy();
+    cyrillicNoteId = r.noteId;
+  });
+
+  it('retrieves note with Cyrillic content', async () => {
+    const r = json<any>(await ctx.call('notes_get', { noteId: cyrillicNoteId }));
+    expect(r.title).toBe('Архитектура системы');
+    expect(r.tags).toContain('архитектура');
+  });
+
+  it('lists notes and finds Cyrillic note', async () => {
+    const r = jsonList<any>(await ctx.call('notes_list', {}));
+    expect(r.some((n: any) => n.title === 'Архитектура системы')).toBe(true);
+  });
+
+  it('creates a task with CJK title', async () => {
+    const r = json<{ taskId: string }>(await ctx.call('tasks_create', {
+      title: 'データベース移行',
+      description: '日本語のタスク説明',
+      priority: 'high',
+    }));
+    expect(r.taskId).toBeTruthy();
+  });
+
+  it('creates a task with emoji in tags', async () => {
+    const r = json<{ taskId: string }>(await ctx.call('tasks_create', {
+      title: 'Deploy with care',
+      description: 'Be careful',
+      priority: 'medium',
+      tags: ['deploy', 'important'],
+    }));
+    expect(r.taskId).toBeTruthy();
+  });
+
+  let mixedNoteId: string;
+
+  it('creates a note with mixed language content', async () => {
+    const r = json<{ noteId: string }>(await ctx.call('notes_create', {
+      title: 'Mixed: English и Русский',
+      content: 'This note has English and русский текст together. Also データ.',
+    }));
+    expect(r.noteId).toBeTruthy();
+    mixedNoteId = r.noteId;
+  });
+
+  it('retrieves mixed language note', async () => {
+    const r = json<any>(await ctx.call('notes_get', { noteId: mixedNoteId }));
+    expect(r.title).toBe('Mixed: English и Русский');
+    expect(r.content).toContain('русский текст');
+  });
+
+  it('searches notes by Cyrillic keyword', async () => {
+    const r = await ctx.call('notes_search', { q: 'архитектура', searchMode: 'keyword' });
+    if (!r.isError) {
+      const items = jsonList<any>(r);
+      expect(items.some((n: any) => n.title.includes('Архитектура'))).toBe(true);
+    }
+  });
+});
diff --git a/src/tests/version-conflict.test.ts b/src/tests/version-conflict.test.ts
