@kaelio/ktx 0.5.0 → 0.7.0

package/dist/context/search/query.test.js

@@ -1,23 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { defaultLaneCandidatePoolLimit, normalizeSearchQuery } from './query.js';
-describe('search query helpers', () => {
-    it('normalizes punctuation and duplicate terms into stable lowercase tokens', () => {
-        expect(normalizeSearchQuery('  Gross-Revenue, gross_revenue! Paid orders  ')).toEqual({
-            raw: '  Gross-Revenue, gross_revenue! Paid orders  ',
-            normalized: 'gross revenue gross_revenue paid orders',
-            terms: ['gross', 'revenue', 'gross_revenue', 'paid', 'orders'],
-        });
-    });
-    it('returns an empty normalized query for punctuation-only input', () => {
-        expect(normalizeSearchQuery('--- ///')).toEqual({
-            raw: '--- ///',
-            normalized: '',
-            terms: [],
-        });
-    });
-    it('sizes per-lane candidate pools before final limiting', () => {
-        expect(defaultLaneCandidatePoolLimit(1)).toBe(25);
-        expect(defaultLaneCandidatePoolLimit(8)).toBe(25);
-        expect(defaultLaneCandidatePoolLimit(10)).toBe(30);
-    });
-});

package/dist/context/search/rrf.test.d.ts

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

package/dist/context/search/rrf.test.js

@@ -1,47 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { compareFusedSearchCandidates, DEFAULT_SEARCH_LANE_WEIGHTS, rrfContribution } from './rrf.js';
-describe('RRF scoring', () => {
-    it('uses the shared lane weights from the hybrid search spec', () => {
-        expect(DEFAULT_SEARCH_LANE_WEIGHTS).toEqual({
-            semantic: 2,
-            dictionary: 2,
-            lexical: 1.5,
-            token: 0.75,
-        });
-    });
-    it('calculates a weighted RRF contribution with k=60 by default', () => {
-        expect(rrfContribution(2, 1)).toBeCloseTo(2 / 61, 12);
-        expect(rrfContribution(1.5, 2)).toBeCloseTo(1.5 / 62, 12);
-    });
-    it('sorts fused candidates by score, lane count, and stable id', () => {
-        const first = {
-            id: 'orders',
-            score: 0.05,
-            matchReasons: ['lexical'],
-            ranksByLane: { lexical: 1 },
-            rawScoresByLane: {},
-            evidenceByLane: {},
-        };
-        const second = {
-            id: 'customers',
-            score: 0.05,
-            matchReasons: ['lexical', 'semantic'],
-            ranksByLane: { lexical: 2, semantic: 1 },
-            rawScoresByLane: {},
-            evidenceByLane: {},
-        };
-        const third = {
-            id: 'accounts',
-            score: 0.04,
-            matchReasons: ['semantic'],
-            ranksByLane: { semantic: 1 },
-            rawScoresByLane: {},
-            evidenceByLane: {},
-        };
-        expect([first, second, third].sort(compareFusedSearchCandidates).map((candidate) => candidate.id)).toEqual([
-            'customers',
-            'orders',
-            'accounts',
-        ]);
-    });
-});

package/dist/context/skills/skills-registry.service.test.d.ts

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

package/dist/context/skills/skills-registry.service.test.js

@@ -1,161 +0,0 @@
-import { mkdtemp, mkdir, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { SkillsRegistryService } from './skills-registry.service.js';
-describe('SkillsRegistryService', () => {
-    let service;
-    let tempDir;
-    beforeEach(async () => {
-        tempDir = await mkdtemp(join(tmpdir(), 'skills-registry-'));
-        service = new SkillsRegistryService({ skillsDir: tempDir });
-    });
-    afterEach(async () => {
-        await rm(tempDir, { recursive: true, force: true });
-    });
-    const writeSkill = async (dirName, body) => {
-        const dir = join(tempDir, dirName);
-        await mkdir(dir, { recursive: true });
-        await writeFile(join(dir, 'SKILL.md'), body, 'utf-8');
-    };
-    describe('parseFrontmatter', () => {
-        it('parses name and description', () => {
-            const frontmatter = service.parseFrontmatter('---\nname: foo\ndescription: Bar baz\n---\n\n# body');
-            expect(frontmatter).toEqual({ name: 'foo', description: 'Bar baz' });
-        });
-        it('supports wrapped description continuation lines', () => {
-            const frontmatter = service.parseFrontmatter(['---', 'name: sl', 'description: Line one', '  continuation of the description.', '---', '', '# body'].join('\n'));
-            expect(frontmatter.name).toBe('sl');
-            expect(frontmatter.description).toContain('Line one');
-            expect(frontmatter.description).toContain('continuation');
-        });
-        it('returns empty fields when no frontmatter block', () => {
-            expect(service.parseFrontmatter('# just a heading')).toEqual({});
-        });
-    });
-    describe('stripFrontmatter', () => {
-        it('removes the frontmatter block and leading blank line', () => {
-            const body = '---\nname: x\ndescription: y\n---\n\n# Hello\n\nparagraph';
-            expect(service.stripFrontmatter(body)).toBe('# Hello\n\nparagraph');
-        });
-        it('is a no-op when no frontmatter exists', () => {
-            expect(service.stripFrontmatter('# hello')).toBe('# hello');
-        });
-    });
-    describe('discoverSkills', () => {
-        it('returns an empty map when the directory does not exist', async () => {
-            const catalog = await service.discoverSkills(join(tempDir, 'missing'));
-            expect(catalog.size).toBe(0);
-        });
-        it('discovers valid skills and skips invalid ones', async () => {
-            await writeSkill('sl', '---\nname: sl\ndescription: Semantic layer.\n---\n\n# SL');
-            await writeSkill('wiki_capture', '---\nname: wiki_capture\ndescription: Wiki capture.\n---\n\n# KC');
-            await writeSkill('broken', '# no frontmatter at all');
-            await mkdir(join(tempDir, 'not_a_skill'), { recursive: true });
-            const catalog = await service.discoverSkills(tempDir);
-            expect(catalog.size).toBe(2);
-            expect(catalog.get('sl')?.name).toBe('sl');
-            expect(catalog.get('wiki_capture')?.description).toContain('Wiki capture');
-            expect(catalog.has('broken')).toBe(false);
-        });
-    });
-    describe('buildSkillsPrompt', () => {
-        it('formats bullet list with name and description', () => {
-            const output = service.buildSkillsPrompt([
-                { name: 'sl', description: 'Semantic layer.', path: '/tmp/sl' },
-                { name: 'wiki_capture', description: 'Wiki capture.', path: '/tmp/kc' },
-            ]);
-            expect(output).toContain('- sl: Semantic layer.');
-            expect(output).toContain('- wiki_capture: Wiki capture.');
-            expect(output).toContain('Use the `load_skill` tool');
-        });
-        it('returns empty string when no skills are available', () => {
-            expect(service.buildSkillsPrompt([])).toBe('');
-        });
-        it('appends the async capture note for the research caller', () => {
-            const output = service.buildSkillsPrompt([{ name: 'sl', description: 'Semantic layer.', path: '/tmp/sl' }], 'research');
-            expect(output).toContain('captured automatically by a post-turn memory agent');
-            expect(output).toContain('Focus on answering, not on saving');
-        });
-        it('does not append the note for memory_agent caller', () => {
-            const output = service.buildSkillsPrompt([{ name: 'sl_capture', description: 'Capture skill.', path: '/tmp/cap' }], 'memory_agent');
-            expect(output).not.toContain('captured automatically by a post-turn memory agent');
-        });
-    });
-    describe('parseFrontmatter callers field', () => {
-        it('parses inline-array form', () => {
-            const frontmatter = service.parseFrontmatter('---\nname: x\ndescription: y\ncallers: [memory_agent]\n---\n');
-            expect(frontmatter.callers).toEqual(['memory_agent']);
-        });
-        it('parses comma-separated form', () => {
-            const frontmatter = service.parseFrontmatter('---\nname: x\ndescription: y\ncallers: research, memory_agent\n---\n');
-            expect(frontmatter.callers).toEqual(['research', 'memory_agent']);
-        });
-        it('returns undefined when callers is absent', () => {
-            const frontmatter = service.parseFrontmatter('---\nname: x\ndescription: y\n---\n');
-            expect(frontmatter.callers).toBeUndefined();
-        });
-        it('drops unknown caller names with a warning', () => {
-            const frontmatter = service.parseFrontmatter('---\nname: x\ndescription: y\ncallers: [bogus, memory_agent]\n---\n');
-            expect(frontmatter.callers).toEqual(['memory_agent']);
-        });
-        it('returns undefined when the value is empty', () => {
-            const frontmatter = service.parseFrontmatter('---\nname: x\ndescription: y\ncallers:\n---\n');
-            expect(frontmatter.callers).toBeUndefined();
-        });
-    });
-    describe('listSkills and getSkill caller filter', () => {
-        beforeEach(async () => {
-            await writeSkill('sl', '---\nname: sl\ndescription: Open to all.\n---\n\n# SL');
-            await writeSkill('sl_capture', '---\nname: sl_capture\ndescription: Memory-only capture skill.\ncallers: [memory_agent]\n---\n\n# Capture');
-            await writeSkill('wiki_capture', '---\nname: wiki_capture\ndescription: Wiki capture.\ncallers: [memory_agent]\n---\n\n# KC');
-            service = new SkillsRegistryService({ skillsDir: tempDir });
-        });
-        it('research caller sees only open skills', async () => {
-            const skills = await service.listSkills('research');
-            expect(skills.map((skill) => skill.name).sort()).toEqual(['sl']);
-        });
-        it('memory_agent caller sees memory-only and open skills', async () => {
-            const skills = await service.listSkills('memory_agent');
-            expect(skills.map((skill) => skill.name).sort()).toEqual(['sl', 'sl_capture', 'wiki_capture']);
-        });
-        it('listSkills with names and caller intersects both filters', async () => {
-            const skills = await service.listSkills(['sl', 'sl_capture'], 'research');
-            expect(skills.map((skill) => skill.name)).toEqual(['sl']);
-        });
-        it('getSkill returns null for memory-only skill when caller is research', async () => {
-            const skill = await service.getSkill('sl_capture', 'research');
-            expect(skill).toBeNull();
-        });
-        it('getSkill returns the skill when caller has access', async () => {
-            const skill = await service.getSkill('sl_capture', 'memory_agent');
-            expect(skill?.name).toBe('sl_capture');
-        });
-        it('getSkill without caller returns the skill regardless of callers field', async () => {
-            const skill = await service.getSkill('sl_capture');
-            expect(skill?.name).toBe('sl_capture');
-        });
-    });
-    it('discovers skills from additional directories when the primary directory misses', async () => {
-        const extraDir = await mkdtemp(join(tmpdir(), 'skills-registry-extra-'));
-        try {
-            await mkdir(join(extraDir, 'wiki_capture'), { recursive: true });
-            await writeFile(join(extraDir, 'wiki_capture', 'SKILL.md'), [
-                '---',
-                'name: wiki_capture',
-                'description: Packaged knowledge capture skill.',
-                'callers: [memory_agent]',
-                '---',
-                '',
-                '# Wiki Capture',
-            ].join('\n'), 'utf-8');
-            service = new SkillsRegistryService({ skillsDir: tempDir, additionalSkillDirs: [extraDir] });
-            const skills = await service.listSkills(['wiki_capture'], 'memory_agent');
-            expect(skills.map((skill) => skill.name)).toEqual(['wiki_capture']);
-            expect(skills[0]?.path).toBe(join(extraDir, 'wiki_capture'));
-        }
-        finally {
-            await rm(extraDir, { recursive: true, force: true });
-        }
-    });
-});

package/dist/context/sl/dictionary-search.test.d.ts

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

package/dist/context/sl/dictionary-search.test.js

@@ -1,204 +0,0 @@
-import { 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 { createKtxDictionarySearchService } from './dictionary-search.js';
-describe('createKtxDictionarySearchService', () => {
-    let tempDir;
-    let project;
-    beforeEach(async () => {
-        tempDir = await mkdtemp(join(tmpdir(), 'ktx-dictionary-search-'));
-        project = await initKtxProject({ projectDir: join(tempDir, 'project') });
-        project.config.connections.warehouse = { driver: 'postgres', url: 'env:DATABASE_URL' };
-        project.config.connections.billing = { driver: 'postgres', url: 'env:BILLING_DATABASE_URL' };
-    });
-    afterEach(async () => {
-        await rm(tempDir, { recursive: true, force: true });
-    });
-    async function seedProfile(input) {
-        await project.fileStore.writeFile(`raw-sources/${input.connectionId}/live-database/${input.syncId}/enrichment/relationship-profile.json`, `${JSON.stringify({
-            connectionId: input.connectionId,
-            driver: 'postgres',
-            sqlAvailable: true,
-            queryCount: 4,
-            tables: [],
-            columns: input.columns,
-            warnings: [],
-        }, null, 2)}\n`, 'ktx', 'ktx@example.com', 'Seed relationship profile');
-    }
-    it('returns matches and non-authoritative misses across configured connections', async () => {
-        await seedProfile({
-            connectionId: 'warehouse',
-            syncId: 'sync-1',
-            columns: {
-                'orders.status': {
-                    table: { catalog: null, db: 'public', name: 'orders' },
-                    column: 'status',
-                    nativeType: 'text',
-                    normalizedType: 'string',
-                    distinctCount: 3,
-                    sampleValues: ['paid', 'refunded', 'pending'],
-                },
-            },
-        });
-        await seedProfile({
-            connectionId: 'billing',
-            syncId: 'sync-2',
-            columns: {
-                'customers.name': {
-                    table: { catalog: null, db: 'public', name: 'customers' },
-                    column: 'name',
-                    nativeType: 'text',
-                    normalizedType: 'string',
-                    distinctCount: 4,
-                    sampleValues: ['Acme Corp', 'Globex'],
-                },
-            },
-        });
-        const service = createKtxDictionarySearchService(project);
-        await expect(service.search({ values: ['PAID', 'missing'] })).resolves.toEqual({
-            searched: [
-                {
-                    connectionId: 'billing',
-                    coverage: {
-                        sampledRows: null,
-                        valuesPerColumn: null,
-                        profiledColumns: 1,
-                        syncId: 'sync-2',
-                        profiledAt: null,
-                    },
-                    status: 'ready',
-                },
-                {
-                    connectionId: 'warehouse',
-                    coverage: {
-                        sampledRows: null,
-                        valuesPerColumn: null,
-                        profiledColumns: 1,
-                        syncId: 'sync-1',
-                        profiledAt: null,
-                    },
-                    status: 'ready',
-                },
-            ],
-            results: [
-                {
-                    value: 'PAID',
-                    matches: [
-                        {
-                            connectionId: 'warehouse',
-                            sourceName: 'orders',
-                            columnName: 'status',
-                            matchedValue: 'paid',
-                            cardinality: 3,
-                        },
-                    ],
-                    misses: [{ connectionId: 'billing', reason: 'value_not_in_sample' }],
-                },
-                {
-                    value: 'missing',
-                    matches: [],
-                    misses: [
-                        { connectionId: 'billing', reason: 'value_not_in_sample' },
-                        { connectionId: 'warehouse', reason: 'value_not_in_sample' },
-                    ],
-                },
-            ],
-        });
-    });
-    it('distinguishes missing profile artifacts from profiles with no candidate columns', async () => {
-        await seedProfile({
-            connectionId: 'billing',
-            syncId: 'sync-empty',
-            columns: {
-                'events.id': {
-                    table: { catalog: null, db: 'public', name: 'events' },
-                    column: 'id',
-                    nativeType: 'integer',
-                    normalizedType: 'integer',
-                    distinctCount: 100,
-                    sampleValues: [1, 2, 3],
-                },
-            },
-        });
-        const service = createKtxDictionarySearchService(project);
-        await expect(service.search({ values: ['Acme'] })).resolves.toEqual({
-            searched: [
-                {
-                    connectionId: 'billing',
-                    coverage: {
-                        sampledRows: null,
-                        valuesPerColumn: null,
-                        profiledColumns: 0,
-                        syncId: 'sync-empty',
-                        profiledAt: null,
-                    },
-                    status: 'no_candidate_columns',
-                },
-                {
-                    connectionId: 'warehouse',
-                    coverage: {
-                        sampledRows: null,
-                        valuesPerColumn: null,
-                        profiledColumns: 0,
-                        syncId: null,
-                        profiledAt: null,
-                    },
-                    status: 'no_profile_artifact',
-                },
-            ],
-            results: [
-                {
-                    value: 'Acme',
-                    matches: [],
-                    misses: [
-                        { connectionId: 'billing', reason: 'no_candidate_columns' },
-                        { connectionId: 'warehouse', reason: 'no_profile_artifact' },
-                    ],
-                },
-            ],
-        });
-    });
-    it('scopes search to the requested connection', async () => {
-        await seedProfile({
-            connectionId: 'warehouse',
-            syncId: 'sync-1',
-            columns: {
-                'orders.status': {
-                    table: { catalog: null, db: 'public', name: 'orders' },
-                    column: 'status',
-                    nativeType: 'text',
-                    normalizedType: 'string',
-                    distinctCount: 3,
-                    sampleValues: ['paid'],
-                },
-            },
-        });
-        await seedProfile({
-            connectionId: 'billing',
-            syncId: 'sync-2',
-            columns: {
-                'invoices.status': {
-                    table: { catalog: null, db: 'public', name: 'invoices' },
-                    column: 'status',
-                    nativeType: 'text',
-                    normalizedType: 'string',
-                    distinctCount: 2,
-                    sampleValues: ['paid'],
-                },
-            },
-        });
-        const service = createKtxDictionarySearchService(project);
-        await expect(service.search({ connectionId: 'billing', values: ['paid'] })).resolves.toMatchObject({
-            searched: [{ connectionId: 'billing', status: 'ready' }],
-            results: [
-                {
-                    value: 'paid',
-                    matches: [{ connectionId: 'billing', sourceName: 'invoices', columnName: 'status', matchedValue: 'paid' }],
-                    misses: [],
-                },
-            ],
-        });
-    });
-});

package/dist/context/sl/local-query.test.d.ts

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