@kaelio/ktx 0.5.0 → 0.7.0

package/dist/context/daemon/semantic-layer-compute.test.js

@@ -1,305 +0,0 @@
-import { once } from 'node:events';
-import { createServer } from 'node:http';
-import { describe, expect, it, vi } from 'vitest';
-import { createHttpSemanticLayerComputePort, createPythonSemanticLayerComputePort } from './semantic-layer-compute.js';
-const source = {
-    name: 'orders',
-    table: 'public.orders',
-    grain: ['id'],
-    columns: [{ name: 'id', type: 'number' }],
-    joins: [],
-    measures: [{ name: 'order_count', expr: 'count(*)' }],
-};
-const sourceGenerationInput = {
-    tables: [
-        {
-            name: 'orders',
-            db: 'public',
-            comment: 'Orders table',
-            columns: [
-                { name: 'id', type: 'integer', primaryKey: true, nullable: false, comment: 'Order ID' },
-                { name: 'customer_id', type: 'integer' },
-                { name: 'amount', type: 'decimal', comment: 'Order amount' },
-            ],
-        },
-        {
-            name: 'customers',
-            db: 'public',
-            columns: [
-                { name: 'id', type: 'integer', primaryKey: true },
-                { name: 'email', type: 'varchar' },
-            ],
-        },
-    ],
-    links: [
-        {
-            fromTable: 'orders',
-            fromColumn: 'customer_id',
-            toTable: 'customers',
-            toColumn: 'id',
-            relationshipType: 'MANY_TO_ONE',
-        },
-    ],
-    dialect: 'postgres',
-};
-const sourceGenerationDaemonPayload = {
-    tables: [
-        {
-            name: 'orders',
-            db: 'public',
-            comment: 'Orders table',
-            columns: [
-                { name: 'id', type: 'integer', primary_key: true, nullable: false, comment: 'Order ID' },
-                { name: 'customer_id', type: 'integer' },
-                { name: 'amount', type: 'decimal', comment: 'Order amount' },
-            ],
-        },
-        {
-            name: 'customers',
-            db: 'public',
-            columns: [
-                { name: 'id', type: 'integer', primary_key: true },
-                { name: 'email', type: 'varchar' },
-            ],
-        },
-    ],
-    links: [
-        {
-            from_table: 'orders',
-            from_column: 'customer_id',
-            to_table: 'customers',
-            to_column: 'id',
-            relationship_type: 'MANY_TO_ONE',
-        },
-    ],
-    dialect: 'postgres',
-};
-const sourceGenerationDaemonResponse = {
-    source_count: 2,
-    sources: [
-        {
-            name: 'orders',
-            table: 'public.orders',
-            grain: ['id'],
-            columns: [{ name: 'id', type: 'number' }],
-            joins: [
-                {
-                    to: 'customers',
-                    on: 'customer_id = customers.id',
-                    relationship: 'many_to_one',
-                },
-            ],
-            measures: [{ name: 'record_count', expr: 'count(id)' }],
-        },
-    ],
-};
-describe('createPythonSemanticLayerComputePort', () => {
-    it('calls the semantic-query stdio command', async () => {
-        const runJson = vi.fn(async () => ({
-            sql: 'select count(*) from public.orders',
-            dialect: 'postgres',
-            columns: [{ name: 'orders.order_count' }],
-            plan: { sources_used: ['orders'] },
-        }));
-        const port = createPythonSemanticLayerComputePort({
-            runJson,
-            projectId: 'hashed-project-id',
-        });
-        await expect(port.query({
-            sources: [source],
-            dialect: 'postgres',
-            query: { measures: ['orders.order_count'], dimensions: [] },
-        })).resolves.toEqual({
-            sql: 'select count(*) from public.orders',
-            dialect: 'postgres',
-            columns: [{ name: 'orders.order_count' }],
-            plan: { sources_used: ['orders'] },
-        });
-        expect(runJson).toHaveBeenCalledWith('semantic-query', {
-            sources: [source],
-            dialect: 'postgres',
-            query: { measures: ['orders.order_count'], dimensions: [] },
-            projectId: 'hashed-project-id',
-        });
-    });
-    it('calls the semantic-validate stdio command', async () => {
-        const runJson = vi.fn(async () => ({
-            valid: true,
-            errors: [],
-            warnings: [],
-            per_source_warnings: {},
-        }));
-        const port = createPythonSemanticLayerComputePort({ runJson });
-        await expect(port.validateSources({
-            sources: [source],
-            dialect: 'postgres',
-            recentlyTouched: ['orders'],
-        })).resolves.toEqual({
-            valid: true,
-            errors: [],
-            warnings: [],
-            perSourceWarnings: {},
-        });
-        expect(runJson).toHaveBeenCalledWith('semantic-validate', {
-            sources: [source],
-            dialect: 'postgres',
-            recently_touched: ['orders'],
-        });
-    });
-    it('calls the semantic-generate-sources stdio command', async () => {
-        const runJson = vi.fn(async () => sourceGenerationDaemonResponse);
-        const port = createPythonSemanticLayerComputePort({ runJson });
-        await expect(port.generateSources(sourceGenerationInput)).resolves.toEqual({
-            sourceCount: 2,
-            sources: sourceGenerationDaemonResponse.sources,
-        });
-        expect(runJson).toHaveBeenCalledWith('semantic-generate-sources', sourceGenerationDaemonPayload);
-    });
-});
-describe('createHttpSemanticLayerComputePort', () => {
-    it('calls semantic query and validate HTTP endpoints through an injected runner', async () => {
-        const requestJson = vi.fn(async (path) => {
-            if (path === '/semantic-layer/query') {
-                return {
-                    sql: 'select count(*) from public.orders',
-                    dialect: 'postgres',
-                    columns: [{ name: 'orders.order_count' }],
-                    plan: { sources_used: ['orders'] },
-                };
-            }
-            return {
-                valid: true,
-                errors: [],
-                warnings: [],
-                per_source_warnings: {},
-            };
-        });
-        const port = createHttpSemanticLayerComputePort({ baseUrl: 'http://127.0.0.1:8765/', requestJson });
-        await expect(port.query({
-            sources: [source],
-            dialect: 'postgres',
-            query: { measures: ['orders.order_count'], dimensions: [] },
-        })).resolves.toEqual({
-            sql: 'select count(*) from public.orders',
-            dialect: 'postgres',
-            columns: [{ name: 'orders.order_count' }],
-            plan: { sources_used: ['orders'] },
-        });
-        await expect(port.validateSources({
-            sources: [source],
-            dialect: 'postgres',
-            recentlyTouched: ['orders'],
-        })).resolves.toEqual({
-            valid: true,
-            errors: [],
-            warnings: [],
-            perSourceWarnings: {},
-        });
-        expect(requestJson).toHaveBeenNthCalledWith(1, '/semantic-layer/query', {
-            sources: [source],
-            dialect: 'postgres',
-            query: { measures: ['orders.order_count'], dimensions: [] },
-        });
-        expect(requestJson).toHaveBeenNthCalledWith(2, '/semantic-layer/validate', {
-            sources: [source],
-            dialect: 'postgres',
-            recently_touched: ['orders'],
-        });
-    });
-    it('calls the semantic source-generation HTTP endpoint through an injected runner', async () => {
-        const requestJson = vi.fn(async () => sourceGenerationDaemonResponse);
-        const port = createHttpSemanticLayerComputePort({ baseUrl: 'http://127.0.0.1:8765/', requestJson });
-        await expect(port.generateSources(sourceGenerationInput)).resolves.toEqual({
-            sourceCount: 2,
-            sources: sourceGenerationDaemonResponse.sources,
-        });
-        expect(requestJson).toHaveBeenCalledWith('/semantic-layer/generate-sources', sourceGenerationDaemonPayload);
-    });
-    it('posts JSON to a running HTTP daemon endpoint', async () => {
-        const requests = [];
-        const server = createServer((request, response) => {
-            const chunks = [];
-            request.on('data', (chunk) => chunks.push(chunk));
-            request.on('end', () => {
-                requests.push({
-                    url: request.url,
-                    body: JSON.parse(Buffer.concat(chunks).toString('utf8')),
-                });
-                response.writeHead(200, { 'content-type': 'application/json' });
-                response.end(JSON.stringify({
-                    sql: 'select count(*) from public.orders',
-                    dialect: 'postgres',
-                    columns: [{ name: 'orders.order_count' }],
-                    plan: { sources_used: ['orders'] },
-                }));
-            });
-        });
-        server.listen(0, '127.0.0.1');
-        await once(server, 'listening');
-        try {
-            const address = server.address();
-            if (!address || typeof address === 'string') {
-                throw new Error('expected TCP server address');
-            }
-            const port = createHttpSemanticLayerComputePort({ baseUrl: `http://127.0.0.1:${address.port}` });
-            await expect(port.query({
-                sources: [source],
-                dialect: 'postgres',
-                query: { measures: ['orders.order_count'], dimensions: [] },
-            })).resolves.toMatchObject({
-                sql: 'select count(*) from public.orders',
-                dialect: 'postgres',
-            });
-            expect(requests).toEqual([
-                {
-                    url: '/semantic-layer/query',
-                    body: {
-                        sources: [source],
-                        dialect: 'postgres',
-                        query: { measures: ['orders.order_count'], dimensions: [] },
-                    },
-                },
-            ]);
-        }
-        finally {
-            server.close();
-        }
-    });
-    it('posts source-generation JSON to a running HTTP daemon endpoint', async () => {
-        const requests = [];
-        const server = createServer((request, response) => {
-            const chunks = [];
-            request.on('data', (chunk) => chunks.push(chunk));
-            request.on('end', () => {
-                requests.push({
-                    url: request.url,
-                    body: JSON.parse(Buffer.concat(chunks).toString('utf8')),
-                });
-                response.writeHead(200, { 'content-type': 'application/json' });
-                response.end(JSON.stringify(sourceGenerationDaemonResponse));
-            });
-        });
-        server.listen(0, '127.0.0.1');
-        await once(server, 'listening');
-        try {
-            const address = server.address();
-            if (!address || typeof address === 'string') {
-                throw new Error('expected TCP server address');
-            }
-            const port = createHttpSemanticLayerComputePort({ baseUrl: `http://127.0.0.1:${address.port}` });
-            await expect(port.generateSources(sourceGenerationInput)).resolves.toEqual({
-                sourceCount: 2,
-                sources: sourceGenerationDaemonResponse.sources,
-            });
-            expect(requests).toEqual([
-                {
-                    url: '/semantic-layer/generate-sources',
-                    body: sourceGenerationDaemonPayload,
-                },
-            ]);
-        }
-        finally {
-            server.close();
-        }
-    });
-});

package/dist/context/index-sync/reindex.test.d.ts

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

package/dist/context/index-sync/reindex.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 { initKtxProject, loadKtxProject } from '../../context/project/project.js';
-import { SqliteKnowledgeIndex } from '../wiki/sqlite-knowledge-index.js';
-import { reindexLocalIndexes } from './reindex.js';
-class FakeEmbeddingPort {
-    maxBatchSize = 8;
-    async computeEmbedding(text) {
-        return [text.length, 1];
-    }
-    async computeEmbeddingsBulk(texts) {
-        return texts.map((text) => [text.length, 1]);
-    }
-}
-async function createProject(tempDir) {
-    await initKtxProject({ projectDir: tempDir, force: true });
-    return loadKtxProject({ projectDir: tempDir });
-}
-describe('reindexLocalIndexes', () => {
-    let tempDir;
-    beforeEach(async () => {
-        tempDir = await mkdtemp(join(tmpdir(), 'ktx-reindex-'));
-    });
-    afterEach(async () => {
-        await rm(tempDir, { recursive: true, force: true });
-    });
-    it('returns an empty summary when no wiki or semantic-layer directories exist', async () => {
-        const project = await createProject(tempDir);
-        await rm(join(project.projectDir, 'wiki'), { recursive: true, force: true });
-        await rm(join(project.projectDir, 'semantic-layer'), { recursive: true, force: true });
-        await expect(reindexLocalIndexes(project, { force: false, embeddingService: null })).resolves.toMatchObject({
-            scopes: [],
-            totals: { scanned: 0, updated: 0, deleted: 0, embeddingsRecomputed: 0, embeddingsFailed: 0 },
-            force: false,
-            embeddingsAvailable: false,
-        });
-    });
-    it('discovers empty directories as zero-row scopes', async () => {
-        const project = await createProject(tempDir);
-        await mkdir(join(project.projectDir, 'wiki/user/local'), { recursive: true });
-        await mkdir(join(project.projectDir, 'semantic-layer/warehouse'), { recursive: true });
-        const summary = await reindexLocalIndexes(project, { force: false, embeddingService: null });
-        expect(summary.scopes.map((scope) => scope.label)).toEqual(['global', 'user/local', 'warehouse']);
-        expect(summary.totals.scanned).toBe(0);
-    });
-    it('indexes mixed wiki and SL sources and reports totals', async () => {
-        const project = await createProject(tempDir);
-        await writeFile(join(project.projectDir, 'wiki/global/revenue.md'), '---\nsummary: Revenue\nusage_mode: auto\n---\n\nPaid orders.\n', 'utf-8');
-        await mkdir(join(project.projectDir, 'semantic-layer/warehouse'), { recursive: true });
-        await writeFile(join(project.projectDir, 'semantic-layer/warehouse/orders.yaml'), 'name: orders\ntable: public.orders\ngrain: [id]\ncolumns:\n  - name: id\n    type: number\njoins: []\nmeasures: []\n', 'utf-8');
-        const summary = await reindexLocalIndexes(project, {
-            force: false,
-            embeddingService: new FakeEmbeddingPort(),
-        });
-        expect(summary.scopes).toHaveLength(2);
-        expect(summary.totals).toMatchObject({ scanned: 2, updated: 2, deleted: 0, embeddingsRecomputed: 2 });
-        expect(summary.embeddingsAvailable).toBe(true);
-    });
-    it('does not report unchanged lexical-only rows as updated on repeated runs', async () => {
-        const project = await createProject(tempDir);
-        await writeFile(join(project.projectDir, 'wiki/global/revenue.md'), '---\nsummary: Revenue\nusage_mode: auto\n---\n\nPaid orders.\n', 'utf-8');
-        await mkdir(join(project.projectDir, 'semantic-layer/warehouse'), { recursive: true });
-        await writeFile(join(project.projectDir, 'semantic-layer/warehouse/orders.yaml'), 'name: orders\ntable: public.orders\ngrain: [id]\ncolumns:\n  - name: id\n    type: number\njoins: []\nmeasures: []\n', 'utf-8');
-        const first = await reindexLocalIndexes(project, { force: false, embeddingService: null });
-        expect(first.totals).toMatchObject({
-            scanned: 2,
-            updated: 2,
-            deleted: 0,
-            embeddingsRecomputed: 0,
-            embeddingsFailed: 0,
-        });
-        const second = await reindexLocalIndexes(project, { force: false, embeddingService: null });
-        expect(second.totals).toMatchObject({
-            scanned: 2,
-            updated: 0,
-            deleted: 0,
-            embeddingsRecomputed: 0,
-            embeddingsFailed: 0,
-        });
-        expect(second.scopes.map((scope) => [scope.label, scope.updated])).toEqual([
-            ['global', 0],
-            ['warehouse', 0],
-        ]);
-    });
-    it('force clears stale rows before rebuilding each discovered scope', async () => {
-        const project = await createProject(tempDir);
-        const wikiIndex = new SqliteKnowledgeIndex({ dbPath: join(project.projectDir, '.ktx/db.sqlite') });
-        wikiIndex.sync([
-            {
-                path: 'wiki/global/stale.md',
-                key: 'stale',
-                scope: 'GLOBAL',
-                scopeId: null,
-                summary: 'Stale',
-                content: 'Stale content',
-                tags: [],
-                embedding: [1, 0],
-            },
-        ]);
-        await writeFile(join(project.projectDir, 'wiki/global/revenue.md'), '---\nsummary: Revenue\nusage_mode: auto\n---\n\nPaid orders.\n', 'utf-8');
-        const summary = await reindexLocalIndexes(project, {
-            force: true,
-            embeddingService: new FakeEmbeddingPort(),
-        });
-        expect(summary.force).toBe(true);
-        expect(summary.totals).toMatchObject({ scanned: 1, updated: 1, deleted: 0 });
-        expect(wikiIndex.search('Stale', 10)).toEqual([]);
-    });
-    it('captures a per-scope error and continues other scopes', async () => {
-        const project = await createProject(tempDir);
-        await writeFile(join(project.projectDir, 'wiki/global/revenue.md'), '---\nsummary: Revenue\nusage_mode: auto\n---\n\nPaid orders.\n', 'utf-8');
-        await mkdir(join(project.projectDir, 'semantic-layer/warehouse'), { recursive: true });
-        await writeFile(join(project.projectDir, 'semantic-layer/warehouse/broken.yaml'), 'not: [valid', 'utf-8');
-        const summary = await reindexLocalIndexes(project, { force: false, embeddingService: null });
-        expect(summary.scopes.find((scope) => scope.label === 'global')?.error).toBeUndefined();
-        expect(summary.scopes.find((scope) => scope.label === 'warehouse')?.error).toContain('YAML');
-    });
-    it('marks a scope errored when configured embeddings fail', async () => {
-        const project = await createProject(tempDir);
-        await writeFile(join(project.projectDir, 'wiki/global/revenue.md'), '---\nsummary: Revenue\nusage_mode: auto\n---\n\nPaid orders.\n', 'utf-8');
-        const embeddingService = {
-            maxBatchSize: 8,
-            async computeEmbedding() {
-                throw new Error('embedding provider unavailable');
-            },
-            async computeEmbeddingsBulk() {
-                throw new Error('embedding provider unavailable');
-            },
-        };
-        const summary = await reindexLocalIndexes(project, { force: false, embeddingService });
-        expect(summary.scopes[0]).toMatchObject({
-            label: 'global',
-            embeddingsFailed: 1,
-            error: '1 embedding recomputation failed',
-        });
-    });
-});

package/dist/context/ingest/action-identity.test.d.ts

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

package/dist/context/ingest/action-identity.test.js

@@ -1,19 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { actionTargetConnectionId, memoryActionIdentity } from './action-identity.js';
-describe('memory action target identity', () => {
-    it('keys SL actions by target connection and wiki actions by run connection', () => {
-        expect(memoryActionIdentity({ target: 'sl', type: 'created', key: 'orders', detail: '', targetConnectionId: 'warehouse-b' }, 'looker-run')).toBe('sl:warehouse-b:orders');
-        expect(memoryActionIdentity({ target: 'sl', type: 'created', key: 'orders', detail: '' }, 'warehouse-a')).toBe('sl:warehouse-a:orders');
-        expect(memoryActionIdentity({
-            target: 'wiki',
-            type: 'created',
-            key: 'wiki/global/orders.md',
-            detail: '',
-            targetConnectionId: 'ignored',
-        }, 'looker-run')).toBe('wiki:looker-run:wiki/global/orders.md');
-    });
-    it('resolves action target connection only for SL actions', () => {
-        expect(actionTargetConnectionId({ target: 'sl', type: 'updated', key: 'orders', detail: '', targetConnectionId: 'warehouse-b' }, 'looker-run')).toBe('warehouse-b');
-        expect(actionTargetConnectionId({ target: 'wiki', type: 'updated', key: 'orders', detail: '' }, 'looker-run')).toBe('looker-run');
-    });
-});

package/dist/context/ingest/adapters/dbt/chunk.test.d.ts

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

package/dist/context/ingest/adapters/dbt/chunk.test.js

@@ -1,30 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { chunkDbtProject } from './chunk.js';
-describe('chunkDbtProject', () => {
-    const diffSet = (modified) => ({ added: [], modified, deleted: [], unchanged: [] });
-    it('caps peerFileIndex when the project has very many yaml files', () => {
-        const modelPaths = Array.from({ length: 201 }, (_, i) => `models/m${i}.yml`);
-        const allPaths = ['dbt_project.yml', ...modelPaths].sort();
-        const { workUnits } = chunkDbtProject({ allPaths });
-        const [first] = workUnits;
-        expect(first).toBeDefined();
-        expect(first?.peerFileIndex).toHaveLength(200);
-        expect(first?.notes).toMatch(/capped at 200/);
-    });
-    it('keeps large-project model work units when dbt_project.yml changes', () => {
-        const modelPaths = Array.from({ length: 30 }, (_, i) => `models/m${i}.yml`);
-        const allPaths = ['dbt_project.yml', ...modelPaths].sort();
-        const { workUnits } = chunkDbtProject({ allPaths }, { diffSet: diffSet(['dbt_project.yml']) });
-        expect(workUnits).toHaveLength(30);
-        expect(workUnits[0]?.rawFiles).toEqual(['models/m0.yml']);
-        expect(workUnits[0]?.dependencyPaths).toContain('dbt_project.yml');
-    });
-    it('keeps large-project model work units when non-model yaml peers change', () => {
-        const modelPaths = Array.from({ length: 30 }, (_, i) => `models/m${i}.yml`);
-        const allPaths = ['dbt_project.yml', 'seeds/seed_properties.yml', ...modelPaths].sort();
-        const { workUnits } = chunkDbtProject({ allPaths }, { diffSet: diffSet(['seeds/seed_properties.yml']) });
-        expect(workUnits).toHaveLength(30);
-        expect(workUnits[0]?.rawFiles).toEqual(['models/m0.yml']);
-        expect(workUnits[0]?.dependencyPaths).toContain('seeds/seed_properties.yml');
-    });
-});

package/dist/context/ingest/adapters/dbt/dbt.adapter.test.d.ts

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

package/dist/context/ingest/adapters/dbt/dbt.adapter.test.js

@@ -1,43 +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 { DbtSourceAdapter } from './dbt.adapter.js';
-describe('DbtSourceAdapter', () => {
-    let stagedDir;
-    let adapter;
-    beforeEach(async () => {
-        stagedDir = await mkdtemp(join(tmpdir(), 'dbt-adapter-'));
-        adapter = new DbtSourceAdapter();
-    });
-    afterEach(async () => {
-        await rm(stagedDir, { recursive: true, force: true });
-    });
-    it('declares the expected source key and skill list', () => {
-        expect(adapter.source).toBe('dbt');
-        expect(adapter.skillNames).toEqual(['dbt_ingest']);
-    });
-    it('detects a staged dbt project root (dbt_project.yml)', async () => {
-        await writeFile(join(stagedDir, 'dbt_project.yml'), "name: 'jaffle'\nversion: '1.0.0'\n", 'utf-8');
-        expect(await adapter.detect(stagedDir)).toBe(true);
-    });
-    it('chunk: dbt_project.yml + models/a.yml yields one WU (≤25 files)', async () => {
-        await writeFile(join(stagedDir, 'dbt_project.yml'), "name: 'jaffle'\n", 'utf-8');
-        await mkdir(join(stagedDir, 'models'), { recursive: true });
-        await writeFile(join(stagedDir, 'models/a.yml'), 'version: 2\nmodels:\n  - name: orders\n    description: Orders\n', 'utf-8');
-        const result = await adapter.chunk(stagedDir);
-        expect(result.workUnits).toHaveLength(1);
-        expect(result.workUnits[0].unitKey).toBe('dbt-all');
-        expect(result.parseArtifacts).toMatchObject({
-            projectName: 'jaffle',
-            tables: [{ name: 'orders', description: 'Orders' }],
-        });
-    });
-    it('implements fetch() for git-backed dbt source setup', () => {
-        expect(adapter.fetch).toBeTypeOf('function');
-    });
-    it('reports mapped warehouse targets for bundle SL discovery', async () => {
-        adapter = new DbtSourceAdapter({ targetConnectionIds: ['postgres-warehouse', 'postgres-warehouse'] });
-        await expect(adapter.listTargetConnectionIds?.(stagedDir)).resolves.toEqual(['postgres-warehouse']);
-    });
-});

package/dist/context/ingest/adapters/dbt/fetch.test.d.ts

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

package/dist/context/ingest/adapters/dbt/fetch.test.js

@@ -1,30 +0,0 @@
-import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { fetchDbtRepo } from './fetch.js';
-describe('fetchDbtRepo', () => {
-    let tempDir;
-    beforeEach(async () => {
-        tempDir = await mkdtemp(join(tmpdir(), 'ktx-dbt-fetch-'));
-    });
-    afterEach(async () => {
-        await rm(tempDir, { recursive: true, force: true });
-    });
-    it('copies dbt yaml files from a fetched repo subpath into staged dir', async () => {
-        const cacheDir = join(tempDir, 'cache');
-        const stagedDir = join(tempDir, 'staged');
-        await mkdir(join(cacheDir, 'analytics', 'models'), { recursive: true });
-        await writeFile(join(cacheDir, 'analytics', 'dbt_project.yml'), 'name: analytics\n', 'utf-8');
-        await writeFile(join(cacheDir, 'analytics', 'models', 'orders.yml'), 'models: []\n', 'utf-8');
-        const cloneOrPull = vi.fn(async () => ({ commitHash: 'abc123' }));
-        await expect(fetchDbtRepo({
-            config: { repoUrl: 'https://github.com/acme/dbt.git', path: 'analytics' },
-            cacheDir,
-            stagedDir,
-            deps: { cloneOrPull },
-        })).resolves.toEqual({ commitHash: 'abc123', filesCopied: 2 });
-        await expect(readFile(join(stagedDir, 'dbt_project.yml'), 'utf-8')).resolves.toContain('analytics');
-        await expect(readFile(join(stagedDir, 'models', 'orders.yml'), 'utf-8')).resolves.toContain('models');
-    });
-});

package/dist/context/ingest/adapters/dbt/parse.test.d.ts

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

package/dist/context/ingest/adapters/dbt/parse.test.js

@@ -1,7 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { normalizeDbtPath } from './parse.js';
-describe('normalizeDbtPath', () => {
-    it('normalizes Windows separators to POSIX separators', () => {
-        expect(normalizeDbtPath('models\\marts\\orders.yml')).toBe('models/marts/orders.yml');
-    });
-});

package/dist/context/ingest/adapters/dbt-descriptions/parse-schema.test.d.ts

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