@selesai/code 0.13.0 → 0.13.1

package/dist/extensions/pi-hermes-memory/tests/store/session-parser.test.ts

@@ -0,0 +1,282 @@
+import { describe, it, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { parseSessionFile, getSessionFiles, decodeProjectDir } from '../../src/store/session-parser.js';
+
+describe('session-parser', () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'session-parser-test-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  describe('parseSessionFile', () => {
+    it('should parse a valid session JSONL file', () => {
+      const filePath = path.join(tmpDir, 'test-session.jsonl');
+      const lines = [
+        JSON.stringify({
+          type: 'session',
+          id: 'session-123',
+          timestamp: '2026-05-03T00:00:00Z',
+          cwd: '/Users/test/Documents/my-project',
+        }),
+        JSON.stringify({
+          type: 'message',
+          id: 'msg-1',
+          parentId: null,
+          timestamp: '2026-05-03T00:01:00Z',
+          message: {
+            role: 'user',
+            content: [{ type: 'text', text: 'Hello, how are you?' }],
+            timestamp: Date.now(),
+          },
+        }),
+        JSON.stringify({
+          type: 'message',
+          id: 'msg-2',
+          parentId: 'msg-1',
+          timestamp: '2026-05-03T00:01:30Z',
+          message: {
+            role: 'assistant',
+            content: [
+              { type: 'thinking', thinking: 'The user said hello' },
+              { type: 'text', text: 'I am doing well, thank you!' },
+            ],
+            timestamp: Date.now(),
+          },
+        }),
+      ];
+      fs.writeFileSync(filePath, lines.join('\n'));
+
+      const result = parseSessionFile(filePath);
+      assert.ok(result);
+      assert.strictEqual(result.id, 'session-123');
+      assert.strictEqual(result.project, 'my-project');
+      assert.strictEqual(result.cwd, '/Users/test/Documents/my-project');
+      assert.strictEqual(result.messages.length, 2);
+      assert.strictEqual(result.messages[0].role, 'user');
+      assert.strictEqual(result.messages[0].content, 'Hello, how are you?');
+      assert.strictEqual(result.messages[1].role, 'assistant');
+      assert.strictEqual(result.messages[1].content, 'I am doing well, thank you!');
+    });
+
+    it('should skip thinking blocks in assistant messages', () => {
+      const filePath = path.join(tmpDir, 'test.jsonl');
+      const lines = [
+        JSON.stringify({ type: 'session', id: 's1', timestamp: '2026-05-03T00:00:00Z', cwd: '/test' }),
+        JSON.stringify({
+          type: 'message',
+          id: 'msg-1',
+          parentId: null,
+          timestamp: '2026-05-03T00:01:00Z',
+          message: {
+            role: 'assistant',
+            content: [
+              { type: 'thinking', thinking: 'Internal reasoning...' },
+              { type: 'text', text: 'Actual response' },
+            ],
+            timestamp: Date.now(),
+          },
+        }),
+      ];
+      fs.writeFileSync(filePath, lines.join('\n'));
+
+      const result = parseSessionFile(filePath);
+      assert.ok(result);
+      assert.strictEqual(result.messages[0].content, 'Actual response');
+    });
+
+    it('should extract tool call names from assistant messages', () => {
+      const filePath = path.join(tmpDir, 'test.jsonl');
+      const lines = [
+        JSON.stringify({ type: 'session', id: 's1', timestamp: '2026-05-03T00:00:00Z', cwd: '/test' }),
+        JSON.stringify({
+          type: 'message',
+          id: 'msg-1',
+          parentId: null,
+          timestamp: '2026-05-03T00:01:00Z',
+          message: {
+            role: 'assistant',
+            content: [
+              { type: 'text', text: 'Let me check...' },
+              { type: 'tool_use', name: 'read', input: {} },
+              { type: 'tool_use', name: 'bash', input: {} },
+            ],
+            timestamp: Date.now(),
+          },
+        }),
+      ];
+      fs.writeFileSync(filePath, lines.join('\n'));
+
+      const result = parseSessionFile(filePath);
+      assert.ok(result);
+      assert.deepStrictEqual(result.messages[0].toolCalls, ['read', 'bash']);
+    });
+
+    it('should skip empty messages', () => {
+      const filePath = path.join(tmpDir, 'test.jsonl');
+      const lines = [
+        JSON.stringify({ type: 'session', id: 's1', timestamp: '2026-05-03T00:00:00Z', cwd: '/test' }),
+        JSON.stringify({
+          type: 'message',
+          id: 'msg-1',
+          parentId: null,
+          timestamp: '2026-05-03T00:01:00Z',
+          message: { role: 'user', content: [], timestamp: Date.now() },
+        }),
+        JSON.stringify({
+          type: 'message',
+          id: 'msg-2',
+          parentId: null,
+          timestamp: '2026-05-03T00:02:00Z',
+          message: { role: 'user', content: [{ type: 'text', text: 'Hello' }], timestamp: Date.now() },
+        }),
+      ];
+      fs.writeFileSync(filePath, lines.join('\n'));
+
+      const result = parseSessionFile(filePath);
+      assert.ok(result);
+      assert.strictEqual(result.messages.length, 1);
+      assert.strictEqual(result.messages[0].content, 'Hello');
+    });
+
+    it('should skip non-message entry types', () => {
+      const filePath = path.join(tmpDir, 'test.jsonl');
+      const lines = [
+        JSON.stringify({ type: 'session', id: 's1', timestamp: '2026-05-03T00:00:00Z', cwd: '/test' }),
+        JSON.stringify({ type: 'model_change', id: 'mc1', parentId: null, timestamp: '2026-05-03T00:00:01Z' }),
+        JSON.stringify({ type: 'thinking_level_change', id: 'tl1', parentId: null, timestamp: '2026-05-03T00:00:02Z' }),
+        JSON.stringify({ type: 'custom', id: 'c1', parentId: null, timestamp: '2026-05-03T00:00:03Z' }),
+        JSON.stringify({
+          type: 'message',
+          id: 'msg-1',
+          parentId: null,
+          timestamp: '2026-05-03T00:01:00Z',
+          message: { role: 'user', content: [{ type: 'text', text: 'Hello' }], timestamp: Date.now() },
+        }),
+      ];
+      fs.writeFileSync(filePath, lines.join('\n'));
+
+      const result = parseSessionFile(filePath);
+      assert.ok(result);
+      assert.strictEqual(result.messages.length, 1);
+    });
+
+    it('should handle malformed JSONL lines gracefully', () => {
+      const filePath = path.join(tmpDir, 'test.jsonl');
+      const content = [
+        JSON.stringify({ type: 'session', id: 's1', timestamp: '2026-05-03T00:00:00Z', cwd: '/test' }),
+        'not valid json',
+        '',
+        JSON.stringify({
+          type: 'message',
+          id: 'msg-1',
+          parentId: null,
+          timestamp: '2026-05-03T00:01:00Z',
+          message: { role: 'user', content: [{ type: 'text', text: 'Hello' }], timestamp: Date.now() },
+        }),
+      ];
+      fs.writeFileSync(filePath, content.join('\n'));
+
+      const result = parseSessionFile(filePath);
+      assert.ok(result);
+      assert.strictEqual(result.messages.length, 1);
+    });
+
+    it('should return null for empty file', () => {
+      const filePath = path.join(tmpDir, 'empty.jsonl');
+      fs.writeFileSync(filePath, '');
+
+      const result = parseSessionFile(filePath);
+      assert.strictEqual(result, null);
+    });
+
+    it('should return null if no session entry found', () => {
+      const filePath = path.join(tmpDir, 'no-session.jsonl');
+      fs.writeFileSync(filePath, JSON.stringify({ type: 'message', id: 'm1' }));
+
+      const result = parseSessionFile(filePath);
+      assert.strictEqual(result, null);
+    });
+
+    it('should skip tool_result content while retaining assistant text', () => {
+      const filePath = path.join(tmpDir, 'test.jsonl');
+      const lines = [
+        JSON.stringify({ type: 'session', id: 's1', timestamp: '2026-05-03T00:00:00Z', cwd: '/test' }),
+        JSON.stringify({
+          type: 'message',
+          id: 'msg-1',
+          parentId: null,
+          timestamp: '2026-05-03T00:01:00Z',
+          message: {
+            role: 'assistant',
+            content: [
+              { type: 'text', text: 'I inspected the file.' },
+              {
+                type: 'tool_result',
+                content: [{ type: 'text', text: 'large file contents must not be indexed' }],
+              },
+            ],
+            timestamp: Date.now(),
+          },
+        }),
+      ];
+      fs.writeFileSync(filePath, lines.join('\n'));
+
+      const result = parseSessionFile(filePath);
+      assert.ok(result);
+      assert.strictEqual(result.messages[0].content, 'I inspected the file.');
+    });
+  });
+
+  describe('getSessionFiles', () => {
+    it('should return empty array if directory does not exist', () => {
+      const result = getSessionFiles('/nonexistent/path');
+      assert.deepStrictEqual(result, []);
+    });
+
+    it('should find all JSONL files across projects', () => {
+      // Create project directories with JSONL files
+      const proj1 = path.join(tmpDir, 'project-a');
+      const proj2 = path.join(tmpDir, 'project-b');
+      fs.mkdirSync(proj1);
+      fs.mkdirSync(proj2);
+      fs.writeFileSync(path.join(proj1, 'session1.jsonl'), '{}');
+      fs.writeFileSync(path.join(proj1, 'session2.jsonl'), '{}');
+      fs.writeFileSync(path.join(proj2, 'session3.jsonl'), '{}');
+      fs.writeFileSync(path.join(proj1, 'not-jsonl.txt'), '{}');
+
+      const result = getSessionFiles(tmpDir);
+      assert.strictEqual(result.length, 3);
+    });
+
+    it('should filter by project directory if specified', () => {
+      const proj1 = path.join(tmpDir, 'project-a');
+      const proj2 = path.join(tmpDir, 'project-b');
+      fs.mkdirSync(proj1);
+      fs.mkdirSync(proj2);
+      fs.writeFileSync(path.join(proj1, 'session1.jsonl'), '{}');
+      fs.writeFileSync(path.join(proj2, 'session2.jsonl'), '{}');
+
+      const result = getSessionFiles(tmpDir, 'project-a');
+      assert.strictEqual(result.length, 1);
+      assert.ok(result[0].includes('session1.jsonl'));
+    });
+  });
+
+  describe('decodeProjectDir', () => {
+    it('should decode project name from directory format', () => {
+      assert.strictEqual(decodeProjectDir('--Users-chandrateja-Documents-pi-hermes-memory--'), 'memory');
+    });
+
+    it('should handle simple directory names', () => {
+      assert.strictEqual(decodeProjectDir('my-project'), 'project');
+    });
+  });
+});

package/dist/extensions/pi-hermes-memory/tests/store/session-search.test.ts

@@ -0,0 +1,287 @@
+import { describe, it, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { DatabaseManager } from '../../src/store/db.js';
+import { indexSession } from '../../src/store/session-indexer.js';
+import { searchSessions, getIndexedMessageCount } from '../../src/store/session-search.js';
+import type { ParsedSession } from '../../src/store/session-parser.js';
+
+describe('session-search', () => {
+  let tmpDir: string;
+  let dbManager: DatabaseManager;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'search-test-'));
+    dbManager = new DatabaseManager(tmpDir);
+  });
+
+  afterEach(() => {
+    dbManager.close();
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  function createTestSession(overrides: Partial<ParsedSession> = {}): ParsedSession {
+    const id = overrides.id ?? 'session-1';
+    return {
+      id,
+      project: 'test-project',
+      cwd: '/test',
+      startedAt: '2026-05-03T00:00:00Z',
+      endedAt: null,
+      messages: [
+        { id: `${id}-msg-1`, role: 'user', content: 'How do I set up Prisma with PostgreSQL?', timestamp: '2026-05-03T00:01:00Z' },
+        { id: `${id}-msg-2`, role: 'assistant', content: 'To set up Prisma, install the package and run prisma init. Then configure your DATABASE_URL in .env', timestamp: '2026-05-03T00:01:30Z' },
+        { id: `${id}-msg-3`, role: 'user', content: 'What about database migrations?', timestamp: '2026-05-03T00:02:00Z' },
+        { id: `${id}-msg-4`, role: 'assistant', content: 'Use prisma migrate dev to create migrations. This generates SQL files and applies them.', timestamp: '2026-05-03T00:02:30Z' },
+        { id: `${id}-msg-5`, role: 'user', content: 'What about gpu timeout issue debugging?', timestamp: '2026-05-03T00:03:00Z' },
+        { id: `${id}-msg-6`, role: 'assistant', content: 'This exact phrase memory search example helps verify phrase queries.', timestamp: '2026-05-03T00:03:30Z' },
+      ],
+      ...overrides,
+    };
+  }
+
+  describe('searchSessions', () => {
+    it('should find messages matching a search query', () => {
+      indexSession(dbManager, createTestSession());
+
+      const results = searchSessions(dbManager, 'Prisma');
+      assert.ok(results.length > 0);
+      assert.ok(results.some(r => r.content.includes('Prisma')));
+    });
+    it('finds pure CJK substrings with the trigram tokenizer', () => {
+      indexSession(dbManager, createTestSession({ id: 'cjk-trigram-session', messages: [
+        { id: 'cjk-trigram-session-msg-1', role: 'assistant', content: '设备清单包含 NAS 和备份策略', timestamp: '2026-05-03T00:01:00Z' },
+      ] }));
+
+      const results = searchSessions(dbManager, '设备清单');
+
+      assert.ok(results.length > 0);
+      assert.ok(results.some((result) => result.content.includes('设备清单')));
+    });
+
+    it('retains English token searches in the trigram index', () => {
+      indexSession(dbManager, createTestSession({ id: 'english-trigram-session', messages: [
+        { id: 'english-trigram-session-msg-1', role: 'assistant', content: 'The NAS backup completed successfully.', timestamp: '2026-05-03T00:01:00Z' },
+      ] }));
+
+      const results = searchSessions(dbManager, 'NAS');
+
+      assert.ok(results.length > 0);
+      assert.ok(results.some((result) => result.content.includes('NAS')));
+    });
+
+
+    it('should return results with snippets', () => {
+      indexSession(dbManager, createTestSession());
+
+      const results = searchSessions(dbManager, 'migrations');
+      assert.ok(results.length > 0);
+      assert.ok(results[0].snippet.length > 0);
+    });
+
+    it('should return results with session metadata', () => {
+      indexSession(dbManager, createTestSession());
+
+      const results = searchSessions(dbManager, 'Prisma');
+      assert.ok(results.length > 0);
+      assert.strictEqual(results[0].sessionId, 'session-1');
+      assert.strictEqual(results[0].project, 'test-project');
+      assert.ok(results[0].timestamp.length > 0);
+    });
+
+    it('should limit results', () => {
+      indexSession(dbManager, createTestSession());
+
+      const results = searchSessions(dbManager, 'Prisma', { limit: 1 });
+      assert.strictEqual(results.length, 1);
+    });
+
+    it('should filter by role', () => {
+      indexSession(dbManager, createTestSession());
+
+      const userResults = searchSessions(dbManager, 'Prisma', { role: 'user' });
+      const assistantResults = searchSessions(dbManager, 'Prisma', { role: 'assistant' });
+
+      // User asked about Prisma, assistant answered about Prisma
+      assert.ok(userResults.length > 0);
+      assert.ok(assistantResults.length > 0);
+      assert.ok(userResults.every(r => r.role === 'user'));
+      assert.ok(assistantResults.every(r => r.role === 'assistant'));
+    });
+
+    it('should filter by project', () => {
+      indexSession(dbManager, createTestSession({ id: 's1', project: 'project-a' }));
+      indexSession(dbManager, createTestSession({ id: 's2', project: 'project-b', messages: [
+        { id: 's2-m1', role: 'user', content: 'Different topic entirely', timestamp: '2026-05-03T00:01:00Z' },
+      ] }));
+
+      const results = searchSessions(dbManager, 'Prisma', { project: 'project-a' });
+      assert.ok(results.length > 0);
+      assert.ok(results.every(r => r.project === 'project-a'));
+    });
+
+    it('should return empty for no matches', () => {
+      indexSession(dbManager, createTestSession());
+
+      const results = searchSessions(dbManager, 'nonexistent-topic-xyz');
+      assert.strictEqual(results.length, 0);
+    });
+
+    it('should return empty for empty database', () => {
+      const results = searchSessions(dbManager, 'anything');
+      assert.strictEqual(results.length, 0);
+    });
+
+    it('should match multi-word queries without requiring an exact phrase', () => {
+      indexSession(dbManager, createTestSession());
+
+      const results = searchSessions(dbManager, 'gpu issue');
+      assert.ok(results.length > 0);
+      assert.ok(results.some((r) => r.content.includes('gpu timeout issue')));
+    });
+
+    it('should ignore lowercase connector words in natural-language queries', () => {
+      indexSession(dbManager, createTestSession());
+
+      const results = searchSessions(dbManager, 'gpu and issue');
+      assert.ok(results.length > 0);
+      assert.ok(results.some((r) => r.content.includes('gpu timeout issue')));
+    });
+
+    it('should preserve explicit quoted phrase searches', () => {
+      indexSession(dbManager, createTestSession());
+
+      const results = searchSessions(dbManager, '"memory search"');
+      assert.ok(results.length > 0);
+      assert.ok(results.every((r) => r.content.includes('memory search')));
+    });
+
+    it('should recover natural-language queries with uppercase operator words and punctuation', () => {
+      indexSession(dbManager, createTestSession({ id: 'recovery-session', messages: [
+        { id: 'recovery-session-msg-1', role: 'assistant', content: 'Never search whole filesystem from root. Do not run find /.', timestamp: '2026-05-03T00:01:00Z' },
+      ] }));
+
+      const results = searchSessions(dbManager, 'DO NOT USE FIND /');
+
+      assert.ok(results.length > 0);
+      assert.ok(results.some((r) => r.content.includes('find')));
+    });
+
+    it('should preserve valid operator queries', () => {
+      indexSession(dbManager, createTestSession());
+
+      const results = searchSessions(dbManager, 'Prisma OR gpu');
+      assert.ok(results.length >= 2);
+      assert.ok(results.some((r) => r.content.includes('Prisma')));
+      assert.ok(results.some((r) => r.content.includes('gpu timeout issue')));
+    });
+
+    it('should fall back to broader natural-language FTS matching when strict term matching misses', () => {
+      indexSession(dbManager, createTestSession({ id: 'fallback-session', messages: [
+        { id: 'fallback-session-msg-1', role: 'assistant', content: "The user's name is Naruto", timestamp: '2026-05-03T00:01:00Z' },
+      ] }));
+
+      const results = searchSessions(dbManager, 'name identity Naruto');
+
+      assert.ok(results.length > 0);
+      assert.ok(results.some((r) => r.content.includes('Naruto')));
+    });
+
+    it('should find mixed Chinese/English queries via fallback', () => {
+      indexSession(dbManager, createTestSession({ id: 'mixed-cjk-session', messages: [
+        { id: 'mixed-cjk-session-msg-1', role: 'assistant', content: 'codex 已经开始执行探索任务了', timestamp: '2026-05-03T00:01:00Z' },
+      ] }));
+
+      const results = searchSessions(dbManager, 'codex 执行 任务');
+
+      assert.ok(results.length > 0);
+      assert.ok(results.some((r) => r.content.includes('codex 已经开始执行探索任务了')));
+    });
+
+    it('should find Chinese-only substrings via LIKE fallback', () => {
+      indexSession(dbManager, createTestSession({ id: 'cjk-only-session', messages: [
+        { id: 'cjk-only-session-msg-1', role: 'assistant', content: '已经开始执行探索任务了', timestamp: '2026-05-03T00:01:00Z' },
+      ] }));
+
+      const results = searchSessions(dbManager, '执行');
+
+      assert.ok(results.length > 0);
+      assert.ok(results.some((r) => r.content.includes('已经开始执行探索任务了')));
+    });
+
+    it('should preserve filters, ordering, and limit during LIKE fallback', () => {
+      indexSession(dbManager, createTestSession({ id: 'cjk-filter-a', project: 'project-a', messages: [
+        { id: 'cjk-filter-a-msg-1', role: 'user', content: '早期已经开始执行探索任务了', timestamp: '2026-05-03T00:01:00Z' },
+        { id: 'cjk-filter-a-msg-2', role: 'user', content: '后续继续执行更多任务', timestamp: '2026-05-03T00:03:00Z' },
+      ] }));
+      indexSession(dbManager, createTestSession({ id: 'cjk-filter-b', project: 'project-b', messages: [
+        { id: 'cjk-filter-b-msg-1', role: 'assistant', content: '另一个项目也执行任务', timestamp: '2026-05-03T00:04:00Z' },
+      ] }));
+
+      const results = searchSessions(dbManager, '执行', {
+        project: 'project-a',
+        role: 'user',
+        since: '2026-05-03T00:02:00Z',
+        limit: 1,
+      });
+
+      assert.strictEqual(results.length, 1);
+      assert.strictEqual(results[0].project, 'project-a');
+      assert.strictEqual(results[0].role, 'user');
+      assert.strictEqual(results[0].timestamp, '2026-05-03T00:03:00Z');
+      assert.ok(results[0].content.includes('后续继续执行更多任务'));
+    });
+
+    it('should escape LIKE wildcard characters during fallback', () => {
+      indexSession(dbManager, createTestSession({ id: 'like-escape-session', messages: [
+        { id: 'like-escape-session-msg-1', role: 'user', content: 'Progress reached 100% today', timestamp: '2026-05-03T00:01:00Z' },
+        { id: 'like-escape-session-msg-2', role: 'user', content: 'A plain message without the wildcard character', timestamp: '2026-05-03T00:02:00Z' },
+      ] }));
+
+      const results = searchSessions(dbManager, '%');
+
+      assert.ok(results.length > 0);
+      assert.ok(results.every((r) => r.content.includes('%')));
+    });
+
+    it('should not broaden explicit operator queries', () => {
+      indexSession(dbManager, createTestSession());
+
+      const results = searchSessions(dbManager, 'Prisma AND nonexistent');
+
+      assert.strictEqual(results.length, 0);
+    });
+
+    it('should handle malformed FTS5 queries gracefully', () => {
+      indexSession(dbManager, createTestSession());
+
+      // Malformed FTS5 query should not throw
+      const results = searchSessions(dbManager, 'AND OR NOT');
+      assert.ok(Array.isArray(results));
+    });
+
+    it('should handle unmatched quotes gracefully', () => {
+      indexSession(dbManager, createTestSession());
+
+      const results = searchSessions(dbManager, 'issue "timeout');
+      assert.ok(Array.isArray(results));
+    });
+
+    it('should return empty for blank queries', () => {
+      assert.deepStrictEqual(searchSessions(dbManager, '   '), []);
+    });
+  });
+
+  describe('getIndexedMessageCount', () => {
+    it('should return 0 for empty database', () => {
+      assert.strictEqual(getIndexedMessageCount(dbManager), 0);
+    });
+
+    it('should return correct count after indexing', () => {
+      indexSession(dbManager, createTestSession());
+      assert.strictEqual(getIndexedMessageCount(dbManager), 6);
+    });
+  });
+});