@kaelio/ktx 0.4.1 → 0.5.0

package/node_modules/@ktx/context/dist/ingest/adapters/metricflow/deep-parse.js

@@ -1,460 +0,0 @@
-import { parse as parseYaml } from 'yaml';
-import { noopLogger } from '../../../core/index.js';
-// ============ Aggregation Mapping ============
-const AGG_MAP = {
-    sum: 'sum',
-    sum_boolean: 'sum',
-    count: 'count',
-    count_distinct: 'count_distinct',
-    average: 'avg',
-    avg: 'avg',
-    min: 'min',
-    max: 'max',
-    median: 'median',
-};
-export function parseMetricflowFiles(files, options = {}) {
-    const parser = new MetricflowDeepParser(options.logger ?? noopLogger);
-    return parser.parseFiles(files);
-}
-export function translateMetricflowJinjaFilter(filter) {
-    return new MetricflowDeepParser(noopLogger).translateJinjaFilter(filter);
-}
-class MetricflowDeepParser {
-    logger;
-    constructor(logger) {
-        this.logger = logger;
-    }
-    parseFiles(files) {
-        this.logger.log(`Parsing ${files.length} files for MetricFlow definitions`);
-        const allSemanticModels = [];
-        const allMetrics = [];
-        const allRelationshipModels = [];
-        const warnings = [];
-        for (const file of files) {
-            const result = this.parseFile(file.content, file.path, warnings);
-            allSemanticModels.push(...result.semanticModels);
-            allMetrics.push(...result.metrics);
-            allRelationshipModels.push(...result.relationshipModels);
-        }
-        // Build measure→model index for cross-model metric resolution
-        const measureToModel = this.buildMeasureIndex(allSemanticModels);
-        // Absorb simple metrics as labels on existing measures, identify cross-model derived metrics
-        const crossModelMetrics = this.resolveMetrics(allMetrics, measureToModel, allSemanticModels, warnings);
-        const relationships = this.deduplicateRelationships(this.extractRelationships(allRelationshipModels));
-        this.logger.log(`Total: ${allSemanticModels.length} semantic models, ${crossModelMetrics.length} cross-model metrics, ${relationships.length} relationships`);
-        return {
-            semanticModels: allSemanticModels,
-            crossModelMetrics,
-            relationships,
-            warnings,
-        };
-    }
-    parseFile(yamlContent, filePath, warnings) {
-        let yaml;
-        try {
-            yaml = parseYaml(yamlContent);
-        }
-        catch (error) {
-            const msg = `Failed to parse YAML${filePath ? ` at ${filePath}` : ''}: ${error}`;
-            this.logger.warn(msg);
-            warnings.push(msg);
-            return { semanticModels: [], metrics: [], relationshipModels: [] };
-        }
-        if (!yaml || typeof yaml !== 'object') {
-            return { semanticModels: [], metrics: [], relationshipModels: [] };
-        }
-        const semanticModels = (yaml.semantic_models ?? []).map((sm) => this.parseSemanticModel(sm, warnings));
-        const metrics = yaml.metrics ?? [];
-        return { semanticModels, metrics, relationshipModels: yaml.semantic_models ?? [] };
-    }
-    parseSemanticModel(sm, warnings) {
-        const dimensions = (sm.dimensions ?? []).map((d) => this.convertDimension(d));
-        const measures = (sm.measures ?? [])
-            .map((m) => this.convertMeasure(m, warnings))
-            .filter(Boolean);
-        this.logger.debug(`Parsed semantic model '${sm.name}': ${dimensions.length} dimensions, ${measures.length} measures`);
-        return {
-            name: sm.name,
-            description: sm.description?.trim() || null,
-            modelRef: this.extractModelRef(sm.model),
-            dimensions,
-            measures,
-            entities: sm.entities ?? [],
-            defaultTimeDimension: sm.defaults?.agg_time_dimension ?? null,
-        };
-    }
-    convertDimension(dim) {
-        const type = dim.type === 'time' ? 'time' : 'string';
-        const column = dim.expr ?? dim.name;
-        return {
-            name: dim.name,
-            column,
-            type,
-            label: dim.label ?? this.toTitleCase(dim.name),
-            description: dim.description?.trim() || undefined,
-        };
-    }
-    convertMeasure(m, warnings) {
-        const column = m.expr ?? m.name;
-        // Handle percentile: map p50 to median, others to none with inline SQL
-        if (m.agg === 'percentile') {
-            const pct = m.agg_params?.percentile ?? 0.5;
-            if (pct === 0.5) {
-                return {
-                    type: 'simple',
-                    name: m.name,
-                    column,
-                    aggregation: 'median',
-                    label: m.label ?? this.toTitleCase(m.name),
-                    description: m.description?.trim() || undefined,
-                };
-            }
-            // Non-median percentile: store as 'none' with the percentile value in description
-            const pctLabel = `p${Math.round(pct * 100)}`;
-            warnings.push(`Measure '${m.name}': non-median percentile (${pctLabel}) stored with aggregation 'none'`);
-            return {
-                type: 'simple',
-                name: m.name,
-                column,
-                aggregation: 'none',
-                label: m.label ?? `${this.toTitleCase(m.name)} (${pctLabel})`,
-                description: m.description?.trim() || `${pctLabel} of ${column}`,
-            };
-        }
-        const aggregation = AGG_MAP[m.agg];
-        if (!aggregation) {
-            const msg = `Measure '${m.name}': unsupported aggregation '${m.agg}', skipped`;
-            this.logger.warn(msg);
-            warnings.push(msg);
-            return null;
-        }
-        return {
-            type: 'simple',
-            name: m.name,
-            column,
-            aggregation,
-            label: m.label ?? this.toTitleCase(m.name),
-            description: m.description?.trim() || undefined,
-        };
-    }
-    extractRelationships(semanticModels) {
-        const relationships = [];
-        // Build a map of primary entity names → (model, column)
-        const primaryEntities = new Map();
-        for (const sm of semanticModels) {
-            // Handle primary_entity shorthand (top-level field)
-            if (sm.primary_entity) {
-                primaryEntities.set(sm.primary_entity, {
-                    model: this.extractModelRef(sm.model),
-                    column: sm.primary_entity,
-                });
-            }
-            for (const entity of sm.entities ?? []) {
-                if (entity.type === 'primary' || entity.type === 'unique') {
-                    primaryEntities.set(entity.name, {
-                        model: this.extractModelRef(sm.model),
-                        column: entity.expr ?? entity.name,
-                    });
-                }
-            }
-        }
-        // Match foreign entities to primary entities by name
-        for (const sm of semanticModels) {
-            const fromTable = this.extractModelRef(sm.model);
-            for (const entity of sm.entities ?? []) {
-                if (entity.type !== 'foreign') {
-                    continue;
-                }
-                const primary = primaryEntities.get(entity.name);
-                if (!primary || primary.model === fromTable) {
-                    continue;
-                }
-                relationships.push({
-                    fromTable,
-                    fromColumn: entity.expr ?? entity.name,
-                    toTable: primary.model,
-                    toColumn: primary.column,
-                    description: entity.description?.trim() || undefined,
-                });
-            }
-        }
-        return relationships;
-    }
-    buildMeasureIndex(models) {
-        const index = new Map();
-        for (const model of models) {
-            for (const measure of model.measures) {
-                index.set(measure.name, model.name);
-            }
-        }
-        return index;
-    }
-    /**
-     * Extract measure name from type_params.measure which can be a string or { name: string }.
-     */
-    extractMeasureName(measure) {
-        if (!measure) {
-            return undefined;
-        }
-        if (typeof measure === 'string') {
-            return measure;
-        }
-        return measure.name;
-    }
-    /**
-     * Normalize metric filter to an array of strings.
-     * MetricFlow filters can be a string, array of strings, or { where_filters: [{ where_sql_template }] }.
-     */
-    normalizeFilter(filter) {
-        if (!filter) {
-            return [];
-        }
-        if (typeof filter === 'string') {
-            return [filter];
-        }
-        if (Array.isArray(filter)) {
-            return filter;
-        }
-        if (filter.where_filters) {
-            return filter.where_filters.map((f) => f.where_sql_template);
-        }
-        return [];
-    }
-    /**
-     * For ratio metrics, build the referenced metrics list from numerator/denominator.
-     * For derived metrics, use type_params.metrics directly.
-     */
-    getReferencedMetrics(metric) {
-        if (metric.type === 'derived') {
-            return metric.type_params.metrics ?? [];
-        }
-        if (metric.type === 'ratio') {
-            const refs = [];
-            if (metric.type_params.numerator) {
-                refs.push(metric.type_params.numerator);
-            }
-            if (metric.type_params.denominator) {
-                refs.push(metric.type_params.denominator);
-            }
-            return refs;
-        }
-        return [];
-    }
-    resolveMetrics(metrics, measureToModel, models, warnings) {
-        const crossModelMetrics = [];
-        // Build metric→model index from simple/cumulative metrics (needed for derived-of-derived resolution)
-        const metricToModel = new Map();
-        for (const metric of metrics) {
-            if (metric.type === 'simple' || metric.type === 'cumulative') {
-                const measureName = this.extractMeasureName(metric.type_params.measure);
-                if (measureName) {
-                    const owner = measureToModel.get(measureName);
-                    if (owner) {
-                        metricToModel.set(metric.name, owner);
-                    }
-                }
-            }
-        }
-        // Build metric→measure name index for resolving dependsOn
-        // For filtered metrics, the new measure will use the metric's name
-        const metricToMeasureName = new Map();
-        for (const metric of metrics) {
-            if (metric.type === 'simple' || metric.type === 'cumulative') {
-                const measureName = this.extractMeasureName(metric.type_params.measure);
-                if (measureName) {
-                    const filterClauses = this.normalizeFilter(metric.filter);
-                    if (filterClauses.length > 0) {
-                        metricToMeasureName.set(metric.name, metric.name);
-                    }
-                    else {
-                        metricToMeasureName.set(metric.name, measureName);
-                    }
-                }
-            }
-        }
-        for (const metric of metrics) {
-            if (metric.type === 'conversion') {
-                this.logger.debug(`Skipping conversion metric '${metric.name}' (not supported)`);
-                warnings.push(`Metric '${metric.name}': conversion metrics are not yet supported, skipped`);
-                continue;
-            }
-            if (metric.type === 'simple' || metric.type === 'cumulative') {
-                const measureName = this.extractMeasureName(metric.type_params.measure);
-                if (!measureName) {
-                    continue;
-                }
-                const ownerModelName = measureToModel.get(measureName);
-                if (!ownerModelName) {
-                    continue;
-                }
-                const model = models.find((m) => m.name === ownerModelName);
-                if (!model) {
-                    continue;
-                }
-                const baseMeasure = model.measures.find((m) => m.name === measureName);
-                if (!baseMeasure) {
-                    continue;
-                }
-                const filterClauses = this.normalizeFilter(metric.filter);
-                if (filterClauses.length > 0 && baseMeasure.type === 'simple') {
-                    // Filtered metric: create a NEW measure (copy of base with metric's identity + filter)
-                    const translatedFilter = filterClauses.map((f) => this.translateJinjaFilter(f)).join(' AND ');
-                    const newMeasure = {
-                        type: 'simple',
-                        name: metric.name,
-                        column: baseMeasure.column,
-                        aggregation: baseMeasure.aggregation,
-                        label: metric.label ?? this.toTitleCase(metric.name),
-                        description: metric.description?.trim() || baseMeasure.description,
-                        filter: translatedFilter,
-                    };
-                    if (metric.type === 'cumulative') {
-                        newMeasure.cumulative = true;
-                    }
-                    if (metric.name === baseMeasure.name) {
-                        // Same name as base measure: replace in-place to avoid duplicates
-                        const idx = model.measures.indexOf(baseMeasure);
-                        model.measures[idx] = newMeasure;
-                    }
-                    else {
-                        model.measures.push(newMeasure);
-                    }
-                    measureToModel.set(metric.name, ownerModelName);
-                }
-                else {
-                    // Unfiltered metric: update base measure's label/description in-place
-                    if (metric.label) {
-                        baseMeasure.label = metric.label;
-                    }
-                    if (metric.description) {
-                        baseMeasure.description = metric.description;
-                    }
-                    if (metric.type === 'cumulative' && baseMeasure.type === 'simple') {
-                        baseMeasure.cumulative = true;
-                    }
-                }
-            }
-            else if (metric.type === 'derived' || metric.type === 'ratio') {
-                const referencedMetrics = this.getReferencedMetrics(metric);
-                if (referencedMetrics.length === 0) {
-                    continue;
-                }
-                // Find which models own the referenced metrics using metricToModel index
-                const ownerModels = new Set();
-                for (const ref of referencedMetrics) {
-                    const owner = metricToModel.get(ref.name);
-                    if (owner) {
-                        ownerModels.add(owner);
-                    }
-                }
-                if (ownerModels.size <= 1 && ownerModels.size > 0) {
-                    // Single-model derived/ratio metric — add as derived measure to that model
-                    const ownerModelName = [...ownerModels][0];
-                    const model = models.find((m) => m.name === ownerModelName);
-                    if (!model) {
-                        continue;
-                    }
-                    const dependsOn = referencedMetrics.map((ref) => metricToMeasureName.get(ref.name) ?? ref.name);
-                    let expr = metric.type_params.expr ?? '';
-                    // For ratio metrics without an explicit expr, generate "numerator / denominator"
-                    if (metric.type === 'ratio' && !metric.type_params.expr) {
-                        const [numName, denName] = dependsOn;
-                        expr = numName && denName ? `${numName} / NULLIF(${denName}, 0)` : dependsOn.join(' / ');
-                    }
-                    // Replace metric name aliases with actual measure names in expression
-                    for (const ref of referencedMetrics) {
-                        const actualName = metricToMeasureName.get(ref.name) ?? ref.name;
-                        const aliasOrName = ref.alias ?? ref.name;
-                        if (aliasOrName !== actualName) {
-                            expr = expr.replace(new RegExp(`\\b${aliasOrName}\\b`, 'g'), actualName);
-                        }
-                    }
-                    const derivedMeasure = {
-                        type: 'derived',
-                        name: metric.name,
-                        expr,
-                        dependsOn,
-                        label: metric.label ?? this.toTitleCase(metric.name),
-                        description: metric.description?.trim() || undefined,
-                    };
-                    model.measures.push(derivedMeasure);
-                    // Register this derived metric in metricToModel so derived-of-derived can find it
-                    metricToModel.set(metric.name, ownerModelName);
-                }
-                else {
-                    // Cross-model or unresolved derived metric
-                    const dependsOn = referencedMetrics.map((ref) => {
-                        const ownerModel = metricToModel.get(ref.name);
-                        return { metricName: ownerModel ?? ref.name, alias: ref.alias };
-                    });
-                    const filterClauses = this.normalizeFilter(metric.filter);
-                    const filter = filterClauses.length > 0 ? filterClauses.map((f) => this.translateJinjaFilter(f)).join(' AND ') : null;
-                    crossModelMetrics.push({
-                        name: metric.name,
-                        label: metric.label ?? null,
-                        description: metric.description?.trim() || null,
-                        type: 'derived',
-                        expr: metric.type_params.expr ?? '',
-                        dependsOn,
-                        filter,
-                    });
-                }
-            }
-        }
-        return crossModelMetrics;
-    }
-    /**
-     * Translate MetricFlow Jinja filter syntax to raw SQL.
-     * {{ Dimension('model__column') }} → column
-     * {{ TimeDimension('model__column', 'day') }} → column
-     */
-    translateJinjaFilter(filter) {
-        return filter
-            .replace(/\{\{\s*Dimension\s*\(\s*'([^']+)'\s*\)\s*\}\}/g, (_match, ref) => {
-            const parts = ref.split('__');
-            return parts[parts.length - 1];
-        })
-            .replace(/\{\{\s*TimeDimension\s*\(\s*'([^']+)'\s*(?:,\s*'[^']*'\s*)?\)\s*\}\}/g, (_match, ref) => {
-            const parts = ref.split('__');
-            return parts[parts.length - 1];
-        })
-            .replace(/\{\{\s*Entity\s*\(\s*'([^']+)'\s*\)\s*\}\}/g, (_match, ref) => {
-            const parts = ref.split('__');
-            return parts[parts.length - 1];
-        })
-            .replace(/\{\{\s*Metric\s*\(\s*'([^']+)'\s*(?:,\s*[^)]+)?\)\s*\}\}/g, (_match, metricName) => metricName)
-            .trim();
-    }
-    /**
-     * Extract model name from ref('model_name') or source('source', 'table').
-     */
-    extractModelRef(modelStr) {
-        const refMatch = modelStr.match(/ref\s*\(\s*['"]([^'"]+)['"]\s*\)/);
-        if (refMatch) {
-            return refMatch[1];
-        }
-        const sourceMatch = modelStr.match(/source\s*\(\s*['"][^'"]+['"]\s*,\s*['"]([^'"]+)['"]\s*\)/);
-        if (sourceMatch) {
-            return sourceMatch[1];
-        }
-        return modelStr;
-    }
-    toTitleCase(snakeCase) {
-        return snakeCase
-            .split('_')
-            .filter(Boolean)
-            .map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase())
-            .join(' ');
-    }
-    deduplicateRelationships(relationships) {
-        const seen = new Set();
-        return relationships.filter((rel) => {
-            const key = `${rel.fromTable}.${rel.fromColumn}->${rel.toTable}.${rel.toColumn}`.toLowerCase();
-            if (seen.has(key)) {
-                return false;
-            }
-            seen.add(key);
-            return true;
-        });
-    }
-}

package/node_modules/@ktx/context/dist/ingest/adapters/metricflow/import-semantic-models.d.ts

@@ -1,29 +0,0 @@
-import type { SemanticLayerService } from '../../../sl/index.js';
-import { type TouchedSlSource } from '../../../tools/index.js';
-import type { MetricFlowParseResult } from './deep-parse.js';
-import { type MetricflowHostTable } from './semantic-models.js';
-export interface MetricFlowImportResult {
-    sourcesCreated: number;
-    sourcesUpdated: number;
-    sourcesSkipped: number;
-    crossModelSourcesCreated: number;
-    relationshipsImported: number;
-    warnings: string[];
-    errors: string[];
-    touchedSources: TouchedSlSource[];
-}
-export type MetricflowSemanticLayerWriter = Pick<SemanticLayerService, 'getManifestEntry' | 'isManifestBacked' | 'loadAllSources' | 'loadSource' | 'writeSource'>;
-export type MetricflowSemanticLayerService = MetricflowSemanticLayerWriter & {
-    forWorktree(workdir: string): MetricflowSemanticLayerWriter;
-};
-export interface ImportMetricflowSemanticModelsDeps {
-    semanticLayerService: MetricflowSemanticLayerService;
-}
-export interface ImportMetricflowSemanticModelsInput {
-    connectionId: string;
-    parseResult: MetricFlowParseResult;
-    targetSchema?: string | null;
-    hostTables: MetricflowHostTable[];
-    workdir?: string;
-}
-export declare function importMetricflowSemanticModels(deps: ImportMetricflowSemanticModelsDeps, input: ImportMetricflowSemanticModelsInput): Promise<MetricFlowImportResult>;

package/node_modules/@ktx/context/dist/ingest/adapters/metricflow/import-semantic-models.js

@@ -1,136 +0,0 @@
-import { addTouchedSlSource, createTouchedSlSources, listTouchedSlSources, } from '../../../tools/index.js';
-import { buildMetricflowJoinsForModel, buildMetricflowSemanticModelSource, filterValidMetricflowRelationships, findMatchingMetricflowTable, getMetricflowAvailableColumnNames, mapCrossModelMetricToSource, resolveMetricflowSemanticModelSourceName, } from './semantic-models.js';
-const DBT_METRICFLOW_AUTHOR = {
-    name: 'dbt MetricFlow',
-    email: ['system@kae', 'lio.dev'].join(''),
-};
-export async function importMetricflowSemanticModels(deps, input) {
-    const semanticLayerService = input.workdir
-        ? deps.semanticLayerService.forWorktree(input.workdir)
-        : deps.semanticLayerService;
-    const warnings = [...input.parseResult.warnings];
-    const errors = [];
-    const touched = createTouchedSlSources();
-    let sourcesCreated = 0;
-    let sourcesUpdated = 0;
-    let sourcesSkipped = 0;
-    let crossModelSourcesCreated = 0;
-    const preexistingSourceNames = new Set((await semanticLayerService.loadAllSources(input.connectionId)).sources.map((source) => source.name));
-    const modelContexts = [];
-    const sourceNameByModelRef = new Map();
-    const sourceNameByManifestName = new Map();
-    const availableColumnNamesByModelRef = new Map();
-    for (const semanticModel of input.parseResult.semanticModels) {
-        const matchedTable = findMatchingMetricflowTable(semanticModel.modelRef, input.hostTables, input.targetSchema);
-        const sourceName = resolveMetricflowSemanticModelSourceName(semanticModel, matchedTable);
-        sourceNameByModelRef.set(semanticModel.modelRef, sourceName);
-        if (matchedTable) {
-            sourceNameByManifestName.set(matchedTable.name, sourceName);
-        }
-        const manifestSource = await resolveManifestSource(semanticLayerService, input.connectionId, sourceName, matchedTable);
-        const context = {
-            model: semanticModel,
-            matchedTable,
-            sourceName,
-            manifestSource,
-        };
-        availableColumnNamesByModelRef.set(semanticModel.modelRef, getMetricflowAvailableColumnNames(context));
-        modelContexts.push(context);
-    }
-    const validRelationships = filterValidMetricflowRelationships(input.parseResult.relationships, availableColumnNamesByModelRef);
-    const availableTargetModelRefs = new Set(modelContexts
-        .filter((context) => preexistingSourceNames.has(context.sourceName) || context.manifestSource?.name === context.sourceName)
-        .map((context) => context.model.modelRef));
-    const successfulModelContexts = [];
-    for (const context of modelContexts) {
-        try {
-            const joins = buildMetricflowJoinsForModel(context.model, validRelationships, sourceNameByModelRef);
-            const source = buildMetricflowSemanticModelSource(context, joins, sourceNameByManifestName);
-            const existing = preexistingSourceNames.has(context.sourceName) ||
-                context.manifestSource?.name === context.sourceName ||
-                Boolean(await semanticLayerService.loadSource(input.connectionId, context.sourceName));
-            await semanticLayerService.writeSource(input.connectionId, source, DBT_METRICFLOW_AUTHOR.name, DBT_METRICFLOW_AUTHOR.email, `dbt MetricFlow sync: ${existing ? 'update' : 'create'} source ${context.sourceName}`, { skipValidation: true });
-            if (existing) {
-                sourcesUpdated++;
-            }
-            else {
-                sourcesCreated++;
-            }
-            availableTargetModelRefs.add(context.model.modelRef);
-            successfulModelContexts.push(context);
-            addTouchedSlSource(touched, input.connectionId, context.sourceName);
-        }
-        catch (error) {
-            errors.push(`Failed to import semantic model '${context.model.name}': ${error instanceof Error ? error.message : String(error)}`);
-            sourcesSkipped++;
-        }
-    }
-    if (successfulModelContexts.length > 0) {
-        try {
-            await repairSourcesAfterPartialImportFailures({
-                semanticLayerService,
-                connectionId: input.connectionId,
-                contexts: successfulModelContexts,
-                relationships: validRelationships,
-                sourceNameByModelRef,
-                sourceNameByManifestName,
-                availableTargetModelRefs,
-                touched,
-            });
-        }
-        catch (error) {
-            errors.push(`Failed to repair semantic-model joins after partial import: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    const relationshipsImported = successfulModelContexts.reduce((count, context) => {
-        return (count +
-            buildMetricflowJoinsForModel(context.model, validRelationships, sourceNameByModelRef, availableTargetModelRefs)
-                .length);
-    }, 0);
-    for (const metric of input.parseResult.crossModelMetrics) {
-        try {
-            const source = mapCrossModelMetricToSource(metric);
-            await semanticLayerService.writeSource(input.connectionId, source, DBT_METRICFLOW_AUTHOR.name, DBT_METRICFLOW_AUTHOR.email, `dbt MetricFlow sync: create cross-model source ${source.name}`, { skipValidation: true });
-            crossModelSourcesCreated++;
-            addTouchedSlSource(touched, input.connectionId, source.name);
-        }
-        catch (error) {
-            errors.push(`Failed to import cross-model metric '${metric.name}': ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    return {
-        sourcesCreated,
-        sourcesUpdated,
-        sourcesSkipped,
-        crossModelSourcesCreated,
-        relationshipsImported,
-        warnings,
-        errors,
-        touchedSources: listTouchedSlSources(touched),
-    };
-}
-async function resolveManifestSource(semanticLayerService, connectionId, sourceName, matchedTable) {
-    if (await semanticLayerService.isManifestBacked(connectionId, sourceName)) {
-        return semanticLayerService.getManifestEntry(connectionId, sourceName);
-    }
-    const matchedTableName = matchedTable?.name;
-    if (!matchedTableName || matchedTableName === sourceName) {
-        return null;
-    }
-    if (await semanticLayerService.isManifestBacked(connectionId, matchedTableName)) {
-        return semanticLayerService.getManifestEntry(connectionId, matchedTableName);
-    }
-    return null;
-}
-async function repairSourcesAfterPartialImportFailures(input) {
-    for (const context of input.contexts) {
-        const fullJoins = buildMetricflowJoinsForModel(context.model, input.relationships, input.sourceNameByModelRef);
-        const repairedJoins = buildMetricflowJoinsForModel(context.model, input.relationships, input.sourceNameByModelRef, input.availableTargetModelRefs);
-        if (fullJoins.length === repairedJoins.length) {
-            continue;
-        }
-        const repairedSource = buildMetricflowSemanticModelSource(context, repairedJoins, input.sourceNameByManifestName);
-        await input.semanticLayerService.writeSource(input.connectionId, repairedSource, DBT_METRICFLOW_AUTHOR.name, DBT_METRICFLOW_AUTHOR.email, `dbt MetricFlow sync: repair source ${context.sourceName} after partial import`, { skipValidation: true });
-        addTouchedSlSource(input.touched, input.connectionId, context.sourceName);
-    }
-}

package/node_modules/@ktx/context/dist/ingest/adapters/metricflow/parse.d.ts

@@ -1,42 +0,0 @@
-export interface ParsedMetricFlowSemanticModel {
-    /** Path relative to stagedDir, e.g. "models/orders.yml". */
-    path: string;
-    /** `name:` on the semantic_model. */
-    name: string;
-    /** Best-effort ref name: `ref('x')` → 'x'; `source('s','t')` → 't'; literal → literal. */
-    modelRef: string;
-    /**
-     * `extends:` parents declared on this semantic_model. MetricFlow does not ship
-     * `extends:` as a first-class field; this adapter treats any `extends:` that
-     * appears as a hint from the author that one model inherits from another.
-     * Empty if absent.
-     */
-    extendsFrom: string[];
-    measureNames: string[];
-    dimensionNames: string[];
-    entityNames: string[];
-    primaryEntities: string[];
-    foreignEntities: string[];
-    defaultTimeDimension: string | null;
-}
-export type MetricFlowMetricType = 'simple' | 'derived' | 'cumulative' | 'ratio' | 'conversion';
-export interface ParsedMetricFlowMetric {
-    path: string;
-    name: string;
-    type: MetricFlowMetricType;
-    /** For `simple` + `cumulative`. `null` for `derived`/`ratio`/`conversion`. */
-    measureRef: string | null;
-    /** For `derived`/`ratio`/`conversion`: the metric names this metric depends on. */
-    dependsOn: string[];
-}
-export interface ParsedMetricFlowProject {
-    semanticModels: ParsedMetricFlowSemanticModel[];
-    metrics: ParsedMetricFlowMetric[];
-    /** All `.yml`/`.yaml` paths seen under stagedDir, relative + sorted. */
-    allPaths: string[];
-    files: Array<{
-        path: string;
-        content: string;
-    }>;
-}
-export declare function parseMetricFlowStagedDir(stagedDir: string): Promise<ParsedMetricFlowProject>;