@kaelio/ktx 0.5.0 → 0.7.0

package/dist/context/ingest/local-bundle-runtime.test.d.ts

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

package/dist/context/ingest/local-bundle-runtime.test.js

@@ -1,240 +0,0 @@
-import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { initKtxProject, loadKtxProject } from '../../context/project/project.js';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { FakeSourceAdapter } from './adapters/fake/fake.adapter.js';
-import { createLocalBundleIngestRuntime } from './local-bundle-runtime.js';
-function testAgentRunner() {
-    return { runLoop: vi.fn().mockResolvedValue({ stopReason: 'natural' }) };
-}
-describe('createLocalBundleIngestRuntime', () => {
-    let tempDir;
-    let project;
-    beforeEach(async () => {
-        tempDir = await mkdtemp(join(tmpdir(), 'ktx-local-bundle-runtime-'));
-        const projectDir = join(tempDir, 'project');
-        await initKtxProject({ projectDir });
-        await writeFile(join(projectDir, 'ktx.yaml'), [
-            'connections:',
-            '  warehouse:',
-            '    driver: postgres',
-            'ingest:',
-            '  adapters:',
-            '    - fake',
-            '  embeddings:',
-            '    backend: none',
-            '',
-        ].join('\n'), 'utf-8');
-        project = await loadKtxProject({ projectDir });
-    });
-    afterEach(async () => {
-        await rm(tempDir, { recursive: true, force: true });
-    });
-    it('requires an agent runner or configured local ingest LLM', () => {
-        expect(() => createLocalBundleIngestRuntime({
-            project,
-            adapters: [new FakeSourceAdapter()],
-        })).toThrow([
-            'ktx ingest requires llm.provider.backend: anthropic, vertex, gateway, or claude-code, or an injected agentRunner.',
-            'Configure a local Claude Code session or API-backed LLM, then rerun ingest:',
-            `  ktx setup --project-dir ${project.projectDir} --llm-backend claude-code --no-input`,
-            `  ktx setup --project-dir ${project.projectDir} --llm-backend anthropic --anthropic-api-key-env ANTHROPIC_API_KEY --llm-model claude-sonnet-4-6 --no-input`,
-        ].join('\n'));
-    });
-    it('uses a runtime-backed agent runner when claude-code is configured', () => {
-        const runtime = {
-            generateText: vi.fn(),
-            generateObject: vi.fn(),
-            runAgentLoop: vi.fn(async () => ({ stopReason: 'natural' })),
-        };
-        project.config.llm = {
-            provider: { backend: 'claude-code' },
-            models: { default: 'sonnet' },
-            promptCaching: { enabled: false },
-        };
-        const createLlmRuntime = vi.fn(() => runtime);
-        const created = createLocalBundleIngestRuntime({
-            project,
-            adapters: [new FakeSourceAdapter()],
-            createLlmRuntime,
-        });
-        expect(created).toBeDefined();
-        expect(createLlmRuntime).toHaveBeenCalledWith(project.config.llm, expect.objectContaining({ projectDir: project.projectDir }));
-    });
-    it('warns when embeddings are configured but no embedding provider is supplied', () => {
-        const logger = { log: vi.fn(), warn: vi.fn(), error: vi.fn() };
-        project.config.ingest.embeddings = {
-            backend: 'openai',
-            model: 'text-embedding-3-small',
-            dimensions: 1536,
-        };
-        createLocalBundleIngestRuntime({
-            project,
-            adapters: [new FakeSourceAdapter()],
-            agentRunner: testAgentRunner(),
-            logger: logger,
-        });
-        expect(logger.warn).toHaveBeenCalledWith('[local-bundle-runtime] embeddings backend "openai" is configured but no embedding provider was passed; embedding-dependent stages will run against a no-op embedding port.');
-    });
-    it('builds runner deps with local SQLite stores and context tools enabled', async () => {
-        const agentRunner = testAgentRunner();
-        const runtime = createLocalBundleIngestRuntime({
-            project,
-            adapters: [new FakeSourceAdapter()],
-            agentRunner,
-            jobIdFactory: () => 'job-1',
-        });
-        expect(runtime.nextJobId()).toBe('job-1');
-        expect(runtime.storage.resolvePullDir('job-1')).toBe(join(project.projectDir, '.ktx/cache/local-ingest/job-1/pull'));
-        expect(runtime.storage.resolveUploadDir('job-1')).toBe(join(project.projectDir, '.ktx/cache/local-ingest/job-1/upload'));
-        expect(runtime.storage.resolveTranscriptDir('job-1')).toBe(join(project.projectDir, '.ktx/ingest-transcripts/job-1'));
-        await mkdir(runtime.storage.resolveUploadDir('job-1'), { recursive: true });
-    });
-    it('exposes canonical warehouse connection types to local ingest SL tools', async () => {
-        project.config.connections.warehouse = {
-            driver: 'postgres',
-            url: 'postgresql://readonly@db.example.test/analytics',
-        };
-        project.config.connections.bq = {
-            driver: 'bigquery',
-            project_id: 'acme',
-            dataset_id: 'warehouse',
-        };
-        const agentRunner = testAgentRunner();
-        const runtime = createLocalBundleIngestRuntime({
-            project,
-            adapters: [new FakeSourceAdapter()],
-            agentRunner,
-        });
-        const connections = runtime.runner.deps.connections;
-        await expect(connections.getConnectionById('warehouse')).resolves.toMatchObject({
-            id: 'warehouse',
-            connectionType: 'POSTGRESQL',
-        });
-        await expect(connections.listEnabledConnections(['warehouse', 'bq'])).resolves.toEqual([
-            { id: 'warehouse', name: 'warehouse', connectionType: 'POSTGRESQL' },
-            { id: 'bq', name: 'bq', connectionType: 'BIGQUERY' },
-        ]);
-    });
-    it('validates manifest-backed scan sources during local ingest gates', async () => {
-        await project.fileStore.writeFile('semantic-layer/warehouse/_schema/public.yaml', [
-            'tables:',
-            '  payments:',
-            '    table: public.payments',
-            '    columns:',
-            '      - name: payment_id',
-            '        type: string',
-            '      - name: amount',
-            '        type: number',
-            '',
-        ].join('\n'), 'ktx', 'ktx@example.com', 'Add warehouse manifest');
-        const agentRunner = testAgentRunner();
-        const runtime = createLocalBundleIngestRuntime({
-            project,
-            adapters: [new FakeSourceAdapter()],
-            agentRunner,
-        });
-        const deps = runtime.runner.deps;
-        await expect(deps.slValidator.validateSingleSource(deps, 'warehouse', 'payments')).resolves.toEqual({
-            errors: [],
-            warnings: expect.any(Array),
-        });
-    });
-    it('does not mask malformed direct overlays with manifest-backed fallback validation', async () => {
-        await project.fileStore.writeFile('semantic-layer/warehouse/_schema/public.yaml', [
-            'tables:',
-            '  payments:',
-            '    table: public.payments',
-            '    columns:',
-            '      - name: payment_id',
-            '        type: string',
-            '',
-        ].join('\n'), 'ktx', 'ktx@example.com', 'Add warehouse manifest');
-        await project.fileStore.writeFile('semantic-layer/warehouse/payments.yaml', ['name: payments', 'columns:', '  - [', ''].join('\n'), 'ktx', 'ktx@example.com', 'Add malformed overlay');
-        const agentRunner = testAgentRunner();
-        const runtime = createLocalBundleIngestRuntime({
-            project,
-            adapters: [new FakeSourceAdapter()],
-            agentRunner,
-        });
-        const deps = runtime.runner.deps;
-        await expect(deps.slValidator.validateSingleSource(deps, 'warehouse', 'payments')).resolves.toEqual({
-            errors: [expect.stringContaining('invalid YAML')],
-            warnings: [],
-        });
-    });
-    it('passes project connection config to local ingest query executors', async () => {
-        const agentRunner = testAgentRunner();
-        const queryExecutor = {
-            execute: vi.fn(async () => ({
-                headers: ['answer'],
-                rows: [[1]],
-                totalRows: 1,
-                command: 'SELECT',
-                rowCount: 1,
-            })),
-        };
-        const runtime = createLocalBundleIngestRuntime({
-            project,
-            adapters: [new FakeSourceAdapter()],
-            agentRunner,
-            queryExecutor,
-        });
-        const connections = runtime.runner.deps.connections;
-        await expect(connections.executeQuery('warehouse', 'select 1')).resolves.toMatchObject({
-            headers: ['answer'],
-        });
-        expect(queryExecutor.execute).toHaveBeenCalledWith({
-            connectionId: 'warehouse',
-            projectDir: project.projectDir,
-            connection: project.config.connections.warehouse,
-            sql: 'select 1',
-        });
-    });
-    it('defaults local bundle ingest to isolated diffs without a shared-worktree fallback setting', () => {
-        const runtime = createLocalBundleIngestRuntime({
-            project,
-            adapters: [new FakeSourceAdapter()],
-            agentRunner: testAgentRunner(),
-        });
-        const settings = runtime.runner.deps.settings;
-        const fallbackSettingKey = ['sharedWorktree', 'SourceKeys'].join('');
-        expect(settings).not.toHaveProperty(fallbackSettingKey);
-        expect(Object.keys(settings).sort()).toEqual([
-            'ingestTraceLevel',
-            'memoryIngestionModel',
-            'probeRowCount',
-            'workUnitFailureMode',
-            'workUnitMaxConcurrency',
-            'workUnitStepBudget',
-        ]);
-    });
-    it('accepts a debug LLM request file when constructing the default agent runner', async () => {
-        await writeFile(join(project.projectDir, 'ktx.yaml'), [
-            'connections:',
-            '  warehouse:',
-            '    driver: postgres',
-            'llm:',
-            '  provider:',
-            '    backend: gateway',
-            '    gateway:',
-            '      base_url: https://gateway.example/v1',
-            '  models:',
-            '    default: anthropic/claude-sonnet-4-6',
-            'ingest:',
-            '  adapters:',
-            '    - fake',
-            '  embeddings:',
-            '    backend: none',
-            '',
-        ].join('\n'), 'utf-8');
-        project = await loadKtxProject({ projectDir: project.projectDir });
-        const runtime = createLocalBundleIngestRuntime({
-            project,
-            adapters: [new FakeSourceAdapter()],
-            llmDebugRequestFile: join(project.projectDir, '.ktx', 'llm-debug.jsonl'),
-        });
-        expect(runtime.storage.resolvePullDir('job-1')).toBe(join(project.projectDir, '.ktx/cache/local-ingest/job-1/pull'));
-    });
-});

package/dist/context/ingest/local-embedding-provider.integration.test.d.ts

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

package/dist/context/ingest/local-embedding-provider.integration.test.js

@@ -1,139 +0,0 @@
-import { mkdir, mkdtemp, 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 { CandidateDedupService } from './context-candidates/candidate-dedup.service.js';
-import { ContextEvidenceIndexService } from './context-evidence/context-evidence-index.service.js';
-import { SqliteContextEvidenceStore } from './context-evidence/sqlite-context-evidence-store.js';
-describe('local ingest embedding providers with SQLite ingest stores', () => {
-    let tempDir;
-    let dbPath;
-    let stagedDir;
-    beforeEach(async () => {
-        tempDir = await mkdtemp(join(tmpdir(), 'ktx-local-ingest-embedding-'));
-        dbPath = join(tempDir, '.ktx', 'db.sqlite');
-        stagedDir = join(tempDir, 'staged');
-        await mkdir(join(stagedDir, 'pages', 'revenue'), { recursive: true });
-        await writeFile(join(stagedDir, 'pages', 'revenue', 'metadata.json'), `${JSON.stringify({
-            objectType: 'page',
-            id: 'page-revenue',
-            title: 'Revenue Policy',
-            path: 'Revenue Policy',
-            url: 'https://notion.test/revenue',
-            parentId: null,
-            lastEditedAt: '2026-04-30T12:00:00.000Z',
-            properties: {},
-        })}\n`, 'utf8');
-        await writeFile(join(stagedDir, 'pages', 'revenue', 'page.md'), ['# Approval', '', 'Owner approval is required before enterprise discounts are granted.', ''].join('\n'), 'utf8');
-    });
-    afterEach(async () => {
-        await rm(tempDir, { recursive: true, force: true });
-    });
-    function embeddings() {
-        return {
-            maxBatchSize: 4,
-            async computeEmbedding() {
-                return [1, 0, 0];
-            },
-            async computeEmbeddingsBulk(texts) {
-                return texts.map(() => [1, 0, 0]);
-            },
-        };
-    }
-    it('indexes and searches context evidence using a package-owned local embedding provider', async () => {
-        const store = new SqliteContextEvidenceStore({ dbPath });
-        const embeddingPort = embeddings();
-        const indexer = new ContextEvidenceIndexService({ store, embeddings: embeddingPort });
-        const diffSet = {
-            added: ['pages/revenue/metadata.json', 'pages/revenue/page.md'],
-            modified: [],
-            deleted: [],
-            unchanged: [],
-        };
-        const summary = await indexer.indexStagedDir({
-            stagedDir,
-            runId: 'run-1',
-            connectionId: 'docs',
-            sourceKey: 'notion',
-            syncId: 'sync-1',
-            diffSet,
-            currentHashes: new Map([
-                ['pages/revenue/metadata.json', 'metadata-hash'],
-                ['pages/revenue/page.md', 'page-hash'],
-            ]),
-        });
-        expect(summary).toMatchObject({
-            documentsIndexed: 1,
-            embeddingFailures: 0,
-        });
-        expect(summary.chunksIndexed).toBeGreaterThan(0);
-        const queryText = [
-            'Revenue Policy',
-            'Revenue Policy',
-            'Approval',
-            'Owner approval is required before enterprise discounts are granted.',
-        ].join('\n');
-        const queryEmbedding = await embeddingPort.computeEmbedding(queryText);
-        const results = await store.searchRRF({
-            connectionId: 'docs',
-            sourceKey: 'notion',
-            queryEmbedding,
-            queryText,
-            limit: 5,
-            includeDeleted: false,
-            currentRunId: 'run-1',
-        });
-        expect(results[0]?.title).toBe('Revenue Policy');
-        expect(results[0]?.stableCitationKey).toContain('notion:page-revenue');
-        expect(results[0]).toMatchObject({
-            matchReasons: expect.arrayContaining(['semantic']),
-            lanes: expect.arrayContaining([
-                expect.objectContaining({ lane: 'semantic', status: 'available' }),
-                expect.objectContaining({ lane: 'lexical', status: 'available' }),
-                expect.objectContaining({ lane: 'token', status: 'available' }),
-            ]),
-        });
-    });
-    it('deduplicates candidates using package-owned local embeddings and SQLite persistence', async () => {
-        const store = new SqliteContextEvidenceStore({ dbPath });
-        const embeddingPort = embeddings();
-        const candidateBase = {
-            runId: 'run-1',
-            connectionId: 'docs',
-            sourceKey: 'notion',
-            topic: 'Enterprise discount approval',
-            assertion: 'Owner approval is required before enterprise discounts are granted.',
-            rationale: 'The source policy states that approval is required.',
-            evidenceChunkIds: [],
-            evidenceRefs: [],
-            suggestedPageKey: 'revenue-policy',
-            actionHint: 'create',
-            durabilityScore: 3,
-            authorityScore: 3,
-            reuseScore: 3,
-            noveltyScore: 2,
-            riskScore: 0,
-            promotionScore: 11,
-            status: 'pending',
-            rejectionReason: null,
-            lane: 'full',
-            embedding: null,
-        };
-        await store.insertCandidate({ ...candidateBase, candidateKey: 'discount-policy-a' });
-        await store.insertCandidate({ ...candidateBase, candidateKey: 'discount-policy-b' });
-        const result = await new CandidateDedupService({
-            store,
-            embeddings: embeddingPort,
-            settings: {
-                enabled: true,
-                topicSimilarityThreshold: -1,
-                scoreAggregation: 'max',
-            },
-        }).deduplicateRun('run-1');
-        expect(result.enabled).toBe(true);
-        expect(result.embeddingFailures).toBe(0);
-        expect(result.candidatesIn).toBe(2);
-        expect(result.clustersOut).toBe(1);
-        expect(result.mergedCount).toBe(1);
-    });
-});

package/dist/context/ingest/local-mapping-reconcile.test.d.ts

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

package/dist/context/ingest/local-mapping-reconcile.test.js

@@ -1,61 +0,0 @@
-import { mkdtemp, rm } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { afterEach, describe, expect, it } from 'vitest';
-import { ktxLocalStateDbPath } from '../../context/project/local-state-db.js';
-import { LocalLookerRuntimeStore } from './adapters/looker/local-runtime-store.js';
-import { seedLocalMappingStateFromKtxYaml } from './local-mapping-reconcile.js';
-describe('local mapping yaml reconciliation bridge', () => {
-    let tempDir;
-    afterEach(async () => {
-        if (tempDir) {
-            await rm(tempDir, { recursive: true, force: true });
-        }
-    });
-    function projectWithConnections(connections) {
-        return {
-            projectDir: tempDir,
-            config: { connections },
-        };
-    }
-    it('does not copy Metabase mapping intent into local SQLite state', async () => {
-        tempDir = await mkdtemp(join(tmpdir(), 'ktx-metabase-yaml-seed-'));
-        const project = projectWithConnections({
-            'prod-metabase': {
-                driver: 'metabase',
-                api_url: 'https://metabase.example.com',
-                mappings: {
-                    databaseMappings: { '1': 'prod-warehouse' },
-                    syncEnabled: { '1': true },
-                    syncMode: 'ONLY',
-                    selections: { collections: [12], items: [] },
-                    defaultTagNames: ['ktx'],
-                },
-            },
-            'prod-warehouse': { driver: 'postgres', url: 'postgresql://readonly@db.test/analytics' },
-        });
-        await expect(seedLocalMappingStateFromKtxYaml(project, 'prod-metabase')).resolves.toBeUndefined();
-    });
-    it('seeds Looker local mappings from ktx.yaml mapping intent', async () => {
-        tempDir = await mkdtemp(join(tmpdir(), 'ktx-looker-yaml-seed-'));
-        const project = projectWithConnections({
-            'prod-looker': {
-                driver: 'looker',
-                base_url: 'https://looker.example.com',
-                client_id: 'client',
-                mappings: { connectionMappings: { analytics: 'prod-warehouse' } },
-            },
-            'prod-warehouse': { driver: 'postgres', url: 'postgresql://readonly@db.test/analytics' },
-        });
-        await seedLocalMappingStateFromKtxYaml(project, 'prod-looker');
-        const store = new LocalLookerRuntimeStore({ dbPath: ktxLocalStateDbPath(project) });
-        await expect(store.listConnectionMappings('prod-looker')).resolves.toMatchObject([
-            { lookerConnectionName: 'analytics', ktxConnectionId: 'prod-warehouse', source: 'ktx.yaml' },
-        ]);
-    });
-    it('does nothing for connections without mapping bootstrap intent', async () => {
-        tempDir = await mkdtemp(join(tmpdir(), 'ktx-no-yaml-seed-'));
-        const project = projectWithConnections({ warehouse: { driver: 'postgres', url: 'env:DATABASE_URL' } });
-        await expect(seedLocalMappingStateFromKtxYaml(project, 'warehouse')).resolves.toBeUndefined();
-    });
-});

package/dist/context/ingest/local-metabase-ingest.test.d.ts

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