@kaelio/ktx 0.0.0 → 0.1.0-rc.0

package/node_modules/@ktx/context/dist/ingest/dbt-shared/project-vars.test.js

@@ -0,0 +1,90 @@
+import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { loadProjectInfo, parseProjectName, parseProjectVars, resolveJinjaVariables, } from './project-vars.js';
+function entries(map) {
+    return Object.fromEntries([...map.entries()].sort(([a], [b]) => a.localeCompare(b)));
+}
+describe('dbt-shared project vars', () => {
+    let tmpRoot;
+    beforeEach(async () => {
+        tmpRoot = await mkdtemp(join(tmpdir(), 'dbt-project-vars-'));
+    });
+    afterEach(async () => {
+        await rm(tmpRoot, { recursive: true, force: true });
+    });
+    it('extracts top-level vars, nested dotted vars, and scalar values only', () => {
+        const vars = parseProjectVars(`
+name: revenue_project
+vars:
+  database: analytics
+  enabled: true
+  threads: 4
+  ignored_list:
+    - a
+  ignored_null:
+  pkg:
+    region: us
+    fiscal_year: 2026
+`);
+        expect(entries(vars)).toEqual({
+            database: 'analytics',
+            enabled: 'true',
+            'pkg.fiscal_year': '2026',
+            'pkg.region': 'us',
+            threads: '4',
+        });
+    });
+    it('returns an empty variable map for missing vars, malformed YAML, arrays, and scalar documents', () => {
+        expect(entries(parseProjectVars('name: no_vars\n'))).toEqual({});
+        expect(entries(parseProjectVars('{{{{ invalid yaml'))).toEqual({});
+        expect(entries(parseProjectVars('- just\n- a\n- list\n'))).toEqual({});
+    });
+    it('extracts a string project name and returns null for invalid or missing names', () => {
+        expect(parseProjectName('name: revenue_project\n')).toBe('revenue_project');
+        expect(parseProjectName('version: 1\n')).toBeNull();
+        expect(parseProjectName('{{{{ invalid yaml')).toBeNull();
+        expect(parseProjectName('name: 42\n')).toBeNull();
+    });
+    it('resolves exact var names, honors defaults, and reports unresolved names without throwing', () => {
+        const variables = new Map([
+            ['database', 'analytics'],
+            ['pkg.region', 'us'],
+        ]);
+        const result = resolveJinjaVariables([
+            'database: "{{ var(\'database\') }}"',
+            'region: "{{ var("pkg.region") }}"',
+            'schema: "{{ var(\'schema\', \'public\') }}"',
+            'missing: "{{ var(\'missing\') }}"',
+        ].join('\n'), variables);
+        expect(result.content).toContain('database: "analytics"');
+        expect(result.content).toContain('region: "us"');
+        expect(result.content).toContain('schema: "public"');
+        expect(result.content).toContain('missing: "{{ var(\'missing\') }}"');
+        expect(result.unresolvedVars).toEqual(['missing']);
+    });
+    it('keeps package-scoped variables exact and does not resolve by suffix', () => {
+        const variables = parseProjectVars(`
+vars:
+  pkg:
+    database: package_db
+`);
+        const result = resolveJinjaVariables('database: "{{ var(\'database\', \'fallback_db\') }}"\npackage_database: "{{ var(\'pkg.database\') }}"\n', variables);
+        expect(result.content).toContain('database: "fallback_db"');
+        expect(result.content).toContain('package_database: "package_db"');
+        expect(result.unresolvedVars).toEqual([]);
+    });
+    it('loads dbt_project.yml before dbt_project.yaml and falls back to an empty project info object', async () => {
+        const projectDir = join(tmpRoot, 'project');
+        await mkdir(projectDir, { recursive: true });
+        await writeFile(join(projectDir, 'dbt_project.yaml'), 'name: yaml_project\nvars:\n  database: yaml_db\n');
+        await writeFile(join(projectDir, 'dbt_project.yml'), 'name: yml_project\nvars:\n  database: yml_db\n');
+        const loaded = await loadProjectInfo(projectDir);
+        expect(loaded.projectName).toBe('yml_project');
+        expect(entries(loaded.variables)).toEqual({ database: 'yml_db' });
+        const missing = await loadProjectInfo(join(tmpRoot, 'missing'));
+        expect(missing.projectName).toBeNull();
+        expect(entries(missing.variables)).toEqual({});
+    });
+});

package/node_modules/@ktx/context/dist/ingest/dbt-shared/schema-files.d.ts

@@ -0,0 +1,3 @@
+import type { DbtSchemaFile } from '../adapters/dbt-descriptions/parse-schema.js';
+export declare function loadDbtSchemaFiles(projectDir: string): Promise<DbtSchemaFile[]>;
+export declare function findDbtSchemaFiles(projectDir: string): Promise<string[]>;

package/node_modules/@ktx/context/dist/ingest/dbt-shared/schema-files.js

@@ -0,0 +1,62 @@
+import { promises as fs } from 'node:fs';
+import { join, relative } from 'node:path';
+const DBT_SCHEMA_SEARCH_DIRS = ['models', 'seeds', 'snapshots', 'analyses', '.'];
+const DBT_CONFIG_YAML_FILES = new Set([
+    'dbt_project.yml',
+    'dbt_project.yaml',
+    'packages.yml',
+    'packages.yaml',
+    'selectors.yml',
+    'selectors.yaml',
+]);
+export async function loadDbtSchemaFiles(projectDir) {
+    const schemaFiles = await findDbtSchemaFiles(projectDir);
+    return Promise.all(schemaFiles.map(async (filePath) => ({
+        content: await fs.readFile(filePath, 'utf-8'),
+        path: relative(projectDir, filePath),
+    })));
+}
+export async function findDbtSchemaFiles(projectDir) {
+    const schemaFiles = [];
+    for (const dir of DBT_SCHEMA_SEARCH_DIRS) {
+        const searchPath = join(projectDir, dir);
+        try {
+            await fs.access(searchPath);
+            schemaFiles.push(...(await findYamlFilesRecursive(searchPath)));
+        }
+        catch {
+            // Missing dbt search directories are normal.
+        }
+    }
+    return [...new Set(schemaFiles)].sort();
+}
+async function findYamlFilesRecursive(dir) {
+    const files = [];
+    let entries;
+    try {
+        entries = await fs.readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        return files;
+    }
+    for (const entry of entries) {
+        const fullPath = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            if (!entry.name.startsWith('.') && entry.name !== 'node_modules') {
+                files.push(...(await findYamlFilesRecursive(fullPath)));
+            }
+            continue;
+        }
+        if (!entry.isFile()) {
+            continue;
+        }
+        const name = entry.name.toLowerCase();
+        if (DBT_CONFIG_YAML_FILES.has(name)) {
+            continue;
+        }
+        if (name.endsWith('.yml') || name.endsWith('.yaml')) {
+            files.push(fullPath);
+        }
+    }
+    return files;
+}

package/node_modules/@ktx/context/dist/ingest/dbt-shared/schema-files.test.d.ts

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

package/node_modules/@ktx/context/dist/ingest/dbt-shared/schema-files.test.js

@@ -0,0 +1,35 @@
+import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { findDbtSchemaFiles, loadDbtSchemaFiles } from './schema-files.js';
+describe('dbt shared schema files', () => {
+    let tmpRoot;
+    beforeEach(async () => {
+        tmpRoot = await mkdtemp(join(tmpdir(), 'dbt-schema-files-'));
+    });
+    afterEach(async () => {
+        await rm(tmpRoot, { recursive: true, force: true });
+    });
+    it('loads schema yaml files from dbt search directories and skips project config files', async () => {
+        await mkdir(join(tmpRoot, 'models', 'nested'), { recursive: true });
+        await mkdir(join(tmpRoot, 'seeds'), { recursive: true });
+        await writeFile(join(tmpRoot, 'dbt_project.yml'), 'name: ignored\n');
+        await writeFile(join(tmpRoot, 'packages.yml'), 'packages: []\n');
+        await writeFile(join(tmpRoot, 'models', 'schema.yml'), 'version: 2\nmodels: []\n');
+        await writeFile(join(tmpRoot, 'models', 'nested', 'customers.yaml'), 'version: 2\nmodels: []\n');
+        await writeFile(join(tmpRoot, 'seeds', 'seed.yml'), 'version: 2\nseeds: []\n');
+        const paths = await findDbtSchemaFiles(tmpRoot);
+        expect(paths.map((path) => path.replace(`${tmpRoot}/`, '')).sort()).toEqual([
+            'models/nested/customers.yaml',
+            'models/schema.yml',
+            'seeds/seed.yml',
+        ]);
+        const files = await loadDbtSchemaFiles(tmpRoot);
+        expect(files.map((file) => file.path).sort()).toEqual([
+            'models/nested/customers.yaml',
+            'models/schema.yml',
+            'seeds/seed.yml',
+        ]);
+    });
+});

package/node_modules/@ktx/context/dist/ingest/diff-set.service.d.ts

@@ -0,0 +1,8 @@
+import type { IngestProvenancePort } from './ports.js';
+import type { DiffSet } from './types.js';
+export declare function computeDiffSetFromHashes(currentHashes: Map<string, string>, priorHashesRaw: Map<string, string>, isPathInScope?: (rawPath: string) => boolean): DiffSet;
+export declare class DiffSetService {
+    private readonly provenance;
+    constructor(provenance: IngestProvenancePort);
+    compute(connectionId: string, sourceKey: string, currentHashes: Map<string, string>, isPathInScope?: (rawPath: string) => boolean): Promise<DiffSet>;
+}

package/node_modules/@ktx/context/dist/ingest/diff-set.service.js

@@ -0,0 +1,41 @@
+export function computeDiffSetFromHashes(currentHashes, priorHashesRaw, isPathInScope) {
+    const priorHashes = isPathInScope
+        ? new Map([...priorHashesRaw].filter(([path]) => isPathInScope(path)))
+        : priorHashesRaw;
+    const added = [];
+    const modified = [];
+    const unchanged = [];
+    const deleted = [];
+    for (const [path, hash] of currentHashes) {
+        const prior = priorHashes.get(path);
+        if (prior === undefined) {
+            added.push(path);
+        }
+        else if (prior === hash) {
+            unchanged.push(path);
+        }
+        else {
+            modified.push(path);
+        }
+    }
+    for (const path of priorHashes.keys()) {
+        if (!currentHashes.has(path)) {
+            deleted.push(path);
+        }
+    }
+    added.sort();
+    modified.sort();
+    unchanged.sort();
+    deleted.sort();
+    return { added, modified, unchanged, deleted };
+}
+export class DiffSetService {
+    provenance;
+    constructor(provenance) {
+        this.provenance = provenance;
+    }
+    async compute(connectionId, sourceKey, currentHashes, isPathInScope) {
+        const priorHashes = await this.provenance.findLatestHashesForCompletedSyncs(connectionId, sourceKey);
+        return computeDiffSetFromHashes(currentHashes, priorHashes, isPathInScope);
+    }
+}

package/node_modules/@ktx/context/dist/ingest/diff-set.service.test.d.ts

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

package/node_modules/@ktx/context/dist/ingest/diff-set.service.test.js

@@ -0,0 +1,132 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { computeDiffSetFromHashes, DiffSetService } from './diff-set.service.js';
+function makeRepo(latest) {
+    return {
+        findLatestHashesForCompletedSyncs: () => Promise.resolve(latest),
+    };
+}
+describe('DiffSetService', () => {
+    let service;
+    const provenanceRepo = { findLatestHashesForCompletedSyncs: vi.fn() };
+    beforeEach(() => {
+        vi.clearAllMocks();
+        service = new DiffSetService(provenanceRepo);
+    });
+    it('first run — no prior completed run — everything is added', async () => {
+        provenanceRepo.findLatestHashesForCompletedSyncs.mockResolvedValue(new Map());
+        const diff = await service.compute('c1', 'fake', new Map([
+            ['a.yml', 'h1'],
+            ['b.yml', 'h2'],
+        ]));
+        expect(diff.added.sort()).toEqual(['a.yml', 'b.yml']);
+        expect(diff.modified).toEqual([]);
+        expect(diff.deleted).toEqual([]);
+        expect(diff.unchanged).toEqual([]);
+    });
+    it('classifies added / modified / deleted / unchanged against the latest-hash baseline', async () => {
+        provenanceRepo.findLatestHashesForCompletedSyncs.mockResolvedValue(new Map([
+            ['a.yml', 'h1'],
+            ['b.yml', 'h_old'],
+            ['c.yml', 'hc'],
+        ]));
+        const now = new Map([
+            ['a.yml', 'h1'],
+            ['b.yml', 'h_new'],
+            ['d.yml', 'hd'],
+        ]);
+        const diff = await service.compute('c1', 'fake', now);
+        expect(diff.unchanged).toEqual(['a.yml']);
+        expect(diff.modified).toEqual(['b.yml']);
+        expect(diff.deleted).toEqual(['c.yml']);
+        expect(diff.added).toEqual(['d.yml']);
+    });
+    it('computes a pure diff from current and prior hash maps', () => {
+        const diff = computeDiffSetFromHashes(new Map([
+            ['a.yml', 'h1'],
+            ['b.yml', 'h2-new'],
+            ['d.yml', 'h4'],
+        ]), new Map([
+            ['a.yml', 'h1'],
+            ['b.yml', 'h2-old'],
+            ['c.yml', 'h3'],
+        ]));
+        expect(diff).toEqual({
+            added: ['d.yml'],
+            modified: ['b.yml'],
+            deleted: ['c.yml'],
+            unchanged: ['a.yml'],
+        });
+    });
+    it('returns sorted arrays for deterministic hashing', async () => {
+        provenanceRepo.findLatestHashesForCompletedSyncs.mockResolvedValue(new Map());
+        const diff = await service.compute('c1', 'fake', new Map([
+            ['z.yml', 'hz'],
+            ['a.yml', 'ha'],
+        ]));
+        expect(diff.added).toEqual(['a.yml', 'z.yml']);
+    });
+    it('with isPathInScope predicate, out-of-scope prior entries are not reported as deleted', async () => {
+        const prior = new Map([
+            ['cards/1.json', 'hashA'],
+            ['cards/2.json', 'hashB'],
+            ['cards/3.json', 'hashC'],
+        ]);
+        const current = new Map([
+            ['cards/1.json', 'hashA'],
+            ['cards/2.json', 'hashB'],
+        ]);
+        const inScope = new Set(['cards/1.json', 'cards/2.json']);
+        const svc = new DiffSetService(makeRepo(prior));
+        const diff = await svc.compute('conn', 'metabase', current, (p) => inScope.has(p));
+        expect(diff.deleted).toEqual([]);
+        expect(diff.unchanged).toEqual(['cards/1.json', 'cards/2.json']);
+    });
+    it('with isPathInScope predicate, in-scope deletions are still reported', async () => {
+        const prior = new Map([
+            ['cards/1.json', 'hashA'],
+            ['cards/2.json', 'hashB'],
+        ]);
+        const current = new Map([['cards/1.json', 'hashA']]);
+        const inScope = new Set(['cards/1.json', 'cards/2.json']);
+        const svc = new DiffSetService(makeRepo(prior));
+        const diff = await svc.compute('conn', 'metabase', current, (p) => inScope.has(p));
+        expect(diff.deleted).toEqual(['cards/2.json']);
+    });
+    it('holds unchanged baseline across multiple incremental re-syncs (regression for skipped-row sync_id drift)', async () => {
+        // After sync 1 wrote (a.yml, h1, sync=S1, skipped) and sync 2 computed a no-op,
+        // sync 3 must still see a.yml as unchanged — the baseline comes from S1, not from
+        // the most recent sync_id alone.
+        provenanceRepo.findLatestHashesForCompletedSyncs.mockResolvedValue(new Map([
+            ['a.yml', 'h1'],
+            ['b.yml', 'h2'],
+        ]));
+        const diff = await service.compute('c1', 'fake', new Map([
+            ['a.yml', 'h1'],
+            ['b.yml', 'h2'],
+        ]));
+        expect(diff.added).toEqual([]);
+        expect(diff.unchanged).toEqual(['a.yml', 'b.yml']);
+    });
+});
+describe('DiffSetService — scope-narrowing scenario', () => {
+    it('scope from [1,2,3] → [1,2] leaves no spurious deletions', async () => {
+        const prior = new Map([
+            ['cards/1.json', 'hashA'],
+            ['cards/2.json', 'hashB'],
+            ['cards/3.json', 'hashC'],
+            ['sync-config.json', 'hashCfg'],
+        ]);
+        const current = new Map([
+            ['cards/1.json', 'hashA'],
+            ['cards/2.json', 'hashB'],
+            ['sync-config.json', 'hashCfg2'],
+        ]);
+        const inScope = new Set(['cards/1.json', 'cards/2.json', 'sync-config.json']);
+        const svc = new DiffSetService(makeRepo(prior));
+        const diff = await svc.compute('conn', 'metabase', current, (p) => inScope.has(p));
+        expect(diff.deleted).toEqual([]);
+        expect(diff.modified).toEqual(['sync-config.json']);
+        expect(diff.unchanged).toEqual(['cards/1.json', 'cards/2.json']);
+        expect(diff.added).toEqual([]);
+    });
+});

package/node_modules/@ktx/context/dist/ingest/git-env.d.ts

@@ -0,0 +1,2 @@
+import { type SimpleGit } from 'simple-git';
+export declare function createSimpleGit(baseDir?: string): SimpleGit;

package/node_modules/@ktx/context/dist/ingest/git-env.js

@@ -0,0 +1,18 @@
+import { simpleGit } from 'simple-git';
+const PRE_COMMIT_GIT_ENV = [
+    'GIT_ALTERNATE_OBJECT_DIRECTORIES',
+    'GIT_CONFIG_COUNT',
+    'GIT_CONFIG_PARAMETERS',
+    'GIT_DIR',
+    'GIT_EXEC_PATH',
+    'GIT_INDEX_FILE',
+    'GIT_PREFIX',
+    'GIT_WORK_TREE',
+];
+export function createSimpleGit(baseDir) {
+    const env = { ...process.env };
+    for (const key of PRE_COMMIT_GIT_ENV) {
+        delete env[key];
+    }
+    return simpleGit(baseDir).env(env);
+}

package/node_modules/@ktx/context/dist/ingest/index.d.ts

@@ -0,0 +1,139 @@
+export { DbtSourceAdapter } from './adapters/dbt/dbt.adapter.js';
+export { FakeSourceAdapter } from './adapters/fake/fake.adapter.js';
+export type { DaemonLiveDatabaseIntrospectionOptions, KtxDaemonDatabaseHttpJsonRunner, KtxDaemonDatabaseIntrospectionCommand, KtxDaemonDatabaseJsonRunner, } from './adapters/live-database/daemon-introspection.js';
+export { createDaemonLiveDatabaseIntrospection } from './adapters/live-database/daemon-introspection.js';
+export type { LiveDatabaseExtractedColumn, LiveDatabaseExtractedForeignKey, LiveDatabaseExtractedSchema, LiveDatabaseExtractedTable, } from './adapters/live-database/extracted-schema.js';
+export { buildLiveDatabaseTableNaturalKey, ktxSchemaSnapshotToExtractedSchema, } from './adapters/live-database/extracted-schema.js';
+export { LiveDatabaseSourceAdapter } from './adapters/live-database/live-database.adapter.js';
+export type { BuildLiveDatabaseManifestShardsInput, BuildLiveDatabaseManifestShardsResult, LiveDatabaseManifestColumn, LiveDatabaseManifestExistingDescriptions, LiveDatabaseManifestJoinData, LiveDatabaseManifestJoinEntry, LiveDatabaseManifestShard, LiveDatabaseManifestTableData, LiveDatabaseManifestTableEntry, } from './adapters/live-database/manifest.js';
+export { buildLiveDatabaseManifestShards } from './adapters/live-database/manifest.js';
+export type { LiveDatabaseStructuralChanges, LiveDatabaseStructuralSyncOperations, LiveDatabaseStructuralSyncPlan, LiveDatabaseStructuralSyncStats, LiveDatabaseSyncedColumn, LiveDatabaseSyncedLink, LiveDatabaseSyncedSchema, LiveDatabaseSyncedTable, PlanLiveDatabaseStructuralSyncInput, } from './adapters/live-database/structural-sync.js';
+export { planLiveDatabaseStructuralSync } from './adapters/live-database/structural-sync.js';
+export type { LiveDatabaseIntrospectionPort, LiveDatabaseSourceAdapterDeps, } from './adapters/live-database/types.js';
+export { getLookerTriageSignals, writeLookerEvidenceDocuments } from './adapters/looker/evidence-documents.js';
+export { LookerClient } from './adapters/looker/client.js';
+export type { LookerClientDeps, LookerClientLogger, LookerConnectionParams, LookerSdkPort, LookerWarehouseConnectionInfo, TestConnectionResult as LookerTestConnectionResult, } from './adapters/looker/client.js';
+export type { LookerClientFactory, LookerEntityRef, LookerRuntimeClient, } from './adapters/looker/fetch.js';
+export { DefaultLookerClientFactory, DefaultLookerConnectionClientFactory, } from './adapters/looker/factory.js';
+export { createDaemonLookerTableIdentifierParser, type DaemonLookerTableIdentifierParserOptions, type KtxDaemonTableIdentifierHttpJsonRunner, } from './adapters/looker/daemon-table-identifier-parser.js';
+export type { LookerConnectionClientFactory, LookerCredentialResolver, } from './adapters/looker/factory.js';
+export { createLocalLookerCredentialResolver, createLocalLookerSourceAdapter, lookerCredentialsFromLocalConnection, } from './adapters/looker/local-looker.adapter.js';
+export { LocalLookerRuntimeStore, type ClearLocalLookerMappingsInput, type LocalLookerConnectionMappingListRow, type LocalLookerMappingSource, type LookerSourceStateReader, type RefreshLocalLookerDiscoveredConnectionsInput, type UpsertLocalLookerConnectionMappingInput, } from './adapters/looker/local-runtime-store.js';
+export { LOOKER_DIALECT_TO_CONNECTION_TYPE, buildLookerPullConfigFromInputs, collectExploreParseItems, computeLookerMappingDrift, discoverLookerConnections, extractWarehouseDatabase, extractWarehouseHost, lookerDialectToConnectionType, normalizeHost, normalizeName, projectParsedIdentifier, refreshLookerMappingPlaceholders, sqlglotDialectForConnectionType, suggestKtxConnectionForLookerConnection, validateLookerMappings, validateLookerWarehouseTarget, } from './adapters/looker/mapping.js';
+export type { LookerConnectionMapping as KtxLookerConnectionMapping, LookerMappingCandidateConnection, LookerMappingClient, LookerMappingDrift, LookerMappingValidationResult, LookerParsedIdentifier, LookerTableIdentifierParseItem, LookerTableIdentifierParser, LookerTargetConnection, LookerWarehouseTargetConnectionType, } from './adapters/looker/mapping.js';
+export { readLookerFetchReport, writeLookerFetchReport, } from './adapters/looker/fetch-report.js';
+export { LookerSourceAdapter, type LookerSourceAdapterDeps } from './adapters/looker/looker.adapter.js';
+export { describeLookerScope, hashLookerScope, isPathInLookerScope, readLookerScope, } from './adapters/looker/scope.js';
+export type { LookerQueryToSlInput, LookerSlFieldProposal, LookerSlMeasureProposal, LookerSlProposal, LookerSlSegmentProposal, } from './adapters/looker/tools/looker-query-to-sl.tool.js';
+export { buildLookerSlProposal, createLookerQueryToSlTool, formatLookerSlProposal, lookerQueryToSlInputSchema, } from './adapters/looker/tools/looker-query-to-sl.tool.js';
+export type { LookerPullConfig, LookerRuntimeCursors, StagedDashboardFile, StagedExploreFile, StagedFoldersTreeFile, StagedGroupFile, StagedLookerFetchIssue, StagedLookerFetchReport, StagedLookerQuery, StagedLookerScopeFile, StagedLookerSignalsFile, StagedLookFile, StagedLookmlModelsFile, StagedUserFile, } from './adapters/looker/types.js';
+export { lookerConnectionIdSchema, lookerRuntimeCursorsSchema, stagedLookerFetchIssueSchema, stagedLookerFetchReportSchema, stagedLookerScopeFileSchema, stagedSyncConfigSchema, } from './adapters/looker/types.js';
+export { LookmlSourceAdapter } from './adapters/lookml/lookml.adapter.js';
+export { parseLookmlStagedDir } from './adapters/lookml/parse.js';
+export type { ParsedLookmlProject } from './adapters/lookml/parse.js';
+export { DEFAULT_METABASE_CLIENT_CONFIG, DefaultMetabaseConnectionClientFactory, MetabaseClient, getDummyValueForWidgetType, stripOptionalClauses, } from './adapters/metabase/client.js';
+export { CardReferenceCycleError, expandCardReferences } from './adapters/metabase/card-references.js';
+export { IngestMetabaseClientFactory } from './adapters/metabase/client-port.js';
+export type { MetabaseClientLogger } from './adapters/metabase/client.js';
+export type { MetabaseCard, MetabaseCardSummary, MetabaseClientConfig, MetabaseClientFactory, MetabaseClientRuntimeConfig, MetabaseCollection, MetabaseCollectionItem, MetabaseConnectionClientFactory, MetabaseDatabase, MetabaseDatasetQuery, MetabaseNativeQueryResult, MetabaseParameter, MetabaseResolvedTemplateTag, MetabaseResultMetadataColumn, MetabaseRuntimeClient, MetabaseTemplateTag, MetabaseUser, ResolvedSqlResult, TestConnectionResult, } from './adapters/metabase/client-port.js';
+export type { MetabaseSourceState, MetabaseSourceStateMapping, MetabaseSourceStateReader, MetabaseSourceStateSelection, } from './adapters/metabase/source-state-port.js';
+export { METABASE_ENGINE_TO_CONNECTION_TYPE, computeMetabaseMappingDrift, computeMetabaseMappingPhysicalMismatches, discoverMetabaseDatabases, findBestMatch, refreshMetabaseMapping, validateMappingPhysicalMatch, validateMetabaseMappings, } from './adapters/metabase/mapping.js';
+export type { AutoMatchCandidate, AutoMatchResult as MetabaseAutoMatchResult, DiscoveredMetabaseDatabase, KtxConnectionPhysicalInfo, MappingPhysicalInfo, MappingRefreshReport, MetabaseMappedConnectionType, MetabaseMappingDrift, MetabaseMappingValidationResult, PhysicalMismatch, PhysicalMismatchInput, } from './adapters/metabase/mapping.js';
+export { planMetabaseFanoutChildren } from './adapters/metabase/fanout-planner.js';
+export type { MetabaseFanoutChildPlan, MetabaseFanoutMappingInput, PlanMetabaseFanoutChildrenInput, } from './adapters/metabase/fanout-planner.js';
+export { MetabaseSourceAdapter } from './adapters/metabase/metabase.adapter.js';
+export { createLocalMetabaseSourceAdapter, metabaseRuntimeConfigFromLocalConnection, } from './adapters/metabase/local-metabase.adapter.js';
+export { LocalMetabaseSourceStateReader } from './adapters/metabase/local-source-state-store.js';
+export type { ClearLocalMetabaseMappingsInput, LocalMetabaseMappingListRow, LocalMetabaseMappingSource, LocalMetabaseSourceStateMappingInput, ReplaceLocalMetabaseSourceStateInput, RefreshLocalMetabaseDiscoveredDatabasesInput, SetLocalMetabaseMappingSyncEnabledInput, SetLocalMetabaseSyncStateInput, UpsertLocalMetabaseDatabaseMappingInput, } from './adapters/metabase/local-source-state-store.js';
+export { metabaseLocalConnectionIdSchema, metabasePullConfigSchema, parseMetabasePullConfig } from './adapters/metabase/types.js';
+export type { MetabasePullConfig, MetabaseSyncMode } from './adapters/metabase/types.js';
+export { fetchMetricflowRepo, } from './adapters/metricflow/fetch.js';
+export type { FetchMetricflowRepoParams, FetchMetricflowRepoResult } from './adapters/metricflow/fetch.js';
+export { parseMetricflowFiles, translateMetricflowJinjaFilter, } from './adapters/metricflow/deep-parse.js';
+export type { DimensionDefinition, MeasureDefinition, MetricFlowParseResult, MetricflowParseOptions, ParsedCrossModelMetric, ParsedMetricflowRelationship, ParsedSemanticModel, SimpleMeasureDefinition, } from './adapters/metricflow/deep-parse.js';
+export { buildMetricflowColumns, buildMetricflowJoinsForModel, buildMetricflowMeasures, buildMetricflowSemanticModelSource, countImportableMetricflowRelationships, filterValidMetricflowRelationships, findMatchingMetricflowTable, getMetricflowAvailableColumnNames, mapCrossModelMetricToSource, mapSemanticModelToSource, normalizeMetricflowJoinOn, parseMetricflowJoinReference, resolveMetricflowSemanticModelSourceName, rewriteMetricflowJoinOn, rewriteMetricflowManifestJoins, toKebabCaseMetricflowName, } from './adapters/metricflow/semantic-models.js';
+export { importMetricflowSemanticModels } from './adapters/metricflow/import-semantic-models.js';
+export type { ImportMetricflowSemanticModelsDeps, ImportMetricflowSemanticModelsInput, MetricFlowImportResult, MetricflowSemanticLayerService, MetricflowSemanticLayerWriter, } from './adapters/metricflow/import-semantic-models.js';
+export type { MetricflowHostTable, MetricflowSemanticModelImportContext, MetricflowSemanticModelJoin, MetricflowWritableSemanticLayerSource, } from './adapters/metricflow/semantic-models.js';
+export { MetricflowSourceAdapter, type MetricflowSourceAdapterDeps } from './adapters/metricflow/metricflow.adapter.js';
+export { metricflowPullConfigSchema, parseMetricflowPullConfig, pullConfigFromMetricflowIntegration, } from './adapters/metricflow/pull-config.js';
+export type { MetricflowIntegrationLike, MetricflowPullConfig, } from './adapters/metricflow/pull-config.js';
+export { NOTION_ORG_KNOWLEDGE_WARNING } from './adapters/notion/chunk.js';
+export { NotionSourceAdapter, type NotionSourceAdapterDeps } from './adapters/notion/notion.adapter.js';
+export { NotionClient, type NotionApi, type NotionBotInfo } from './adapters/notion/notion-client.js';
+export { chunkHistoricSqlStagedDir, describeHistoricSqlScope } from './adapters/historic-sql/chunk.js';
+export { detectHistoricSqlStagedDir } from './adapters/historic-sql/detect.js';
+export { HistoricSqlExtensionMissingError, HistoricSqlGrantsMissingError, HistoricSqlVersionUnsupportedError, } from './adapters/historic-sql/errors.js';
+export { HistoricSqlSourceAdapter } from './adapters/historic-sql/historic-sql.adapter.js';
+export { BigQueryHistoricSqlQueryHistoryReader } from './adapters/historic-sql/bigquery-query-history-reader.js';
+export type { BigQueryHistoricSqlQueryHistoryReaderOptions } from './adapters/historic-sql/bigquery-query-history-reader.js';
+export { PostgresPgssQueryHistoryReader } from './adapters/historic-sql/postgres-pgss-query-history-reader.js';
+export { SnowflakeHistoricSqlQueryHistoryReader } from './adapters/historic-sql/snowflake-query-history-reader.js';
+export { stageHistoricSqlTemplates } from './adapters/historic-sql/stage.js';
+export { pgssBaselinePath, readPgssBaseline, stagePgStatStatementsTemplates, writePgssBaselineAtomic, } from './adapters/historic-sql/stage-pgss.js';
+export type { PgssBaseline, StagePgStatStatementsTemplatesResult } from './adapters/historic-sql/stage-pgss.js';
+export type { HistoricSqlDialect, HistoricSqlManifest, HistoricSqlMetadata, HistoricSqlPullConfig, HistoricSqlQueryHistoryReader, HistoricSqlRawQueryRow, HistoricSqlSourceAdapterDeps, HistoricSqlTimeWindow, HistoricSqlUsage, KtxPostgresQueryClient, PostgresPgssAggregateRow, PostgresPgssProbeResult, PostgresPgssReader, PostgresPgssRow, PostgresPgssSnapshot, } from './adapters/historic-sql/types.js';
+export { HISTORIC_SQL_OBJECT_TYPE, HISTORIC_SQL_SOURCE_KEY, historicSqlManifestSchema, historicSqlMetadataSchema, historicSqlPullConfigSchema, historicSqlRawQueryRowSchema, historicSqlUsageSchema, } from './adapters/historic-sql/types.js';
+export type { CanonicalPin } from './canonical-pins.js';
+export { buildCanonicalPinsPromptBlock, selectRelevantCanonicalPins } from './canonical-pins.js';
+export type { BudgetExhaustedCandidateForCarryForward, CandidateDedupServiceDeps, CandidateDedupSettings, ContextCandidateActionHint, ContextCandidateCarryforwardArgs, ContextCandidateCarryforwardResult, ContextCandidateCarryforwardServiceDeps, ContextCandidateCarryforwardSettings, ContextCandidateEmbeddingPort, ContextCandidateForPrompt, ContextCandidateLane, ContextCandidateRejectionReason, ContextCandidateScoreAggregation, ContextCandidateStatus, ContextCandidateStorePort, ContextCandidateVerdictSummary, CuratorPaginationInput, CuratorPaginationServiceDeps, CuratorPaginationSettings, CurrentRunEvidenceChunkForCarryForward, InsertContextCandidateInput, MarkContextCandidateClusterInput, } from './context-candidates/index.js';
+export { buildContextCandidateEmbeddingText, CandidateDedupService, ContextCandidateCarryforwardService, CuratorPaginationService, } from './context-candidates/index.js';
+export type { ContextEvidenceDocumentRef, ContextEvidenceEmbeddingPort, ContextEvidenceIndexStorePort, ContextEvidenceIndexSummary as PackageContextEvidenceIndexSummary, EvidencePublishState, ReplaceContextEvidenceChunk, SqliteContextEvidenceStoreOptions, UpsertContextEvidenceDocument, } from './context-evidence/index.js';
+export { ContextEvidenceIndexService, SqliteContextEvidenceStore, } from './context-evidence/index.js';
+export { DiffSetService } from './diff-set.service.js';
+export { IngestBundleRunner } from './ingest-bundle.runner.js';
+export type { DefaultLocalIngestAdaptersOptions } from './local-adapters.js';
+export { createDefaultLocalIngestAdapters, localPullConfigForAdapter } from './local-adapters.js';
+export type { LocalIngestMcpOptions, LocalIngestResult, LocalMetabaseFanoutChild, LocalMetabaseFanoutProgress, LocalMetabaseFanoutProgressChild, LocalMetabaseFanoutResult, RunLocalIngestOptions, RunLocalMetabaseIngestOptions, } from './local-ingest.js';
+export { getLatestLocalIngestStatus, getLocalIngestStatus, runLocalIngest, runLocalMetabaseIngest } from './local-ingest.js';
+export { seedLocalMappingStateFromKtxYaml } from './local-mapping-reconcile.js';
+export type { CreateLocalBundleIngestRuntimeOptions, LocalBundleIngestRuntime, } from './local-bundle-runtime.js';
+export { createLocalBundleIngestRuntime } from './local-bundle-runtime.js';
+export type { LocalIngestDiffPaths, LocalIngestRunRecord, LocalIngestStatus, RunLocalStageOnlyIngestOptions, } from './local-stage-ingest.js';
+export { getLocalStageOnlyIngestStatus, runLocalStageOnlyIngest } from './local-stage-ingest.js';
+export { ingestReportToMemoryFlowReplay, localIngestRunToMemoryFlowReplay, } from './memory-flow/events.js';
+export { buildAuthenticatedUrl, cleanupRepoDir, cloneOrPull, RepoConfigError, RepoFetchError, repoDirExists, sanitizeRepoError, testRepoConnection, validateRepoConfig, } from './repo-fetch.js';
+export type { RepoFetchConfig } from './repo-fetch.js';
+export { loadProjectInfo, parseProjectName, parseProjectVars, resolveJinjaVariables, } from './dbt-shared/project-vars.js';
+export type { DbtProjectInfo, ResolveJinjaVariablesResult } from './dbt-shared/project-vars.js';
+export { findDbtSchemaFiles, loadDbtSchemaFiles } from './dbt-shared/schema-files.js';
+export { computeDbtSchemaHash, parseDbtSchemaFile, parseDbtSchemaFiles, } from './adapters/dbt-descriptions/parse-schema.js';
+export type { DbtParsedColumn, DbtColumnConstraints, DbtDataTestRef, DbtParsedRelationship, DbtParsedTable, DbtSchemaFile, DbtSchemaParseResult, } from './adapters/dbt-descriptions/parse-schema.js';
+export { findMatchingKtxTable, matchDbtTables } from './adapters/dbt-descriptions/match-tables.js';
+export type { DbtHostTableLite, DbtTableMatch } from './adapters/dbt-descriptions/match-tables.js';
+export { toDescriptionUpdates } from './adapters/dbt-descriptions/to-description-updates.js';
+export type { DbtDescriptionUpdates } from './adapters/dbt-descriptions/to-description-updates.js';
+export { toRelationshipUpdates } from './adapters/dbt-descriptions/to-relationship-updates.js';
+export type { DbtRelationshipUpdates } from './adapters/dbt-descriptions/to-relationship-updates.js';
+export { toMetadataUpdates } from './adapters/dbt-descriptions/to-metadata-updates.js';
+export { mergeSemanticModelTables } from './adapters/dbt-descriptions/merge-semantic-model-tables.js';
+export type { KtxJoinUpdate, KtxMetadataUpdate } from '../scan/enrichment-types.js';
+export { createInitialMemoryFlowInteractionState, findMemoryFlowSearchMatches, reduceMemoryFlowInteractionState, selectedMemoryFlowColumn, selectedMemoryFlowDetails, selectMemoryFlowChip, selectMemoryFlowColumn, visibleMemoryFlowChips, } from './memory-flow/interaction.js';
+export { renderMemoryFlowInteractive } from './memory-flow/interactive-render.js';
+export { createMemoryFlowLiveBuffer, sanitizeMemoryFlowError } from './memory-flow/live-buffer.js';
+export { renderMemoryFlowReplay } from './memory-flow/render.js';
+export { formatMemoryFlowFinalSummary } from './memory-flow/summary.js';
+export type { MemoryFlowStreamEvent } from './memory-flow/schema.js';
+export { memoryFlowActionDetailSchema, memoryFlowDetailSectionsSchema, memoryFlowEventSchema, memoryFlowPlannedWorkUnitSchema, memoryFlowReplayInputSchema, memoryFlowRunStatusSchema, memoryFlowStreamEventSchema, parseMemoryFlowReplayInput, } from './memory-flow/schema.js';
+export type { MemoryFlowChip, MemoryFlowColumnId, MemoryFlowColumnView, MemoryFlowDisplayStatus, MemoryFlowEvent, MemoryFlowEventSink, MemoryFlowFilterMode, MemoryFlowInteractionCommand, MemoryFlowInteractionState, MemoryFlowLiveBufferOptions, MemoryFlowPaneId, MemoryFlowPlannedWorkUnit, MemoryFlowRenderOptions, MemoryFlowReplayInput, MemoryFlowReplayPatch, MemoryFlowRunStatus, MemoryFlowViewModel, } from './memory-flow/types.js';
+export { buildMemoryFlowViewModel } from './memory-flow/view-model.js';
+export type { MemoryFlowStatusBadge, MemoryFlowVisualColumn, MemoryFlowVisualModel, } from './memory-flow/visuals.js';
+export { buildMemoryFlowVisualModel, memoryFlowStatusBadge, renderMemoryFlowConnectorLine, } from './memory-flow/visuals.js';
+export type { PageTriageEvidenceChunk, PageTriageReport, PageTriageRunArgs, PageTriageServiceDeps, PageTriageSettings, PageTriageStorePort, } from './page-triage/index.js';
+export { PageTriageService } from './page-triage/index.js';
+export type { CandidateDedupPort, CandidateDedupResult, ContextCandidateCarryforwardPort, ContextCandidateForDedup, ContextCandidateSummary, ContextEvidenceCandidatesPort, ContextEvidenceIndexPort, ContextEvidenceIndexSummary, CreateIngestRunArgs, CuratorPaginationPort, CuratorPaginationReport, DiffSetComputerPort, IngestBundleRunnerDeps, IngestCanonicalPinsPort, IngestCommitMessagePort, IngestFileStorePort, IngestGitAuthor, IngestKnowledgeIndexPort, IngestLockPort, IngestProvenanceInsert, IngestProvenancePort, IngestProvenanceRow, IngestReportsPort, IngestRunnerJob, IngestRunRecord, IngestRunsPort, IngestSessionWorktree, IngestSessionWorktreePort, IngestSettingsPort, IngestStoragePort, IngestToolsetFactoryPort, IngestToolsetLike, PageTriagePort, PageTriageRunResult, ProvenanceActionType, SourceAdapterRegistryPort, } from './ports.js';
+export { buildSyncId, provenanceMarker, rawSourcesDirForSync, rawSourcesRoot, } from './raw-sources-paths.js';
+export { ingestReportSnapshotSchema, parseIngestReportSnapshot } from './report-snapshot.js';
+export type { IngestReportBody, IngestReportSnapshot } from './reports.js';
+export * from './reports.js';
+export { SourceAdapterRegistry } from './source-adapter-registry.js';
+export type { SqliteBundleIngestStoreOptions } from './sqlite-bundle-ingest-store.js';
+export { SqliteBundleIngestStore } from './sqlite-bundle-ingest-store.js';
+export type { SaveCompletedLocalIngestRunInput, SqliteLocalIngestStoreOptions, } from './sqlite-local-ingest-store.js';
+export { SqliteLocalIngestStore } from './sqlite-local-ingest-store.js';
+export type { ReconcileCandidateForPrompt, ReconcileCandidateSummary, ReconcilePromptRunState, WikiPageRef, } from './stages/build-reconcile-context.js';
+export { buildReconcileSystemPrompt, buildReconcileToolSet, buildReconcileUserPrompt, } from './stages/build-reconcile-context.js';
+export type { ReconciliationOutcome } from './stages/stage-4-reconciliation.js';
+export { runReconciliationStage4 } from './stages/stage-4-reconciliation.js';
+export type { StageIndex } from './stages/stage-index.types.js';
+export type { ChunkResult, DiffSet, EvictionUnit, FetchContext, IngestBundleJob, IngestBundleRef, IngestBundleResult, IngestDiffSummary, IngestJobContext, IngestJobPhase, IngestTrigger, ScopeDescriptor, SourceAdapter, SourceFetchIssue, SourceFetchReport, TriageLane, TriageSignals, UnresolvedCardInfo, WorkUnit, } from './types.js';