@kaelio/ktx 0.4.0 → 0.5.0

package/dist/context/ingest/tools/warehouse-verification/entity-details.tool.js

@@ -0,0 +1,137 @@
+import { z } from 'zod';
+import { BaseTool } from '../../../../context/tools/base-tool.js';
+const targetSchema = z.union([
+    z.object({ display: z.string().min(1) }),
+    z.object({
+        catalog: z.string().nullable(),
+        db: z.string().nullable(),
+        name: z.string().min(1),
+        column: z.string().optional(),
+    }),
+]);
+const entityDetailsInputSchema = z.object({
+    connectionId: z.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9_-]*$/),
+    targets: z.array(targetSchema).min(1).max(50),
+}).strict();
+function allowedConnectionNames(context) {
+    return context.session?.allowedConnectionNames ?? null;
+}
+function targetLabel(target) {
+    if ('display' in target) {
+        return target.display;
+    }
+    return [target.catalog, target.db, target.name, target.column].filter((part) => !!part).join('.');
+}
+function appendMissingTargetMarkdown(parts, target, candidates) {
+    parts.push(`Not found in scan: ${targetLabel(target)}`);
+    if (candidates.length > 0) {
+        parts.push(`Closest matches: ${candidates.map((candidate) => candidate.name).join(', ')}`);
+    }
+}
+async function resolveTarget(catalog, connectionId, target) {
+    if ('display' in target) {
+        return catalog.resolveDisplayTarget(connectionId, target.display);
+    }
+    const candidateResolution = await catalog.resolveDisplayTarget(connectionId, targetLabel(target));
+    return {
+        resolved: {
+            catalog: target.catalog,
+            db: target.db,
+            name: target.name,
+            column: target.column,
+        },
+        candidates: candidateResolution.candidates,
+    };
+}
+function sampleText(values) {
+    return values.length > 0 ? ` - sample: ${JSON.stringify(values.slice(0, 10))}` : '';
+}
+function appendTableMarkdown(parts, detail, columnName) {
+    const columns = columnName ? detail.columns.filter((column) => column.name === columnName) : detail.columns;
+    parts.push(`### ${detail.display}`);
+    parts.push(`Type: ${detail.kind} | Native columns: ${detail.columns.length}`);
+    if (detail.description || detail.comment) {
+        parts.push(`Description: ${detail.description ?? detail.comment}`);
+    }
+    parts.push('', 'Columns:');
+    for (const column of columns) {
+        const pk = column.primaryKey ? ', PK' : '';
+        parts.push(`- ${column.name} (${column.nativeType}, nullable=${column.nullable}${pk})${sampleText(column.sampleValues)}`);
+    }
+    parts.push('');
+}
+function findColumn(detail, columnName) {
+    const normalized = columnName.toLowerCase();
+    return detail.columns.find((column) => column.name.toLowerCase() === normalized) ?? null;
+}
+export class EntityDetailsTool extends BaseTool {
+    catalogFactory;
+    name = 'entity_details';
+    constructor(catalogFactory) {
+        super();
+        this.catalogFactory = catalogFactory;
+    }
+    get description() {
+        return 'Verify warehouse tables and columns from the latest live-database scan before writing them into wiki or semantic-layer output.';
+    }
+    get inputSchema() {
+        return entityDetailsInputSchema;
+    }
+    async call(input, context) {
+        const allowed = allowedConnectionNames(context);
+        if (allowed && !allowed.has(input.connectionId)) {
+            return {
+                markdown: `Connection "${input.connectionId}" is not available to this ingest stage.`,
+                structured: { resolved: [], missing: [], scanAvailable: false },
+            };
+        }
+        const catalog = this.catalogFactory(context);
+        const scanAvailable = await catalog.hasScan(input.connectionId);
+        if (!scanAvailable) {
+            return {
+                markdown: `No live-database scan available for connection "${input.connectionId}"; run \`ktx scan\` first.`,
+                structured: { resolved: [], missing: [], scanAvailable: false },
+            };
+        }
+        const parts = [];
+        const resolved = [];
+        const missing = [];
+        for (const target of input.targets) {
+            const resolution = await resolveTarget(catalog, input.connectionId, target);
+            if (!resolution.resolved) {
+                missing.push({ target, candidates: resolution.candidates });
+                appendMissingTargetMarkdown(parts, target, resolution.candidates);
+                continue;
+            }
+            const detail = await catalog.getTable({ connectionId: input.connectionId, ...resolution.resolved });
+            if (!detail) {
+                missing.push({ target, candidates: resolution.candidates });
+                appendMissingTargetMarkdown(parts, target, resolution.candidates);
+                continue;
+            }
+            const requestedColumn = resolution.resolved.column;
+            if (requestedColumn) {
+                const column = findColumn(detail, requestedColumn);
+                if (!column) {
+                    missing.push({
+                        target,
+                        candidates: [{ catalog: detail.catalog, db: detail.db, name: detail.name }],
+                    });
+                    parts.push(`Column not found in scan: ${detail.display}.${requestedColumn}`);
+                    parts.push(`Available columns: ${detail.columns.map((candidate) => candidate.name).join(', ')}`);
+                    continue;
+                }
+                const scopedDetail = { ...detail, columns: [column] };
+                resolved.push(scopedDetail);
+                appendTableMarkdown(parts, scopedDetail, column.name);
+                continue;
+            }
+            resolved.push(detail);
+            appendTableMarkdown(parts, detail);
+        }
+        return {
+            markdown: parts.join('\n').trim(),
+            structured: { resolved, missing, scanAvailable: true },
+        };
+    }
+}

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

@@ -0,0 +1,146 @@
+import { mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { initKtxProject } from '../../../../context/project/project.js';
+import { WarehouseCatalogService } from '../../../scan/warehouse-catalog.js';
+import { EntityDetailsTool } from './entity-details.tool.js';
+describe('EntityDetailsTool', () => {
+    let tempDir;
+    let project;
+    let tool;
+    let context;
+    beforeEach(async () => {
+        tempDir = await mkdtemp(join(tmpdir(), 'ktx-entity-details-'));
+        project = await initKtxProject({ projectDir: join(tempDir, 'project') });
+        await seedLiveDatabaseScan();
+        tool = new EntityDetailsTool(() => new WarehouseCatalogService({ fileStore: project.fileStore }));
+        context = {
+            sourceId: 'ingest',
+            messageId: 'm1',
+            userId: 'system',
+            session: {
+                allowedConnectionNames: new Set(['warehouse']),
+            },
+        };
+    });
+    afterEach(async () => {
+        await rm(tempDir, { recursive: true, force: true });
+    });
+    async function seedLiveDatabaseScan(connectionId = 'warehouse', syncId = 'sync-1') {
+        const root = `raw-sources/${connectionId}/live-database/${syncId}`;
+        await project.fileStore.writeFile(`${root}/connection.json`, JSON.stringify({ connectionId, driver: 'postgres', extractedAt: '2026-05-12T00:00:00.000Z' }, null, 2), 'ktx', 'ktx@example.com', 'seed connection');
+        await project.fileStore.writeFile(`${root}/tables/orders.json`, JSON.stringify({
+            catalog: null,
+            db: 'public',
+            name: 'orders',
+            kind: 'table',
+            comment: 'Customer orders',
+            estimatedRows: 12,
+            columns: [
+                {
+                    name: 'id',
+                    nativeType: 'integer',
+                    normalizedType: 'integer',
+                    dimensionType: 'number',
+                    nullable: false,
+                    primaryKey: true,
+                    comment: 'Order id',
+                },
+                {
+                    name: 'status',
+                    nativeType: 'text',
+                    normalizedType: 'text',
+                    dimensionType: 'string',
+                    nullable: false,
+                    primaryKey: false,
+                    comment: 'Order status',
+                },
+            ],
+            foreignKeys: [],
+        }, null, 2), 'ktx', 'ktx@example.com', 'seed orders');
+        await project.fileStore.writeFile(`${root}/enrichment/relationship-profile.json`, JSON.stringify({
+            connectionId,
+            driver: 'postgres',
+            tables: [{ table: { catalog: null, db: 'public', name: 'orders' }, rowCount: 12 }],
+            columns: {
+                'orders.status': {
+                    table: { catalog: null, db: 'public', name: 'orders' },
+                    column: 'status',
+                    rowCount: 12,
+                    nullCount: 0,
+                    distinctCount: 2,
+                    nullRate: 0,
+                    sampleValues: ['paid', 'refunded'],
+                },
+            },
+        }, null, 2), 'ktx', 'ktx@example.com', 'seed profile');
+    }
+    it('returns scoped table detail for a display target', async () => {
+        const result = await tool.call({ connectionId: 'warehouse', targets: [{ display: 'public.orders' }] }, context);
+        expect(result.markdown).toContain('### public.orders');
+        expect(result.markdown).toContain('- status (text, nullable=false)');
+        expect(result.markdown).toContain('sample: ["paid","refunded"]');
+        expect(result.structured.scanAvailable).toBe(true);
+        expect(result.structured.resolved).toHaveLength(1);
+    });
+    it('resolves display targets that include a column name', async () => {
+        const result = await tool.call({ connectionId: 'warehouse', targets: [{ display: 'public.orders.status' }] }, context);
+        expect(result.markdown).toContain('### public.orders');
+        expect(result.markdown).toContain('- status (text, nullable=false)');
+        expect(result.markdown).not.toContain('- id (integer');
+        expect(result.structured.resolved).toHaveLength(1);
+        expect(result.structured.resolved[0]?.columns.map((column) => column.name)).toEqual(['status']);
+    });
+    it('reports missing explicit columns instead of returning an empty column list', async () => {
+        const result = await tool.call({ connectionId: 'warehouse', targets: [{ display: 'public.orders.plan_tier' }] }, context);
+        expect(result.markdown).toContain('Column not found in scan: public.orders.plan_tier');
+        expect(result.markdown).toContain('Available columns: id, status');
+        expect(result.structured.resolved).toHaveLength(0);
+        expect(result.structured.missing).toHaveLength(1);
+    });
+    it('reports missing structured table targets in model-visible markdown', async () => {
+        const result = await tool.call({
+            connectionId: 'warehouse',
+            targets: [{ catalog: null, db: 'public', name: 'orderz' }],
+        }, context);
+        expect(result.markdown).toContain('Not found in scan: public.orderz');
+        expect(result.markdown).toContain('Closest matches: orders');
+        expect(result.structured.resolved).toHaveLength(0);
+        expect(result.structured.missing).toHaveLength(1);
+    });
+    it('reports missing structured column targets in model-visible markdown', async () => {
+        const result = await tool.call({
+            connectionId: 'warehouse',
+            targets: [{ catalog: null, db: 'public', name: 'orders', column: 'plan_tier' }],
+        }, context);
+        expect(result.markdown).toContain('Column not found in scan: public.orders.plan_tier');
+        expect(result.markdown).toContain('Available columns: id, status');
+        expect(result.structured.resolved).toHaveLength(0);
+        expect(result.structured.missing).toHaveLength(1);
+    });
+    it('returns a no-scan state distinct from not found', async () => {
+        const result = await tool.call({ connectionId: 'empty', targets: [{ display: 'public.orders' }] }, { ...context, session: { ...context.session, allowedConnectionNames: new Set(['empty']) } });
+        expect(result.markdown).toContain('No live-database scan available for connection "empty"; run `ktx scan` first.');
+        expect(result.structured.scanAvailable).toBe(false);
+    });
+    it('refuses out-of-scope connections', async () => {
+        const result = await tool.call({ connectionId: 'billing', targets: [{ display: 'public.orders' }] }, context);
+        expect(result.markdown).toContain('Connection "billing" is not available to this ingest stage.');
+        expect(result.structured.scanAvailable).toBe(false);
+    });
+    it('uses connectionId as the public input field', async () => {
+        const legacyConnectionField = ['connection', 'Name'].join('');
+        expect(tool.parseInput({
+            connectionId: 'warehouse',
+            targets: [{ display: 'public.orders' }],
+        })).toEqual({
+            connectionId: 'warehouse',
+            targets: [{ display: 'public.orders' }],
+        });
+        expect(() => tool.parseInput({
+            [legacyConnectionField]: 'warehouse',
+            targets: [{ display: 'public.orders' }],
+        })).toThrow();
+    });
+});

package/dist/context/ingest/tools/warehouse-verification/sql-execution.tool.d.ts

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+import type { SlConnectionCatalogPort } from '../../../../context/sl/ports.js';
+import { BaseTool, type ToolContext, type ToolOutput } from '../../../../context/tools/base-tool.js';
+declare const sqlExecutionInputSchema: z.ZodObject<{
+    connectionId: z.ZodString;
+    sql: z.ZodString;
+    rowLimit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, z.core.$strict>;
+type SqlExecutionInput = z.input<typeof sqlExecutionInputSchema>;
+export interface SqlExecutionStructured {
+    headers: string[];
+    rows: unknown[][];
+    rowCount: number;
+    truncated: boolean;
+    sql: string;
+    wrappedSql: string;
+    error?: string;
+}
+export declare class SqlExecutionTool extends BaseTool<typeof sqlExecutionInputSchema> {
+    private readonly connections;
+    readonly name = "sql_execution";
+    constructor(connections: SlConnectionCatalogPort);
+    get description(): string;
+    get inputSchema(): z.ZodObject<{
+        connectionId: z.ZodString;
+        sql: z.ZodString;
+        rowLimit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    }, z.core.$strict>;
+    call(input: SqlExecutionInput, context: ToolContext): Promise<ToolOutput<SqlExecutionStructured>>;
+}
+export {};

package/dist/context/ingest/tools/warehouse-verification/sql-execution.tool.js

@@ -0,0 +1,84 @@
+import { z } from 'zod';
+import { assertReadOnlySql, limitSqlForExecution } from '../../../../context/connections/read-only-sql.js';
+import { BaseTool } from '../../../../context/tools/base-tool.js';
+const sqlExecutionInputSchema = z.object({
+    connectionId: z.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9_-]*$/),
+    sql: z.string().min(1),
+    rowLimit: z.number().int().positive().max(1000).optional().default(100),
+}).strict();
+function markdownTable(headers, rows, totalRows) {
+    if (headers.length === 0) {
+        return rows.length === 0 ? 'Query returned no rows.' : JSON.stringify(rows.slice(0, 20));
+    }
+    const visible = rows.slice(0, 20);
+    const lines = [
+        `| ${headers.join(' | ')} |`,
+        `| ${headers.map(() => '---').join(' | ')} |`,
+        ...visible.map((row) => `| ${row.map((value) => String(value ?? '')).join(' | ')} |`),
+    ];
+    if (totalRows > visible.length) {
+        lines.push(`... +${totalRows - visible.length} more rows`);
+    }
+    return lines.join('\n');
+}
+export class SqlExecutionTool extends BaseTool {
+    connections;
+    name = 'sql_execution';
+    constructor(connections) {
+        super();
+        this.connections = connections;
+    }
+    get description() {
+        return 'Run a single read-only SELECT or WITH probe against an allowed warehouse connection and return a capped markdown table or the warehouse error.';
+    }
+    get inputSchema() {
+        return sqlExecutionInputSchema;
+    }
+    async call(input, context) {
+        const allowed = context.session?.allowedConnectionNames;
+        if (allowed && !allowed.has(input.connectionId)) {
+            return {
+                markdown: `Connection "${input.connectionId}" is not available to this ingest stage.`,
+                structured: {
+                    headers: [],
+                    rows: [],
+                    rowCount: 0,
+                    truncated: false,
+                    sql: input.sql,
+                    wrappedSql: '',
+                    error: 'connection_not_allowed',
+                },
+            };
+        }
+        let sql;
+        let wrappedSql;
+        try {
+            sql = assertReadOnlySql(input.sql);
+            wrappedSql = limitSqlForExecution(sql, input.rowLimit);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                markdown: message,
+                structured: { headers: [], rows: [], rowCount: 0, truncated: false, sql: input.sql, wrappedSql: '', error: message },
+            };
+        }
+        try {
+            const result = await this.connections.executeQuery(input.connectionId, wrappedSql);
+            const headers = result.headers ?? [];
+            const rows = result.rows ?? [];
+            const rowCount = result.totalRows ?? rows.length;
+            return {
+                markdown: markdownTable(headers, rows, rowCount),
+                structured: { headers, rows, rowCount, truncated: rowCount > rows.length, sql, wrappedSql },
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                markdown: `SQL execution failed: ${message}`,
+                structured: { headers: [], rows: [], rowCount: 0, truncated: false, sql, wrappedSql, error: message },
+            };
+        }
+    }
+}

package/dist/context/ingest/types.d.ts

@@ -0,0 +1,203 @@
+import type { KtxEmbeddingPort } from '../core/embedding.js';
+import type { MemoryAction } from '../../context/memory/types.js';
+import type { SemanticLayerService } from '../../context/sl/semantic-layer.service.js';
+import type { TouchedSlSource } from '../../context/tools/touched-sl-sources.js';
+import type { KtxTableRefKey } from '../scan/table-ref.js';
+import type { MemoryFlowEventSink } from './memory-flow/types.js';
+import type { StageIndex } from './stages/stage-index.types.js';
+import type { WorkUnitOutcome } from './stages/stage-3-work-units.js';
+export type IngestTrigger = 'upload' | 'scheduled_pull' | 'manual_resync' | 'manual_override';
+export interface DiffSet {
+    added: string[];
+    modified: string[];
+    deleted: string[];
+    unchanged: string[];
+}
+export interface WorkUnit {
+    unitKey: string;
+    displayLabel?: string;
+    rawFiles: string[];
+    peerFileIndex: string[];
+    dependencyPaths: string[];
+    notes?: string;
+    slDisallowed?: boolean;
+    slDisallowedReason?: 'lookml_connection_mismatch';
+}
+export interface EvictionUnit {
+    deletedRawPaths: string[];
+}
+export interface UnresolvedCardInfo {
+    cardId: number;
+    name?: string;
+    reason: 'cycle' | 'missing_native' | 'api_500' | 'unknown';
+    errorMessage?: string;
+}
+export interface ChunkResult {
+    workUnits: WorkUnit[];
+    eviction?: EvictionUnit;
+    unresolvedCards?: UnresolvedCardInfo[];
+    reconcileNotes?: string[];
+    contextReport?: {
+        capped?: boolean;
+        warnings?: string[];
+    };
+    parseArtifacts?: unknown;
+}
+export interface FetchContext {
+    connectionId: string;
+    sourceKey: string;
+    tableScope?: ReadonlySet<KtxTableRefKey>;
+    memoryFlow?: MemoryFlowEventSink;
+}
+type SourceFetchIssueKind = 'unmapped_looker_connection' | 'unparseable_sql_table_name' | 'looker_template_unresolved' | 'derived_table_not_supported' | 'lookml_connection_mismatch';
+interface SourceFetchIssue {
+    rawPath: string;
+    entityType: string;
+    entityId: string | null;
+    severity: 'warning' | 'error';
+    statusCode: number | null;
+    message: string;
+    retryRecommended: boolean;
+    kind?: SourceFetchIssueKind;
+    details?: Record<string, unknown>;
+}
+export interface SourceFetchReport {
+    status: 'success' | 'partial';
+    retryRecommended: boolean;
+    skipped: SourceFetchIssue[];
+    warnings: SourceFetchIssue[];
+}
+export interface ScopeDescriptor {
+    fingerprint: string;
+    isPathInScope(rawPath: string): boolean;
+}
+export type TriageLane = 'skip' | 'light' | 'full';
+export interface TriageSignals {
+    parentType?: string;
+    objectType?: string;
+    isDateTitled?: boolean;
+    lastEditedAt?: string;
+    propertyHints?: Record<string, string>;
+}
+export interface ClusterWorkUnitsContext {
+    workUnits: WorkUnit[];
+    stagedDir: string;
+    embedding: KtxEmbeddingPort;
+}
+export interface DeterministicProjectionContext {
+    connectionId: string;
+    sourceKey: string;
+    syncId: string;
+    jobId: string;
+    runId: string;
+    stagedDir: string;
+    workdir: string;
+    parseArtifacts?: unknown;
+    semanticLayerService: SemanticLayerService;
+}
+export interface ProjectionResult {
+    warnings: string[];
+    errors: string[];
+    touchedSources: Array<{
+        connectionId: string;
+        sourceName: string;
+    }>;
+    changedWikiPageKeys: string[];
+    result?: unknown;
+}
+export interface FinalizationOverrideReplay {
+    priorJobId: string;
+    priorRunId: string;
+    priorSyncId: string;
+    evictionRawPaths: string[];
+}
+export interface DeterministicFinalizationContext {
+    connectionId: string;
+    sourceKey: string;
+    syncId: string;
+    jobId: string;
+    runId: string;
+    stagedDir: string;
+    workdir: string;
+    parseArtifacts?: unknown;
+    stageIndex: StageIndex;
+    workUnitOutcomes: WorkUnitOutcome[];
+    reconciliationActions: MemoryAction[];
+    overrideReplay?: FinalizationOverrideReplay;
+}
+export interface FinalizationResult {
+    warnings: string[];
+    errors: string[];
+    touchedSources: TouchedSlSource[];
+    changedWikiPageKeys: string[];
+    actions?: MemoryAction[];
+    result?: unknown;
+}
+export interface SourceAdapter {
+    readonly source: string;
+    readonly skillNames: string[];
+    readonly reconcileSkillNames?: string[];
+    readonly evidenceIndexing?: 'documents';
+    readonly triageSupported?: boolean;
+    getTriageSignals?(stagedDir: string, externalId: string): Promise<TriageSignals>;
+    detect(stagedDir: string): Promise<boolean>;
+    fetch?(pullConfig: unknown, stagedDir: string, ctx: FetchContext): Promise<void>;
+    readFetchReport?(stagedDir: string): Promise<SourceFetchReport | null>;
+    listTargetConnectionIds?(stagedDir: string): Promise<string[]>;
+    chunk(stagedDir: string, diffSet?: DiffSet): Promise<ChunkResult>;
+    clusterWorkUnits?(ctx: ClusterWorkUnitsContext): Promise<WorkUnit[]>;
+    project?(ctx: DeterministicProjectionContext): Promise<ProjectionResult>;
+    finalize?(ctx: DeterministicFinalizationContext): Promise<FinalizationResult>;
+    describeScope?(stagedDir: string): Promise<ScopeDescriptor>;
+    onPullSucceeded?(ctx: {
+        connectionId: string;
+        sourceKey: string;
+        syncId: string;
+        trigger: IngestTrigger;
+        completedAt: Date;
+        stagedDir: string;
+    }): Promise<void>;
+}
+type IngestBundleRef = {
+    kind: 'upload';
+    uploadId: string;
+} | {
+    kind: 'scheduled_pull';
+    config: unknown;
+} | {
+    kind: 'override';
+    priorJobId: string;
+};
+export interface IngestBundleJob {
+    jobId: string;
+    connectionId: string;
+    sourceKey: string;
+    trigger: IngestTrigger;
+    bundleRef: IngestBundleRef;
+}
+export interface IngestDiffSummary {
+    added: number;
+    modified: number;
+    deleted: number;
+    unchanged: number;
+}
+export interface IngestBundleResult {
+    jobId: string;
+    runId: string;
+    syncId: string;
+    diffSummary: IngestDiffSummary;
+    workUnitCount: number;
+    failedWorkUnits: string[];
+    artifactsWritten: number;
+    commitSha: string | null;
+}
+export interface IngestJobPhase {
+    updateProgress(progress: number, message?: string): Promise<void>;
+    startPhase(weight: number): IngestJobPhase;
+}
+export interface IngestJobContext {
+    jobId: string;
+    memoryFlow?: MemoryFlowEventSink;
+    startPhase(weight: number): IngestJobPhase;
+}
+export {};

package/dist/context/ingest/wiki-body-refs.d.ts

@@ -0,0 +1,26 @@
+import type { SemanticLayerSource } from '../../context/sl/types.js';
+/** @internal */
+export type WikiBodyRef = {
+    kind: 'sl_entity';
+    connectionId: string | null;
+    sourceName: string;
+    entityName: string;
+} | {
+    kind: 'sl_source';
+    connectionId: string | null;
+    sourceName: string;
+} | {
+    kind: 'table';
+    connectionId: string | null;
+    tableRef: string;
+};
+export interface WikiBodyRefValidationInput {
+    pageKey: string;
+    body: string;
+    visibleConnectionIds: string[];
+    loadSources(connectionId: string): Promise<SemanticLayerSource[]>;
+    tableExists(connectionId: string, tableRef: string): Promise<boolean>;
+}
+/** @internal */
+export declare function parseWikiBodyRefs(body: string): WikiBodyRef[];
+export declare function findInvalidWikiBodyRefs(input: WikiBodyRefValidationInput): Promise<string[]>;