@kaelio/ktx 0.5.0 → 0.6.0

package/dist/context/ingest/tools/read-raw-file.tool.test.js

@@ -1,45 +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 { createReadRawFileTool } from './read-raw-file.tool.js';
-describe('read_raw_file tool', () => {
-    let stagedDir;
-    beforeEach(async () => {
-        stagedDir = await mkdtemp(join(tmpdir(), 'readraw-'));
-        await mkdir(join(stagedDir, 'views'), { recursive: true });
-        await writeFile(join(stagedDir, 'views', 'a.yml'), 'line1\nline2\nline3\n', 'utf-8');
-        await writeFile(join(stagedDir, 'peer.yml'), 'secret', 'utf-8');
-    });
-    afterEach(async () => rm(stagedDir, { recursive: true, force: true }));
-    it('returns content for an allowed path', async () => {
-        const tool = createReadRawFileTool({ stagedDir, allowedPaths: new Set(['views/a.yml']) });
-        const result = await tool.execute({ path: 'views/a.yml' }, { toolCallId: 't1', messages: [] });
-        expect(result).toContain('line1');
-        expect(result).toContain('line2');
-    });
-    it('refuses to return oversized files and directs callers to read spans', async () => {
-        await writeFile(join(stagedDir, 'views', 'huge.yml'), `${'x'.repeat(160_000)}\n`, 'utf-8');
-        const tool = createReadRawFileTool({ stagedDir, allowedPaths: new Set(['views/huge.yml']) });
-        const result = await tool.execute({ path: 'views/huge.yml' }, { toolCallId: 't1', messages: [] });
-        expect(result).toMatch(/too large/i);
-        expect(result).toMatch(/read_raw_span/i);
-        expect(String(result).length).toBeLessThan(1000);
-    });
-    it('rejects a path not in the allow-list', async () => {
-        const tool = createReadRawFileTool({ stagedDir, allowedPaths: new Set(['views/a.yml']) });
-        const result = await tool.execute({ path: 'peer.yml' }, { toolCallId: 't1', messages: [] });
-        expect(result).toMatch(/not accessible/i);
-        expect(result).not.toContain('secret');
-    });
-    it('rejects directory traversal attempts', async () => {
-        const tool = createReadRawFileTool({ stagedDir, allowedPaths: new Set(['views/a.yml']) });
-        const result = await tool.execute({ path: '../outside.yml' }, { toolCallId: 't1', messages: [] });
-        expect(result).toMatch(/not accessible/i);
-    });
-    it('returns a clear error when the file is missing despite being allowed', async () => {
-        const tool = createReadRawFileTool({ stagedDir, allowedPaths: new Set(['views/missing.yml']) });
-        const result = await tool.execute({ path: 'views/missing.yml' }, { toolCallId: 't1', messages: [] });
-        expect(result).toMatch(/not found/i);
-    });
-});

package/dist/context/ingest/tools/read-raw-span.tool.test.d.ts

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

package/dist/context/ingest/tools/read-raw-span.tool.test.js

@@ -1,34 +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 { createReadRawSpanTool } from './read-raw-span.tool.js';
-describe('read_raw_span tool', () => {
-    let stagedDir;
-    beforeEach(async () => {
-        stagedDir = await mkdtemp(join(tmpdir(), 'readspan-'));
-        await mkdir(join(stagedDir, 'v'), { recursive: true });
-        await writeFile(join(stagedDir, 'v', 'a.yml'), 'line1\nline2\nline3\nline4\nline5\n', 'utf-8');
-    });
-    afterEach(async () => rm(stagedDir, { recursive: true, force: true }));
-    it('returns the requested 1-based inclusive line range', async () => {
-        const tool = createReadRawSpanTool({ stagedDir, allowedPaths: new Set(['v/a.yml']) });
-        const result = await tool.execute({ path: 'v/a.yml', startLine: 2, endLine: 4 }, { toolCallId: 't1', messages: [] });
-        expect(result).toBe('line2\nline3\nline4');
-    });
-    it('clamps endLine to the end of the file', async () => {
-        const tool = createReadRawSpanTool({ stagedDir, allowedPaths: new Set(['v/a.yml']) });
-        const result = await tool.execute({ path: 'v/a.yml', startLine: 4, endLine: 99 }, { toolCallId: 't1', messages: [] });
-        expect(result).toBe('line4\nline5');
-    });
-    it('rejects start > end', async () => {
-        const tool = createReadRawSpanTool({ stagedDir, allowedPaths: new Set(['v/a.yml']) });
-        const result = await tool.execute({ path: 'v/a.yml', startLine: 5, endLine: 2 }, { toolCallId: 't1', messages: [] });
-        expect(result).toMatch(/startLine must be/i);
-    });
-    it('rejects paths not in the allow-list', async () => {
-        const tool = createReadRawSpanTool({ stagedDir, allowedPaths: new Set([]) });
-        const result = await tool.execute({ path: 'v/a.yml', startLine: 1, endLine: 1 }, { toolCallId: 't1', messages: [] });
-        expect(result).toMatch(/not accessible/i);
-    });
-});

package/dist/context/ingest/tools/stage-diff.tool.test.d.ts

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

package/dist/context/ingest/tools/stage-diff.tool.test.js

@@ -1,112 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { createStageDiffTool } from './stage-diff.tool.js';
-describe('stage_diff tool', () => {
-    const stageIndex = {
-        jobId: 'j',
-        connectionId: 'c1',
-        workUnits: [
-            {
-                unitKey: 'u1',
-                rawFiles: [],
-                status: 'success',
-                actions: [{ target: 'sl', type: 'created', key: 'churn_risk_score', detail: 'customers' }],
-                touchedSlSources: [{ connectionId: 'c1', sourceName: 'customers' }],
-            },
-            {
-                unitKey: 'u2',
-                rawFiles: [],
-                status: 'success',
-                actions: [{ target: 'sl', type: 'created', key: 'churn_risk_score', detail: 'billing' }],
-                touchedSlSources: [{ connectionId: 'c1', sourceName: 'billing' }],
-            },
-        ],
-        conflictsResolved: [],
-        evictionsApplied: [],
-        unmappedFallbacks: [],
-    };
-    it('finds overlapping artifact keys between two WUs', async () => {
-        const tool = createStageDiffTool({ stageIndex });
-        const out = (await tool.execute({ unitKeyA: 'u1', unitKeyB: 'u2' }, { toolCallId: 't', messages: [] }));
-        expect(out).toContain('churn_risk_score');
-        expect(out).toMatch(/overlap/i);
-    });
-    it('says no overlap when keys are disjoint', async () => {
-        const tool = createStageDiffTool({
-            stageIndex: {
-                jobId: 'j',
-                connectionId: 'c1',
-                workUnits: [
-                    {
-                        unitKey: 'u1',
-                        rawFiles: [],
-                        status: 'success',
-                        actions: [{ target: 'sl', type: 'created', key: 'a', detail: '' }],
-                        touchedSlSources: [{ connectionId: 'c1', sourceName: 'a' }],
-                    },
-                    {
-                        unitKey: 'u2',
-                        rawFiles: [],
-                        status: 'success',
-                        actions: [{ target: 'sl', type: 'created', key: 'b', detail: '' }],
-                        touchedSlSources: [{ connectionId: 'c1', sourceName: 'b' }],
-                    },
-                ],
-                conflictsResolved: [],
-                evictionsApplied: [],
-                unmappedFallbacks: [],
-            },
-        });
-        const out = (await tool.execute({ unitKeyA: 'u1', unitKeyB: 'u2' }, { toolCallId: 't', messages: [] }));
-        expect(out).toMatch(/no overlap/i);
-    });
-    it('does not overlap same-named SL actions on different target connections', async () => {
-        const tool = createStageDiffTool({
-            stageIndex: {
-                jobId: 'j',
-                connectionId: 'looker-run',
-                workUnits: [
-                    {
-                        unitKey: 'u1',
-                        rawFiles: [],
-                        status: 'success',
-                        actions: [
-                            {
-                                target: 'sl',
-                                type: 'created',
-                                key: 'looker__b2b__sales_pipeline',
-                                detail: 'W1',
-                                targetConnectionId: 'W1',
-                            },
-                        ],
-                        touchedSlSources: [{ connectionId: 'W1', sourceName: 'looker__b2b__sales_pipeline' }],
-                    },
-                    {
-                        unitKey: 'u2',
-                        rawFiles: [],
-                        status: 'success',
-                        actions: [
-                            {
-                                target: 'sl',
-                                type: 'created',
-                                key: 'looker__b2b__sales_pipeline',
-                                detail: 'W2',
-                                targetConnectionId: 'W2',
-                            },
-                        ],
-                        touchedSlSources: [{ connectionId: 'W2', sourceName: 'looker__b2b__sales_pipeline' }],
-                    },
-                ],
-                conflictsResolved: [],
-                evictionsApplied: [],
-                unmappedFallbacks: [],
-            },
-        });
-        const out = (await tool.execute({ unitKeyA: 'u1', unitKeyB: 'u2' }, { toolCallId: 't', messages: [] }));
-        expect(out).toMatch(/no overlap/i);
-    });
-    it('returns an error when a unitKey is unknown', async () => {
-        const tool = createStageDiffTool({ stageIndex });
-        const out = (await tool.execute({ unitKeyA: 'u1', unitKeyB: 'nope' }, { toolCallId: 't', messages: [] }));
-        expect(out).toMatch(/unknown/i);
-    });
-});

package/dist/context/ingest/tools/stage-list.tool.test.d.ts

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

package/dist/context/ingest/tools/stage-list.tool.test.js

@@ -1,58 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { createStageListTool } from './stage-list.tool.js';
-describe('stage_list tool', () => {
-    it('returns a compact summary of the stage index', async () => {
-        const tool = createStageListTool({
-            stageIndex: {
-                jobId: 'j1',
-                connectionId: 'c1',
-                workUnits: [
-                    {
-                        unitKey: 'u1',
-                        rawFiles: ['a.yml'],
-                        status: 'success',
-                        actions: [{ target: 'sl', type: 'created', key: 'src_a', detail: '' }],
-                        touchedSlSources: [{ connectionId: 'c1', sourceName: 'src_a' }],
-                    },
-                    {
-                        unitKey: 'u2',
-                        rawFiles: ['b.yml'],
-                        status: 'success',
-                        actions: [
-                            {
-                                target: 'wiki',
-                                type: 'created',
-                                key: 'page_b',
-                                detail: 'tables: orbit_analytics.customer',
-                            },
-                        ],
-                        touchedSlSources: [],
-                    },
-                ],
-                conflictsResolved: [],
-                evictionsApplied: [],
-                unmappedFallbacks: [],
-            },
-        });
-        const out = (await tool.execute({}, { toolCallId: 't', messages: [] }));
-        expect(out).toContain('u1');
-        expect(out).toContain('src_a');
-        expect(out).toContain('u2');
-        expect(out).toContain('page_b');
-        expect(out).toContain('tables: orbit_analytics.customer');
-    });
-    it('says empty when no writes', async () => {
-        const tool = createStageListTool({
-            stageIndex: {
-                jobId: 'j',
-                connectionId: 'c1',
-                workUnits: [],
-                conflictsResolved: [],
-                evictionsApplied: [],
-                unmappedFallbacks: [],
-            },
-        });
-        const out = (await tool.execute({}, { toolCallId: 't', messages: [] }));
-        expect(out).toMatch(/empty/i);
-    });
-});

package/dist/context/ingest/tools/tool-transcript-summary.test.d.ts

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

package/dist/context/ingest/tools/tool-transcript-summary.test.js

@@ -1,141 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { createMutableToolTranscriptSummary, recordToolTranscriptEntry } from './tool-transcript-summary.js';
-function entry(overrides) {
-    return {
-        ts: '2026-05-11T00:00:00.000Z',
-        wuKey: 'wu-1',
-        toolName: 'wiki_write',
-        durationMs: 1,
-        input: {},
-        ...overrides,
-    };
-}
-describe('tool transcript summaries', () => {
-    it('keeps recovered wiki_write structured failures out of fatal failures', () => {
-        const summary = createMutableToolTranscriptSummary('wu-1', '/tmp/wu-1.jsonl');
-        recordToolTranscriptEntry(summary, entry({
-            input: { key: 'orbit-customers' },
-            output: { structured: { success: false, key: 'orbit-customers' } },
-        }));
-        recordToolTranscriptEntry(summary, entry({
-            input: { key: 'orbit-customers' },
-            output: { structured: { success: true, key: 'orbit-customers' } },
-        }));
-        expect(summary.errorCount).toBe(1);
-        expect(summary.fatalErrorCount).toBe(0);
-    });
-    it('treats a suggested flat wiki key retry as recovery for an invalid nested key', () => {
-        const summary = createMutableToolTranscriptSummary('wu-1', '/tmp/wu-1.jsonl');
-        recordToolTranscriptEntry(summary, entry({
-            input: { key: 'historic-sql/top-accounts-by-contract-arr' },
-            output: { structured: { success: false, key: 'historic-sql/top-accounts-by-contract-arr' } },
-        }));
-        recordToolTranscriptEntry(summary, entry({
-            input: { key: 'historic-sql-top-accounts-by-contract-arr' },
-            output: { structured: { success: true, key: 'historic-sql-top-accounts-by-contract-arr' } },
-        }));
-        expect(summary.errorCount).toBe(1);
-        expect(summary.fatalErrorCount).toBe(0);
-    });
-    it('counts unrecovered wiki_remove structured failures as fatal transcript errors', () => {
-        const summary = createMutableToolTranscriptSummary('reconcile', '/tmp/reconcile.jsonl');
-        recordToolTranscriptEntry(summary, {
-            ts: '2026-05-11T00:00:00.000Z',
-            wuKey: 'reconcile',
-            toolCallId: 'remove-1',
-            toolName: 'wiki_remove',
-            durationMs: 1,
-            input: { key: 'duplicate-page' },
-            output: { structured: { success: false, key: 'duplicate-page' } },
-        });
-        expect(summary.errorCount).toBe(1);
-        expect(summary.fatalErrorCount).toBe(1);
-    });
-    it('keeps unrecovered structured write failures fatal', () => {
-        const summary = createMutableToolTranscriptSummary('wu-1', '/tmp/wu-1.jsonl');
-        recordToolTranscriptEntry(summary, entry({
-            input: { key: 'orbit-customers' },
-            output: { structured: { success: false, key: 'orbit-customers' } },
-        }));
-        expect(summary.errorCount).toBe(1);
-        expect(summary.fatalErrorCount).toBe(1);
-    });
-    it('treats a later sl_edit_source success as recovery for the same SL source', () => {
-        const summary = createMutableToolTranscriptSummary('wu-1', '/tmp/wu-1.jsonl');
-        recordToolTranscriptEntry(summary, entry({
-            toolName: 'sl_write_source',
-            input: { connectionId: 'warehouse', sourceName: 'orbit_customers' },
-            output: { structured: { success: false, sourceName: 'orbit_customers' } },
-        }));
-        recordToolTranscriptEntry(summary, entry({
-            toolName: 'sl_edit_source',
-            input: { connectionId: 'warehouse', sourceName: 'orbit_customers' },
-            output: { structured: { success: true, sourceName: 'orbit_customers' } },
-        }));
-        expect(summary.errorCount).toBe(1);
-        expect(summary.fatalErrorCount).toBe(0);
-    });
-    it('treats explicit unmapped fallback as recovery for guarded SL write failures', () => {
-        const summary = createMutableToolTranscriptSummary('wu-1', '/tmp/wu-1.jsonl');
-        recordToolTranscriptEntry(summary, entry({
-            toolName: 'sl_write_source',
-            input: { connectionId: 'dbt-main', sourceName: 'stg_accounts' },
-            output: { structured: { success: false, sourceName: 'stg_accounts' } },
-        }));
-        recordToolTranscriptEntry(summary, entry({
-            toolName: 'emit_unmapped_fallback',
-            input: { rawPath: 'models/schema.yml', reason: 'no_physical_table', tableRef: 'stg_accounts', fallback: 'wiki_only' },
-            output: 'recorded unmapped fallback for models/schema.yml (wiki_only)',
-        }));
-        expect(summary.errorCount).toBe(1);
-        expect(summary.fatalErrorCount).toBe(0);
-    });
-    it('treats an untargeted unmapped fallback as recovery when there is only one pending SL failure', () => {
-        const summary = createMutableToolTranscriptSummary('wu-1', '/tmp/wu-1.jsonl');
-        recordToolTranscriptEntry(summary, entry({
-            toolName: 'sl_write_source',
-            input: { connectionId: 'dbt-main', sourceName: 'stg_accounts' },
-            output: { structured: { success: false, sourceName: 'stg_accounts' } },
-        }));
-        recordToolTranscriptEntry(summary, entry({
-            toolName: 'emit_unmapped_fallback',
-            input: { rawPath: 'models/schema.yml', reason: 'no_physical_table', fallback: 'wiki_only' },
-            output: 'recorded unmapped fallback for models/schema.yml (wiki_only)',
-        }));
-        expect(summary.errorCount).toBe(1);
-        expect(summary.fatalErrorCount).toBe(0);
-    });
-    it('keeps unrelated SL write failures fatal when one source gets an unmapped fallback', () => {
-        const summary = createMutableToolTranscriptSummary('wu-1', '/tmp/wu-1.jsonl');
-        recordToolTranscriptEntry(summary, entry({
-            toolName: 'sl_write_source',
-            input: { connectionId: 'dbt-main', sourceName: 'stg_accounts' },
-            output: { structured: { success: false, sourceName: 'stg_accounts' } },
-        }));
-        recordToolTranscriptEntry(summary, entry({
-            toolName: 'sl_write_source',
-            input: { connectionId: 'dbt-main', sourceName: 'stg_orders' },
-            output: { structured: { success: false, sourceName: 'stg_orders' } },
-        }));
-        recordToolTranscriptEntry(summary, entry({
-            toolName: 'emit_unmapped_fallback',
-            input: { rawPath: 'models/schema.yml', reason: 'no_physical_table', tableRef: 'stg_accounts', fallback: 'wiki_only' },
-            output: 'recorded unmapped fallback for models/schema.yml (wiki_only)',
-        }));
-        expect(summary.errorCount).toBe(2);
-        expect(summary.fatalErrorCount).toBe(1);
-    });
-    it('keeps thrown tool errors fatal even after a successful write', () => {
-        const summary = createMutableToolTranscriptSummary('wu-1', '/tmp/wu-1.jsonl');
-        recordToolTranscriptEntry(summary, entry({
-            input: { key: 'orbit-customers' },
-            error: { message: 'tool crashed' },
-        }));
-        recordToolTranscriptEntry(summary, entry({
-            input: { key: 'orbit-customers' },
-            output: { structured: { success: true, key: 'orbit-customers' } },
-        }));
-        expect(summary.errorCount).toBe(1);
-        expect(summary.fatalErrorCount).toBe(1);
-    });
-});

package/dist/context/ingest/tools/warehouse-verification/discover-data.tool.test.d.ts

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

package/dist/context/ingest/tools/warehouse-verification/discover-data.tool.test.js

@@ -1,107 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { DiscoverDataTool } from './discover-data.tool.js';
-describe('DiscoverDataTool', () => {
-    const wikiSearchTool = { call: vi.fn() };
-    const slDiscoverTool = { call: vi.fn() };
-    const catalog = { searchByName: vi.fn() };
-    const context = {
-        sourceId: 'ingest',
-        messageId: 'm1',
-        userId: 'system',
-        session: { allowedConnectionNames: new Set(['warehouse']) },
-    };
-    const tool = new DiscoverDataTool({
-        wikiSearchTool,
-        slDiscoverTool,
-        catalogFactory: () => catalog,
-    });
-    beforeEach(() => {
-        wikiSearchTool.call.mockReset();
-        slDiscoverTool.call.mockReset();
-        catalog.searchByName.mockReset();
-        wikiSearchTool.call.mockResolvedValue({
-            markdown: '- orders wiki',
-            structured: { totalFound: 1, results: [{ key: 'orders' }] },
-        });
-        slDiscoverTool.call.mockResolvedValue({
-            markdown: '- orders source',
-            structured: { totalSources: 1, sources: [{ sourceName: 'orders' }] },
-        });
-        catalog.searchByName.mockResolvedValue([
-            {
-                kind: 'table',
-                connectionId: 'warehouse',
-                ref: { catalog: null, db: 'public', name: 'orders' },
-                display: 'public.orders',
-                matchedOn: 'name',
-            },
-        ]);
-    });
-    it('groups wiki, semantic layer, and raw schema hits with routing hints', async () => {
-        const result = await tool.call({ query: 'orders', connectionId: 'warehouse', limit: 5 }, context);
-        expect(result.markdown).toContain('## Wiki Pages');
-        expect(result.markdown).toContain('use `wiki_read(blockKey)` for full content');
-        expect(result.markdown).toContain('## Semantic Layer Sources');
-        expect(result.markdown).toContain('use `sl_read_source(sourceName)` for the YAML');
-        expect(result.markdown).toContain('## Raw Warehouse Schema');
-        expect(result.markdown).toContain('use `entity_details({connectionId, targets: [{display}]})`');
-        expect(result.structured.raw?.hits).toHaveLength(1);
-    });
-    it('includes connectionId on raw schema hits so entity_details can follow up', async () => {
-        const multiConnectionContext = {
-            ...context,
-            session: { allowedConnectionNames: new Set(['warehouse', 'analytics']) },
-        };
-        catalog.searchByName.mockImplementation(async (connectionId, query) => [
-            {
-                kind: 'table',
-                connectionId,
-                ref: { catalog: null, db: 'public', name: `${connectionId}_${query}` },
-                display: `public.${connectionId}_${query}`,
-                matchedOn: 'name',
-            },
-        ]);
-        const result = await tool.call({ query: 'orders', limit: 10 }, multiConnectionContext);
-        expect(catalog.searchByName).toHaveBeenCalledWith('analytics', 'orders', 10);
-        expect(catalog.searchByName).toHaveBeenCalledWith('warehouse', 'orders', 10);
-        expect(result.markdown).toContain('connectionId=analytics');
-        expect(result.markdown).toContain('connectionId=warehouse');
-        expect(result.markdown).toContain('entity_details({connectionId: "analytics", targets: [{display: "public.analytics_orders"}]})');
-        expect(result.structured.raw?.hits.map((hit) => hit.connectionId)).toEqual(['analytics', 'warehouse']);
-    });
-    it('refuses explicit out-of-scope connection names', async () => {
-        const result = await tool.call({ query: 'orders', connectionId: 'billing' }, context);
-        expect(result.markdown).toContain('Connection "billing" is not available to this ingest stage.');
-        expect(result.structured).toEqual({ wiki: null, sl: null, raw: null });
-        expect(wikiSearchTool.call).not.toHaveBeenCalled();
-        expect(slDiscoverTool.call).not.toHaveBeenCalled();
-        expect(catalog.searchByName).not.toHaveBeenCalled();
-    });
-    it('delegates sourceName inspect mode to sl_discover only', async () => {
-        slDiscoverTool.call.mockResolvedValueOnce({
-            markdown: 'source detail',
-            structured: { sourceName: 'orders' },
-        });
-        const result = await tool.call({ sourceName: 'orders', connectionId: 'warehouse' }, context);
-        expect(slDiscoverTool.call).toHaveBeenCalledWith({ sourceName: 'orders', connectionId: 'warehouse' }, context);
-        expect(wikiSearchTool.call).not.toHaveBeenCalled();
-        expect(catalog.searchByName).not.toHaveBeenCalled();
-        expect(result.markdown).toContain('source detail');
-    });
-    it('returns the empty-state message when all sections are empty', async () => {
-        wikiSearchTool.call.mockResolvedValueOnce({ markdown: '', structured: { totalFound: 0, results: [] } });
-        slDiscoverTool.call.mockResolvedValueOnce({ markdown: '', structured: { totalSources: 0, sources: [] } });
-        catalog.searchByName.mockResolvedValueOnce([]);
-        const result = await tool.call({ query: 'customer source', connectionId: 'warehouse' }, context);
-        expect(result.markdown).toContain('No matches for "customer source" across wiki, semantic layer, or raw warehouse schema.');
-    });
-    it('uses connectionId as the optional connection filter', () => {
-        const legacyConnectionField = ['connection', 'Name'].join('');
-        expect(tool.parseInput({ query: 'orders', connectionId: 'warehouse', limit: 5 })).toEqual({
-            query: 'orders',
-            connectionId: 'warehouse',
-            limit: 5,
-        });
-        expect(() => tool.parseInput({ query: 'orders', [legacyConnectionField]: 'warehouse', limit: 5 })).toThrow();
-    });
-});

package/dist/context/ingest/tools/warehouse-verification/entity-details.tool.test.d.ts

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