@kaelio/ktx 0.5.0 → 0.7.0

package/dist/context/wiki/knowledge-wiki.service.test.js

@@ -1,205 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { KnowledgeWikiService } from './knowledge-wiki.service.js';
-function makeService() {
-    const pagesRepository = {
-        upsertPage: vi.fn().mockResolvedValue(undefined),
-        deleteByKey: vi.fn().mockResolvedValue(0),
-        deleteByScope: vi.fn().mockResolvedValue(0),
-        deleteStale: vi.fn().mockResolvedValue(0),
-        getExistingSearchTexts: vi.fn().mockResolvedValue(new Map()),
-        applyDiffTransactional: vi.fn().mockResolvedValue(undefined),
-    };
-    const embeddingService = {
-        computeEmbedding: vi.fn().mockResolvedValue([0.1, 0.2, 0.3]),
-        computeEmbeddingsBulk: vi.fn().mockResolvedValue([]),
-        maxBatchSize: 16,
-    };
-    const configService = {
-        forWorktree: vi.fn().mockReturnValue({
-            writeFile: vi.fn(),
-            readFile: vi.fn(),
-            deleteFile: vi.fn(),
-            listFiles: vi.fn(),
-            getFileHistory: vi.fn(),
-        }),
-        writeFile: vi.fn(),
-        readFile: vi.fn(),
-        deleteFile: vi.fn(),
-        listFiles: vi.fn(),
-        getFileHistory: vi.fn(),
-    };
-    const gitService = {
-        diffNameStatus: vi.fn().mockResolvedValue([]),
-        getFileAtCommit: vi.fn().mockResolvedValue(''),
-    };
-    const logger = {
-        log: vi.fn(),
-        warn: vi.fn(),
-        error: vi.fn(),
-    };
-    const service = new KnowledgeWikiService(configService, embeddingService, pagesRepository, gitService, logger);
-    return { service, pagesRepository, embeddingService, configService, gitService, logger };
-}
-const fm = { summary: 'sum', usage_mode: 'auto' };
-describe('KnowledgeWikiService file reads', () => {
-    it('warns and returns null when an existing page cannot be parsed', async () => {
-        const { service, configService, logger } = makeService();
-        configService.readFile.mockResolvedValue({ content: '---\nsummary: [\n---\nBody' });
-        await expect(service.readPage('GLOBAL', null, 'revenue')).resolves.toBeNull();
-        expect(configService.readFile).toHaveBeenCalledWith('wiki/global/revenue.md');
-        expect(logger.warn).toHaveBeenCalledWith(expect.stringContaining('[readPage] wiki/global/revenue.md: parse failed:'));
-    });
-    it('warns and returns an empty page list when directory listing fails', async () => {
-        const { service, configService, logger } = makeService();
-        configService.listFiles.mockRejectedValue(new Error('filesystem unavailable'));
-        await expect(service.listPageKeys('GLOBAL', null)).resolves.toEqual([]);
-        expect(logger.warn).toHaveBeenCalledWith('[listPageKeys] wiki/global: filesystem unavailable');
-    });
-});
-describe('KnowledgeWikiService.syncIndex result stats', () => {
-    it('reports scanned, updated, deleted, and embedding counts', async () => {
-        const { service, pagesRepository, embeddingService, configService } = makeService();
-        configService.listFiles.mockResolvedValue({ files: ['wiki/global/revenue.md'] });
-        configService.readFile.mockResolvedValue({
-            content: '---\nsummary: Revenue\nusage_mode: auto\ntags:\n  - finance\n---\n\nPaid orders.\n',
-        });
-        pagesRepository.getExistingSearchTexts.mockResolvedValue(new Map([
-            ['old-page', { searchText: 'old', hasEmbedding: true }],
-        ]));
-        embeddingService.computeEmbeddingsBulk.mockResolvedValue([[0.1, 0.2, 0.3]]);
-        pagesRepository.deleteStale.mockResolvedValue(1);
-        await expect(service.syncIndex('GLOBAL', null)).resolves.toEqual({
-            scanned: 1,
-            updated: 1,
-            deleted: 1,
-            embeddingsRecomputed: 1,
-            embeddingsFailed: 0,
-        });
-    });
-    it('indexes lexical rows when embeddings are not configured', async () => {
-        const { pagesRepository, configService, gitService, logger } = makeService();
-        const service = new KnowledgeWikiService(configService, null, pagesRepository, gitService, logger);
-        configService.listFiles.mockResolvedValue({ files: ['wiki/global/revenue.md'] });
-        configService.readFile.mockResolvedValue({
-            content: '---\nsummary: Revenue\nusage_mode: auto\n---\n\nPaid orders.\n',
-        });
-        pagesRepository.getExistingSearchTexts.mockResolvedValue(new Map());
-        pagesRepository.deleteStale.mockResolvedValue(0);
-        const result = await service.syncIndex('GLOBAL', null);
-        expect(result.embeddingsRecomputed).toBe(0);
-        expect(result.embeddingsFailed).toBe(0);
-        expect(pagesRepository.upsertPage).toHaveBeenCalledWith(expect.objectContaining({ pageKey: 'revenue', embedding: null }));
-    });
-    it('does not update unchanged lexical-only wiki rows on repeated sync', async () => {
-        const { pagesRepository, configService, gitService, logger } = makeService();
-        const service = new KnowledgeWikiService(configService, null, pagesRepository, gitService, logger);
-        configService.listFiles.mockResolvedValue({ files: ['wiki/global/revenue.md'] });
-        configService.readFile.mockResolvedValue({
-            content: '---\nsummary: Revenue\nusage_mode: auto\n---\n\nPaid orders.\n',
-        });
-        pagesRepository.getExistingSearchTexts.mockResolvedValue(new Map([
-            ['revenue', { searchText: 'revenue\nRevenue\nPaid orders.', hasEmbedding: false }],
-        ]));
-        pagesRepository.deleteStale.mockResolvedValue(0);
-        await expect(service.syncIndex('GLOBAL', null)).resolves.toEqual({
-            scanned: 1,
-            updated: 0,
-            deleted: 0,
-            embeddingsRecomputed: 0,
-            embeddingsFailed: 0,
-        });
-        expect(pagesRepository.upsertPage).not.toHaveBeenCalled();
-        expect(pagesRepository.deleteStale).toHaveBeenCalledWith('GLOBAL', null, ['revenue']);
-    });
-});
-describe('KnowledgeWikiService.forWorktree isolation', () => {
-    it('syncSinglePage in worktree scope does not call pagesRepository.upsertPage', async () => {
-        const { service, pagesRepository, embeddingService } = makeService();
-        const scoped = service.forWorktree('/tmp/fake-worktree');
-        await scoped.syncSinglePage('GLOBAL', null, 'key', fm, 'body');
-        expect(pagesRepository.upsertPage).not.toHaveBeenCalled();
-        expect(embeddingService.computeEmbedding).not.toHaveBeenCalled();
-    });
-    it('deleteFromIndex in worktree scope does not call pagesRepository.deleteByKey', async () => {
-        const { service, pagesRepository } = makeService();
-        const scoped = service.forWorktree('/tmp/fake-worktree');
-        await scoped.deleteFromIndex('GLOBAL', null, 'key');
-        expect(pagesRepository.deleteByKey).not.toHaveBeenCalled();
-    });
-    it('syncSinglePage in main scope still calls pagesRepository.upsertPage', async () => {
-        const { service, pagesRepository } = makeService();
-        await service.syncSinglePage('GLOBAL', null, 'key', fm, 'body');
-        expect(pagesRepository.upsertPage).toHaveBeenCalledTimes(1);
-    });
-});
-describe('KnowledgeWikiService.syncFromCommit', () => {
-    it('applies upserts for added/modified files and deletes for removed files in a single transactional batch', async () => {
-        const { service, pagesRepository, gitService } = makeService();
-        gitService.diffNameStatus.mockResolvedValue([
-            { status: 'A', path: 'wiki/global/new-page.md' },
-            { status: 'M', path: 'wiki/global/changed-page.md' },
-            { status: 'D', path: 'wiki/global/gone-page.md' },
-        ]);
-        gitService.getFileAtCommit.mockImplementation((path) => {
-            if (path.endsWith('new-page.md')) {
-                return Promise.resolve('---\nsummary: new\nusage_mode: auto\n---\n\nbody-new\n');
-            }
-            if (path.endsWith('changed-page.md')) {
-                return Promise.resolve('---\nsummary: changed\nusage_mode: auto\n---\n\nbody-changed\n');
-            }
-            return Promise.reject(new Error(`unexpected getFileAtCommit path: ${path}`));
-        });
-        await service.syncFromCommit('sha-before', 'sha-after', 'run-uuid');
-        expect(pagesRepository.applyDiffTransactional).toHaveBeenCalledTimes(1);
-        const call = pagesRepository.applyDiffTransactional.mock.calls[0][0];
-        expect(call.runId).toBe('run-uuid');
-        expect(call.upserts).toHaveLength(2);
-        expect(call.upserts).toEqual(expect.arrayContaining([
-            expect.objectContaining({ scope: 'GLOBAL', pageKey: 'new-page', summary: 'new' }),
-            expect.objectContaining({ scope: 'GLOBAL', pageKey: 'changed-page', summary: 'changed' }),
-        ]));
-        expect(call.deletes).toEqual([{ scope: 'GLOBAL', scopeId: null, pageKey: 'gone-page' }]);
-    });
-    it('indexes only flat wiki pages and skips nested paths from commit sync', async () => {
-        const { service, pagesRepository, gitService, logger } = makeService();
-        gitService.diffNameStatus.mockResolvedValue([
-            { status: 'A', path: 'wiki/global/revenue-policy.md' },
-            { status: 'A', path: 'wiki/global/historic-sql-order-lifecycle.md' },
-            { status: 'A', path: 'wiki/global/historic-sql/order-lifecycle.md' },
-            { status: 'A', path: 'wiki/global/orbit/company-overview.md' },
-        ]);
-        gitService.getFileAtCommit.mockImplementation((path) => {
-            if (path.endsWith('revenue-policy.md')) {
-                return Promise.resolve('---\nsummary: revenue\nusage_mode: auto\n---\n\nbody-revenue\n');
-            }
-            if (path.endsWith('order-lifecycle.md')) {
-                return Promise.resolve('---\nsummary: order lifecycle\nusage_mode: auto\n---\n\nbody-orders\n');
-            }
-            if (path.endsWith('retired-pattern.md')) {
-                return Promise.resolve('---\nsummary: retired\nusage_mode: never\n---\n\nbody-retired\n');
-            }
-            return Promise.reject(new Error(`unexpected getFileAtCommit path: ${path}`));
-        });
-        await service.syncFromCommit('sha-before', 'sha-after', 'run-uuid');
-        expect(gitService.getFileAtCommit).not.toHaveBeenCalledWith('wiki/global/orbit/company-overview.md', 'sha-after');
-        expect(gitService.getFileAtCommit).not.toHaveBeenCalledWith('wiki/global/historic-sql/order-lifecycle.md', 'sha-after');
-        expect(logger.warn).toHaveBeenCalledWith('[wiki.sync] skipping unparseable path: wiki/global/orbit/company-overview.md');
-        expect(logger.warn).toHaveBeenCalledWith('[wiki.sync] skipping unparseable path: wiki/global/historic-sql/order-lifecycle.md');
-        const call = pagesRepository.applyDiffTransactional.mock.calls[0][0];
-        expect(call.upserts).toEqual(expect.arrayContaining([
-            expect.objectContaining({ scope: 'GLOBAL', pageKey: 'revenue-policy', summary: 'revenue' }),
-            expect.objectContaining({
-                scope: 'GLOBAL',
-                pageKey: 'historic-sql-order-lifecycle',
-                summary: 'order lifecycle',
-            }),
-        ]));
-        expect(call.upserts).toHaveLength(2);
-    });
-    it('is a no-op when the diff between shas has no knowledge changes', async () => {
-        const { service, pagesRepository, gitService } = makeService();
-        gitService.diffNameStatus.mockResolvedValue([]);
-        await service.syncFromCommit('sha-before', 'sha-after', 'run-uuid');
-        expect(pagesRepository.applyDiffTransactional).not.toHaveBeenCalled();
-    });
-});

package/dist/context/wiki/local-knowledge.test.d.ts

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

package/dist/context/wiki/local-knowledge.test.js

@@ -1,270 +0,0 @@
-import { access, mkdtemp, rm } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { initKtxProject } from '../../context/project/project.js';
-import { listLocalKnowledgePages, readLocalKnowledgePage, searchLocalKnowledgePages, writeLocalKnowledgePage, } from './local-knowledge.js';
-class FakeEmbeddingPort {
-    maxBatchSize = 16;
-    async computeEmbedding(text) {
-        return text.toLowerCase().includes('semantic revenue') ? [1, 0] : [0, 1];
-    }
-    async computeEmbeddingsBulk(texts) {
-        return Promise.all(texts.map((text) => this.computeEmbedding(text)));
-    }
-}
-class ArrSynonymEmbeddingPort {
-    maxBatchSize = 16;
-    async computeEmbedding(text) {
-        const lower = text.toLowerCase();
-        if (lower.trim() === 'annual recurring revenue' || lower.includes('arr') || lower.includes('contract-first')) {
-            return [1, 0];
-        }
-        if (lower.includes('net revenue') || lower.includes('gross') || lower.includes('refund')) {
-            return [0, 1];
-        }
-        return [0.5, 0.5];
-    }
-    async computeEmbeddingsBulk(texts) {
-        return Promise.all(texts.map((text) => this.computeEmbedding(text)));
-    }
-}
-describe('local knowledge helpers', () => {
-    let tempDir;
-    let project;
-    beforeEach(async () => {
-        tempDir = await mkdtemp(join(tmpdir(), 'ktx-local-knowledge-'));
-        project = await initKtxProject({ projectDir: join(tempDir, 'project') });
-    });
-    afterEach(async () => {
-        await rm(tempDir, { recursive: true, force: true });
-    });
-    it('writes, reads, lists, and searches global wiki pages', async () => {
-        const write = await writeLocalKnowledgePage(project, {
-            key: 'metrics-revenue',
-            scope: 'GLOBAL',
-            summary: 'Revenue metric definition',
-            content: 'Revenue is recognized when an order is paid.',
-            tags: ['finance'],
-            refs: ['semantic-layer/warehouse/orders.yaml'],
-            slRefs: ['orders'],
-        });
-        expect(write.path).toBe('wiki/global/metrics-revenue.md');
-        expect(write.operation).toBe('write');
-        await expect(readLocalKnowledgePage(project, { key: 'metrics-revenue', userId: 'local' })).resolves.toMatchObject({
-            key: 'metrics-revenue',
-            scope: 'GLOBAL',
-            summary: 'Revenue metric definition',
-            content: 'Revenue is recognized when an order is paid.',
-            tags: ['finance'],
-            refs: ['semantic-layer/warehouse/orders.yaml'],
-            slRefs: ['orders'],
-        });
-        await expect(listLocalKnowledgePages(project, { userId: 'local' })).resolves.toEqual([
-            {
-                key: 'metrics-revenue',
-                path: 'wiki/global/metrics-revenue.md',
-                scope: 'GLOBAL',
-                summary: 'Revenue metric definition',
-            },
-        ]);
-        const search = await searchLocalKnowledgePages(project, { query: 'paid order', userId: 'local' });
-        expect(search).toEqual([
-            expect.objectContaining({
-                key: 'metrics-revenue',
-                path: 'wiki/global/metrics-revenue.md',
-                scope: 'GLOBAL',
-                score: expect.any(Number),
-                matchReasons: expect.arrayContaining(['lexical']),
-                lanes: expect.arrayContaining([expect.objectContaining({ lane: 'lexical', status: 'available' })]),
-            }),
-        ]);
-        expect(search[0]?.score).toBeGreaterThan(0);
-        await expect(access(join(project.projectDir, '.ktx', 'db.sqlite'))).resolves.toBeUndefined();
-    });
-    it('adds the token lane alongside lexical wiki matches', async () => {
-        await writeLocalKnowledgePage(project, {
-            key: 'metrics-revenue',
-            scope: 'GLOBAL',
-            summary: 'Revenue metric definition',
-            content: 'Revenue is recognized when an order is paid.',
-            tags: ['finance'],
-        });
-        const search = await searchLocalKnowledgePages(project, { query: 'paid---', userId: 'local', limit: 5 });
-        expect(search[0]).toMatchObject({
-            key: 'metrics-revenue',
-            matchReasons: expect.arrayContaining(['token']),
-            lanes: expect.arrayContaining([expect.objectContaining({ lane: 'token', status: 'available' })]),
-        });
-    });
-    it('uses stored page embeddings when a wiki embedding backend is configured', async () => {
-        await writeLocalKnowledgePage(project, {
-            key: 'metrics-revenue',
-            scope: 'GLOBAL',
-            summary: 'Semantic revenue definition',
-            content: 'Revenue search text.',
-            tags: ['finance'],
-        });
-        await writeLocalKnowledgePage(project, {
-            key: 'support-escalations',
-            scope: 'GLOBAL',
-            summary: 'Support escalation process',
-            content: 'Support search text.',
-            tags: ['operations'],
-        });
-        const search = await searchLocalKnowledgePages(project, {
-            query: 'semantic revenue',
-            userId: 'local',
-            limit: 5,
-            embeddingService: new FakeEmbeddingPort(),
-        });
-        expect(search[0]).toMatchObject({
-            key: 'metrics-revenue',
-            matchReasons: expect.arrayContaining(['semantic']),
-            lanes: expect.arrayContaining([expect.objectContaining({ lane: 'semantic', status: 'available' })]),
-        });
-    });
-    it('ranks ARR synonym queries by semantic page embeddings over stronger lexical revenue matches', async () => {
-        await writeLocalKnowledgePage(project, {
-            key: 'arr-definition',
-            scope: 'GLOBAL',
-            summary: 'ARR is calculated contract-first for active customer contracts.',
-            content: 'Contract-first active contract value takes precedence over subscription values.',
-            tags: ['arr', 'contracts', 'finance'],
-        });
-        await writeLocalKnowledgePage(project, {
-            key: 'net-revenue-definition',
-            scope: 'GLOBAL',
-            summary: 'Net revenue definition',
-            content: 'Annual revenue is gross invoice revenue minus credits and refunds.',
-            tags: ['revenue', 'finance'],
-        });
-        const search = await searchLocalKnowledgePages(project, {
-            query: 'annual recurring revenue',
-            userId: 'local',
-            limit: 2,
-            embeddingService: new ArrSynonymEmbeddingPort(),
-        });
-        expect(search.map((result) => result.key)).toEqual(['arr-definition', 'net-revenue-definition']);
-        expect(search[0]).toMatchObject({
-            key: 'arr-definition',
-            matchReasons: expect.arrayContaining(['semantic']),
-            lanes: expect.arrayContaining([expect.objectContaining({ lane: 'semantic', status: 'available' })]),
-        });
-    });
-    it('reports semantic lane as skipped when wiki embeddings are not configured', async () => {
-        await writeLocalKnowledgePage(project, {
-            key: 'metrics-revenue',
-            scope: 'GLOBAL',
-            summary: 'Revenue metric definition',
-            content: 'Revenue is recognized when an order is paid.',
-            tags: ['finance'],
-        });
-        const search = await searchLocalKnowledgePages(project, { query: 'revenue', userId: 'local', limit: 5 });
-        expect(search[0]?.lanes).toEqual(expect.arrayContaining([
-            expect.objectContaining({ lane: 'semantic', status: 'skipped', reason: 'embedding_unconfigured' }),
-        ]));
-    });
-    it('prefers user knowledge over global pages with the same key', async () => {
-        await writeLocalKnowledgePage(project, {
-            key: 'handoff',
-            scope: 'GLOBAL',
-            summary: 'Global handoff',
-            content: 'Global context.',
-        });
-        await writeLocalKnowledgePage(project, {
-            key: 'handoff',
-            scope: 'USER',
-            userId: 'agent-1',
-            summary: 'User handoff',
-            content: 'User context.',
-        });
-        await expect(readLocalKnowledgePage(project, { key: 'handoff', userId: 'agent-1' })).resolves.toMatchObject({
-            scope: 'USER',
-            summary: 'User handoff',
-        });
-    });
-    it('serializes historic-SQL frontmatter fields for global pages', async () => {
-        await writeLocalKnowledgePage(project, {
-            key: 'monthly-paid-orders',
-            scope: 'GLOBAL',
-            summary: 'Monthly paid orders',
-            content: '## Monthly paid order count',
-            tags: ['historic-sql', 'query-pattern'],
-            slRefs: ['analytics.orders'],
-            source: 'historic-sql',
-            intent: 'Monthly paid order count',
-            tables: ['analytics.orders'],
-            representativeSql: "SELECT count(*) FROM analytics.orders WHERE status = 'paid'",
-            usage: {
-                executions: 42,
-                distinct_users: 3,
-                first_seen: '2026-02-01',
-                last_seen: '2026-05-04',
-                p50_runtime_ms: 100,
-                p95_runtime_ms: 200,
-                error_rate: 0,
-                rows_produced: 42,
-            },
-            fingerprints: ['fp_paid_orders'],
-        });
-        const raw = await project.fileStore.readFile('wiki/global/monthly-paid-orders.md');
-        expect(raw.content).toContain('source: historic-sql');
-        expect(raw.content).toContain('intent: Monthly paid order count');
-        expect(raw.content).toContain(['tables:', '  - analytics.orders'].join('\n'));
-        expect(raw.content).toContain("representative_sql: SELECT count(*) FROM analytics.orders WHERE status = 'paid'");
-        expect(raw.content).toContain(['usage:', '  executions: 42', '  distinct_users: 3'].join('\n'));
-        expect(raw.content).toContain(['fingerprints:', '  - fp_paid_orders'].join('\n'));
-    });
-    it('falls back to Markdown scanning when the config does not select sqlite-fts5', async () => {
-        project.config.storage.search = 'postgres-hybrid';
-        await writeLocalKnowledgePage(project, {
-            key: 'metrics-revenue',
-            scope: 'GLOBAL',
-            summary: 'Revenue metric definition',
-            content: 'Revenue is recognized when an order is paid.',
-            tags: ['finance'],
-        });
-        await expect(searchLocalKnowledgePages(project, { query: 'paid order', userId: 'local' })).resolves.toEqual([
-            expect.objectContaining({
-                key: 'metrics-revenue',
-                score: 3,
-                matchReasons: ['token'],
-            }),
-        ]);
-    });
-    it('rejects unsafe knowledge keys', async () => {
-        await expect(writeLocalKnowledgePage(project, {
-            key: '../secret',
-            scope: 'GLOBAL',
-            summary: 'bad',
-            content: 'bad',
-        })).rejects.toThrow('Invalid wiki key "../secret". Wiki keys must be flat; use "secret".');
-    });
-    it('rejects slash-delimited knowledge keys with a flat-key suggestion', async () => {
-        await expect(writeLocalKnowledgePage(project, {
-            key: 'orbit/company-overview',
-            scope: 'GLOBAL',
-            summary: 'bad',
-            content: 'bad',
-        })).rejects.toThrow('Invalid wiki key "orbit/company-overview". Wiki keys must be flat; use "orbit-company-overview".');
-    });
-    it('ignores nested historic-SQL legacy paths when listing local wiki pages', async () => {
-        await writeLocalKnowledgePage(project, {
-            key: 'historic-sql-paid-orders',
-            scope: 'GLOBAL',
-            summary: 'Flat historic SQL page',
-            content: 'Flat page body.',
-            tags: ['historic-sql'],
-        });
-        await project.fileStore.writeFile('wiki/global/historic-sql/paid-orders.md', '---\nsummary: Nested historic SQL page\nusage_mode: auto\n---\n\nNested body\n', 'Test', 'test@example.com', 'Write nested legacy page');
-        await expect(listLocalKnowledgePages(project, { userId: 'local' })).resolves.toEqual([
-            {
-                key: 'historic-sql-paid-orders',
-                path: 'wiki/global/historic-sql-paid-orders.md',
-                scope: 'GLOBAL',
-                summary: 'Flat historic SQL page',
-            },
-        ]);
-    });
-});

package/dist/context/wiki/sqlite-knowledge-index.test.d.ts

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

package/dist/context/wiki/sqlite-knowledge-index.test.js

@@ -1,129 +0,0 @@
-import { access, mkdtemp, rm } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { SqliteKnowledgeIndex } from './sqlite-knowledge-index.js';
-describe('SqliteKnowledgeIndex', () => {
-    let tempDir;
-    let dbPath;
-    beforeEach(async () => {
-        tempDir = await mkdtemp(join(tmpdir(), 'ktx-sqlite-knowledge-index-'));
-        dbPath = join(tempDir, 'db.sqlite');
-    });
-    afterEach(async () => {
-        await rm(tempDir, { recursive: true, force: true });
-    });
-    function page(overrides = {}) {
-        return {
-            path: 'wiki/global/revenue.md',
-            key: 'revenue',
-            scope: 'GLOBAL',
-            summary: 'Revenue definition',
-            content: 'Revenue is the sum of paid order amounts.',
-            tags: ['finance'],
-            embedding: null,
-            ...overrides,
-        };
-    }
-    it('creates a SQLite FTS5 index and returns lexical lane candidates', async () => {
-        const index = new SqliteKnowledgeIndex({ dbPath });
-        index.sync([
-            page(),
-            page({
-                path: 'wiki/global/support.md',
-                key: 'support',
-                summary: 'Support queue',
-                content: 'Tickets are grouped by priority.',
-                tags: ['operations'],
-            }),
-        ]);
-        await expect(access(dbPath)).resolves.toBeUndefined();
-        expect(index.searchLexicalCandidates({ queryText: 'paid order', limit: 10 })).toEqual([
-            expect.objectContaining({
-                id: 'wiki/global/revenue.md',
-                path: 'wiki/global/revenue.md',
-                rank: 1,
-                rawScore: expect.any(Number),
-            }),
-        ]);
-    });
-    it('removes stale rows when the Markdown source list changes', () => {
-        const index = new SqliteKnowledgeIndex({ dbPath });
-        index.rebuild([page(), page({ path: 'wiki/global/churn.md', key: 'churn', content: 'Churn risk.' })]);
-        expect(index.search('churn', 10)).toHaveLength(1);
-        index.rebuild([page()]);
-        expect(index.search('churn', 10)).toEqual([]);
-    });
-    it('clear removes one wiki scope and leaves other scopes intact', async () => {
-        const index = new SqliteKnowledgeIndex({ dbPath });
-        index.sync([
-            page({ path: 'wiki/global/revenue.md', key: 'revenue', scope: 'GLOBAL', scopeId: null }),
-            page({
-                path: 'wiki/user/local/revenue.md',
-                key: 'revenue',
-                scope: 'USER',
-                scopeId: 'local',
-                summary: 'Local revenue',
-                content: 'Local revenue notes.',
-            }),
-            page({
-                path: 'wiki/user/alex/revenue.md',
-                key: 'revenue',
-                scope: 'USER',
-                scopeId: 'alex',
-                summary: 'Alex revenue',
-                content: 'Alex revenue notes.',
-            }),
-        ]);
-        expect(index.clear('USER', 'local')).toBe(1);
-        expect(index.search('Local', 10)).toEqual([]);
-        expect(index.search('Alex', 10)).toEqual([expect.objectContaining({ path: 'wiki/user/alex/revenue.md' })]);
-        expect(index.search('definition', 10)).toEqual([expect.objectContaining({ path: 'wiki/global/revenue.md' })]);
-    });
-    it('exposes existing search text and embedding state for incremental refresh', () => {
-        const index = new SqliteKnowledgeIndex({ dbPath });
-        index.sync([page({ path: 'wiki/global/revenue.md', key: 'revenue', embedding: [1, 0] })]);
-        expect(index.getExistingPages()).toEqual(new Map([
-            [
-                'wiki/global/revenue.md',
-                expect.objectContaining({
-                    searchText: expect.stringContaining('Revenue definition'),
-                    embedding: [1, 0],
-                }),
-            ],
-        ]));
-    });
-    it('does not treat empty embeddings as indexed semantic vectors', () => {
-        const index = new SqliteKnowledgeIndex({ dbPath });
-        index.sync([page({ path: 'wiki/global/revenue.md', key: 'revenue', embedding: [] })]);
-        expect(index.getExistingPages().get('wiki/global/revenue.md')?.embedding).toBeNull();
-        expect(index.searchSemanticCandidates({ queryEmbedding: [1, 0], limit: 10 })).toEqual([]);
-    });
-    it('returns semantic lane candidates from stored page embeddings', () => {
-        const index = new SqliteKnowledgeIndex({ dbPath });
-        index.sync([
-            page({ path: 'wiki/global/revenue.md', key: 'revenue', embedding: [1, 0] }),
-            page({ path: 'wiki/global/support.md', key: 'support', summary: 'Support queue', embedding: [0, 1] }),
-        ]);
-        expect(index.searchSemanticCandidates({ queryEmbedding: [1, 0], limit: 10 })).toEqual([
-            expect.objectContaining({
-                id: 'wiki/global/revenue.md',
-                path: 'wiki/global/revenue.md',
-                rank: 1,
-                rawScore: 1,
-            }),
-            expect.objectContaining({
-                id: 'wiki/global/support.md',
-                path: 'wiki/global/support.md',
-                rank: 2,
-                rawScore: 0,
-            }),
-        ]);
-    });
-    it('returns an empty result for blank or punctuation-only queries', () => {
-        const index = new SqliteKnowledgeIndex({ dbPath });
-        index.rebuild([page()]);
-        expect(index.search('   ', 10)).toEqual([]);
-        expect(index.search('---', 10)).toEqual([]);
-    });
-});

package/dist/context/wiki/tools/wiki-list-tags.tool.test.d.ts

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

package/dist/context/wiki/tools/wiki-list-tags.tool.test.js

@@ -1,35 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { WikiListTagsTool } from './wiki-list-tags.tool.js';
-describe('WikiListTagsTool', () => {
-    const baseContext = { sourceId: 's', messageId: 'm', userId: 'u' };
-    it("returns distinct sorted tags across the user's visible pages", async () => {
-        const pagesRepository = {
-            listPagesForUser: vi.fn().mockResolvedValue([
-                { scope: 'GLOBAL', scope_id: null, page_key: 'k1', tags: ['metrics', 'finance'] },
-                { scope: 'USER', scope_id: 'u', page_key: 'k2', tags: ['metrics'] },
-            ]),
-        };
-        const tool = new WikiListTagsTool(pagesRepository);
-        const result = await tool.call({}, baseContext);
-        expect(result.markdown).toContain('finance');
-        expect(result.markdown).toContain('metrics');
-        expect(result.structured.tags).toEqual(['finance', 'metrics']);
-    });
-    it('lists tags from historic-SQL indexed pages with flat wiki keys', async () => {
-        const pagesRepository = {
-            listPagesForUser: vi.fn().mockResolvedValue([
-                { scope: 'GLOBAL', scope_id: null, page_key: 'company-overview', tags: ['notion'] },
-                { scope: 'GLOBAL', scope_id: null, page_key: 'historic-sql-revenue-pattern', tags: ['historic-sql', 'pattern'] },
-            ]),
-        };
-        const tool = new WikiListTagsTool(pagesRepository);
-        const result = await tool.call({}, baseContext);
-        expect(result.structured.tags).toEqual(['historic-sql', 'notion', 'pattern']);
-    });
-    it('returns a friendly message when no pages have tags', async () => {
-        const pagesRepository = { listPagesForUser: vi.fn().mockResolvedValue([]) };
-        const tool = new WikiListTagsTool(pagesRepository);
-        const result = await tool.call({}, baseContext);
-        expect(result.markdown).toMatch(/no tags/i);
-    });
-});

package/dist/context/wiki/tools/wiki-read.tool.test.d.ts

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