@dbt-tools/core 0.3.2

package/dist/analysis/analysis-snapshot.js

@@ -0,0 +1,615 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildAnalysisSnapshotFromParsedArtifacts = buildAnalysisSnapshotFromParsedArtifacts;
+exports.buildAnalysisSnapshotFromArtifacts = buildAnalysisSnapshotFromArtifacts;
+const run_results_search_1 = require("./run-results-search");
+const execution_analyzer_1 = require("./execution-analyzer");
+const manifest_graph_1 = require("./manifest-graph");
+const RESOURCE_TYPE_ORDER = [
+    "model",
+    "source",
+    "test",
+    "metric",
+    "semantic_model",
+    "exposure",
+    "seed",
+    "snapshot",
+    "unit_test",
+    "analysis",
+    "macro",
+];
+function now() {
+    return performance.now();
+}
+function statusTone(status) {
+    const normalized = status === null || status === void 0 ? void 0 : status.trim().toLowerCase();
+    if (!normalized)
+        return "neutral";
+    if (["success", "pass", "passed"].includes(normalized)) {
+        return "positive";
+    }
+    if (["warn", "warning"].includes(normalized)) {
+        return "warning";
+    }
+    if (["error", "fail", "failed", "run error"].includes(normalized)) {
+        return "danger";
+    }
+    return "neutral";
+}
+function statusLabel(status) {
+    if (!status)
+        return "Unknown";
+    return status
+        .split(/[\s_-]+/)
+        .filter(Boolean)
+        .map((part) => part[0].toUpperCase() + part.slice(1).toLowerCase())
+        .join(" ");
+}
+function inferPackageNameFromUniqueId(uniqueId) {
+    var _a;
+    const parts = uniqueId.split(".");
+    if (parts.length < 2)
+        return "";
+    return (_a = parts[1]) !== null && _a !== void 0 ? _a : "";
+}
+function inferResourceTypeFromId(uniqueId) {
+    var _a;
+    const prefix = (_a = uniqueId.split(".")[0]) !== null && _a !== void 0 ? _a : "";
+    const known = new Set([
+        "model",
+        "test",
+        "unit_test",
+        "seed",
+        "snapshot",
+        "source",
+        "source_freshness",
+        "exposure",
+        "metric",
+        "semantic_model",
+        "analysis",
+        "macro",
+    ]);
+    return known.has(prefix) ? prefix : "operation";
+}
+function resourceTypeLabel(resourceType) {
+    return resourceType
+        .split("_")
+        .map((part) => part[0].toUpperCase() + part.slice(1))
+        .join(" ");
+}
+function normalizeStringArray(value) {
+    return Array.isArray(value)
+        ? value.filter((entry) => typeof entry === "string")
+        : [];
+}
+function buildMetricDefinition(attributes) {
+    const primaryMeasure = typeof attributes.metric_measure === "string"
+        ? attributes.metric_measure
+        : null;
+    const measures = normalizeStringArray(attributes.metric_input_measures);
+    return {
+        kind: "metric",
+        label: typeof attributes.label === "string" ? attributes.label : null,
+        description: typeof attributes.description === "string"
+            ? attributes.description
+            : null,
+        metricType: typeof attributes.metric_type === "string"
+            ? attributes.metric_type
+            : null,
+        expression: typeof attributes.metric_expression === "string"
+            ? attributes.metric_expression
+            : null,
+        sourceReference: typeof attributes.metric_source_reference === "string"
+            ? attributes.metric_source_reference
+            : typeof attributes.metric_measure === "string"
+                ? attributes.metric_measure
+                : null,
+        filters: normalizeStringArray(attributes.metric_filters),
+        timeGranularity: typeof attributes.metric_time_granularity === "string"
+            ? attributes.metric_time_granularity
+            : null,
+        measures: measures.length > 0
+            ? measures
+            : primaryMeasure != null
+                ? [primaryMeasure]
+                : [],
+        metrics: normalizeStringArray(attributes.metric_input_metrics),
+    };
+}
+function buildSemanticModelDefinition(attributes) {
+    return {
+        kind: "semantic_model",
+        label: typeof attributes.label === "string" ? attributes.label : null,
+        description: typeof attributes.description === "string"
+            ? attributes.description
+            : null,
+        sourceReference: typeof attributes.semantic_model_reference === "string"
+            ? attributes.semantic_model_reference
+            : null,
+        defaultTimeDimension: typeof attributes.semantic_model_default_time_dimension === "string"
+            ? attributes.semantic_model_default_time_dimension
+            : null,
+        entities: normalizeStringArray(attributes.semantic_model_entities),
+        measures: normalizeStringArray(attributes.semantic_model_measures),
+        dimensions: normalizeStringArray(attributes.semantic_model_dimensions),
+    };
+}
+function buildResourceDefinition(resourceType, attributes) {
+    if (resourceType === "metric") {
+        return buildMetricDefinition(attributes);
+    }
+    if (resourceType === "semantic_model") {
+        return buildSemanticModelDefinition(attributes);
+    }
+    return null;
+}
+function sortByResourceType(a, b) {
+    const aIndex = RESOURCE_TYPE_ORDER.indexOf(a);
+    const bIndex = RESOURCE_TYPE_ORDER.indexOf(b);
+    if (aIndex === -1 && bIndex === -1)
+        return a.localeCompare(b);
+    if (aIndex === -1)
+        return 1;
+    if (bIndex === -1)
+        return -1;
+    return aIndex - bIndex;
+}
+function sortResources(a, b) {
+    const typeOrder = sortByResourceType(a.resourceType, b.resourceType);
+    if (typeOrder !== 0)
+        return typeOrder;
+    return a.name.localeCompare(b.name);
+}
+function buildResourcesAndDependencyIndex(graph, executionById) {
+    const resources = [];
+    const dependencyIndex = {};
+    const graphologyGraph = graph.getGraph();
+    graphologyGraph.forEachNode((uniqueId, attributes) => {
+        const execution = executionById.get(uniqueId);
+        resources.push({
+            uniqueId,
+            name: String(attributes.name || uniqueId),
+            resourceType: String(attributes.resource_type || "unknown"),
+            packageName: String(attributes.package_name || ""),
+            path: typeof attributes.path === "string" ? attributes.path : null,
+            originalFilePath: typeof attributes.original_file_path === "string"
+                ? attributes.original_file_path
+                : null,
+            patchPath: typeof attributes.patch_path === "string"
+                ? attributes.patch_path
+                : null,
+            database: typeof attributes.database === "string" ? attributes.database : null,
+            schema: typeof attributes.schema === "string" ? attributes.schema : null,
+            description: typeof attributes.description === "string"
+                ? attributes.description
+                : null,
+            compiledCode: typeof attributes.compiled_code === "string"
+                ? attributes.compiled_code
+                : null,
+            rawCode: typeof attributes.raw_code === "string" ? attributes.raw_code : null,
+            definition: buildResourceDefinition(String(attributes.resource_type || "unknown"), attributes),
+            status: (execution === null || execution === void 0 ? void 0 : execution.status) ? statusLabel(execution.status) : null,
+            statusTone: statusTone(execution === null || execution === void 0 ? void 0 : execution.status),
+            executionTime: typeof (execution === null || execution === void 0 ? void 0 : execution.execution_time) === "number"
+                ? execution.execution_time
+                : null,
+            threadId: typeof (execution === null || execution === void 0 ? void 0 : execution.thread_id) === "string" ? execution.thread_id : null,
+        });
+        const upstream = graph.getUpstream(uniqueId);
+        const downstream = graph.getDownstream(uniqueId);
+        dependencyIndex[uniqueId] = {
+            upstreamCount: upstream.length,
+            downstreamCount: downstream.length,
+            upstream: upstream.slice(0, 8).map((entry) => {
+                const attrs = graphologyGraph.getNodeAttributes(entry.nodeId);
+                return {
+                    uniqueId: entry.nodeId,
+                    name: String((attrs === null || attrs === void 0 ? void 0 : attrs.name) || entry.nodeId),
+                    resourceType: String((attrs === null || attrs === void 0 ? void 0 : attrs.resource_type) || "unknown"),
+                    depth: entry.depth,
+                };
+            }),
+            downstream: downstream.slice(0, 8).map((entry) => {
+                const attrs = graphologyGraph.getNodeAttributes(entry.nodeId);
+                return {
+                    uniqueId: entry.nodeId,
+                    name: String((attrs === null || attrs === void 0 ? void 0 : attrs.name) || entry.nodeId),
+                    resourceType: String((attrs === null || attrs === void 0 ? void 0 : attrs.resource_type) || "unknown"),
+                    depth: entry.depth,
+                };
+            }),
+        };
+    });
+    resources.sort(sortResources);
+    return { resources, dependencyIndex };
+}
+function buildResourceGroups(resources) {
+    var _a;
+    const groupedResources = new Map();
+    for (const resource of resources) {
+        const current = (_a = groupedResources.get(resource.resourceType)) !== null && _a !== void 0 ? _a : [];
+        current.push(resource);
+        groupedResources.set(resource.resourceType, current);
+    }
+    return [...groupedResources.entries()]
+        .sort(([a], [b]) => sortByResourceType(a, b))
+        .map(([resourceType, grouped]) => ({
+        resourceType,
+        label: resourceTypeLabel(resourceType),
+        count: grouped.length,
+        attentionCount: grouped.filter((r) => r.statusTone === "danger" || r.statusTone === "warning").length,
+        resources: grouped,
+    }));
+}
+function buildManifestEntryLookup(manifestJson) {
+    const lookup = new Map();
+    const addEntries = (value) => {
+        if (value == null || typeof value !== "object")
+            return;
+        for (const [key, entry] of Object.entries(value)) {
+            if (entry != null && typeof entry === "object") {
+                lookup.set(key, entry);
+            }
+        }
+    };
+    addEntries(manifestJson.nodes);
+    addEntries(manifestJson.sources);
+    addEntries(manifestJson.unit_tests);
+    if (manifestJson.disabled != null &&
+        typeof manifestJson.disabled === "object") {
+        for (const [key, entries] of Object.entries(manifestJson.disabled)) {
+            if (!Array.isArray(entries))
+                continue;
+            for (const entry of entries) {
+                if (entry != null && typeof entry === "object") {
+                    lookup.set(key, entry);
+                }
+            }
+        }
+    }
+    return lookup;
+}
+function getManifestAttrs(uniqueId, graphologyGraph, manifestEntryLookup) {
+    if (graphologyGraph.hasNode(uniqueId)) {
+        return graphologyGraph.getNodeAttributes(uniqueId);
+    }
+    return manifestEntryLookup.get(uniqueId);
+}
+function resolveTestParentFromManifest(graph, graphologyGraph, manifestEntryLookup, testUniqueId) {
+    var _a, _b;
+    const upstream = graph.getUpstream(testUniqueId);
+    const direct = upstream.filter((u) => u.depth === 1);
+    const candidates = direct.length > 0 ? direct : upstream;
+    for (const u of candidates) {
+        const uAttrs = getManifestAttrs(u.nodeId, graphologyGraph, manifestEntryLookup);
+        const uType = String((_a = uAttrs === null || uAttrs === void 0 ? void 0 : uAttrs.resource_type) !== null && _a !== void 0 ? _a : "");
+        if (uType !== "test" && uType !== "unit_test" && uType !== "") {
+            return u.nodeId;
+        }
+    }
+    const testAttrs = manifestEntryLookup.get(testUniqueId);
+    const attachedNode = typeof (testAttrs === null || testAttrs === void 0 ? void 0 : testAttrs.attached_node) === "string"
+        ? testAttrs.attached_node
+        : null;
+    if (attachedNode != null) {
+        return attachedNode;
+    }
+    const dependsOn = testAttrs === null || testAttrs === void 0 ? void 0 : testAttrs.depends_on;
+    if (Array.isArray(dependsOn === null || dependsOn === void 0 ? void 0 : dependsOn.nodes)) {
+        for (const parentId of dependsOn.nodes) {
+            if (typeof parentId !== "string")
+                continue;
+            const parentAttrs = getManifestAttrs(parentId, graphologyGraph, manifestEntryLookup);
+            const parentType = String((_b = parentAttrs === null || parentAttrs === void 0 ? void 0 : parentAttrs.resource_type) !== null && _b !== void 0 ? _b : inferResourceTypeFromId(parentId));
+            if (parentType !== "test" && parentType !== "unit_test") {
+                return parentId;
+            }
+        }
+    }
+    return null;
+}
+function manifestDisplayPath(attrs) {
+    if (typeof (attrs === null || attrs === void 0 ? void 0 : attrs.original_file_path) === "string") {
+        return attrs.original_file_path;
+    }
+    if (typeof (attrs === null || attrs === void 0 ? void 0 : attrs.path) === "string") {
+        return attrs.path;
+    }
+    return null;
+}
+function enrichGanttItemRow(item, graph, graphologyGraph, manifestEntryLookup) {
+    const attrs = getManifestAttrs(item.unique_id, graphologyGraph, manifestEntryLookup);
+    const rtRaw = attrs === null || attrs === void 0 ? void 0 : attrs.resource_type;
+    const resourceType = typeof rtRaw === "string" && rtRaw
+        ? rtRaw
+        : inferResourceTypeFromId(item.unique_id);
+    const parentId = resourceType === "test" || resourceType === "unit_test"
+        ? resolveTestParentFromManifest(graph, graphologyGraph, manifestEntryLookup, item.unique_id)
+        : null;
+    const pkg = typeof (attrs === null || attrs === void 0 ? void 0 : attrs.package_name) === "string" && attrs.package_name.length > 0
+        ? attrs.package_name
+        : inferPackageNameFromUniqueId(item.unique_id);
+    const mat = attrs === null || attrs === void 0 ? void 0 : attrs.materialized;
+    const materialized = typeof mat === "string" && mat.trim() !== "" ? mat : null;
+    return Object.assign(Object.assign({}, item), { resourceType, packageName: pkg, path: manifestDisplayPath(attrs), parentId,
+        materialized });
+}
+function statusSeverity(status) {
+    const normalized = status === null || status === void 0 ? void 0 : status.trim().toLowerCase();
+    if (!normalized)
+        return 0;
+    if (["error", "fail", "failed", "run error"].includes(normalized)) {
+        return 3;
+    }
+    if (["warn", "warning"].includes(normalized)) {
+        return 2;
+    }
+    if (["success", "pass", "passed"].includes(normalized)) {
+        return 1;
+    }
+    return 0;
+}
+function pickRepresentativeStatus(items) {
+    var _a, _b;
+    let bestStatus = (_b = (_a = items[0]) === null || _a === void 0 ? void 0 : _a.status) !== null && _b !== void 0 ? _b : "unknown";
+    let bestSeverity = statusSeverity(bestStatus);
+    for (const item of items.slice(1)) {
+        const severity = statusSeverity(item.status);
+        if (severity > bestSeverity) {
+            bestSeverity = severity;
+            bestStatus = item.status;
+        }
+    }
+    return bestStatus;
+}
+function compareGanttItems(a, b) {
+    const startDiff = a.start - b.start;
+    if (startDiff !== 0)
+        return startDiff;
+    const durationDiff = b.duration - a.duration;
+    if (durationDiff !== 0)
+        return durationDiff;
+    return a.name.localeCompare(b.name);
+}
+function buildSyntheticSourceRows(enrichedGanttData, graphologyGraph) {
+    var _a, _b;
+    const existingIds = new Set(enrichedGanttData.map((item) => item.unique_id));
+    const testsBySourceId = new Map();
+    for (const item of enrichedGanttData) {
+        if ((item.resourceType !== "test" && item.resourceType !== "unit_test") ||
+            item.parentId == null ||
+            !graphologyGraph.hasNode(item.parentId)) {
+            continue;
+        }
+        const parentAttrs = graphologyGraph.getNodeAttributes(item.parentId);
+        if (String((_a = parentAttrs === null || parentAttrs === void 0 ? void 0 : parentAttrs.resource_type) !== null && _a !== void 0 ? _a : "") !== "source") {
+            continue;
+        }
+        const existing = (_b = testsBySourceId.get(item.parentId)) !== null && _b !== void 0 ? _b : [];
+        existing.push(item);
+        testsBySourceId.set(item.parentId, existing);
+    }
+    const syntheticRows = [];
+    for (const [sourceId, tests] of testsBySourceId.entries()) {
+        if (existingIds.has(sourceId) || tests.length === 0) {
+            continue;
+        }
+        const sourceAttrs = graphologyGraph.getNodeAttributes(sourceId);
+        const sortedTests = [...tests].sort(compareGanttItems);
+        const start = Math.min(...sortedTests.map((item) => item.start));
+        const end = Math.max(...sortedTests.map((item) => item.end));
+        syntheticRows.push({
+            unique_id: sourceId,
+            name: typeof (sourceAttrs === null || sourceAttrs === void 0 ? void 0 : sourceAttrs.name) === "string" && sourceAttrs.name.length > 0
+                ? sourceAttrs.name
+                : sourceId,
+            start,
+            end,
+            duration: Math.max(0, end - start),
+            status: pickRepresentativeStatus(sortedTests),
+            resourceType: "source",
+            packageName: typeof (sourceAttrs === null || sourceAttrs === void 0 ? void 0 : sourceAttrs.package_name) === "string" &&
+                sourceAttrs.package_name.length > 0
+                ? sourceAttrs.package_name
+                : inferPackageNameFromUniqueId(sourceId),
+            path: manifestDisplayPath(sourceAttrs),
+            parentId: null,
+            compileStart: null,
+            compileEnd: null,
+            executeStart: null,
+            executeEnd: null,
+            materialized: null,
+        });
+    }
+    return syntheticRows.sort(compareGanttItems);
+}
+function buildStatusBreakdown(summary, nodeExecutions) {
+    var _a, _b;
+    const durationByStatus = new Map();
+    for (const execution of nodeExecutions) {
+        const status = statusLabel(execution.status);
+        durationByStatus.set(status, ((_a = durationByStatus.get(status)) !== null && _a !== void 0 ? _a : 0) + ((_b = execution.execution_time) !== null && _b !== void 0 ? _b : 0));
+    }
+    return Object.entries(summary.nodes_by_status)
+        .map(([status, count]) => {
+        var _a;
+        return ({
+            status: statusLabel(status),
+            count,
+            duration: (_a = durationByStatus.get(statusLabel(status))) !== null && _a !== void 0 ? _a : 0,
+            share: summary.total_nodes > 0 ? count / summary.total_nodes : 0,
+            tone: statusTone(status),
+        });
+    })
+        .sort((a, b) => b.count - a.count);
+}
+function buildTimelineAdjacency(graphologyGraph, executedUniqueIds) {
+    const out = {};
+    for (const id of executedUniqueIds) {
+        out[id] = graphologyGraph.hasNode(id)
+            ? {
+                inbound: [...graphologyGraph.inboundNeighbors(id)],
+                outbound: [...graphologyGraph.outboundNeighbors(id)],
+            }
+            : { inbound: [], outbound: [] };
+    }
+    return out;
+}
+function buildThreadStats(executions) {
+    var _a, _b;
+    const threadAggregation = new Map();
+    for (const execution of executions) {
+        const threadId = (_a = execution.threadId) !== null && _a !== void 0 ? _a : "unknown";
+        const current = (_b = threadAggregation.get(threadId)) !== null && _b !== void 0 ? _b : {
+            count: 0,
+            totalExecutionTime: 0,
+        };
+        current.count += 1;
+        current.totalExecutionTime += execution.executionTime;
+        threadAggregation.set(threadId, current);
+    }
+    return [...threadAggregation.entries()]
+        .map(([threadId, value]) => ({
+        threadId,
+        count: value.count,
+        totalExecutionTime: value.totalExecutionTime,
+    }))
+        .sort((a, b) => b.totalExecutionTime - a.totalExecutionTime);
+}
+function buildProjectName(manifestJson) {
+    const metaMaybe = manifestJson.metadata;
+    if (metaMaybe !== null &&
+        typeof metaMaybe === "object" &&
+        "project_name" in metaMaybe &&
+        typeof metaMaybe.project_name === "string" &&
+        metaMaybe.project_name !== "") {
+        return metaMaybe.project_name;
+    }
+    return null;
+}
+function buildInvocationId(runResultsJson) {
+    const metadata = runResultsJson.metadata != null &&
+        typeof runResultsJson.metadata === "object"
+        ? runResultsJson.metadata
+        : null;
+    return typeof (metadata === null || metadata === void 0 ? void 0 : metadata.invocation_id) === "string"
+        ? metadata.invocation_id
+        : null;
+}
+function buildWarehouseType(manifestJson) {
+    const metaMaybe = manifestJson.metadata;
+    if (metaMaybe !== null &&
+        typeof metaMaybe === "object" &&
+        "adapter_type" in metaMaybe &&
+        typeof metaMaybe.adapter_type === "string" &&
+        metaMaybe.adapter_type !== "") {
+        return metaMaybe.adapter_type;
+    }
+    return null;
+}
+function buildAnalysisSnapshotFromParsedArtifacts(manifestJson, runResultsJson, manifest, runResults) {
+    var _a, _b, _c, _d;
+    const graphStart = now();
+    const graph = new manifest_graph_1.ManifestGraph(manifest);
+    const analyzer = new execution_analyzer_1.ExecutionAnalyzer(runResults, graph);
+    const graphBuildMs = now() - graphStart;
+    const snapshotStart = now();
+    const projectName = buildProjectName(manifestJson);
+    const warehouseType = buildWarehouseType(manifestJson);
+    const summary = analyzer.getSummary();
+    const manifestEntryLookup = buildManifestEntryLookup(manifestJson);
+    const ganttData = analyzer.getGanttData();
+    const nodeExecutions = analyzer.getNodeExecutions();
+    const startTimestamps = nodeExecutions
+        .map((e) => (e.started_at ? new Date(e.started_at).getTime() : null))
+        .filter((t) => t !== null);
+    const runStartedAt = startTimestamps.length > 0 ? Math.min(...startTimestamps) : null;
+    const bottlenecks = (0, run_results_search_1.detectBottlenecks)(summary.node_executions, {
+        mode: "top_n",
+        top: 5,
+        graph,
+    });
+    const graphSummary = graph.getSummary();
+    const ganttById = new Map(ganttData.map((item) => [item.unique_id, item]));
+    const executionById = new Map(nodeExecutions.map((e) => [e.unique_id, e]));
+    const { resources, dependencyIndex } = buildResourcesAndDependencyIndex(graph, executionById);
+    const graphologyGraph = graph.getGraph();
+    const enrichedGanttData = ganttData.map((item) => enrichGanttItemRow(item, graph, graphologyGraph, manifestEntryLookup));
+    const syntheticSourceRows = buildSyntheticSourceRows(enrichedGanttData, graphologyGraph);
+    const timelineGanttData = [...enrichedGanttData, ...syntheticSourceRows].sort(compareGanttItems);
+    const timelineAdjacency = buildTimelineAdjacency(graphologyGraph, timelineGanttData.map((g) => g.unique_id));
+    const executions = nodeExecutions
+        .map((execution) => {
+        var _a, _b, _c;
+        const attrs = graphologyGraph.hasNode(execution.unique_id)
+            ? graphologyGraph.getNodeAttributes(execution.unique_id)
+            : undefined;
+        const gantt = ganttById.get(execution.unique_id);
+        return {
+            uniqueId: execution.unique_id,
+            name: String((attrs === null || attrs === void 0 ? void 0 : attrs.name) || execution.unique_id),
+            resourceType: String((attrs === null || attrs === void 0 ? void 0 : attrs.resource_type) || inferResourceTypeFromId(execution.unique_id)),
+            packageName: (() => {
+                const pkg = attrs === null || attrs === void 0 ? void 0 : attrs.package_name;
+                if (typeof pkg === "string" && pkg.length > 0)
+                    return pkg;
+                return inferPackageNameFromUniqueId(execution.unique_id);
+            })(),
+            path: typeof (attrs === null || attrs === void 0 ? void 0 : attrs.original_file_path) === "string"
+                ? attrs.original_file_path
+                : typeof (attrs === null || attrs === void 0 ? void 0 : attrs.path) === "string"
+                    ? attrs.path
+                    : null,
+            status: statusLabel(execution.status),
+            statusTone: statusTone(execution.status),
+            executionTime: (_a = execution.execution_time) !== null && _a !== void 0 ? _a : 0,
+            threadId: typeof execution.thread_id === "string" ? execution.thread_id : null,
+            start: (_b = gantt === null || gantt === void 0 ? void 0 : gantt.start) !== null && _b !== void 0 ? _b : null,
+            end: (_c = gantt === null || gantt === void 0 ? void 0 : gantt.end) !== null && _c !== void 0 ? _c : null,
+        };
+    })
+        .sort((a, b) => b.executionTime - a.executionTime);
+    const resourceGroups = buildResourceGroups(resources);
+    const statusBreakdown = buildStatusBreakdown(summary, nodeExecutions);
+    const threadStats = buildThreadStats(executions);
+    const selectedResourceId = (_d = (_b = (_a = resources.find((r) => r.resourceType === "model")) === null || _a === void 0 ? void 0 : _a.uniqueId) !== null && _b !== void 0 ? _b : (_c = resources[0]) === null || _c === void 0 ? void 0 : _c.uniqueId) !== null && _d !== void 0 ? _d : null;
+    const analysis = {
+        summary,
+        projectName,
+        warehouseType,
+        runStartedAt,
+        ganttData: timelineGanttData,
+        bottlenecks,
+        graphSummary: {
+            totalNodes: graphSummary.total_nodes,
+            totalEdges: graphSummary.total_edges,
+            hasCycles: graphSummary.has_cycles,
+            nodesByType: graphSummary.nodes_by_type,
+        },
+        resources,
+        resourceGroups,
+        executions,
+        statusBreakdown,
+        threadStats,
+        dependencyIndex,
+        timelineAdjacency,
+        selectedResourceId,
+        invocationId: buildInvocationId(runResultsJson),
+    };
+    return {
+        analysis,
+        timings: {
+            graphBuildMs,
+            snapshotBuildMs: now() - snapshotStart,
+        },
+    };
+}
+async function buildAnalysisSnapshotFromArtifacts(manifestJson, runResultsJson) {
+    const [{ parseManifest }, { parseRunResults }] = await Promise.all([
+        import("dbt-artifacts-parser/manifest"),
+        import("dbt-artifacts-parser/run_results"),
+    ]);
+    const manifest = parseManifest(manifestJson);
+    const runResults = parseRunResults(runResultsJson);
+    return buildAnalysisSnapshotFromParsedArtifacts(manifestJson, runResultsJson, manifest, runResults).analysis;
+}

package/dist/analysis/dependency-service.d.ts

@@ -0,0 +1,56 @@
+import type { ManifestGraph } from "./manifest-graph";
+/**
+ * Dependency analysis result (flat format)
+ */
+export interface DependencyResult {
+    resource_id: string;
+    direction: "upstream" | "downstream";
+    build_order?: boolean;
+    dependencies: Array<{
+        unique_id: string;
+        resource_type: string;
+        name: string;
+        package_name: string;
+        depth: number;
+        [key: string]: unknown;
+    }>;
+    count: number;
+}
+/**
+ * Nested dependency node for tree format
+ */
+export interface DependencyTreeNode {
+    unique_id: string;
+    resource_type: string;
+    name: string;
+    package_name: string;
+    depth: number;
+    dependencies: DependencyTreeNode[];
+    [key: string]: unknown;
+}
+/**
+ * Dependency result in tree format
+ */
+export interface DependencyResultTree {
+    resource_id: string;
+    direction: "upstream" | "downstream";
+    dependencies: DependencyTreeNode[];
+    count: number;
+}
+/**
+ * DependencyService wraps ManifestGraph dependency methods with formatting
+ * and field filtering capabilities.
+ */
+export declare class DependencyService {
+    /**
+     * Get dependencies for a resource with optional field filtering, depth limit, output format, and build order.
+     * @param depth - Optional max traversal depth; 1 = immediate neighbors, undefined = all levels
+     * @param format - Output structure: flat list or nested tree
+     * @param buildOrder - When true and direction is upstream, return dependencies in topological build order
+     */
+    static getDependencies(graph: ManifestGraph, resourceId: string, direction: "upstream" | "downstream", fields?: string, depth?: number, format?: "flat" | "tree", buildOrder?: boolean): DependencyResult | DependencyResultTree;
+    /**
+     * Build nested tree from BFS entries with parent tracking
+     */
+    private static getDependenciesTree;
+}