aws-runtime-bridge 1.9.130 → 1.9.134

package/package/aws-client-agent-mcp/dist/memory-store.test.js

@@ -1,664 +0,0 @@
-import assert from 'node:assert/strict';
-import { mkdtemp, readdir, readFile, rm } from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
-import { describe, it } from 'node:test';
-import { MemoryStore, normalizeBoundFilePath } from './memory-store.js';
-describe('MemoryStore', () => {
-    it('creates and reads memory by uri', async () => {
-        const dir = await mkdtemp(path.join(os.tmpdir(), 'aws-memory-store-'));
-        const storePath = path.join(dir, 'memory');
-        const store = new MemoryStore(storePath);
-        try {
-            const created = await store.createMemory({
-                memory_type: 'project_memory',
-                uri: 'core://agent/profile',
-                content: 'I am a backend expert.'
-            });
-            assert.equal(created.uri, 'core://agent/profile');
-            const loaded = await store.readMemory({ uri: 'core://agent/profile', memory_type: 'project_memory' });
-            assert.ok(loaded);
-            assert.equal(loaded?.content, 'I am a backend expert.');
-        }
-        finally {
-            await rm(dir, { recursive: true, force: true });
-        }
-    });
-    it('updates memory with exact replace and append', async () => {
-        const dir = await mkdtemp(path.join(os.tmpdir(), 'aws-memory-store-'));
-        const storePath = path.join(dir, 'memory');
-        const store = new MemoryStore(storePath);
-        try {
-            await store.createMemory({
-                memory_type: 'project_memory',
-                uri: 'notes://project/todo',
-                content: 'finish api docs'
-            });
-            const replaced = await store.updateMemory({
-                memory_type: 'project_memory',
-                uri: 'notes://project/todo',
-                old_string: 'api docs',
-                new_string: 'API docs v2'
-            });
-            assert.equal(replaced.content, 'finish API docs v2');
-            const appended = await store.updateMemory({
-                memory_type: 'project_memory',
-                uri: 'notes://project/todo',
-                append: '\n- add memory tests'
-            });
-            assert.match(appended.content, /add memory tests/);
-        }
-        finally {
-            await rm(dir, { recursive: true, force: true });
-        }
-    });
-    it('searches memories by query and supports limit', async () => {
-        const dir = await mkdtemp(path.join(os.tmpdir(), 'aws-memory-store-'));
-        const storePath = path.join(dir, 'memory');
-        const store = new MemoryStore(storePath);
-        try {
-            await store.createMemory({
-                memory_type: 'project_memory',
-                uri: 'core://agent/skills',
-                content: 'java spring boot mysql'
-            });
-            await store.createMemory({
-                memory_type: 'project_memory',
-                uri: 'notes://project/readme',
-                content: 'project setup and architecture'
-            });
-            const result = await store.searchMemory({ query: 'project', limit: 1, memory_type: 'project_memory' });
-            assert.equal(result.results.length, 1);
-            assert.equal(result.results[0]?.uri, 'notes://project/readme');
-        }
-        finally {
-            await rm(dir, { recursive: true, force: true });
-        }
-    });
-    it('deletes memory and no longer reads it', async () => {
-        const dir = await mkdtemp(path.join(os.tmpdir(), 'aws-memory-store-'));
-        const storePath = path.join(dir, 'memory');
-        const store = new MemoryStore(storePath);
-        try {
-            await store.createMemory({
-                memory_type: 'project_memory',
-                uri: 'core://agent/temp',
-                content: 'temporary memory'
-            });
-            const deleted = await store.deleteMemory({ uri: 'core://agent/temp', memory_type: 'project_memory' });
-            assert.equal(deleted, true);
-            const loaded = await store.readMemory({ uri: 'core://agent/temp', memory_type: 'project_memory' });
-            assert.equal(loaded, null);
-        }
-        finally {
-            await rm(dir, { recursive: true, force: true });
-        }
-    });
-    it('supports memory_type classification and list/filter', async () => {
-        const dir = await mkdtemp(path.join(os.tmpdir(), 'aws-memory-store-'));
-        const storePath = path.join(dir, 'memory');
-        const store = new MemoryStore(storePath);
-        try {
-            const types = ['recently_memory', 'agent_memory', 'project_memory'];
-            await store.createMemory({ memory_type: types[0], uri: 'task://todo/1', content: 'fix tests' });
-            await store.createMemory({ memory_type: types[1], uri: 'recent://ctx/1', content: 'just discussed API design' });
-            await store.createMemory({ memory_type: types[2], uri: 'core://archive/1', content: 'long-term architecture decision' });
-            const taskList = await store.listByType('recently_memory');
-            assert.equal(taskList.length, 1);
-            assert.equal(taskList[0]?.memory_type, 'recently_memory');
-            const recentList = await store.listByType('agent_memory');
-            assert.equal(recentList.length, 1);
-            assert.equal(recentList[0]?.memory_type, 'agent_memory');
-            // project_memory 已放开列举限制（文件变更检测需枚举永久记忆），应正常返回
-            const projectList = await store.listByType('project_memory');
-            assert.equal(projectList.length, 1);
-            assert.equal(projectList[0]?.memory_type, 'project_memory');
-            await assert.rejects(() => store.listByType('invalid_type'), /Invalid memory_type/);
-        }
-        finally {
-            await rm(dir, { recursive: true, force: true });
-        }
-    });
-    it('deletes task_list memory via deleteMemory', async () => {
-        const dir = await mkdtemp(path.join(os.tmpdir(), 'aws-memory-store-'));
-        const storePath = path.join(dir, 'memory');
-        const store = new MemoryStore(storePath);
-        try {
-            await store.createMemory({ memory_type: 'recently_memory', uri: 'task://todo/remove-1', content: 'to be removed' });
-            const deleted = await store.deleteMemory({ uri: 'task://todo/remove-1', memory_type: 'recently_memory' });
-            assert.equal(deleted, true);
-            assert.equal(await store.readMemory({ uri: 'task://todo/remove-1' }), null);
-        }
-        finally {
-            await rm(dir, { recursive: true, force: true });
-        }
-    });
-    it('reports memory stats with top-level counts and per-domain occupancy', async () => {
-        const dir = await mkdtemp(path.join(os.tmpdir(), 'aws-memory-store-'));
-        const storePath = path.join(dir, 'memory');
-        const store = new MemoryStore(storePath);
-        try {
-            await store.createMemory({ memory_type: 'recently_memory', uri: 'task://todo/stats', content: 'task' });
-            await store.createMemory({ memory_type: 'recently_memory', uri: 'task://todo/other', content: 'another task' });
-            await store.createMemory({ memory_type: 'agent_memory', uri: 'recent://ctx/stats', content: 'recent' });
-            await store.createMemory({ memory_type: 'agent_memory', uri: 'note://ctx/stats', content: 'recent note' });
-            await store.createMemory({ memory_type: 'project_memory', uri: 'core://stats/long-term', content: 'long term' });
-            const stats = await store.getStats();
-            assert.equal(stats.total, 5);
-            assert.deepEqual(stats.listable, { count: 4, limit: 64, hardLimit: 128, exceeded: false, hardExceeded: false });
-            assert.equal(stats.by_type.recently_memory.count, 2);
-            assert.equal(stats.by_type.recently_memory.domainCount, 1);
-            assert.equal(stats.by_type.recently_memory.by_domain.task?.count, 2);
-            assert.equal(stats.by_type.agent_memory.count, 2);
-            assert.equal(stats.by_type.agent_memory.domainCount, 2);
-            assert.equal(stats.by_type.agent_memory.by_domain.recent?.count, 1);
-            assert.equal(stats.by_type.agent_memory.by_domain.note?.count, 1);
-            assert.equal(stats.by_type.project_memory.count, 1);
-            assert.equal(stats.by_type.project_memory.domainCount, 1);
-            assert.equal(stats.by_type.project_memory.by_domain.core?.count, 1);
-        }
-        finally {
-            await rm(dir, { recursive: true, force: true });
-        }
-    });
-    it('saves memory data atomically without leaving temporary files after successful writes', async () => {
-        const dir = await mkdtemp(path.join(os.tmpdir(), 'aws-memory-store-'));
-        const storePath = path.join(dir, 'memory');
-        const store = new MemoryStore(storePath);
-        try {
-            await store.createMemory({ memory_type: 'project_memory', uri: 'core://atomic/write', content: 'persisted' });
-            const files = await readdir(storePath);
-            assert.deepEqual(files, ['core.json']);
-        }
-        finally {
-            await rm(dir, { recursive: true, force: true });
-        }
-    });
-    it('stores directory-mode memories in per-domain json files', async () => {
-        const dir = await mkdtemp(path.join(os.tmpdir(), 'aws-memory-store-'));
-        const storePath = path.join(dir, 'memory');
-        const store = new MemoryStore(storePath);
-        try {
-            await store.createMemory({ memory_type: 'project_memory', uri: 'core://agent/profile', content: 'profile' });
-            await store.createMemory({ memory_type: 'project_memory', uri: 'notes://project/readme', content: 'readme' });
-            assert.deepEqual((await readdir(storePath)).sort(), ['core.json', 'notes.json']);
-            const coreRaw = JSON.parse(await readFile(path.join(storePath, 'core.json'), 'utf-8'));
-            const notesRaw = JSON.parse(await readFile(path.join(storePath, 'notes.json'), 'utf-8'));
-            assert.equal(coreRaw.by_uri['core://agent/profile']?.content, 'profile');
-            assert.equal(notesRaw.by_uri['notes://project/readme']?.content, 'readme');
-            const searched = await store.searchMemory({ query: 'readme', memory_type: 'project_memory' });
-            assert.equal(searched.results[0]?.uri, 'notes://project/readme');
-        }
-        finally {
-            await rm(dir, { recursive: true, force: true });
-        }
-    });
-    it('removes an empty domain file after deleting the last memory in that domain', async () => {
-        const dir = await mkdtemp(path.join(os.tmpdir(), 'aws-memory-store-'));
-        const storePath = path.join(dir, 'memory');
-        const store = new MemoryStore(storePath);
-        try {
-            await store.createMemory({ memory_type: 'project_memory', uri: 'core://agent/profile', content: 'profile' });
-            await store.createMemory({ memory_type: 'project_memory', uri: 'notes://project/readme', content: 'readme' });
-            assert.equal(await store.deleteMemory({ uri: 'notes://project/readme', memory_type: 'project_memory' }), true);
-            assert.deepEqual(await readdir(storePath), ['core.json']);
-            assert.equal(await store.readMemory({ uri: 'notes://project/readme', memory_type: 'project_memory' }), null);
-        }
-        finally {
-            await rm(dir, { recursive: true, force: true });
-        }
-    });
-    it('marks soft listable limits as exceeded without blocking creation', async () => {
-        const dir = await mkdtemp(path.join(os.tmpdir(), 'aws-memory-store-'));
-        const storePath = path.join(dir, 'memory');
-        const store = new MemoryStore(storePath);
-        try {
-            for (let index = 0; index < 32; index += 1) {
-                await store.createMemory({
-                    memory_type: 'recently_memory',
-                    uri: `task://todo/${index}`,
-                    content: `task ${index}`
-                });
-                await store.createMemory({
-                    memory_type: 'agent_memory',
-                    uri: `recent://ctx/${index}`,
-                    content: `recent context ${index}`
-                });
-            }
-            const longTermMemory = await store.createMemory({
-                memory_type: 'project_memory',
-                uri: 'core://long-term/not-listable',
-                content: 'long-term memories are not constrained by listable limits'
-            });
-            assert.equal(longTermMemory.memory_type, 'project_memory');
-            const stats = await store.getStats();
-            assert.equal(stats.listable.count, 64);
-            assert.equal(stats.listable.exceeded, false);
-            assert.equal(stats.listable.hardExceeded, false);
-            assert.equal(stats.by_type.recently_memory.exceeded, false);
-            assert.equal(stats.by_type.agent_memory.exceeded, false);
-            const allowedBeyondSoftLimit = await store.createMemory({
-                memory_type: 'recently_memory',
-                uri: 'task://todo/beyond-soft-limit',
-                content: 'allowed beyond soft limit until hard limit'
-            });
-            assert.equal(allowedBeyondSoftLimit.memory_type, 'recently_memory');
-            const exceededStats = await store.getStats();
-            assert.equal(exceededStats.listable.exceeded, true);
-            assert.equal(exceededStats.by_type.recently_memory.exceeded, false);
-            assert.equal(exceededStats.by_type.recently_memory.by_domain.task?.exceeded, true);
-        }
-        finally {
-            await rm(dir, { recursive: true, force: true });
-        }
-    });
-    it('does not block creation by global listable total when domain limits are healthy', async () => {
-        const dir = await mkdtemp(path.join(os.tmpdir(), 'aws-memory-store-'));
-        const storePath = path.join(dir, 'memory');
-        const store = new MemoryStore(storePath);
-        try {
-            for (let index = 0; index < 64; index += 1) {
-                await store.createMemory({
-                    memory_type: 'recently_memory',
-                    uri: `task${index}://todo/current`,
-                    content: `task ${index}`
-                });
-                await store.createMemory({
-                    memory_type: 'agent_memory',
-                    uri: `recent${index}://ctx/current`,
-                    content: `recent ${index}`
-                });
-            }
-            const created = await store.createMemory({
-                memory_type: 'recently_memory',
-                uri: 'task0://todo/extra',
-                content: 'same domain remains below item hard limit'
-            });
-            assert.equal(created.memory_type, 'recently_memory');
-            const stats = await store.getStats();
-            assert.equal(stats.listable.hardExceeded, true);
-            assert.equal(stats.by_type.recently_memory.hardExceeded, true);
-            assert.equal(stats.by_type.recently_memory.by_domain.task0?.count, 2);
-        }
-        finally {
-            await rm(dir, { recursive: true, force: true });
-        }
-    });
-    it('rejects invalid memory_type on create', async () => {
-        const dir = await mkdtemp(path.join(os.tmpdir(), 'aws-memory-store-'));
-        const storePath = path.join(dir, 'memory');
-        const store = new MemoryStore(storePath);
-        try {
-            await assert.rejects(() => store.createMemory({ memory_type: 'invalid_type', uri: 'x://1', content: 'x' }), /Invalid memory_type/);
-        }
-        finally {
-            await rm(dir, { recursive: true, force: true });
-        }
-    });
-    it('sets expiresAt for recently_memory on create', async () => {
-        const dir = await mkdtemp(path.join(os.tmpdir(), 'aws-memory-store-'));
-        const storePath = path.join(dir, 'memory');
-        const store = new MemoryStore(storePath);
-        try {
-            const created = await store.createMemory({
-                memory_type: 'agent_memory',
-                uri: 'recent://expire/test1',
-                content: 'test expiration'
-            });
-            assert.ok(created.expiresAt, 'expiresAt should be set for recently_memory');
-            const expiresDate = new Date(created.expiresAt);
-            const now = new Date();
-            const diffHours = (expiresDate.getTime() - now.getTime()) / (60 * 60 * 1000);
-            // Should be approximately 12 hours from now (initial TTL)
-            assert.ok(diffHours > 11 && diffHours < 13, `expiresAt should be ~12h from now, got ${diffHours}h`);
-            // memory type should NOT have expiresAt
-            const memoryCreated = await store.createMemory({
-                memory_type: 'project_memory',
-                uri: 'core://perm/test1',
-                content: 'permanent'
-            });
-            assert.equal(memoryCreated.expiresAt, undefined, 'memory type should not have expiresAt');
-        }
-        finally {
-            await rm(dir, { recursive: true, force: true });
-        }
-    });
-    it('updates recently_memory expiresAt on content change', async () => {
-        const dir = await mkdtemp(path.join(os.tmpdir(), 'aws-memory-store-'));
-        const storePath = path.join(dir, 'memory');
-        const store = new MemoryStore(storePath);
-        try {
-            const created = await store.createMemory({
-                memory_type: 'agent_memory',
-                uri: 'recent://expire/test2',
-                content: 'original content'
-            });
-            const originalExpiresAt = created.expiresAt;
-            // Wait 50ms so the new expiresAt is guaranteed different
-            await new Promise(r => setTimeout(r, 50));
-            const updated = await store.updateMemory({
-                uri: 'recent://expire/test2',
-                old_string: 'original',
-                new_string: 'updated',
-            });
-            assert.ok(updated.expiresAt, 'expiresAt should still be set after update');
-            assert.notEqual(updated.expiresAt, originalExpiresAt, 'expiresAt should be refreshed on content change');
-        }
-        finally {
-            await rm(dir, { recursive: true, force: true });
-        }
-    });
-    it('lists expired recently_memories', async () => {
-        const dir = await mkdtemp(path.join(os.tmpdir(), 'aws-memory-store-'));
-        const storePath = path.join(dir, 'memory');
-        const store = new MemoryStore(storePath);
-        try {
-            // Already expired (pass expiresAt in the past)
-            await store.createMemory({
-                memory_type: 'agent_memory',
-                uri: 'recent://expire/past1',
-                content: 'already expired',
-                expiresAt: new Date(Date.now() - 60_000).toISOString(), // 1 minute ago
-            });
-            // Future expiration
-            await store.createMemory({
-                memory_type: 'agent_memory',
-                uri: 'recent://expire/future1',
-                content: 'not expired yet',
-            });
-            const expired = await store.listExpiredRecentlyMemories();
-            assert.equal(expired.length, 1, 'should find exactly 1 expired memory');
-            assert.equal(expired[0]?.uri, 'recent://expire/past1', 'should find the past-expired memory');
-        }
-        finally {
-            await rm(dir, { recursive: true, force: true });
-        }
-    });
-    // ========== v2.x 并发认领语义测试 ==========
-    it('claims up to limit expired memories as recalling with owner and lease', async () => {
-        const dir = await mkdtemp(path.join(os.tmpdir(), 'aws-memory-store-'));
-        const storePath = path.join(dir, 'memory');
-        const store = new MemoryStore(storePath);
-        try {
-            // 创建 3 条已过期记忆（不同过期时间，验证最早过期优先）
-            const times = [Date.now() - 180_000, Date.now() - 120_000, Date.now() - 60_000];
-            const uris = [];
-            for (let i = 0; i < 3; i++) {
-                const uri = `recent://claim/expire${i}`;
-                uris.push(uri);
-                await store.createMemory({
-                    memory_type: 'agent_memory',
-                    uri,
-                    content: `expired memory ${i}`,
-                    expiresAt: new Date(times[i]).toISOString(),
-                });
-            }
-            // 认领（不传 uris → 全部认领）
-            const claim = await store.markExpiredMemoriesRecalling();
-            assert.equal(claim.marked, 3, 'should claim all 3 expired memories');
-            assert.deepEqual(new Set(claim.uris), new Set(uris));
-            // 认领后的记录：recalling + owner + 租约
-            const held = await store.listExpiredRecentlyMemories();
-            assert.equal(held.length, 3, 'own claimed memories still visible via list');
-            for (const m of held) {
-                assert.equal(m.memory_status, 'recalling');
-                assert.equal(m.updating_agent_id, 'local');
-                assert.ok(m.lease_expires_at, 'lease should be set');
-            }
-            // 幂等：再次认领不重复计数，仅续期
-            const claimAgain = await store.markExpiredMemoriesRecalling();
-            assert.equal(claimAgain.marked, 3, 'idempotent: no new claims counted');
-        }
-        finally {
-            await rm(dir, { recursive: true, force: true });
-        }
-    });
-    it('excludes others-recalling memories from list (ownership filter)', async () => {
-        const dir = await mkdtemp(path.join(os.tmpdir(), 'aws-memory-store-'));
-        const storePath = path.join(dir, 'memory');
-        const store = new MemoryStore(storePath);
-        try {
-            // 直接构造一条"他人认领"（updating_agent_id != 'local'）的过期记忆
-            await store.createMemory({
-                memory_type: 'agent_memory',
-                uri: 'recent://claim/other1',
-                content: 'claimed by another instance',
-                expiresAt: new Date(Date.now() - 60_000).toISOString(),
-            });
-            const data = await store.loadData();
-            const rec = data.by_uri['recent://claim/other1'];
-            rec.memory_status = 'recalling';
-            rec.updating_agent_id = 'other-instance';
-            await store.saveData(data);
-            // 自己的可认领记忆
-            await store.createMemory({
-                memory_type: 'agent_memory',
-                uri: 'recent://claim/mine1',
-                content: 'mine to claim',
-                expiresAt: new Date(Date.now() - 30_000).toISOString(),
-            });
-            // 他人的 recalling 不可见，仅自己的 normal 可见
-            const expired = await store.listExpiredRecentlyMemories();
-            assert.equal(expired.length, 1, 'others-recalling should be filtered out');
-            assert.equal(expired[0]?.uri, 'recent://claim/mine1');
-        }
-        finally {
-            await rm(dir, { recursive: true, force: true });
-        }
-    });
-    it('clearRecallingExpiredMemories only deletes own claimed + supports uris filter', async () => {
-        const dir = await mkdtemp(path.join(os.tmpdir(), 'aws-memory-store-'));
-        const storePath = path.join(dir, 'memory');
-        const store = new MemoryStore(storePath);
-        try {
-            // 两条自己认领的过期记忆 + 一条他人认领的过期记忆
-            await store.createMemory({
-                memory_type: 'agent_memory',
-                uri: 'recent://clear/own1',
-                content: 'own 1',
-                expiresAt: new Date(Date.now() - 60_000).toISOString(),
-            });
-            await store.createMemory({
-                memory_type: 'agent_memory',
-                uri: 'recent://clear/own2',
-                content: 'own 2',
-                expiresAt: new Date(Date.now() - 60_000).toISOString(),
-            });
-            await store.createMemory({
-                memory_type: 'agent_memory',
-                uri: 'recent://clear/other1',
-                content: 'other 1',
-                expiresAt: new Date(Date.now() - 60_000).toISOString(),
-            });
-            await store.markExpiredMemoriesRecalling();
-            // 标记"他人认领"（模拟另一实例）
-            const data = await store.loadData();
-            data.by_uri['recent://clear/other1'].memory_status = 'recalling';
-            data.by_uri['recent://clear/other1'].updating_agent_id = 'other-instance';
-            await store.saveData(data);
-            // 分批收尾：只删 own1
-            const partial = await store.clearRecallingExpiredMemories(['recent://clear/own1']);
-            assert.equal(partial.deleted, 1);
-            assert.deepEqual(partial.uris, ['recent://clear/own1']);
-            // own2 仍在，他人认领的仍在（归属校验）
-            const remaining = await store.listExpiredRecentlyMemories();
-            const remainingUris = remaining.map(m => m.uri).sort();
-            assert.deepEqual(remainingUris, ['recent://clear/own2']);
-            // 最终收尾：不传 uris 删全部本人认领的
-            const final = await store.clearRecallingExpiredMemories();
-            assert.equal(final.deleted, 1);
-            assert.deepEqual(final.uris, ['recent://clear/own2']);
-            // 他人认领的始终未被删除（模拟：其 URI 仍在数据中）
-            const dataAfter = await store.loadData();
-            assert.ok(dataAfter.by_uri['recent://clear/other1'], 'others-recalling must not be deleted');
-        }
-        finally {
-            await rm(dir, { recursive: true, force: true });
-        }
-    });
-});
-// ========== listByFile 与 normalizeBoundFilePath 测试 ==========
-describe('normalizeBoundFilePath', () => {
-    it('normalizes @/ prefix to ./', () => {
-        assert.equal(normalizeBoundFilePath('@/src/main.ts'), './src/main.ts');
-    });
-    it('normalizes / prefix to ./', () => {
-        assert.equal(normalizeBoundFilePath('/src/main.ts'), './src/main.ts');
-    });
-    it('normalizes bare path to ./', () => {
-        assert.equal(normalizeBoundFilePath('src/main.ts'), './src/main.ts');
-    });
-    it('keeps ./ prefix as-is', () => {
-        assert.equal(normalizeBoundFilePath('./src/main.ts'), './src/main.ts');
-    });
-    it('trims whitespace', () => {
-        assert.equal(normalizeBoundFilePath('  ./src/main.ts  '), './src/main.ts');
-    });
-    it('converts backslashes to forward slashes (Windows path alignment with Java)', () => {
-        assert.equal(normalizeBoundFilePath('src\\utils\\file.ts'), './src/utils/file.ts');
-        assert.equal(normalizeBoundFilePath('.\\src\\utils\\file.ts'), './src/utils/file.ts');
-        assert.equal(normalizeBoundFilePath('@\\src\\utils\\file.ts'), './src/utils/file.ts');
-    });
-    it('collapses multiple leading slashes', () => {
-        assert.equal(normalizeBoundFilePath('//src/main.ts'), './src/main.ts');
-        assert.equal(normalizeBoundFilePath('///src/main.ts'), './src/main.ts');
-    });
-    it('produces identical output for slash-equivalent paths (TS/Java consistency)', () => {
-        const candidates = [
-            './src/utils/file.ts',
-            'src/utils/file.ts',
-            '/src/utils/file.ts',
-            '@/src/utils/file.ts',
-            'src\\utils\\file.ts',
-            '.\\src\\utils\\file.ts',
-        ];
-        const results = new Set(candidates.map(normalizeBoundFilePath));
-        assert.equal(results.size, 1, `expected all to normalize identically, got: ${[...results].join(', ')}`);
-        assert.equal([...results][0], './src/utils/file.ts');
-    });
-});
-describe('MemoryStore listByFile', () => {
-    it('finds memories by exact bound_files match', async () => {
-        const dir = await mkdtemp(path.join(os.tmpdir(), 'aws-memory-listbyfile-'));
-        const storePath = path.join(dir, 'memory');
-        const store = new MemoryStore(storePath);
-        try {
-            await store.createMemory({
-                memory_type: 'project_memory',
-                uri: 'core://file/notes',
-                content: 'Notes about main.ts',
-                bound_files: ['./src/main.ts'],
-            });
-            await store.createMemory({
-                memory_type: 'project_memory',
-                uri: 'core://other/entry',
-                content: 'Unrelated memory',
-                bound_files: ['./src/utils.ts'],
-            });
-            const results = await store.listByFile('./src/main.ts');
-            assert.equal(results.length, 1);
-            assert.equal(results[0]?.uri, 'core://file/notes');
-        }
-        finally {
-            await rm(dir, { recursive: true, force: true });
-        }
-    });
-    it('normalizes file path before matching', async () => {
-        const dir = await mkdtemp(path.join(os.tmpdir(), 'aws-memory-listbyfile-'));
-        const storePath = path.join(dir, 'memory');
-        const store = new MemoryStore(storePath);
-        try {
-            await store.createMemory({
-                memory_type: 'project_memory',
-                uri: 'core://file/notes',
-                content: 'Notes',
-                bound_files: ['./src/main.ts'],
-            });
-            // Search with @/ prefix should normalize to ./src/main.ts
-            const results = await store.listByFile('@/src/main.ts');
-            assert.equal(results.length, 1);
-            assert.equal(results[0]?.uri, 'core://file/notes');
-            // Search with bare path should also match
-            const results2 = await store.listByFile('src/main.ts');
-            assert.equal(results2.length, 1);
-            // Search with / prefix should also match
-            const results3 = await store.listByFile('/src/main.ts');
-            assert.equal(results3.length, 1);
-        }
-        finally {
-            await rm(dir, { recursive: true, force: true });
-        }
-    });
-    it('returns empty when no bound_files match', async () => {
-        const dir = await mkdtemp(path.join(os.tmpdir(), 'aws-memory-listbyfile-'));
-        const storePath = path.join(dir, 'memory');
-        const store = new MemoryStore(storePath);
-        try {
-            await store.createMemory({
-                memory_type: 'project_memory',
-                uri: 'core://other/entry',
-                content: 'No files bound',
-            });
-            const results = await store.listByFile('./src/main.ts');
-            assert.equal(results.length, 0);
-        }
-        finally {
-            await rm(dir, { recursive: true, force: true });
-        }
-    });
-    it('matches memories with multiple bound_files', async () => {
-        const dir = await mkdtemp(path.join(os.tmpdir(), 'aws-memory-listbyfile-'));
-        const storePath = path.join(dir, 'memory');
-        const store = new MemoryStore(storePath);
-        try {
-            await store.createMemory({
-                memory_type: 'project_memory',
-                uri: 'core://multi/file',
-                content: 'Multi-file memory',
-                bound_files: ['./src/main.ts', './src/utils.ts'],
-            });
-            const results1 = await store.listByFile('./src/main.ts');
-            assert.equal(results1.length, 1);
-            const results2 = await store.listByFile('./src/utils.ts');
-            assert.equal(results2.length, 1);
-            const results3 = await store.listByFile('./src/other.ts');
-            assert.equal(results3.length, 0);
-        }
-        finally {
-            await rm(dir, { recursive: true, force: true });
-        }
-    });
-    it('filters by memory_type when provided', async () => {
-        const dir = await mkdtemp(path.join(os.tmpdir(), 'aws-memory-listbyfile-'));
-        const storePath = path.join(dir, 'memory');
-        const store = new MemoryStore(storePath);
-        try {
-            await store.createMemory({
-                memory_type: 'project_memory',
-                uri: 'core://permanent/notes',
-                content: 'Permanent notes',
-                bound_files: ['./src/main.ts'],
-            });
-            await store.createMemory({
-                memory_type: 'agent_memory',
-                uri: 'recent://temp/notes',
-                content: 'Temporary notes',
-                bound_files: ['./src/main.ts'],
-            });
-            // Both types match without filter
-            const allResults = await store.listByFile('./src/main.ts');
-            assert.equal(allResults.length, 2);
-            // Filter by memory type
-            const memResults = await store.listByFile('./src/main.ts', 'project_memory');
-            assert.equal(memResults.length, 1);
-            assert.equal(memResults[0]?.memory_type, 'project_memory');
-            // Filter with options object
-            const recentResults = await store.listByFile('./src/main.ts', { memory_type: 'agent_memory' });
-            assert.equal(recentResults.length, 1);
-            assert.equal(recentResults[0]?.memory_type, 'agent_memory');
-        }
-        finally {
-            await rm(dir, { recursive: true, force: true });
-        }
-    });
-});

package/package/aws-client-agent-mcp/dist/message-buffer.test.d.ts

@@ -1 +0,0 @@
-export {};