@kaelio/ktx 0.5.0 → 0.7.0

package/dist/context/project/driver-schemas.test.js

@@ -1,125 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { connectionConfigSchema } from './driver-schemas.js';
-describe('connectionConfigSchema (driver discriminated union)', () => {
-    it.each([
-        ['postgres', 'postgres://user:pass@host:5432/db'], // pragma: allowlist secret
-        ['postgresql', 'postgresql://user:pass@host:5432/db'], // pragma: allowlist secret
-        ['mysql', 'mysql://user:pass@host:3306/db'], // pragma: allowlist secret
-        ['snowflake', 'snowflake://account/db'],
-        ['bigquery', 'bigquery://project/dataset'],
-        ['sqlite', 'sqlite:///tmp/db.sqlite'],
-        ['clickhouse', 'clickhouse://host:8123/db'],
-        ['sqlserver', 'sqlserver://host:1433;database=db'],
-    ])('parses %s warehouse connection', (driver, url) => {
-        expect(connectionConfigSchema.parse({ driver, url })).toMatchObject({ driver, url });
-    });
-    it('preserves unknown warehouse fields via looseObject passthrough', () => {
-        const parsed = connectionConfigSchema.parse({
-            driver: 'postgres',
-            url: 'postgres://x',
-            customField: { enabled: true },
-            context: { queryHistory: { enabled: false } },
-        });
-        expect(parsed).toMatchObject({
-            driver: 'postgres',
-            customField: { enabled: true },
-            context: { queryHistory: { enabled: false } },
-        });
-    });
-    it('rejects an unknown driver', () => {
-        expect(() => connectionConfigSchema.parse({ driver: 'nope', url: 'x' })).toThrow();
-    });
-});
-describe('connectionConfigSchema - context source drivers with mappings', () => {
-    it('parses a metabase connection with mappings', () => {
-        const parsed = connectionConfigSchema.parse({
-            driver: 'metabase',
-            api_url: 'https://metabase.example.com',
-            api_key_ref: 'env:METABASE_API_KEY', // pragma: allowlist secret
-            mappings: {
-                databaseMappings: { '3': 'prod-warehouse' },
-                syncEnabled: { '3': true },
-                syncMode: 'ONLY',
-            },
-        });
-        expect(parsed).toMatchObject({
-            driver: 'metabase',
-            api_url: 'https://metabase.example.com',
-            mappings: {
-                databaseMappings: { '3': 'prod-warehouse' },
-                syncMode: 'ONLY',
-            },
-        });
-    });
-    it('parses a looker connection with connectionMappings', () => {
-        const parsed = connectionConfigSchema.parse({
-            driver: 'looker',
-            base_url: 'https://looker.example.com',
-            client_id: 'abc',
-            client_secret_ref: 'env:LOOKER_CLIENT_SECRET', // pragma: allowlist secret
-            mappings: { connectionMappings: { bigquery_prod: 'wh' } },
-        });
-        expect(parsed.mappings).toEqual({ connectionMappings: { bigquery_prod: 'wh' } });
-    });
-    it('parses a lookml connection with expectedLookerConnectionName', () => {
-        const parsed = connectionConfigSchema.parse({
-            driver: 'lookml',
-            repoUrl: 'https://github.com/acme/looker.git',
-            branch: 'main',
-            mappings: { expectedLookerConnectionName: 'bigquery_prod' },
-        });
-        expect(parsed.mappings).toEqual({ expectedLookerConnectionName: 'bigquery_prod' });
-    });
-    it('rejects metabase mapping with non-integer database key', () => {
-        expect(() => connectionConfigSchema.parse({
-            driver: 'metabase',
-            api_url: 'https://x',
-            mappings: { databaseMappings: { abc: 'wh' } },
-        })).toThrow();
-    });
-});
-describe('connectionConfigSchema - notion / dbt / metricflow', () => {
-    it('parses a notion connection with selected_roots crawl', () => {
-        const parsed = connectionConfigSchema.parse({
-            driver: 'notion',
-            auth_token_ref: 'env:NOTION_TOKEN',
-            crawl_mode: 'selected_roots',
-            root_page_ids: ['abc', 'def'],
-            max_pages_per_run: 500,
-        });
-        expect(parsed).toMatchObject({
-            driver: 'notion',
-            crawl_mode: 'selected_roots',
-            root_page_ids: ['abc', 'def'],
-            max_pages_per_run: 500,
-        });
-    });
-    it('rejects notion with unknown crawl_mode', () => {
-        expect(() => connectionConfigSchema.parse({
-            driver: 'notion',
-            auth_token_ref: 'env:NOTION_TOKEN',
-            crawl_mode: 'everything',
-        })).toThrow();
-    });
-    it('parses a dbt connection from a local source_dir', () => {
-        const parsed = connectionConfigSchema.parse({
-            driver: 'dbt',
-            source_dir: '/tmp/dbt-project',
-            target: 'dev',
-        });
-        expect(parsed).toMatchObject({ driver: 'dbt', source_dir: '/tmp/dbt-project', target: 'dev' });
-    });
-    it('parses a metricflow connection with nested config', () => {
-        const parsed = connectionConfigSchema.parse({
-            driver: 'metricflow',
-            metricflow: {
-                repoUrl: 'https://github.com/acme/sl.git',
-                branch: 'main',
-            },
-        });
-        expect(parsed).toMatchObject({
-            driver: 'metricflow',
-            metricflow: { repoUrl: 'https://github.com/acme/sl.git' },
-        });
-    });
-});

package/dist/context/project/local-git-file-store.test.d.ts

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

package/dist/context/project/local-git-file-store.test.js

@@ -1,71 +0,0 @@
-import { mkdtemp, readFile, rm, stat } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { GitService } from '../../context/core/git.service.js';
-import { LocalGitFileStore } from './local-git-file-store.js';
-describe('LocalGitFileStore', () => {
-    let tempDir;
-    let store;
-    beforeEach(async () => {
-        tempDir = await mkdtemp(join(tmpdir(), 'ktx-local-store-'));
-        const coreConfig = {
-            storage: { configDir: tempDir, homeDir: tempDir },
-            git: {
-                userName: 'ktx',
-                userEmail: 'ktx@example.com',
-                bootstrapMessage: 'Initialize test project',
-                bootstrapAuthor: 'ktx',
-                bootstrapAuthorEmail: 'ktx@example.com',
-            },
-        };
-        const git = new GitService(coreConfig);
-        await git.onModuleInit();
-        store = new LocalGitFileStore({ rootDir: tempDir, git });
-    });
-    afterEach(async () => {
-        await rm(tempDir, { recursive: true, force: true });
-    });
-    it('writes, commits, and reads a project file', async () => {
-        const write = await store.writeFile('wiki/global/revenue.md', '# Revenue\n', 'Agent', 'agent@example.com', 'Add revenue page');
-        expect(write.commitHash).toMatch(/^[0-9a-f]{40}$/);
-        await expect(readFile(join(tempDir, 'wiki/global/revenue.md'), 'utf-8')).resolves.toBe('# Revenue\n');
-        await expect(store.readFile('wiki/global/revenue.md')).resolves.toMatchObject({
-            content: '# Revenue\n',
-        });
-    });
-    it('lists files recursively and can strip the requested prefix', async () => {
-        await store.writeFile('wiki/global/a.md', 'a', 'Agent', 'agent@example.com', 'Add a');
-        await store.writeFile('wiki/global/nested/b.md', 'b', 'Agent', 'agent@example.com', 'Add b');
-        await expect(store.listFiles('wiki')).resolves.toEqual({
-            files: ['wiki/global/a.md', 'wiki/global/nested/b.md'],
-        });
-        await expect(store.listFiles('wiki/global', true)).resolves.toEqual({
-            files: ['a.md', 'nested/b.md'],
-        });
-    });
-    it('deletes and commits an existing file', async () => {
-        await store.writeFile('semantic-layer/conn/orders.yaml', 'name: orders\n', 'Agent', 'agent@example.com', 'Add SL');
-        const deleted = await store.deleteFile('semantic-layer/conn/orders.yaml', 'Agent', 'agent@example.com', 'Delete SL');
-        expect(deleted?.commitHash).toMatch(/^[0-9a-f]{40}$/);
-        await expect(stat(join(tempDir, 'semantic-layer/conn/orders.yaml'))).rejects.toThrow();
-    });
-    it('returns null when deleting a missing file', async () => {
-        await expect(store.deleteFile('missing.md', 'Agent', 'agent@example.com', 'Delete missing')).resolves.toBeNull();
-    });
-    it('exposes Git history for a file', async () => {
-        await store.writeFile('wiki/global/history.md', 'v1', 'Agent', 'agent@example.com', 'Add history');
-        await store.writeFile('wiki/global/history.md', 'v2', 'Agent', 'agent@example.com', 'Update history');
-        const history = await store.getFileHistory('wiki/global/history.md');
-        expect(Array.isArray(history)).toBe(true);
-        expect(history[0]).toMatchObject({ message: 'Update history' });
-        expect(history[1]).toMatchObject({ message: 'Add history' });
-    });
-    it('rejects absolute paths and parent-directory traversal', async () => {
-        await expect(store.writeFile('/tmp/outside.md', 'bad', 'Agent', 'agent@example.com', 'Bad write')).rejects.toThrow('Path must be relative');
-        await expect(store.readFile('../outside.md')).rejects.toThrow('Path escapes the project directory');
-    });
-    it('rejects direct .git access', async () => {
-        await expect(store.readFile('.git/config')).rejects.toThrow('Path cannot access .git');
-    });
-});

package/dist/context/project/mappings-yaml-schema.test.d.ts

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

package/dist/context/project/mappings-yaml-schema.test.js

@@ -1,79 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { lookerMappingsSchema, lookmlMappingsSchema, metabaseMappingsSchema, parseConnectionMappingBootstrap, parseLookmlMappingBootstrap, parseLookerMappingBootstrap, parseMetabaseMappingBootstrap, } from './mappings-yaml-schema.js';
-describe('ktx.yaml mapping bootstrap schema', () => {
-    it('parses Metabase mapping intent with CLI syncMode default ALL', () => {
-        const bootstrap = parseMetabaseMappingBootstrap('prod-metabase', {
-            driver: 'metabase',
-            mappings: {
-                databaseMappings: { '1': 'prod-warehouse', '2': null },
-                syncEnabled: { '1': true, '2': false },
-                selections: { collections: [12], items: [345] },
-                defaultTagNames: ['ktx', 'prod'],
-            },
-        });
-        expect(bootstrap).toEqual({
-            adapter: 'metabase',
-            connectionId: 'prod-metabase',
-            databaseMappings: { '1': 'prod-warehouse', '2': null },
-            syncEnabled: { '1': true, '2': false },
-            syncMode: 'ALL',
-            selections: { collections: [12], items: [345] },
-            defaultTagNames: ['ktx', 'prod'],
-        });
-    });
-    it('rejects Metabase non-integer mapping keys', () => {
-        expect(() => parseMetabaseMappingBootstrap('prod-metabase', {
-            driver: 'metabase',
-            mappings: { databaseMappings: { abc: 'warehouse' } },
-        })).toThrow(/databaseMappings key "abc" must be a positive integer string/);
-    });
-    it('parses Looker connection mapping intent', () => {
-        const bootstrap = parseLookerMappingBootstrap('prod-looker', {
-            driver: 'looker',
-            mappings: {
-                connectionMappings: {
-                    bigquery_prod: 'prod-warehouse',
-                    snowflake_dev: null,
-                },
-            },
-        });
-        expect(bootstrap).toEqual({
-            adapter: 'looker',
-            connectionId: 'prod-looker',
-            connectionMappings: {
-                bigquery_prod: 'prod-warehouse',
-                snowflake_dev: null,
-            },
-        });
-    });
-    it('parses LookML expected connection from mappings block', () => {
-        expect(parseLookmlMappingBootstrap('prod-lookml', {
-            driver: 'lookml',
-            repo_url: 'https://github.com/acme/looker.git',
-            mappings: { expectedLookerConnectionName: 'bigquery_prod' },
-        })).toEqual({
-            adapter: 'lookml',
-            connectionId: 'prod-lookml',
-            expectedLookerConnectionName: 'bigquery_prod',
-        });
-    });
-    it('dispatches by flat driver and returns null for connections with no mappings block', () => {
-        expect(parseConnectionMappingBootstrap('warehouse', { driver: 'postgres', url: 'env:DATABASE_URL' })).toBeNull();
-        expect(parseConnectionMappingBootstrap('prod-looker', {
-            driver: 'looker',
-            mappings: { connectionMappings: { analytics: 'prod-warehouse' } },
-        })).toMatchObject({ adapter: 'looker', connectionId: 'prod-looker' });
-    });
-    it('exports mapping shapes that parse documented examples', () => {
-        expect(metabaseMappingsSchema.parse({ databaseMappings: { '1': 'wh' } })).toMatchObject({
-            databaseMappings: { '1': 'wh' },
-            syncMode: 'ALL',
-        });
-        expect(lookerMappingsSchema.parse({ connectionMappings: { x: 'wh' } })).toEqual({
-            connectionMappings: { x: 'wh' },
-        });
-        expect(lookmlMappingsSchema.parse({ expectedLookerConnectionName: 'x' })).toEqual({
-            expectedLookerConnectionName: 'x',
-        });
-    });
-});

package/dist/context/project/project.test.d.ts

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

package/dist/context/project/project.test.js

@@ -1,55 +0,0 @@
-import { mkdtemp, readFile, rm, stat } 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 './project.js';
-describe('KTX local project runtime', () => {
-    let tempDir;
-    beforeEach(async () => {
-        tempDir = await mkdtemp(join(tmpdir(), 'ktx-project-runtime-'));
-    });
-    afterEach(async () => {
-        await rm(tempDir, { recursive: true, force: true });
-    });
-    it('initializes the standalone project layout and commits it', async () => {
-        const projectDir = join(tempDir, 'warehouse');
-        const result = await initKtxProject({
-            projectDir,
-            authorName: 'Agent',
-            authorEmail: 'agent@example.com',
-        });
-        expect(result.projectDir).toBe(projectDir);
-        expect(result.commitHash).toMatch(/^[0-9a-f]{40}$/);
-        await expect(readFile(join(projectDir, 'ktx.yaml'), 'utf-8')).resolves.not.toContain('project:');
-        const gitignore = await readFile(join(projectDir, '.ktx/.gitignore'), 'utf-8');
-        expect(gitignore).toContain('cache/');
-        expect(gitignore).toContain('db.sqlite');
-        expect(gitignore).toContain('db.sqlite-*');
-        expect(gitignore).toContain('ingest-transcripts/');
-        expect(gitignore).toContain('secrets/');
-        expect(gitignore).toContain('setup/');
-        expect(gitignore).toContain('agents/');
-        await expect(stat(join(projectDir, 'wiki/global/.gitkeep'))).resolves.toBeDefined();
-        await expect(stat(join(projectDir, 'semantic-layer/.gitkeep'))).resolves.toBeDefined();
-        await expect(stat(join(projectDir, '_schema/.gitkeep'))).rejects.toMatchObject({ code: 'ENOENT' });
-        await expect(stat(join(projectDir, 'raw-sources/.gitkeep'))).resolves.toBeDefined();
-        await expect(stat(join(projectDir, '.git'))).resolves.toBeDefined();
-    });
-    it('loads an initialized project with a working file store', async () => {
-        const projectDir = join(tempDir, 'warehouse');
-        await initKtxProject({ projectDir });
-        const loaded = await loadKtxProject({ projectDir });
-        await loaded.fileStore.writeFile('wiki/global/revenue.md', '# Revenue\n', 'Agent', 'agent@example.com', 'Add revenue page');
-        await expect(loaded.fileStore.readFile('wiki/global/revenue.md')).resolves.toMatchObject({
-            content: '# Revenue\n',
-        });
-    });
-    it('rejects reinitializing an existing project unless force is set', async () => {
-        const projectDir = join(tempDir, 'warehouse');
-        await initKtxProject({ projectDir });
-        await expect(initKtxProject({ projectDir })).rejects.toThrow('Project already contains ktx.yaml');
-        await expect(initKtxProject({ projectDir, force: true })).resolves.toMatchObject({
-            configPath: join(projectDir, 'ktx.yaml'),
-        });
-    });
-});

package/dist/context/project/setup-config.test.d.ts

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

package/dist/context/project/setup-config.test.js

@@ -1,38 +0,0 @@
-import { mkdtemp, readFile, rm } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { buildDefaultKtxProjectConfig } from './config.js';
-import { markKtxSetupStateStepComplete, mergeKtxSetupGitignoreEntries, readKtxSetupState, setKtxSetupDatabaseConnectionIds, } from './setup-config.js';
-describe('KTX setup config helpers', () => {
-    let tempDir;
-    beforeEach(async () => {
-        tempDir = await mkdtemp(join(tmpdir(), 'ktx-setup-state-'));
-    });
-    afterEach(async () => {
-        await rm(tempDir, { recursive: true, force: true });
-    });
-    it('marks setup steps complete in local state without duplicating existing state', async () => {
-        await markKtxSetupStateStepComplete(tempDir, 'project');
-        await markKtxSetupStateStepComplete(tempDir, 'project');
-        await markKtxSetupStateStepComplete(tempDir, 'llm');
-        await markKtxSetupStateStepComplete(tempDir, 'runtime');
-        await markKtxSetupStateStepComplete(tempDir, 'context');
-        expect(await readKtxSetupState(tempDir)).toEqual({
-            completed_steps: ['project', 'llm', 'runtime', 'context'],
-        });
-        await expect(readFile(join(tempDir, '.ktx', 'setup', 'state.json'), 'utf-8')).resolves.toBe(`${JSON.stringify({ completed_steps: ['project', 'llm', 'runtime', 'context'] }, null, 2)}\n`);
-    });
-    it('sets setup database connection ids without duplicates', () => {
-        const config = buildDefaultKtxProjectConfig();
-        const withDatabases = setKtxSetupDatabaseConnectionIds(config, ['warehouse', 'analytics', 'warehouse']);
-        expect(withDatabases.setup).toEqual({
-            database_connection_ids: ['warehouse', 'analytics'],
-        });
-        expect(config.setup).toBeUndefined();
-    });
-    it('merges setup-local gitignore entries without removing existing lines', () => {
-        expect(mergeKtxSetupGitignoreEntries('cache/\ndb.sqlite\n')).toBe(['cache/', 'db.sqlite', 'db.sqlite-*', 'ingest-transcripts/', 'secrets/', 'setup/', 'agents/', ''].join('\n'));
-        expect(mergeKtxSetupGitignoreEntries('cache/\nsecrets/\n')).toBe(['cache/', 'secrets/', 'db.sqlite', 'db.sqlite-*', 'ingest-transcripts/', 'setup/', 'agents/', ''].join('\n'));
-    });
-});

package/dist/context/prompts/prompt.service.test.d.ts

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

package/dist/context/prompts/prompt.service.test.js

@@ -1,43 +0,0 @@
-import { 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 { PromptService } from './prompt.service.js';
-describe('PromptService', () => {
-    let dir;
-    beforeEach(async () => {
-        dir = await mkdtemp(join(tmpdir(), 'ktx-prompts-'));
-    });
-    afterEach(async () => {
-        await rm(dir, { recursive: true, force: true });
-    });
-    it('loads prompt files from the configured prompt directory', async () => {
-        await writeFile(join(dir, 'hello.md'), 'Hello {{name}}', 'utf-8');
-        const service = new PromptService({ promptsDir: dir, partials: [] });
-        await expect(service.loadPrompt('hello')).resolves.toBe('Hello {{name}}');
-    });
-    it('loads prompts from additional directories when the primary directory misses', async () => {
-        const extraDir = await mkdtemp(join(tmpdir(), 'ktx-prompts-extra-'));
-        try {
-            await writeFile(join(extraDir, 'memory_agent_research.md'), '<role>Packaged memory prompt</role>', 'utf-8');
-            const service = new PromptService({ promptsDir: dir, additionalPromptDirs: [extraDir], partials: [] });
-            await expect(service.loadPrompt('memory_agent_research')).resolves.toBe('<role>Packaged memory prompt</role>');
-        }
-        finally {
-            await rm(extraDir, { recursive: true, force: true });
-        }
-    });
-    it('formats prompts with default settings and context settings', async () => {
-        await writeFile(join(dir, 'settings.md'), '{{settings.flag}} {{settings.mode}} {{name}}', 'utf-8');
-        const service = new PromptService({
-            promptsDir: dir,
-            partials: [],
-            defaultSettings: { flag: true, mode: 'default' },
-        });
-        const rendered = await service.formatPrompt('settings', {
-            name: 'Ada',
-            settings: { mode: 'override' },
-        });
-        expect(rendered).toBe('true override Ada');
-    });
-});

package/dist/context/scan/credentials.test.d.ts

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

package/dist/context/scan/credentials.test.js

@@ -1,162 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { REDACTED_KTX_CREDENTIAL_VALUE } from '../core/redaction.js';
-import { redactKtxCredentialEnvelope, redactKtxCredentialValue, redactKtxScanMetadata, redactKtxScanReport, redactKtxScanWarning, } from './credentials.js';
-describe('KTX scan credential redaction', () => {
-    it('keeps credential references inspectable', () => {
-        const envReference = { kind: 'env', name: 'DATABASE_URL' };
-        const fileReference = { kind: 'file', path: '~/.config/ktx/warehouse' };
-        expect(redactKtxCredentialEnvelope(envReference)).toEqual(envReference);
-        expect(redactKtxCredentialEnvelope(fileReference)).toEqual(fileReference);
-    });
-    it('redacts resolved credential envelope values recursively', () => {
-        expect(redactKtxCredentialEnvelope({
-            kind: 'resolved',
-            source: 'host',
-            values: {
-                username: 'readonly',
-                password: 'secret-password', // pragma: allowlist secret
-                nested: {
-                    api_key: 'phx_123', // pragma: allowlist secret
-                    warehouse: 'compute_wh',
-                },
-                headers: [{ authorizationToken: 'token-value' }, { label: 'safe' }],
-            },
-        })).toEqual({
-            kind: 'resolved',
-            source: 'host',
-            redacted: true,
-            values: {
-                username: 'readonly',
-                password: REDACTED_KTX_CREDENTIAL_VALUE,
-                nested: {
-                    api_key: REDACTED_KTX_CREDENTIAL_VALUE,
-                    warehouse: 'compute_wh',
-                },
-                headers: [{ authorizationToken: REDACTED_KTX_CREDENTIAL_VALUE }, { label: 'safe' }],
-            },
-        });
-    });
-    it('redacts scan metadata fields that commonly contain secrets', () => {
-        expect(redactKtxScanMetadata({
-            driver: 'postgres',
-            url: 'postgres://user:pass@example.test/db', // pragma: allowlist secret
-            serviceAccountJson: {
-                client_email: 'reader@example.test',
-                private_key: 'pem-value', // pragma: allowlist secret
-            },
-            safeCount: 3,
-        })).toEqual({
-            driver: 'postgres',
-            url: REDACTED_KTX_CREDENTIAL_VALUE,
-            serviceAccountJson: {
-                client_email: 'reader@example.test',
-                private_key: REDACTED_KTX_CREDENTIAL_VALUE,
-            },
-            safeCount: 3,
-        });
-    });
-    it('redacts scan warning messages and metadata without hiding safe context', () => {
-        const warning = {
-            code: 'sampling_failed',
-            message: 'sample failed for postgres://reader:secret@example.test/db', // pragma: allowlist secret
-            recoverable: true,
-            metadata: {
-                table: 'orders',
-                url: 'postgres://reader:secret@example.test/db', // pragma: allowlist secret
-                nested: {
-                    api_key: 'sk_test_123', // pragma: allowlist secret
-                    schema: 'public',
-                },
-            },
-        };
-        expect(redactKtxScanWarning(warning)).toEqual({
-            code: 'sampling_failed',
-            message: 'sample failed for postgres://reader:<redacted>@example.test/db',
-            recoverable: true,
-            metadata: {
-                table: 'orders',
-                url: REDACTED_KTX_CREDENTIAL_VALUE,
-                nested: {
-                    api_key: REDACTED_KTX_CREDENTIAL_VALUE,
-                    schema: 'public',
-                },
-            },
-        });
-    });
-    it('redacts scan report warning metadata recursively', () => {
-        const report = {
-            connectionId: 'warehouse',
-            driver: 'postgres',
-            syncId: 'sync-1',
-            runId: 'run-1',
-            trigger: 'cli',
-            mode: 'structural',
-            dryRun: false,
-            artifactPaths: {
-                rawSourcesDir: 'raw-sources/warehouse/live-database/sync-1',
-                reportPath: 'raw-sources/warehouse/live-database/sync-1/scan-report.json',
-                manifestShards: [],
-                enrichmentArtifacts: [],
-            },
-            diffSummary: {
-                tablesAdded: 0,
-                tablesModified: 0,
-                tablesDeleted: 0,
-                tablesUnchanged: 0,
-                columnsAdded: 0,
-                columnsModified: 0,
-                columnsDeleted: 0,
-            },
-            manifestShardsWritten: 0,
-            structuralSyncStats: {
-                tablesCreated: 0,
-                tablesUpdated: 0,
-                tablesDeleted: 0,
-                columnsCreated: 0,
-                columnsUpdated: 0,
-                columnsDeleted: 0,
-            },
-            enrichment: {
-                dataDictionary: 'skipped',
-                tableDescriptions: 'skipped',
-                columnDescriptions: 'skipped',
-                embeddings: 'skipped',
-                deterministicRelationships: 'skipped',
-                llmRelationshipValidation: 'skipped',
-                statisticalValidation: 'skipped',
-            },
-            capabilityGaps: [],
-            warnings: [
-                {
-                    code: 'credential_redacted',
-                    message: 'metadata redacted',
-                    recoverable: true,
-                    metadata: {
-                        credentials_json: '{"private_key":"pem-value"}', // pragma: allowlist secret
-                        safeCount: 2,
-                    },
-                },
-            ],
-            relationships: { accepted: 0, review: 0, rejected: 0, skipped: 0 },
-            enrichmentState: {
-                resumedStages: [],
-                completedStages: [],
-                failedStages: [],
-            },
-            createdAt: '2026-04-29T00:00:00.000Z',
-        };
-        const redacted = redactKtxScanReport(report);
-        expect(redacted.warnings[0]?.metadata).toEqual({
-            credentials_json: REDACTED_KTX_CREDENTIAL_VALUE,
-            safeCount: 2,
-        });
-        expect(report.warnings[0]?.metadata).toEqual({
-            credentials_json: '{"private_key":"pem-value"}', // pragma: allowlist secret
-            safeCount: 2,
-        });
-    });
-    it('redacts standalone primitive credential values only when the field key is sensitive', () => {
-        expect(redactKtxCredentialValue('password', 'abc')).toBe(REDACTED_KTX_CREDENTIAL_VALUE);
-        expect(redactKtxCredentialValue('schema', 'public')).toBe('public');
-    });
-});

package/dist/context/scan/data-dictionary.test.d.ts

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