@kaelio/ktx 0.0.0 → 0.1.0-rc.1

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

@@ -0,0 +1,318 @@
+import { describe, expect, it, vi } from 'vitest';
+import { importMetricflowSemanticModels } from './import-semantic-models.js';
+const DBT_SYSTEM_EMAIL = ['system@kae', 'lio.dev'].join('');
+function parseResult() {
+    return {
+        semanticModels: [
+            {
+                name: 'orders',
+                description: 'Orders',
+                modelRef: 'orders',
+                dimensions: [{ name: 'status', column: 'status', type: 'string', label: 'Status' }],
+                measures: [{ type: 'simple', name: 'order_count', column: 'id', aggregation: 'count' }],
+                entities: [{ name: 'customer', type: 'foreign', expr: 'customer_id' }],
+                defaultTimeDimension: null,
+            },
+        ],
+        crossModelMetrics: [
+            {
+                name: 'global_revenue',
+                label: null,
+                description: 'Revenue everywhere',
+                type: 'derived',
+                expr: 'sum(revenue)',
+                dependsOn: [{ metricName: 'orders' }],
+                filter: null,
+            },
+        ],
+        relationships: [{ fromTable: 'orders', fromColumn: 'customer_id', toTable: 'customers', toColumn: 'id' }],
+        warnings: ['parser warning'],
+    };
+}
+describe('importMetricflowSemanticModels', () => {
+    it('writes semantic models through a worktree-scoped semantic layer service and returns touched sources', async () => {
+        const scoped = {
+            getManifestEntry: vi.fn().mockResolvedValue(null),
+            isManifestBacked: vi.fn().mockResolvedValue(false),
+            loadAllSources: vi.fn().mockResolvedValue({ sources: [], loadErrors: [] }),
+            loadSource: vi.fn().mockResolvedValue(null),
+            writeSource: vi.fn().mockResolvedValue({ warnings: [] }),
+        };
+        const semanticLayerService = {
+            forWorktree: vi.fn().mockReturnValue(scoped),
+            getManifestEntry: vi.fn(),
+            isManifestBacked: vi.fn(),
+            loadAllSources: vi.fn(),
+            loadSource: vi.fn(),
+            writeSource: vi.fn(),
+        };
+        const result = await importMetricflowSemanticModels({ semanticLayerService }, {
+            connectionId: 'warehouse-1',
+            parseResult: parseResult(),
+            targetSchema: null,
+            hostTables: [
+                { id: 'orders-table', name: 'orders', catalog: null, db: null, columns: [{ id: 'c1', name: 'customer_id' }] },
+                { id: 'customers-table', name: 'customers', catalog: null, db: null, columns: [{ id: 'c2', name: 'id' }] },
+            ],
+            workdir: '/tmp/session-worktree',
+        });
+        expect(semanticLayerService.forWorktree).toHaveBeenCalledWith('/tmp/session-worktree');
+        expect(scoped.writeSource).toHaveBeenCalledTimes(2);
+        expect(scoped.writeSource).toHaveBeenNthCalledWith(1, 'warehouse-1', expect.objectContaining({ name: 'orders' }), 'dbt MetricFlow', DBT_SYSTEM_EMAIL, 'dbt MetricFlow sync: create source orders', { skipValidation: true });
+        expect(scoped.writeSource).toHaveBeenNthCalledWith(2, 'warehouse-1', expect.objectContaining({ name: 'global-revenue' }), 'dbt MetricFlow', DBT_SYSTEM_EMAIL, 'dbt MetricFlow sync: create cross-model source global-revenue', { skipValidation: true });
+        expect(result).toEqual({
+            sourcesCreated: 1,
+            sourcesUpdated: 0,
+            sourcesSkipped: 0,
+            crossModelSourcesCreated: 1,
+            relationshipsImported: 0,
+            warnings: ['parser warning'],
+            errors: [],
+            touchedSources: [
+                { connectionId: 'warehouse-1', sourceName: 'global-revenue' },
+                { connectionId: 'warehouse-1', sourceName: 'orders' },
+            ],
+        });
+    });
+    it('updates count when an existing semantic model source exists', async () => {
+        const scoped = {
+            getManifestEntry: vi.fn().mockResolvedValue(null),
+            isManifestBacked: vi.fn().mockResolvedValue(false),
+            loadAllSources: vi.fn().mockResolvedValue({ sources: [], loadErrors: [] }),
+            loadSource: vi.fn().mockImplementation((connectionId, sourceName) => Promise.resolve(sourceName === 'orders' ? { name: 'orders' } : null)),
+            writeSource: vi.fn().mockResolvedValue({ warnings: [] }),
+        };
+        const semanticLayerService = {
+            forWorktree: vi.fn().mockReturnValue(scoped),
+            getManifestEntry: vi.fn(),
+            isManifestBacked: vi.fn(),
+            loadAllSources: vi.fn(),
+            loadSource: vi.fn(),
+            writeSource: vi.fn(),
+        };
+        const result = await importMetricflowSemanticModels({ semanticLayerService }, {
+            connectionId: 'warehouse-1',
+            parseResult: { ...parseResult(), crossModelMetrics: [], relationships: [] },
+            targetSchema: null,
+            hostTables: [],
+            workdir: '/tmp/session-worktree',
+        });
+        expect(result.sourcesCreated).toBe(0);
+        expect(result.sourcesUpdated).toBe(1);
+        expect(result.crossModelSourcesCreated).toBe(0);
+    });
+    it('keeps domain write failures structured and continues processing', async () => {
+        const scoped = {
+            getManifestEntry: vi.fn().mockResolvedValue(null),
+            isManifestBacked: vi.fn().mockResolvedValue(false),
+            loadAllSources: vi.fn().mockResolvedValue({ sources: [], loadErrors: [] }),
+            loadSource: vi.fn().mockResolvedValue(null),
+            writeSource: vi.fn().mockRejectedValueOnce(new Error('cannot write orders')).mockResolvedValue({ warnings: [] }),
+        };
+        const semanticLayerService = {
+            forWorktree: vi.fn().mockReturnValue(scoped),
+            getManifestEntry: vi.fn(),
+            isManifestBacked: vi.fn(),
+            loadAllSources: vi.fn(),
+            loadSource: vi.fn(),
+            writeSource: vi.fn(),
+        };
+        const result = await importMetricflowSemanticModels({ semanticLayerService }, {
+            connectionId: 'warehouse-1',
+            parseResult: parseResult(),
+            targetSchema: null,
+            hostTables: [],
+            workdir: '/tmp/session-worktree',
+        });
+        expect(result.sourcesSkipped).toBe(1);
+        expect(result.crossModelSourcesCreated).toBe(1);
+        expect(result.errors).toEqual(["Failed to import semantic model 'orders': cannot write orders"]);
+        expect(result.touchedSources).toEqual([{ connectionId: 'warehouse-1', sourceName: 'global-revenue' }]);
+    });
+    it('writes manifest-backed semantic models as overlays', async () => {
+        const manifestOrders = {
+            name: 'orders',
+            table: 'analytics.orders',
+            grain: ['id'],
+            columns: [
+                { name: 'id', type: 'string' },
+                { name: 'customer_id', type: 'string' },
+            ],
+            joins: [],
+            measures: [],
+            descriptions: { db: 'Orders table from scan' },
+        };
+        const written = [];
+        const scoped = {
+            getManifestEntry: vi.fn().mockImplementation(async (_connectionId, sourceName) => {
+                return sourceName === 'orders' ? manifestOrders : null;
+            }),
+            isManifestBacked: vi.fn().mockImplementation(async (_connectionId, sourceName) => {
+                return sourceName === 'orders';
+            }),
+            loadAllSources: vi.fn().mockResolvedValue({ sources: [], loadErrors: [] }),
+            loadSource: vi.fn().mockResolvedValue(null),
+            writeSource: vi.fn().mockImplementation(async (_connectionId, source) => {
+                written.push(source);
+                return { warnings: [] };
+            }),
+        };
+        const semanticLayerService = {
+            forWorktree: vi.fn().mockReturnValue(scoped),
+            getManifestEntry: vi.fn(),
+            isManifestBacked: vi.fn(),
+            loadAllSources: vi.fn(),
+            loadSource: vi.fn(),
+            writeSource: vi.fn(),
+        };
+        const result = await importMetricflowSemanticModels({ semanticLayerService }, {
+            connectionId: 'warehouse-1',
+            parseResult: {
+                ...parseResult(),
+                semanticModels: [
+                    parseResult().semanticModels[0],
+                    {
+                        name: 'customers',
+                        description: null,
+                        modelRef: 'customers',
+                        dimensions: [{ name: 'id', column: 'id', type: 'string' }],
+                        measures: [],
+                        entities: [],
+                        defaultTimeDimension: null,
+                    },
+                ],
+                crossModelMetrics: [],
+            },
+            targetSchema: null,
+            hostTables: [
+                {
+                    id: 'orders-table',
+                    name: 'orders',
+                    catalog: null,
+                    db: null,
+                    columns: [
+                        { id: 'c1', name: 'customer_id' },
+                        { id: 'c2', name: 'id' },
+                    ],
+                },
+                { id: 'customers-table', name: 'customers', catalog: null, db: null, columns: [{ id: 'c3', name: 'id' }] },
+            ],
+            workdir: '/tmp/session-worktree',
+        });
+        expect(written[0]).toMatchObject({
+            name: 'orders',
+            joins: [{ to: 'customers', on: 'orders.customer_id = customers.id', relationship: 'many_to_one' }],
+            descriptions: { dbt: 'Orders' },
+        });
+        expect(written[0]).not.toHaveProperty('table');
+        expect(written[0]).not.toHaveProperty('columns');
+        expect(result.sourcesUpdated).toBe(1);
+        expect(result.relationshipsImported).toBe(1);
+    });
+    it('drops joins whose keys are absent from manifest-backed source columns', async () => {
+        const scoped = {
+            getManifestEntry: vi.fn().mockResolvedValue({
+                name: 'orders',
+                table: 'analytics.orders',
+                grain: ['id'],
+                columns: [{ name: 'id', type: 'string' }],
+                joins: [],
+                measures: [],
+            }),
+            isManifestBacked: vi.fn().mockImplementation(async (_connectionId, sourceName) => {
+                return sourceName === 'orders';
+            }),
+            loadAllSources: vi.fn().mockResolvedValue({ sources: [], loadErrors: [] }),
+            loadSource: vi.fn().mockResolvedValue(null),
+            writeSource: vi.fn().mockResolvedValue({ warnings: [] }),
+        };
+        const semanticLayerService = {
+            forWorktree: vi.fn().mockReturnValue(scoped),
+            getManifestEntry: vi.fn(),
+            isManifestBacked: vi.fn(),
+            loadAllSources: vi.fn(),
+            loadSource: vi.fn(),
+            writeSource: vi.fn(),
+        };
+        const result = await importMetricflowSemanticModels({ semanticLayerService }, {
+            connectionId: 'warehouse-1',
+            parseResult: { ...parseResult(), crossModelMetrics: [] },
+            targetSchema: null,
+            hostTables: [
+                { id: 'orders-table', name: 'orders', catalog: null, db: null, columns: [{ id: 'c1', name: 'id' }] },
+                { id: 'customers-table', name: 'customers', catalog: null, db: null, columns: [{ id: 'c2', name: 'id' }] },
+            ],
+            workdir: '/tmp/session-worktree',
+        });
+        expect(scoped.writeSource).toHaveBeenCalledWith('warehouse-1', expect.not.objectContaining({ joins: expect.anything() }), expect.any(String), expect.any(String), expect.any(String), { skipValidation: true });
+        expect(result.relationshipsImported).toBe(0);
+    });
+    it('repairs earlier sources when a later related model fails to write', async () => {
+        const written = [];
+        const scoped = {
+            getManifestEntry: vi.fn().mockResolvedValue(null),
+            isManifestBacked: vi.fn().mockResolvedValue(false),
+            loadAllSources: vi.fn().mockResolvedValue({ sources: [], loadErrors: [] }),
+            loadSource: vi.fn().mockResolvedValue(null),
+            writeSource: vi
+                .fn()
+                .mockImplementationOnce(async (_connectionId, source) => {
+                written.push(source);
+                return { warnings: [] };
+            })
+                .mockRejectedValueOnce(new Error('disk full'))
+                .mockImplementation(async (_connectionId, source) => {
+                written.push(source);
+                return { warnings: [] };
+            }),
+        };
+        const semanticLayerService = {
+            forWorktree: vi.fn().mockReturnValue(scoped),
+            getManifestEntry: vi.fn(),
+            isManifestBacked: vi.fn(),
+            loadAllSources: vi.fn(),
+            loadSource: vi.fn(),
+            writeSource: vi.fn(),
+        };
+        const result = await importMetricflowSemanticModels({ semanticLayerService }, {
+            connectionId: 'warehouse-1',
+            parseResult: {
+                ...parseResult(),
+                semanticModels: [
+                    parseResult().semanticModels[0],
+                    {
+                        name: 'customers',
+                        description: null,
+                        modelRef: 'customers',
+                        dimensions: [{ name: 'id', column: 'id', type: 'string' }],
+                        measures: [],
+                        entities: [],
+                        defaultTimeDimension: null,
+                    },
+                ],
+                crossModelMetrics: [],
+            },
+            targetSchema: null,
+            hostTables: [
+                {
+                    id: 'orders-table',
+                    name: 'orders',
+                    catalog: null,
+                    db: null,
+                    columns: [
+                        { id: 'c1', name: 'customer_id' },
+                        { id: 'c2', name: 'id' },
+                    ],
+                },
+                { id: 'customers-table', name: 'customers', catalog: null, db: null, columns: [{ id: 'c3', name: 'id' }] },
+            ],
+            workdir: '/tmp/session-worktree',
+        });
+        expect(result.sourcesCreated).toBe(1);
+        expect(result.sourcesSkipped).toBe(1);
+        expect(result.relationshipsImported).toBe(0);
+        expect(result.errors).toContain("Failed to import semantic model 'customers': disk full");
+        expect(written.filter((source) => source.name === 'orders')).toHaveLength(2);
+        expect(written[written.length - 1]).toMatchObject({ name: 'orders', joins: [] });
+    });
+});

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

@@ -0,0 +1,16 @@
+import type { ChunkResult, DiffSet, FetchContext, SourceAdapter } from '../../types.js';
+export interface MetricflowSourceAdapterDeps {
+    homeDir: string;
+    targetConnectionIds?: string[];
+}
+export declare class MetricflowSourceAdapter implements SourceAdapter {
+    private readonly deps;
+    readonly source = "metricflow";
+    readonly skillNames: string[];
+    constructor(deps: MetricflowSourceAdapterDeps);
+    detect(stagedDir: string): Promise<boolean>;
+    fetch(pullConfig: unknown, stagedDir: string, ctx: FetchContext): Promise<void>;
+    listTargetConnectionIds(_stagedDir: string): Promise<string[]>;
+    chunk(stagedDir: string, diffSet?: DiffSet): Promise<ChunkResult>;
+    private resolveCacheDir;
+}

package/node_modules/@ktx/context/dist/ingest/adapters/metricflow/metricflow.adapter.js

@@ -0,0 +1,44 @@
+import { join } from 'node:path';
+import { chunkMetricFlowProject } from './chunk.js';
+import { detectMetricFlowStagedDir } from './detect.js';
+import { parseMetricflowFiles } from './deep-parse.js';
+import { fetchMetricflowRepo } from './fetch.js';
+import { parseMetricFlowStagedDir } from './parse.js';
+import { parseMetricflowPullConfig } from './pull-config.js';
+function uniqueSorted(values) {
+    return [...new Set(values ?? [])].sort((left, right) => left.localeCompare(right));
+}
+export class MetricflowSourceAdapter {
+    deps;
+    source = 'metricflow';
+    skillNames = ['metricflow_ingest'];
+    constructor(deps) {
+        this.deps = deps;
+    }
+    detect(stagedDir) {
+        return detectMetricFlowStagedDir(stagedDir);
+    }
+    async fetch(pullConfig, stagedDir, ctx) {
+        const config = parseMetricflowPullConfig(pullConfig);
+        await fetchMetricflowRepo({
+            config,
+            cacheDir: this.resolveCacheDir(ctx.connectionId),
+            stagedDir,
+        });
+    }
+    async listTargetConnectionIds(_stagedDir) {
+        return uniqueSorted(this.deps.targetConnectionIds);
+    }
+    async chunk(stagedDir, diffSet) {
+        const project = await parseMetricFlowStagedDir(stagedDir);
+        const chunk = await chunkMetricFlowProject(project, { diffSet });
+        const parseArtifacts = parseMetricflowStagedDirForImport(project);
+        return { ...chunk, parseArtifacts };
+    }
+    resolveCacheDir(connectionId) {
+        return join(this.deps.homeDir, 'ingest-metricflow-repos', connectionId);
+    }
+}
+function parseMetricflowStagedDirForImport(project) {
+    return parseMetricflowFiles(project.files);
+}

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

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

package/node_modules/@ktx/context/dist/ingest/adapters/metricflow/metricflow.adapter.test.js

@@ -0,0 +1,97 @@
+import { mkdir, mkdtemp, readFile, 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 { makeLocalGitRepo } from '../../../test/make-local-git-repo.js';
+import { MetricflowSourceAdapter } from './metricflow.adapter.js';
+function compileOnlyRequiredDepsCheck() {
+    // @ts-expect-error MetricflowSourceAdapter requires an explicit cache home.
+    new MetricflowSourceAdapter();
+}
+void compileOnlyRequiredDepsCheck;
+async function makeRepo(tmpRoot, files) {
+    const fixtureDir = join(tmpRoot, 'fixture-src');
+    for (const [path, content] of Object.entries(files)) {
+        const dest = join(fixtureDir, path);
+        await mkdir(join(dest, '..'), { recursive: true });
+        await writeFile(dest, content, 'utf-8');
+    }
+    return makeLocalGitRepo(fixtureDir, join(tmpRoot, 'origin'));
+}
+describe('MetricflowSourceAdapter', () => {
+    let tmpRoot;
+    let stagedDir;
+    let adapter;
+    beforeEach(async () => {
+        tmpRoot = await mkdtemp(join(tmpdir(), 'mf-adapter-'));
+        stagedDir = join(tmpRoot, 'stage');
+        adapter = new MetricflowSourceAdapter({ homeDir: join(tmpRoot, 'cache-home') });
+    });
+    afterEach(async () => {
+        await rm(tmpRoot, { recursive: true, force: true });
+    });
+    it('declares the expected source key and skill list', () => {
+        expect(adapter.source).toBe('metricflow');
+        expect(adapter.skillNames).toEqual(['metricflow_ingest']);
+    });
+    it('returns configured target warehouse connection ids', async () => {
+        const metricflow = new MetricflowSourceAdapter({
+            homeDir: join(tmpRoot, 'cache-home'),
+            targetConnectionIds: ['warehouse', 'analytics', 'warehouse'],
+        });
+        await expect(metricflow.listTargetConnectionIds?.(stagedDir)).resolves.toEqual(['analytics', 'warehouse']);
+    });
+    it('detects a staged dir with a semantic_models YAML', async () => {
+        await mkdir(join(stagedDir, 'models'), { recursive: true });
+        await writeFile(join(stagedDir, 'models/orders.yml'), 'semantic_models:\n  - {name: orders, model: x, measures: [{name: c, agg: count, expr: id}]}\n', 'utf-8');
+        expect(await adapter.detect(stagedDir)).toBe(true);
+    });
+    it('rejects a staged dir with no MetricFlow-shaped YAML', async () => {
+        await mkdir(stagedDir, { recursive: true });
+        await writeFile(join(stagedDir, 'dbt_project.yml'), 'name: proj\n', 'utf-8');
+        expect(await adapter.detect(stagedDir)).toBe(false);
+    });
+    it('chunk: first-run on a minimal single-model dir emits one WU', async () => {
+        await mkdir(join(stagedDir, 'models'), { recursive: true });
+        await writeFile(join(stagedDir, 'models/orders.yml'), 'semantic_models:\n  - {name: orders, model: x, measures: [{name: c, agg: count, expr: id}]}\n', 'utf-8');
+        const result = await adapter.chunk(stagedDir);
+        expect(result.workUnits).toHaveLength(1);
+        expect(result.workUnits[0].unitKey).toBe('metricflow-orders');
+    });
+    it('attaches deep parse artifacts to the chunk result', async () => {
+        await mkdir(stagedDir, { recursive: true });
+        await writeFile(join(stagedDir, 'semantic_models.yml'), [
+            'semantic_models:',
+            '  - name: orders',
+            "    model: ref('orders')",
+            '    dimensions: []',
+            '    measures:',
+            '      - name: order_count',
+            '        agg: count',
+            "        expr: '1'",
+        ].join('\n'));
+        const chunk = await adapter.chunk(stagedDir);
+        expect(chunk.parseArtifacts).toMatchObject({
+            semanticModels: [{ name: 'orders', modelRef: 'orders' }],
+            crossModelMetrics: [],
+            relationships: [],
+            warnings: [],
+        });
+    });
+    it('fetches repo YAML files into the staged directory using a per-connection cache', async () => {
+        const repo = await makeRepo(tmpRoot, {
+            'dbt_project.yml': 'name: analytics\n',
+            'models/orders.yml': 'semantic_models:\n  - name: orders\n    model: ref("orders")\n',
+            'models/readme.md': '# ignored\n',
+        });
+        await adapter.fetch?.({
+            repoUrl: repo.repoUrl,
+            branch: 'main',
+            path: null,
+            authToken: null,
+            parsedTargetTables: {},
+        }, stagedDir, { connectionId: 'warehouse-1', sourceKey: 'metricflow' });
+        await expect(readFile(join(stagedDir, 'models/orders.yml'), 'utf-8')).resolves.toContain('semantic_models');
+        expect(await adapter.detect(stagedDir)).toBe(true);
+    });
+});

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

@@ -0,0 +1,42 @@
+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>;

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

@@ -0,0 +1,150 @@
+import { readdir, readFile } from 'node:fs/promises';
+import { join, relative } from 'node:path';
+import { parse as parseYaml } from 'yaml';
+const YAML_EXT_RE = /\.(ya?ml)$/i;
+async function collectYamlFiles(stagedDir) {
+    const entries = await readdir(stagedDir, { withFileTypes: true, recursive: true });
+    const paths = [];
+    for (const entry of entries) {
+        if (!entry.isFile() || !YAML_EXT_RE.test(entry.name)) {
+            continue;
+        }
+        const abs = join(entry.parentPath, entry.name);
+        paths.push(relative(stagedDir, abs));
+    }
+    paths.sort();
+    return paths;
+}
+function asStringArray(value) {
+    if (Array.isArray(value)) {
+        return value.filter((v) => typeof v === 'string');
+    }
+    if (typeof value === 'string') {
+        return [value];
+    }
+    return [];
+}
+/** Extract `ref('x')` / `source('s','t')` / literal from a MetricFlow `model:` field. */
+function 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;
+}
+function extractMeasureFromInput(input) {
+    if (typeof input === 'string') {
+        return input;
+    }
+    if (input && typeof input === 'object' && 'name' in input && typeof input.name === 'string') {
+        return input.name;
+    }
+    return null;
+}
+function extractReferencedMetricNames(m) {
+    const tp = m.type_params ?? {};
+    const names = [];
+    for (const ref of tp.metrics ?? []) {
+        if (ref && typeof ref.name === 'string') {
+            names.push(ref.name);
+        }
+    }
+    const num = extractMeasureFromInput(tp.numerator);
+    const den = extractMeasureFromInput(tp.denominator);
+    if (num) {
+        names.push(num);
+    }
+    if (den) {
+        names.push(den);
+    }
+    return [...new Set(names)].sort();
+}
+function parseSemanticModel(sm, path) {
+    if (typeof sm.name !== 'string') {
+        return null;
+    }
+    const entities = (sm.entities ?? []).filter((e) => e && typeof e.name === 'string');
+    const primaryEntities = entities
+        .filter((e) => e.type === 'primary' || e.type === 'unique')
+        .map((e) => e.name)
+        .sort();
+    const foreignEntities = entities
+        .filter((e) => e.type === 'foreign')
+        .map((e) => e.name)
+        .sort();
+    const entityNames = entities.map((e) => e.name).sort();
+    const measureNames = (sm.measures ?? []).filter((m) => m && typeof m.name === 'string')
+        .map((m) => m.name)
+        .sort();
+    const dimensionNames = (sm.dimensions ?? []).filter((d) => d && typeof d.name === 'string')
+        .map((d) => d.name)
+        .sort();
+    const modelRef = typeof sm.model === 'string' ? extractModelRef(sm.model) : '';
+    const extendsFrom = asStringArray(sm.extends);
+    const defaultTimeDimension = typeof sm.defaults?.agg_time_dimension === 'string' ? sm.defaults.agg_time_dimension : null;
+    return {
+        path,
+        name: sm.name,
+        modelRef,
+        extendsFrom,
+        measureNames,
+        dimensionNames,
+        entityNames,
+        primaryEntities,
+        foreignEntities,
+        defaultTimeDimension,
+    };
+}
+function parseMetric(m, path) {
+    if (typeof m.name !== 'string') {
+        return null;
+    }
+    const typeStr = typeof m.type === 'string' ? m.type : '';
+    const ALLOWED = ['simple', 'derived', 'cumulative', 'ratio', 'conversion'];
+    if (!ALLOWED.includes(typeStr)) {
+        return null;
+    }
+    const type = typeStr;
+    const measureRef = type === 'simple' || type === 'cumulative' ? extractMeasureFromInput(m.type_params?.measure) : null;
+    const dependsOn = extractReferencedMetricNames(m);
+    return { path, name: m.name, type, measureRef, dependsOn };
+}
+export async function parseMetricFlowStagedDir(stagedDir) {
+    const allPaths = await collectYamlFiles(stagedDir);
+    const semanticModels = [];
+    const metrics = [];
+    const files = [];
+    for (const path of allPaths) {
+        const body = await readFile(join(stagedDir, path), 'utf-8');
+        files.push({ path, content: body });
+        let yaml;
+        try {
+            yaml = parseYaml(body);
+        }
+        catch {
+            yaml = null;
+        }
+        if (!yaml || typeof yaml !== 'object') {
+            continue;
+        }
+        for (const sm of yaml.semantic_models ?? []) {
+            const parsed = parseSemanticModel(sm, path);
+            if (parsed) {
+                semanticModels.push(parsed);
+            }
+        }
+        for (const m of yaml.metrics ?? []) {
+            const parsed = parseMetric(m, path);
+            if (parsed) {
+                metrics.push(parsed);
+            }
+        }
+    }
+    semanticModels.sort((a, b) => a.name.localeCompare(b.name) || a.path.localeCompare(b.path));
+    metrics.sort((a, b) => a.name.localeCompare(b.name) || a.path.localeCompare(b.path));
+    return { semanticModels, metrics, allPaths, files };
+}

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

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