@kaelio/ktx 0.4.1 → 0.6.0

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

@@ -0,0 +1,61 @@
+import * as z from 'zod';
+declare const metabaseSyncModeSchema: z.ZodEnum<{
+    ALL: "ALL";
+    ONLY: "ONLY";
+    EXCEPT: "EXCEPT";
+}>;
+export declare const metabaseMappingsSchema: z.ZodObject<{
+    databaseMappings: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodString>>>;
+    syncEnabled: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
+    syncMode: z.ZodDefault<z.ZodEnum<{
+        ALL: "ALL";
+        ONLY: "ONLY";
+        EXCEPT: "EXCEPT";
+    }>>;
+    selections: z.ZodDefault<z.ZodObject<{
+        collections: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
+        items: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
+    }, z.core.$strip>>;
+    defaultTagNames: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export declare const lookerMappingsSchema: z.ZodObject<{
+    connectionMappings: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodString>>>;
+}, z.core.$strip>;
+export declare const lookmlMappingsSchema: z.ZodObject<{
+    expectedLookerConnectionName: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export type MetabaseMappingBootstrap = {
+    adapter: 'metabase';
+    connectionId: string;
+    databaseMappings: Record<string, string | null>;
+    syncEnabled: Record<string, boolean>;
+    syncMode: z.infer<typeof metabaseSyncModeSchema>;
+    selections: {
+        collections: number[];
+        items: number[];
+    };
+    defaultTagNames: string[];
+};
+export type LookerMappingBootstrap = {
+    adapter: 'looker';
+    connectionId: string;
+    connectionMappings: Record<string, string | null>;
+};
+/** @internal */
+export type LookmlMappingBootstrap = {
+    adapter: 'lookml';
+    connectionId: string;
+    expectedLookerConnectionName: string | null;
+};
+export type ConnectionMappingBootstrap = MetabaseMappingBootstrap | LookerMappingBootstrap | LookmlMappingBootstrap;
+type MappingConnectionInput = Record<string, unknown> & {
+    driver?: unknown;
+    mappings?: unknown;
+};
+export declare function parseMetabaseMappingBootstrap(connectionId: string, connection: MappingConnectionInput): MetabaseMappingBootstrap;
+/** @internal */
+export declare function parseLookerMappingBootstrap(connectionId: string, connection: MappingConnectionInput): LookerMappingBootstrap;
+/** @internal */
+export declare function parseLookmlMappingBootstrap(connectionId: string, connection: MappingConnectionInput): LookmlMappingBootstrap;
+export declare function parseConnectionMappingBootstrap(connectionId: string, connection: MappingConnectionInput): ConnectionMappingBootstrap | null;
+export {};

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

@@ -0,0 +1,111 @@
+import * as z from 'zod';
+const metabaseSyncModeSchema = z.enum(['ALL', 'ONLY', 'EXCEPT']);
+const positiveIntegerValueSchema = z.number().int().positive();
+const stringTargetSchema = z.string().min(1).nullable();
+const metabaseSelectionsSchema = z
+    .object({
+    collections: z.array(positiveIntegerValueSchema).default([]),
+    items: z.array(positiveIntegerValueSchema).default([]),
+});
+export const metabaseMappingsSchema = z
+    .object({
+    databaseMappings: z
+        .record(z.string(), stringTargetSchema)
+        .default({})
+        .describe('Map of Metabase database ID (positive integer string) to KTX connection ID. Use null to explicitly unmap.'),
+    syncEnabled: z
+        .record(z.string(), z.boolean())
+        .default({})
+        .describe('Per-Metabase-database sync toggle, keyed by Metabase database ID string.'),
+    syncMode: metabaseSyncModeSchema
+        .default('ALL')
+        .describe('Sync scope: ALL ingests every mapped DB; ONLY restricts to syncEnabled=true; EXCEPT excludes syncEnabled=true.'),
+    selections: metabaseSelectionsSchema
+        .default({ collections: [], items: [] })
+        .describe('Optional Metabase collection and item IDs to scope ingest.'),
+    defaultTagNames: z
+        .array(z.string().min(1))
+        .default([])
+        .describe('Default tag names applied to ingested Metabase artifacts.'),
+})
+    .describe('Metabase database-to-warehouse mapping and sync configuration.');
+export const lookerMappingsSchema = z
+    .object({
+    connectionMappings: z
+        .record(z.string().min(1), stringTargetSchema)
+        .default({})
+        .describe('Map of Looker connection name to KTX connection ID. Use null to explicitly unmap.'),
+})
+    .describe('Looker connection-to-warehouse mapping configuration.');
+export const lookmlMappingsSchema = z
+    .object({
+    expectedLookerConnectionName: z
+        .string()
+        .min(1)
+        .nullable()
+        .default(null)
+        .describe('Looker connection name that LookML models must declare; mismatches block sl_write_source at ingest time.'),
+})
+    .describe('LookML connection-name expectation for ingest gating.');
+function recordValue(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value) ? value : {};
+}
+function assertPositiveIntegerKeys(field, record) {
+    for (const key of Object.keys(record)) {
+        if (!/^[1-9]\d*$/.test(key)) {
+            throw new Error(`${field} key "${key}" must be a positive integer string`);
+        }
+    }
+}
+function driverOf(connection) {
+    return String(connection.driver ?? '').toLowerCase();
+}
+export function parseMetabaseMappingBootstrap(connectionId, connection) {
+    const rawMappings = recordValue(connection.mappings);
+    assertPositiveIntegerKeys('databaseMappings', recordValue(rawMappings.databaseMappings));
+    assertPositiveIntegerKeys('syncEnabled', recordValue(rawMappings.syncEnabled));
+    const parsed = metabaseMappingsSchema.parse(rawMappings);
+    return {
+        adapter: 'metabase',
+        connectionId,
+        databaseMappings: parsed.databaseMappings,
+        syncEnabled: parsed.syncEnabled,
+        syncMode: parsed.syncMode,
+        selections: parsed.selections,
+        defaultTagNames: parsed.defaultTagNames,
+    };
+}
+/** @internal */
+export function parseLookerMappingBootstrap(connectionId, connection) {
+    const parsed = lookerMappingsSchema.parse(recordValue(connection.mappings));
+    return {
+        adapter: 'looker',
+        connectionId,
+        connectionMappings: parsed.connectionMappings,
+    };
+}
+/** @internal */
+export function parseLookmlMappingBootstrap(connectionId, connection) {
+    const parsed = lookmlMappingsSchema.parse(recordValue(connection.mappings));
+    return {
+        adapter: 'lookml',
+        connectionId,
+        expectedLookerConnectionName: parsed.expectedLookerConnectionName,
+    };
+}
+export function parseConnectionMappingBootstrap(connectionId, connection) {
+    if (!connection.mappings || typeof connection.mappings !== 'object' || Array.isArray(connection.mappings)) {
+        return null;
+    }
+    const driver = driverOf(connection);
+    if (driver === 'metabase') {
+        return parseMetabaseMappingBootstrap(connectionId, connection);
+    }
+    if (driver === 'looker') {
+        return parseLookerMappingBootstrap(connectionId, connection);
+    }
+    if (driver === 'lookml') {
+        return parseLookmlMappingBootstrap(connectionId, connection);
+    }
+    return null;
+}

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

@@ -0,0 +1,30 @@
+import { GitService } from '../../context/core/git.service.js';
+import { type KtxCoreConfig, type KtxLogger } from '../../context/core/config.js';
+import type { KtxProjectConfig } from './config.js';
+import { LocalGitFileStore } from './local-git-file-store.js';
+export interface InitKtxProjectOptions {
+    projectDir: string;
+    force?: boolean;
+    authorName?: string;
+    authorEmail?: string;
+    logger?: KtxLogger;
+}
+export interface LoadKtxProjectOptions {
+    projectDir: string;
+    authorName?: string;
+    authorEmail?: string;
+    logger?: KtxLogger;
+}
+export interface KtxLocalProject {
+    projectDir: string;
+    configPath: string;
+    config: KtxProjectConfig;
+    coreConfig: KtxCoreConfig;
+    git: GitService;
+    fileStore: LocalGitFileStore;
+}
+export interface InitKtxProjectResult extends KtxLocalProject {
+    commitHash: string | null;
+}
+export declare function initKtxProject(options: InitKtxProjectOptions): Promise<InitKtxProjectResult>;
+export declare function loadKtxProject(options: LoadKtxProjectOptions): Promise<KtxLocalProject>;

package/dist/context/project/project.js

@@ -0,0 +1,94 @@
+import { promises as fs } from 'node:fs';
+import { basename, dirname, join, resolve } from 'node:path';
+import { GitService } from '../../context/core/git.service.js';
+import { noopLogger } from '../../context/core/config.js';
+import { buildDefaultKtxProjectConfig, parseKtxProjectConfig, serializeKtxProjectConfig } from './config.js';
+import { LocalGitFileStore } from './local-git-file-store.js';
+const TRACKED_SCAFFOLD_FILES = [
+    {
+        path: '.ktx/.gitignore',
+        content: 'cache/\ndb.sqlite\ndb.sqlite-*\ningest-transcripts/\nsecrets/\nsetup/\nagents/\n',
+    },
+    { path: '.ktx/prompts/.gitkeep', content: '' },
+    { path: '.ktx/skills/.gitkeep', content: '' },
+    { path: 'wiki/global/.gitkeep', content: '' },
+    { path: 'semantic-layer/.gitkeep', content: '' },
+    { path: 'raw-sources/.gitkeep', content: '' },
+];
+function createCoreConfig(projectDir, authorName, authorEmail) {
+    return {
+        storage: {
+            configDir: projectDir,
+            homeDir: dirname(projectDir),
+            worktreesDir: join(projectDir, '.ktx/worktrees'),
+        },
+        git: {
+            userName: authorName,
+            userEmail: authorEmail,
+            bootstrapMessage: 'Initialize ktx project repository',
+            bootstrapAuthor: authorName,
+            bootstrapAuthorEmail: authorEmail,
+        },
+    };
+}
+async function fileExists(path) {
+    try {
+        await fs.access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function writeProjectFile(projectDir, relativePath, content) {
+    const absolutePath = join(projectDir, relativePath);
+    await fs.mkdir(dirname(absolutePath), { recursive: true });
+    await fs.writeFile(absolutePath, content, 'utf-8');
+}
+async function createRuntime(projectDir, config, authorName, authorEmail, logger) {
+    const coreConfig = createCoreConfig(projectDir, authorName, authorEmail);
+    const git = new GitService(coreConfig, logger);
+    await git.onModuleInit();
+    return {
+        projectDir,
+        configPath: join(projectDir, 'ktx.yaml'),
+        config,
+        coreConfig,
+        git,
+        fileStore: new LocalGitFileStore({ rootDir: projectDir, git }),
+    };
+}
+export async function initKtxProject(options) {
+    const projectDir = resolve(options.projectDir);
+    const projectName = basename(projectDir) || 'ktx-project';
+    const authorName = options.authorName ?? 'ktx';
+    const authorEmail = options.authorEmail ?? 'ktx@example.com';
+    const logger = options.logger ?? noopLogger;
+    const configPath = join(projectDir, 'ktx.yaml');
+    await fs.mkdir(projectDir, { recursive: true });
+    if (!options.force && (await fileExists(configPath))) {
+        throw new Error(`Project already contains ktx.yaml: ${configPath}`);
+    }
+    const config = buildDefaultKtxProjectConfig();
+    const runtime = await createRuntime(projectDir, config, authorName, authorEmail, logger);
+    await writeProjectFile(projectDir, 'ktx.yaml', serializeKtxProjectConfig(config));
+    await fs.mkdir(join(projectDir, '.ktx/cache'), { recursive: true });
+    for (const file of TRACKED_SCAFFOLD_FILES) {
+        await writeProjectFile(projectDir, file.path, file.content);
+    }
+    const commit = await runtime.git.commitFiles(['ktx.yaml', ...TRACKED_SCAFFOLD_FILES.map((file) => file.path)], `Initialize KTX project: ${projectName}`, authorName, authorEmail);
+    return {
+        ...runtime,
+        commitHash: commit.commitHash,
+    };
+}
+export async function loadKtxProject(options) {
+    const projectDir = resolve(options.projectDir);
+    const authorName = options.authorName ?? 'ktx';
+    const authorEmail = options.authorEmail ?? 'ktx@example.com';
+    const logger = options.logger ?? noopLogger;
+    const configPath = join(projectDir, 'ktx.yaml');
+    const raw = await fs.readFile(configPath, 'utf-8');
+    const config = parseKtxProjectConfig(raw);
+    return createRuntime(projectDir, config, authorName, authorEmail, logger);
+}

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

@@ -0,0 +1,13 @@
+import type { KtxProjectConfig } from './config.js';
+declare const KTX_SETUP_STEPS: readonly ["project", "llm", "embeddings", "databases", "sources", "runtime", "context", "agents"];
+export type KtxSetupStep = (typeof KTX_SETUP_STEPS)[number];
+export interface KtxSetupState {
+    completed_steps: KtxSetupStep[];
+}
+export declare function readKtxSetupState(projectDir: string): Promise<KtxSetupState>;
+/** @internal */
+export declare function writeKtxSetupState(projectDir: string, state: KtxSetupState): Promise<void>;
+export declare function markKtxSetupStateStepComplete(projectDir: string, step: KtxSetupStep): Promise<KtxSetupState>;
+export declare function setKtxSetupDatabaseConnectionIds(config: KtxProjectConfig, connectionIds: string[]): KtxProjectConfig;
+export declare function mergeKtxSetupGitignoreEntries(content: string): string;
+export {};

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

@@ -0,0 +1,80 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+const KTX_SETUP_STEPS = [
+    'project',
+    'llm',
+    'embeddings',
+    'databases',
+    'sources',
+    'runtime',
+    'context',
+    'agents',
+];
+const SETUP_GITIGNORE_ENTRIES = [
+    'cache/',
+    'db.sqlite',
+    'db.sqlite-*',
+    'ingest-transcripts/',
+    'secrets/',
+    'setup/',
+    'agents/',
+];
+function isKtxSetupStep(value) {
+    return typeof value === 'string' && KTX_SETUP_STEPS.includes(value);
+}
+function uniqueSetupSteps(steps) {
+    if (!Array.isArray(steps)) {
+        return [];
+    }
+    return [...new Set(steps.filter(isKtxSetupStep))];
+}
+function ktxSetupStatePath(projectDir) {
+    return join(projectDir, '.ktx', 'setup', 'state.json');
+}
+export async function readKtxSetupState(projectDir) {
+    try {
+        const parsed = JSON.parse(await readFile(ktxSetupStatePath(projectDir), 'utf-8'));
+        return { completed_steps: uniqueSetupSteps(parsed.completed_steps) };
+    }
+    catch (error) {
+        if (error && typeof error === 'object' && 'code' in error && error.code === 'ENOENT') {
+            return { completed_steps: [] };
+        }
+        throw error;
+    }
+}
+/** @internal */
+export async function writeKtxSetupState(projectDir, state) {
+    await mkdir(join(projectDir, '.ktx', 'setup'), { recursive: true });
+    await writeFile(ktxSetupStatePath(projectDir), `${JSON.stringify({ completed_steps: uniqueSetupSteps(state.completed_steps) }, null, 2)}\n`, 'utf-8');
+}
+export async function markKtxSetupStateStepComplete(projectDir, step) {
+    const state = await readKtxSetupState(projectDir);
+    const completedSteps = state.completed_steps.includes(step) ? state.completed_steps : [...state.completed_steps, step];
+    const nextState = { completed_steps: completedSteps };
+    await writeKtxSetupState(projectDir, nextState);
+    return nextState;
+}
+export function setKtxSetupDatabaseConnectionIds(config, connectionIds) {
+    const uniqueConnectionIds = [...new Set(connectionIds.filter((connectionId) => connectionId.trim().length > 0))];
+    return {
+        ...config,
+        setup: {
+            database_connection_ids: uniqueConnectionIds,
+        },
+    };
+}
+export function mergeKtxSetupGitignoreEntries(content) {
+    const lines = content
+        .split(/\r?\n/)
+        .map((line) => line.trimEnd())
+        .filter((line, index, all) => line.length > 0 || index < all.length - 1);
+    const existing = new Set(lines);
+    for (const entry of SETUP_GITIGNORE_ENTRIES) {
+        if (!existing.has(entry)) {
+            lines.push(entry);
+            existing.add(entry);
+        }
+    }
+    return `${lines.join('\n')}\n`;
+}

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

@@ -0,0 +1,28 @@
+import { type KtxLogger } from '../../context/core/config.js';
+export interface PromptContext {
+    current_date?: string;
+    business_rules?: string;
+    datasource_description?: string;
+    tables_and_columns_summary?: string;
+    metadata?: string;
+    settings?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+export interface PromptServiceOptions {
+    promptsDir: string;
+    additionalPromptDirs?: string[];
+    defaultSettings?: Record<string, unknown>;
+    partials?: string[];
+    logger?: KtxLogger;
+}
+export declare class PromptService {
+    private readonly options;
+    private readonly logger;
+    private readonly partials;
+    private partialsRegistered;
+    constructor(options: PromptServiceOptions);
+    private promptDirs;
+    private ensurePartials;
+    loadPrompt(promptName: string, extension?: string): Promise<string>;
+    formatPrompt(promptName: string, context: PromptContext): Promise<string>;
+}

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

@@ -0,0 +1,84 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import Handlebars from 'handlebars';
+import { noopLogger } from '../../context/core/config.js';
+export class PromptService {
+    options;
+    logger;
+    partials;
+    partialsRegistered = false;
+    constructor(options) {
+        this.options = options;
+        this.logger = options.logger ?? noopLogger;
+        this.partials = options.partials ?? [];
+        Handlebars.registerHelper('eq', (a, b) => a === b);
+        Handlebars.registerHelper('json', (context) => JSON.stringify(context, null, 2));
+        Handlebars.registerHelper('truncate', (str, len) => typeof str === 'string' && str.length > len ? `${str.substring(0, len)}...` : str);
+        Handlebars.registerHelper('addOne', (index) => index + 1);
+        this.logger.log(`Prompt service initialized with directory: ${options.promptsDir}`);
+    }
+    promptDirs() {
+        return [this.options.promptsDir, ...(this.options.additionalPromptDirs ?? [])];
+    }
+    async ensurePartials() {
+        if (this.partialsRegistered) {
+            return;
+        }
+        for (const name of this.partials) {
+            let registered = false;
+            for (const promptsDir of this.promptDirs()) {
+                try {
+                    const content = await readFile(join(promptsDir, `${name}.md`), 'utf-8');
+                    Handlebars.registerPartial(name, content);
+                    registered = true;
+                    break;
+                }
+                catch { }
+            }
+            if (!registered) {
+                this.logger.warn(`Could not register ${name} partial`);
+            }
+        }
+        this.partialsRegistered = true;
+    }
+    async loadPrompt(promptName, extension = 'md') {
+        const tried = [];
+        for (const promptsDir of this.promptDirs()) {
+            const promptFile = join(promptsDir, `${promptName}.${extension}`);
+            tried.push(promptFile);
+            try {
+                const content = await readFile(promptFile, 'utf-8');
+                this.logger.debug(`Loaded prompt template: ${promptName}.${extension}`);
+                return content;
+            }
+            catch { }
+        }
+        const paths = tried.join(', ');
+        this.logger.error(`Prompt file not found: ${paths}`);
+        throw new Error(`Prompt file not found in any configured directory: ${paths}`);
+    }
+    async formatPrompt(promptName, context) {
+        await this.ensurePartials();
+        try {
+            const fullContext = {
+                current_date: context.current_date || new Date().toISOString().split('T')[0],
+                business_rules: context.business_rules || '',
+                ...context,
+                settings: {
+                    ...this.options.defaultSettings,
+                    ...context.settings,
+                },
+            };
+            const templateSource = await this.loadPrompt(promptName);
+            const template = Handlebars.compile(templateSource, { noEscape: true });
+            const rendered = template(fullContext);
+            this.logger.debug(`Formatted prompt: ${promptName} (${rendered.length} chars)`);
+            return rendered;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            this.logger.error(`Error formatting prompt ${promptName}: ${errorMessage}`);
+            throw new Error(`Failed to format prompt ${promptName}: ${errorMessage}`);
+        }
+    }
+}

package/dist/context/scan/constraint-discovery.d.ts

@@ -0,0 +1,19 @@
+import type { KtxScanWarning } from './types.js';
+export type ConstraintDiscoveryKind = 'primary_key' | 'foreign_key';
+export interface ConstraintQueryContext {
+    schema: string;
+    kind: ConstraintDiscoveryKind;
+    isDeniedError: (error: unknown) => boolean;
+}
+export type ConstraintQueryOutcome<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    warning: KtxScanWarning;
+};
+export declare function constraintDiscoveryWarning(input: {
+    schema: string;
+    kind: ConstraintDiscoveryKind;
+}): KtxScanWarning;
+export declare function tryConstraintQuery<T>(ctx: ConstraintQueryContext, fn: () => Promise<T>): Promise<ConstraintQueryOutcome<T>>;

package/dist/context/scan/constraint-discovery.js

@@ -0,0 +1,23 @@
+export function constraintDiscoveryWarning(input) {
+    return {
+        code: 'constraint_discovery_unauthorized',
+        message: `Skipped ${input.kind === 'primary_key' ? 'primary-key' : 'foreign-key'} ` +
+            `discovery in ${input.schema} (insufficient grants on system catalogs)`,
+        recoverable: true,
+        metadata: { schema: input.schema, kind: input.kind },
+    };
+}
+export async function tryConstraintQuery(ctx, fn) {
+    try {
+        return { ok: true, value: await fn() };
+    }
+    catch (error) {
+        if (!ctx.isDeniedError(error)) {
+            throw error;
+        }
+        return {
+            ok: false,
+            warning: constraintDiscoveryWarning({ schema: ctx.schema, kind: ctx.kind }),
+        };
+    }
+}

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

@@ -0,0 +1,10 @@
+import type { KtxCredentialEnvelope, KtxScanReport, KtxScanWarning } from './types.js';
+/** @internal */
+export declare function redactKtxCredentialValue(key: string, value: unknown): unknown;
+/** @internal */
+export declare function redactKtxScanMetadata(metadata: Record<string, unknown>): Record<string, unknown>;
+/** @internal */
+export declare function redactKtxCredentialEnvelope(envelope: KtxCredentialEnvelope): KtxCredentialEnvelope;
+/** @internal */
+export declare function redactKtxScanWarning(warning: KtxScanWarning): KtxScanWarning;
+export declare function redactKtxScanReport(report: KtxScanReport): KtxScanReport;

package/dist/context/scan/credentials.js

@@ -0,0 +1,41 @@
+import { redactKtxSensitiveMetadata, redactKtxSensitiveText, redactKtxSensitiveValue, } from '../core/redaction.js';
+/** @internal */
+export function redactKtxCredentialValue(key, value) {
+    return redactKtxSensitiveValue(key, value);
+}
+/** @internal */
+export function redactKtxScanMetadata(metadata) {
+    return redactKtxSensitiveMetadata(metadata);
+}
+/** @internal */
+export function redactKtxCredentialEnvelope(envelope) {
+    if (envelope.kind !== 'resolved') {
+        return envelope;
+    }
+    return {
+        kind: 'resolved',
+        source: envelope.source,
+        redacted: true,
+        values: redactKtxScanMetadata(envelope.values),
+    };
+}
+/** @internal */
+export function redactKtxScanWarning(warning) {
+    if (!warning.metadata) {
+        return {
+            ...warning,
+            message: redactKtxSensitiveText(warning.message),
+        };
+    }
+    return {
+        ...warning,
+        message: redactKtxSensitiveText(warning.message),
+        metadata: redactKtxScanMetadata(warning.metadata),
+    };
+}
+export function redactKtxScanReport(report) {
+    return {
+        ...report,
+        warnings: report.warnings.map((warning) => redactKtxScanWarning(warning)),
+    };
+}

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

@@ -0,0 +1,26 @@
+export interface KtxDataDictionarySettings {
+    cardinalityThreshold: number;
+    maxValuesToStore: number;
+    sampleSize: number;
+    useDbStatistics: boolean;
+    excludePatterns: string[];
+}
+export declare const defaultKtxDataDictionarySettings: KtxDataDictionarySettings;
+type KtxDataDictionarySkipReason = 'not_candidate' | 'already_populated' | 'empty_column' | 'high_cardinality';
+/** @internal */
+export interface KtxDataDictionarySampleDecision {
+    sample: boolean;
+    reason?: KtxDataDictionarySkipReason;
+}
+/** @internal */
+export interface KtxDataDictionaryColumnState {
+    columnType: string;
+    columnName: string;
+    sampleValues?: readonly string[] | null;
+    cardinality?: number | null;
+    settings: KtxDataDictionarySettings;
+}
+export declare function isKtxDataDictionaryCandidate(columnType: string, columnName: string, excludePatterns?: readonly string[]): boolean;
+/** @internal */
+export declare function shouldKtxSampleColumnForDictionary(input: KtxDataDictionaryColumnState): KtxDataDictionarySampleDecision;
+export {};