@duckcodeailabs/dql-core 1.6.1 → 1.6.2

package/dist/manifest/builder.js

@@ -8,11 +8,13 @@
 import { readdirSync, readFileSync, existsSync } from 'node:fs';
 import { join, extname, relative } from 'node:path';
 import { Parser } from '../parser/index.js';
+import { analyze } from '../semantic/index.js';
 import { extractTablesFromSql } from '../lineage/sql-parser.js';
 import { extractColumnLineage } from '../lineage/column-lineage.js';
 import { buildLineageGraph } from '../lineage/builder.js';
 import { detectDomainFlows, getDomainTrustOverview } from '../lineage/domain-lineage.js';
 import { loadSemanticLayerFromDir } from '../semantic/index.js';
+import { DataLexContractRegistry } from '../contracts/index.js';
 import { loadAppDocument, findAppDocuments, findDashboardsForApp, loadDashboardDocument, extractDashboardBlockRefs, appFolderRelPath, } from '../apps/index.js';
 /**
  * Enumerate every file whose contents could change the manifest output.
@@ -30,11 +32,25 @@ export function collectInputFiles(options) {
     if (existsSync(configPath))
         files.add(configPath);
     const config = loadProjectConfig(projectRoot);
+    const datalexManifestPath = resolveDataLexManifestPath(projectRoot, options.datalexManifestPath, config);
+    if (datalexManifestPath && existsSync(datalexManifestPath)) {
+        files.add(datalexManifestPath);
+    }
     const blockDirs = ['blocks', 'dashboards', 'workbooks', ...(options.extraBlockDirs ?? [])];
     for (const dir of blockDirs) {
         for (const f of scanFilesRecursive(join(projectRoot, dir), ['.dql']))
             files.add(f);
     }
+    const businessViewDirs = ['blocks', 'business-views', 'dashboards', 'workbooks', ...(options.extraBlockDirs ?? [])];
+    for (const dir of businessViewDirs) {
+        for (const f of scanFilesRecursive(join(projectRoot, dir), ['.dql']))
+            files.add(f);
+    }
+    const termDirs = ['terms', 'blocks', 'business-views', 'dashboards', 'workbooks', ...(options.extraBlockDirs ?? [])];
+    for (const dir of termDirs) {
+        for (const f of scanFilesRecursive(join(projectRoot, dir), ['.dql']))
+            files.add(f);
+    }
     const notebookDirs = ['notebooks', 'blocks', 'dashboards', 'workbooks', ...(options.extraNotebookDirs ?? [])];
     for (const dir of notebookDirs) {
         for (const f of scanFilesRecursive(join(projectRoot, dir), ['.dqlnb']))
@@ -64,18 +80,38 @@ export function buildManifest(options) {
     // Load project config
     const config = loadProjectConfig(projectRoot);
     const projectName = config.project ?? 'dql-project';
+    const datalexManifestPath = resolveDataLexManifestPath(projectRoot, options.datalexManifestPath, config);
+    const datalexRegistry = datalexManifestPath
+        ? new DataLexContractRegistry({ manifestPath: datalexManifestPath })
+        : undefined;
+    for (const message of datalexRegistry?.loadDiagnostics() ?? []) {
+        diagnostics.push({
+            kind: 'config',
+            filePath: datalexManifestPath ? relative(projectRoot, datalexManifestPath) : undefined,
+            severity: 'warning',
+            message,
+        });
+    }
     // Scan blocks
     const blockDirs = ['blocks', 'dashboards', 'workbooks', ...(options.extraBlockDirs ?? [])];
-    const blocks = scanBlocks(projectRoot, blockDirs, diagnostics);
+    const blocks = scanBlocks(projectRoot, blockDirs, diagnostics, datalexRegistry);
+    // Scan business composition views
+    const businessViewDirs = ['blocks', 'business-views', 'dashboards', 'workbooks', ...(options.extraBlockDirs ?? [])];
+    const businessViews = scanBusinessViews(projectRoot, businessViewDirs, diagnostics);
+    // Scan business glossary terms
+    const termDirs = ['terms', 'blocks', 'business-views', 'dashboards', 'workbooks', ...(options.extraBlockDirs ?? [])];
+    const terms = scanTerms(projectRoot, termDirs, diagnostics);
     // Scan notebooks
     const notebookDirs = ['notebooks', 'blocks', 'dashboards', 'workbooks', ...(options.extraNotebookDirs ?? [])];
-    const notebooks = scanNotebooks(projectRoot, notebookDirs, diagnostics);
+    const notebooks = scanNotebooks(projectRoot, notebookDirs, diagnostics, datalexRegistry);
     // Extract blocks declared inside notebook DQL cells
-    const notebookBlocks = extractNotebookBlocks(notebooks, projectRoot);
+    const notebookBlocks = extractNotebookBlocks(notebooks);
     for (const [name, block] of Object.entries(notebookBlocks)) {
         if (!blocks[name])
             blocks[name] = block;
     }
+    validateBusinessViews(businessViews, blocks, diagnostics);
+    validateTermRefs(terms, blocks, businessViews, diagnostics);
     // Load semantic layer
     const semanticDir = resolveSemanticPath(projectRoot, config);
     const { metrics, dimensions } = loadSemanticDefinitions(projectRoot, semanticDir);
@@ -113,7 +149,7 @@ export function buildManifest(options) {
     // because dashboard refs are resolved against the block path → name map.
     const { apps, dashboards } = scanAppsAndDashboards(projectRoot, blocks, diagnostics);
     // Build lineage
-    const lineage = buildManifestLineage(blocks, metrics, dimensions, notebooks, dbtImport, apps, dashboards);
+    const lineage = buildManifestLineage(blocks, metrics, dimensions, notebooks, dbtImport, apps, dashboards, businessViews, terms);
     return {
         manifestVersion: 2,
         dqlVersion,
@@ -121,6 +157,8 @@ export function buildManifest(options) {
         project: projectName,
         projectRoot,
         blocks,
+        businessViews,
+        terms,
         notebooks,
         metrics,
         dimensions,
@@ -172,6 +210,19 @@ export function resolveDbtManifestPath(projectRoot, explicit) {
         return fallback;
     return null;
 }
+export function resolveDataLexManifestPath(projectRoot, explicit, config = loadProjectConfig(projectRoot)) {
+    if (explicit) {
+        return isAbsPath(explicit) ? explicit : join(projectRoot, explicit);
+    }
+    const configured = config.datalex?.manifestPath;
+    if (configured) {
+        return isAbsPath(configured) ? configured : join(projectRoot, configured);
+    }
+    const fallback = join(projectRoot, 'datalex-manifest.json');
+    if (existsSync(fallback))
+        return fallback;
+    return null;
+}
 function isAbsPath(p) {
     return p.startsWith('/') || /^[A-Za-z]:[\\/]/.test(p);
 }
@@ -202,7 +253,7 @@ function scanFilesRecursive(dir, extensions) {
     return results;
 }
 // ---- Block Scanning ----
-function scanBlocks(projectRoot, dirs, diagnostics) {
+function scanBlocks(projectRoot, dirs, diagnostics, datalexRegistry) {
     const blocks = {};
     for (const dir of dirs) {
         const dirPath = join(projectRoot, dir);
@@ -213,67 +264,12 @@ function scanBlocks(projectRoot, dirs, diagnostics) {
                 const source = readFileSync(filePath, 'utf-8');
                 const parser = new Parser(source, relPath);
                 const ast = parser.parse();
+                collectContractDiagnostics(ast, relPath, diagnostics, datalexRegistry);
                 for (const stmt of ast.statements) {
                     const block = stmt;
                     if (block.kind !== 'BlockDecl')
                         continue;
-                    const sql = block.query?.rawSQL ?? '';
-                    const parseResult = extractTablesFromSql(sql);
-                    const columnLineage = sql ? extractColumnLineage(sql) : null;
-                    const domain = extractProp(block, 'domain');
-                    const owner = extractProp(block, 'owner');
-                    const description = extractProp(block, 'description');
-                    const tags = extractTags(block);
-                    const tests = extractTests(block);
-                    const agent = extractAgentMetadata(block);
-                    blocks[block.name] = {
-                        name: block.name,
-                        filePath: relPath,
-                        domain,
-                        owner,
-                        status: extractProp(block, 'status'),
-                        blockType: block.blockType,
-                        sql,
-                        rawTableRefs: parseResult.tables,
-                        tableDependencies: parseResult.tables.map(normalizeTableName),
-                        refDependencies: parseResult.refs,
-                        metricRefs: parseResult.metricRefs,
-                        dimensionRefs: parseResult.dimensionRefs,
-                        dimensionsRef: block.dimensionsRef,
-                        allDependencies: [
-                            ...parseResult.refs,
-                            ...parseResult.tables.map(normalizeTableName),
-                            ...parseResult.metricRefs.map((m) => `@metric(${m})`),
-                            ...parseResult.dimensionRefs.map((d) => `@dim(${d})`),
-                            ...((block.metricsRef ?? (block.metricRef ? [block.metricRef] : [])).map((m) => `@metric(${m})`)),
-                            ...((block.dimensionsRef ?? []).map((d) => `@dim(${d})`)),
-                        ],
-                        chartType: extractVisualizationChart(block),
-                        metricRef: block.metricRef,
-                        metricsRef: block.metricsRef,
-                        tests,
-                        tags,
-                        description,
-                        llmContext: agent.llmContext,
-                        examples: agent.examples,
-                        invariants: agent.invariants,
-                        businessOutcome: agent.businessOutcome,
-                        businessOwner: agent.businessOwner,
-                        decisionUse: agent.decisionUse,
-                        reviewCadence: agent.reviewCadence,
-                        businessRules: agent.businessRules,
-                        caveats: agent.caveats,
-                        datalexContract: typeof block.datalexContract === 'string' ? block.datalexContract : undefined,
-                        outputs: columnLineage?.parsed && columnLineage.columns.length > 0
-                            ? columnLineage.columns.map((c) => ({
-                                name: c.name,
-                                isAggregate: c.isAggregate,
-                                aggregateFn: c.aggregateFn,
-                                sources: c.sources,
-                                unresolved: c.unresolved,
-                            }))
-                            : undefined,
-                    };
+                    blocks[block.name] = blockDeclToManifestBlock(block, relPath);
                 }
             }
             catch (err) {
@@ -291,8 +287,216 @@ function scanBlocks(projectRoot, dirs, diagnostics) {
     }
     return blocks;
 }
+// ---- Business View Scanning ----
+function scanBusinessViews(projectRoot, dirs, diagnostics) {
+    const views = {};
+    const seenFiles = new Set();
+    for (const dir of dirs) {
+        const dirPath = join(projectRoot, dir);
+        const files = scanFilesRecursive(dirPath, ['.dql']);
+        for (const filePath of files) {
+            if (seenFiles.has(filePath))
+                continue;
+            seenFiles.add(filePath);
+            const relPath = relative(projectRoot, filePath);
+            try {
+                const source = readFileSync(filePath, 'utf-8');
+                if (!source.includes('business_view'))
+                    continue;
+                const parser = new Parser(source, relPath);
+                const ast = parser.parse();
+                for (const stmt of ast.statements) {
+                    const view = stmt;
+                    if (view.kind !== 'BusinessViewDecl')
+                        continue;
+                    if (views[view.name]) {
+                        diagnostics?.push({
+                            kind: 'resolve',
+                            filePath: relPath,
+                            severity: 'error',
+                            message: `duplicate business_view "${view.name}" also declared in ${views[view.name].filePath}`,
+                        });
+                        continue;
+                    }
+                    views[view.name] = businessViewDeclToManifestBusinessView(view, relPath);
+                }
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                diagnostics?.push({
+                    kind: 'parse',
+                    filePath: relPath,
+                    severity: 'error',
+                    message: `Failed to parse business view file: ${msg}`,
+                });
+            }
+        }
+    }
+    return views;
+}
+// ---- Business Term Scanning ----
+function scanTerms(projectRoot, dirs, diagnostics) {
+    const terms = {};
+    const seenFiles = new Set();
+    for (const dir of dirs) {
+        const dirPath = join(projectRoot, dir);
+        const files = scanFilesRecursive(dirPath, ['.dql']);
+        for (const filePath of files) {
+            if (seenFiles.has(filePath))
+                continue;
+            seenFiles.add(filePath);
+            const relPath = relative(projectRoot, filePath);
+            try {
+                const source = readFileSync(filePath, 'utf-8');
+                if (!source.includes('term'))
+                    continue;
+                const parser = new Parser(source, relPath);
+                const ast = parser.parse();
+                for (const stmt of ast.statements) {
+                    const term = stmt;
+                    if (term.kind !== 'TermDecl')
+                        continue;
+                    if (terms[term.name]) {
+                        diagnostics?.push({
+                            kind: 'resolve',
+                            filePath: relPath,
+                            severity: 'error',
+                            message: `duplicate term "${term.name}" also declared in ${terms[term.name].filePath}`,
+                        });
+                        continue;
+                    }
+                    terms[term.name] = termDeclToManifestTerm(term, relPath);
+                }
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                diagnostics?.push({
+                    kind: 'parse',
+                    filePath: relPath,
+                    severity: 'error',
+                    message: `Failed to parse term file: ${msg}`,
+                });
+            }
+        }
+    }
+    return terms;
+}
+function validateBusinessViews(views, blocks, diagnostics) {
+    const blockNames = new Set(Object.keys(blocks));
+    const viewNames = new Set(Object.keys(views));
+    for (const view of Object.values(views)) {
+        view.unresolvedBlockRefs = view.blockRefs.filter((ref) => !blockNames.has(ref));
+        view.blockRefs = view.blockRefs.filter((ref) => blockNames.has(ref));
+        view.unresolvedBusinessViewRefs = view.businessViewRefs.filter((ref) => !viewNames.has(ref));
+        view.businessViewRefs = view.businessViewRefs.filter((ref) => viewNames.has(ref));
+        if (view.unresolvedBlockRefs.length > 0) {
+            diagnostics.push({
+                kind: 'resolve',
+                filePath: view.filePath,
+                severity: 'error',
+                message: `business_view "${view.name}" has unresolved block refs: ${view.unresolvedBlockRefs.join(', ')}`,
+            });
+        }
+        if (view.unresolvedBusinessViewRefs.length > 0) {
+            diagnostics.push({
+                kind: 'resolve',
+                filePath: view.filePath,
+                severity: 'error',
+                message: `business_view "${view.name}" has unresolved business_view refs: ${view.unresolvedBusinessViewRefs.join(', ')}`,
+            });
+        }
+    }
+    detectBusinessViewCycles(views, diagnostics);
+}
+function validateTermRefs(terms, blocks, views, diagnostics) {
+    const termNames = new Set(Object.keys(terms));
+    for (const block of Object.values(blocks)) {
+        const declared = block.termRefs ?? [];
+        block.unresolvedTermRefs = declared.filter((ref) => !termNames.has(ref));
+        block.termRefs = declared.filter((ref) => termNames.has(ref));
+        if (block.unresolvedTermRefs.length > 0) {
+            diagnostics.push({
+                kind: 'resolve',
+                filePath: block.filePath,
+                severity: 'error',
+                message: `block "${block.name}" has unresolved term refs: ${block.unresolvedTermRefs.join(', ')}`,
+            });
+        }
+    }
+    for (const view of Object.values(views)) {
+        const declared = view.declaredTermRefs ?? [];
+        view.unresolvedTermRefs = declared.filter((ref) => !termNames.has(ref));
+        view.declaredTermRefs = declared.filter((ref) => termNames.has(ref));
+        if (view.unresolvedTermRefs.length > 0) {
+            diagnostics.push({
+                kind: 'resolve',
+                filePath: view.filePath,
+                severity: 'error',
+                message: `business_view "${view.name}" has unresolved term refs: ${view.unresolvedTermRefs.join(', ')}`,
+            });
+        }
+    }
+    const collectTermsForView = (viewName, seen = new Set()) => {
+        const view = views[viewName];
+        if (!view || seen.has(viewName))
+            return [];
+        seen.add(viewName);
+        const refs = new Set(view.declaredTermRefs ?? []);
+        for (const blockRef of view.blockRefs) {
+            for (const termRef of blocks[blockRef]?.termRefs ?? [])
+                refs.add(termRef);
+        }
+        for (const viewRef of view.businessViewRefs) {
+            for (const termRef of collectTermsForView(viewRef, seen))
+                refs.add(termRef);
+        }
+        return [...refs];
+    };
+    for (const view of Object.values(views)) {
+        const declaredSet = new Set(view.declaredTermRefs ?? []);
+        const allRefs = collectTermsForView(view.name);
+        view.termRefs = allRefs;
+        view.inheritedTermRefs = allRefs.filter((ref) => !declaredSet.has(ref));
+    }
+}
+function detectBusinessViewCycles(views, diagnostics) {
+    const visiting = new Set();
+    const visited = new Set();
+    const stack = [];
+    const reported = new Set();
+    const visit = (name) => {
+        if (visited.has(name))
+            return;
+        if (visiting.has(name)) {
+            const cycleStart = stack.indexOf(name);
+            const cycle = [...stack.slice(cycleStart), name];
+            const key = cycle.join(' -> ');
+            if (!reported.has(key)) {
+                reported.add(key);
+                diagnostics.push({
+                    kind: 'resolve',
+                    filePath: views[name]?.filePath,
+                    severity: 'error',
+                    message: `business_view cycle detected: ${cycle.join(' -> ')}`,
+                });
+            }
+            return;
+        }
+        visiting.add(name);
+        stack.push(name);
+        for (const ref of views[name]?.businessViewRefs ?? []) {
+            visit(ref);
+        }
+        stack.pop();
+        visiting.delete(name);
+        visited.add(name);
+    };
+    for (const name of Object.keys(views)) {
+        visit(name);
+    }
+}
 // ---- Notebook Scanning ----
-function scanNotebooks(projectRoot, dirs, diagnostics) {
+function scanNotebooks(projectRoot, dirs, diagnostics, datalexRegistry) {
     const notebooks = {};
     const seen = new Set();
     for (const dir of dirs) {
@@ -323,6 +527,7 @@ function scanNotebooks(projectRoot, dirs, diagnostics) {
                         try {
                             const parser = new Parser(source, `${relPath}:${cell.id}`);
                             const ast = parser.parse();
+                            collectContractDiagnostics(ast, relPath, diagnostics, datalexRegistry);
                             for (const stmt of ast.statements) {
                                 if (stmt.kind === 'BlockDecl') {
                                     blockName = stmt.name;
@@ -372,7 +577,7 @@ function scanNotebooks(projectRoot, dirs, diagnostics) {
     return notebooks;
 }
 /** Extract blocks declared inside notebook DQL cells into the blocks map. */
-function extractNotebookBlocks(notebooks, projectRoot) {
+function extractNotebookBlocks(notebooks) {
     const blocks = {};
     for (const [nbPath, nb] of Object.entries(notebooks)) {
         for (const cell of nb.cells) {
@@ -380,17 +585,26 @@ function extractNotebookBlocks(notebooks, projectRoot) {
                 continue;
             // Only add if not already found as a standalone block file
             if (!blocks[cell.blockName]) {
-                const parseResult = extractTablesFromSql(cell.source);
-                blocks[cell.blockName] = {
-                    name: cell.blockName,
-                    filePath: `${nbPath}#${cell.id}`,
-                    sql: cell.source,
-                    rawTableRefs: parseResult.tables,
-                    tableDependencies: parseResult.tables.map(normalizeTableName),
-                    refDependencies: parseResult.refs,
-                    allDependencies: [...parseResult.refs, ...parseResult.tables.map(normalizeTableName)],
-                    tests: [],
-                };
+                try {
+                    const ast = new Parser(cell.source, `${nbPath}:${cell.id}`).parse();
+                    const block = ast.statements.find((stmt) => stmt.kind === 'BlockDecl' && stmt.name === cell.blockName);
+                    if (block) {
+                        blocks[cell.blockName] = blockDeclToManifestBlock(block, `${nbPath}#${cell.id}`);
+                    }
+                }
+                catch {
+                    const parseResult = extractTablesFromSql(cell.source);
+                    blocks[cell.blockName] = {
+                        name: cell.blockName,
+                        filePath: `${nbPath}#${cell.id}`,
+                        sql: '',
+                        rawTableRefs: parseResult.tables,
+                        tableDependencies: parseResult.tables.map(normalizeTableName),
+                        refDependencies: parseResult.refs,
+                        allDependencies: [...parseResult.refs, ...parseResult.tables.map(normalizeTableName)],
+                        tests: [],
+                    };
+                }
             }
         }
     }
@@ -960,7 +1174,7 @@ function appDocumentToManifest(app, filePath, dashboardIds) {
     };
 }
 // ---- Lineage Builder ----
-function buildManifestLineage(blocks, metrics, dimensions, notebooks, dbtImport, apps, appDashboards) {
+function buildManifestLineage(blocks, metrics, dimensions, notebooks, dbtImport, apps, appDashboards, businessViews, terms) {
     // Convert to lineage builder input format
     const lineageBlocks = Object.values(blocks).map((b) => ({
         name: b.name,
@@ -974,6 +1188,19 @@ function buildManifestLineage(blocks, metrics, dimensions, notebooks, dbtImport,
         dimensionsRef: b.dimensionsRef,
         chartType: b.chartType,
         filePath: b.filePath,
+        termRefs: b.termRefs,
+    }));
+    const lineageTerms = Object.values(terms ?? {}).map((term) => ({
+        name: term.name,
+        domain: term.domain,
+        owner: term.owner,
+        status: term.status,
+        termType: term.termType,
+        filePath: term.filePath,
+        description: term.description,
+        identifiers: term.identifiers,
+        synonyms: term.synonyms,
+        businessOutcome: term.businessOutcome,
     }));
     const lineageMetrics = Object.values(metrics).map((m) => ({
         name: m.name,
@@ -985,6 +1212,19 @@ function buildManifestLineage(blocks, metrics, dimensions, notebooks, dbtImport,
         name: d.name,
         table: d.table,
     }));
+    const lineageBusinessViews = Object.values(businessViews ?? {}).map((view) => ({
+        name: view.name,
+        domain: view.domain,
+        owner: view.owner,
+        status: view.status,
+        filePath: view.filePath,
+        description: view.description,
+        businessOutcome: view.businessOutcome,
+        blockRefs: view.blockRefs,
+        businessViewRefs: view.businessViewRefs,
+        termRefs: view.termRefs,
+        declaredTermRefs: view.declaredTermRefs,
+    }));
     // Pre-build a map of table name → block names that query that table.
     // Used to resolve "which blocks feed into a notebook" when a notebook
     // references a table directly rather than via ref().
@@ -1084,6 +1324,8 @@ function buildManifestLineage(blocks, metrics, dimensions, notebooks, dbtImport,
         dbtModels,
         dashboards: [...dashboards, ...appDashboardInputs],
         apps: lineageApps,
+        businessViews: lineageBusinessViews,
+        terms: lineageTerms,
     });
     // Serialize to manifest format
     const graphJson = graph.toJSON();
@@ -1107,7 +1349,7 @@ function buildManifestLineage(blocks, metrics, dimensions, notebooks, dbtImport,
             domain: n.domain,
             owner: n.owner,
             status: n.status,
-            filePath: blocks[n.name]?.filePath ?? n.metadata?.filePath,
+            filePath: blocks[n.name]?.filePath ?? businessViews?.[n.name]?.filePath ?? terms?.[n.name]?.filePath ?? n.metadata?.filePath,
             columns: n.columns,
             metadata: n.metadata,
         })),
@@ -1128,6 +1370,138 @@ function buildManifestLineage(blocks, metrics, dimensions, notebooks, dbtImport,
     };
 }
 // ---- AST Helpers ----
+function blockDeclToManifestBlock(block, filePath) {
+    const sql = block.query?.rawSQL ?? '';
+    const parseResult = extractTablesFromSql(sql);
+    const columnLineage = sql ? extractColumnLineage(sql) : null;
+    const domain = extractProp(block, 'domain');
+    const owner = extractProp(block, 'owner');
+    const description = extractProp(block, 'description');
+    const tags = extractTags(block);
+    const tests = extractTests(block);
+    const agent = extractAgentMetadata(block);
+    return {
+        name: block.name,
+        filePath,
+        domain,
+        owner,
+        status: extractProp(block, 'status'),
+        blockType: block.blockType,
+        sql,
+        rawTableRefs: parseResult.tables,
+        tableDependencies: parseResult.tables.map(normalizeTableName),
+        refDependencies: parseResult.refs,
+        metricRefs: parseResult.metricRefs,
+        dimensionRefs: parseResult.dimensionRefs,
+        dimensionsRef: block.dimensionsRef,
+        allDependencies: [
+            ...parseResult.refs,
+            ...parseResult.tables.map(normalizeTableName),
+            ...parseResult.metricRefs.map((m) => `@metric(${m})`),
+            ...parseResult.dimensionRefs.map((d) => `@dim(${d})`),
+            ...((block.metricsRef ?? (block.metricRef ? [block.metricRef] : [])).map((m) => `@metric(${m})`)),
+            ...((block.dimensionsRef ?? []).map((d) => `@dim(${d})`)),
+        ],
+        chartType: extractVisualizationChart(block),
+        metricRef: block.metricRef,
+        metricsRef: block.metricsRef,
+        tests,
+        tags,
+        description,
+        termRefs: Array.isArray(block.termRefs) ? block.termRefs : undefined,
+        unresolvedTermRefs: [],
+        llmContext: agent.llmContext,
+        examples: agent.examples,
+        invariants: agent.invariants,
+        businessOutcome: agent.businessOutcome,
+        businessOwner: agent.businessOwner,
+        decisionUse: agent.decisionUse,
+        reviewCadence: agent.reviewCadence,
+        businessRules: agent.businessRules,
+        caveats: agent.caveats,
+        datalexContract: typeof block.datalexContract === 'string' ? block.datalexContract : undefined,
+        outputs: columnLineage?.parsed && columnLineage.columns.length > 0
+            ? columnLineage.columns.map((c) => ({
+                name: c.name,
+                isAggregate: c.isAggregate,
+                aggregateFn: c.aggregateFn,
+                sources: c.sources,
+                unresolved: c.unresolved,
+            }))
+            : undefined,
+    };
+}
+function termDeclToManifestTerm(term, filePath) {
+    return {
+        name: term.name,
+        filePath,
+        domain: extractProp(term, 'domain'),
+        owner: extractProp(term, 'owner'),
+        status: extractProp(term, 'status'),
+        termType: typeof term.termType === 'string' ? term.termType : undefined,
+        tags: extractTags(term),
+        description: extractProp(term, 'description'),
+        identifiers: Array.isArray(term.identifiers) ? term.identifiers : undefined,
+        synonyms: Array.isArray(term.synonyms) ? term.synonyms : undefined,
+        businessOutcome: typeof term.businessOutcome === 'string' ? term.businessOutcome : undefined,
+        businessOwner: typeof term.businessOwner === 'string' ? term.businessOwner : undefined,
+        decisionUse: typeof term.decisionUse === 'string' ? term.decisionUse : undefined,
+        reviewCadence: typeof term.reviewCadence === 'string' ? term.reviewCadence : undefined,
+        businessRules: Array.isArray(term.businessRules) ? term.businessRules : undefined,
+        caveats: Array.isArray(term.caveats) ? term.caveats : undefined,
+    };
+}
+function businessViewDeclToManifestBusinessView(view, filePath) {
+    const blockRefs = [];
+    const businessViewRefs = [];
+    for (const ref of view.includes ?? []) {
+        if (ref.refType === 'block')
+            blockRefs.push(ref.name);
+        if (ref.refType === 'business_view')
+            businessViewRefs.push(ref.name);
+    }
+    return {
+        name: view.name,
+        filePath,
+        domain: extractProp(view, 'domain'),
+        owner: extractProp(view, 'owner'),
+        status: extractProp(view, 'status'),
+        tags: extractTags(view),
+        description: extractProp(view, 'description'),
+        businessOutcome: typeof view.businessOutcome === 'string' ? view.businessOutcome : undefined,
+        businessOwner: typeof view.businessOwner === 'string' ? view.businessOwner : undefined,
+        decisionUse: typeof view.decisionUse === 'string' ? view.decisionUse : undefined,
+        reviewCadence: typeof view.reviewCadence === 'string' ? view.reviewCadence : undefined,
+        businessRules: Array.isArray(view.businessRules) ? view.businessRules : undefined,
+        caveats: Array.isArray(view.caveats) ? view.caveats : undefined,
+        blockRefs,
+        businessViewRefs,
+        termRefs: Array.isArray(view.termRefs) ? view.termRefs : [],
+        declaredTermRefs: Array.isArray(view.termRefs) ? view.termRefs : [],
+        inheritedTermRefs: [],
+        unresolvedTermRefs: [],
+        unresolvedBlockRefs: [],
+        unresolvedBusinessViewRefs: [],
+    };
+}
+function collectContractDiagnostics(ast, relPath, diagnostics, datalexRegistry) {
+    if (!diagnostics)
+        return;
+    const hasContractRef = ast.statements.some((stmt) => stmt.kind === 'BlockDecl' && typeof stmt.datalexContract === 'string' && stmt.datalexContract.trim() !== '');
+    if (!hasContractRef)
+        return;
+    const semanticDiagnostics = analyze(ast, { datalexRegistry });
+    for (const diag of semanticDiagnostics) {
+        if (!diag.message.includes('datalex_contract') && !diag.message.includes('DataLex manifest'))
+            continue;
+        diagnostics.push({
+            kind: 'semantic',
+            filePath: relPath,
+            severity: diag.severity === 'error' ? 'error' : 'warning',
+            message: diag.message,
+        });
+    }
+}
 function extractProp(block, propName) {
     if (block[propName] !== undefined && block[propName] !== null) {
         return String(block[propName]);
@@ -1145,6 +1519,9 @@ function extractVisualizationChart(block) {
     if (!block.visualization)
         return undefined;
     for (const prop of block.visualization.properties ?? []) {
+        if (prop.name === 'chart' && prop.value?.kind === 'StringLiteral') {
+            return String(prop.value.value);
+        }
         if (prop.key === 'chart' && prop.value?.kind === 'Literal') {
             return String(prop.value.value);
         }
@@ -1185,6 +1562,14 @@ function extractAgentMetadata(block) {
     };
 }
 function extractTests(block) {
+    if (Array.isArray(block.tests)) {
+        return block.tests.map((a) => {
+            if (typeof a === 'string')
+                return a;
+            const expected = formatManifestTestExpected(a.expected);
+            return `${a.field ?? ''} ${a.operator ?? ''} ${expected}`.trim();
+        });
+    }
     if (!block.tests?.assertions)
         return [];
     return block.tests.assertions.map((a) => {
@@ -1193,6 +1578,23 @@ function extractTests(block) {
         return `${a.field ?? ''} ${a.operator ?? ''} ${a.expected ?? ''}`.trim();
     });
 }
+function formatManifestTestExpected(node) {
+    if (!node || typeof node !== 'object')
+        return String(node ?? '');
+    switch (node.kind) {
+        case 'StringLiteral':
+            return JSON.stringify(node.value);
+        case 'NumberLiteral':
+        case 'BooleanLiteral':
+            return String(node.value);
+        case 'Identifier':
+            return node.name;
+        case 'ArrayLiteral':
+            return `[${(node.elements ?? []).map(formatManifestTestExpected).join(', ')}]`;
+        default:
+            return String(node.value ?? '');
+    }
+}
 /**
  * Normalize DuckDB reader function calls to plain table names.
  * e.g., "read_csv_auto('./data/revenue.csv')" → "revenue"