@dbt-tools/core 0.3.2

package/dist/formatting/field-filter.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FieldFilter = void 0;
+/**
+ * FieldFilter provides field selection to reduce context window usage.
+ * Supports simple and nested field paths.
+ */
+class FieldFilter {
+    /**
+     * Filter fields from an object based on a comma-separated field list
+     */
+    static filterFields(data, fields) {
+        if (!fields || !fields.trim()) {
+            return data;
+        }
+        if (!data || typeof data !== "object") {
+            return data;
+        }
+        const fieldList = fields
+            .split(",")
+            .map((f) => f.trim())
+            .filter((f) => f.length > 0);
+        if (fieldList.length === 0) {
+            return data;
+        }
+        return this.filterObjectFields(data, fieldList);
+    }
+    /**
+     * Filter fields from an array of objects
+     */
+    static filterArrayFields(data, fields) {
+        if (!fields || !fields.trim()) {
+            return data;
+        }
+        if (!Array.isArray(data)) {
+            return data;
+        }
+        return data.map((item) => this.filterFields(item, fields));
+    }
+    /**
+     * Filter fields from an object using field paths
+     */
+    static filterObjectFields(obj, fieldPaths) {
+        const result = Object.create(null);
+        for (const fieldPath of fieldPaths) {
+            const value = this.getNestedValue(obj, fieldPath);
+            if (value !== undefined) {
+                this.setNestedValue(result, fieldPath, value);
+            }
+        }
+        return result;
+    }
+    /** Rejects prototype-pollution keys (__proto__, constructor, prototype). */
+    static isUnsafeKey(part) {
+        return (part === "__proto__" || part === "constructor" || part === "prototype");
+    }
+    /**
+     * Get a nested value from an object using dot notation.
+     * Rejects prototype-pollution keys (__proto__, constructor, prototype).
+     */
+    static getNestedValue(obj, path) {
+        const parts = path.split(".");
+        let current = obj;
+        for (const part of parts) {
+            if (this.isUnsafeKey(part))
+                return undefined;
+            if (current === null ||
+                current === undefined ||
+                typeof current !== "object") {
+                return undefined;
+            }
+            if (!Object.prototype.hasOwnProperty.call(current, part)) {
+                return undefined;
+            }
+            // nosemgrep: javascript.lang.security.audit.prototype-pollution.prototype-pollution-loop
+            // Part is validated by isUnsafeKey above; hasOwnProperty ensures we don't read proto chain.
+            current = current[part];
+        }
+        return current;
+    }
+    /**
+     * Set a nested value in an object using dot notation
+     */
+    static setNestedValue(obj, path, value) {
+        const parts = path.split(".");
+        let current = obj;
+        for (let i = 0; i < parts.length - 1; i++) {
+            const part = parts[i];
+            if (part === "__proto__" ||
+                part === "constructor" ||
+                part === "prototype") {
+                return;
+            }
+            if (!Object.prototype.hasOwnProperty.call(current, part) ||
+                typeof current[part] !== "object" ||
+                current[part] === null) {
+                current[part] = Object.create(null);
+            }
+            // nosemgrep: javascript.lang.security.audit.prototype-pollution.prototype-pollution-loop
+            // Part is validated by isUnsafeKey check above; assignment creates own property only.
+            current = current[part];
+        }
+        const lastPart = parts[parts.length - 1];
+        if (lastPart === "__proto__" ||
+            lastPart === "constructor" ||
+            lastPart === "prototype") {
+            return;
+        }
+        current[lastPart] = value;
+    }
+}
+exports.FieldFilter = FieldFilter;

package/dist/formatting/graph-export.d.ts

@@ -0,0 +1,9 @@
+import type { DirectedGraph } from "graphology";
+import type { GraphNodeAttributes, GraphEdgeAttributes } from "../types";
+export interface GraphExportOptions {
+    format?: string;
+    output?: string;
+    fields?: string;
+}
+export declare function exportGraphToFormat(graph: DirectedGraph<GraphNodeAttributes, GraphEdgeAttributes>, options: GraphExportOptions): string;
+export declare function writeGraphOutput(output: string, outputPath?: string): void;

package/dist/formatting/graph-export.js

@@ -0,0 +1,147 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exportGraphToFormat = exportGraphToFormat;
+exports.writeGraphOutput = writeGraphOutput;
+/**
+ * Graph export helpers for JSON, DOT, and GEXF formats.
+ * Used by the CLI graph command and other graph export consumers.
+ */
+const fs = __importStar(require("fs"));
+const field_filter_1 = require("./field-filter");
+function exportGraphToFormat(graph, options) {
+    var _a;
+    const fmt = (_a = options.format) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+    if (fmt === "json")
+        return exportGraphJson(graph, options);
+    if (fmt === "dot")
+        return exportGraphDot(graph);
+    if (fmt === "gexf")
+        return exportGraphGexf(graph);
+    throw new Error(`Unsupported format: ${options.format}`);
+}
+function exportGraphJson(graph, options) {
+    const nodes = [];
+    const edges = [];
+    graph.forEachNode((nodeId, attributes) => {
+        let filteredAttrs = attributes;
+        if (options.fields) {
+            filteredAttrs = field_filter_1.FieldFilter.filterFields(attributes, options.fields);
+        }
+        nodes.push({ id: nodeId, attributes: filteredAttrs });
+    });
+    graph.forEachEdge((_edgeId, attributes, source, target) => {
+        edges.push({ source, target, attributes });
+    });
+    return JSON.stringify({ nodes, edges }, null, 2);
+}
+function exportGraphDot(graph) {
+    const lines = ["digraph DbtGraph {"];
+    lines.push("  compound=true;");
+    lines.push("  node [shape=box, style=filled, fillcolor=white];");
+    const resourceNodes = [];
+    const fieldNodesByParent = {};
+    graph.forEachNode((nodeId, attributes) => {
+        if (attributes.resource_type === "field") {
+            const parentId = attributes.parent_id;
+            if (!fieldNodesByParent[parentId]) {
+                fieldNodesByParent[parentId] = [];
+            }
+            fieldNodesByParent[parentId].push(nodeId);
+        }
+        else {
+            resourceNodes.push(nodeId);
+        }
+    });
+    for (const nodeId of resourceNodes) {
+        const attributes = graph.getNodeAttributes(nodeId);
+        const name = attributes.name || nodeId;
+        const fields = fieldNodesByParent[nodeId];
+        if (fields && fields.length > 0) {
+            lines.push(`  subgraph "cluster_${nodeId}" {`);
+            lines.push(`    label = "${name}";`);
+            lines.push("    style = filled;");
+            lines.push("    fillcolor = lightgrey;");
+            for (const fieldId of fields) {
+                const fieldAttr = graph.getNodeAttributes(fieldId);
+                lines.push(`    "${fieldId}" [label="${fieldAttr.name}", fillcolor=white];`);
+            }
+            lines.push("  }");
+        }
+        else {
+            lines.push(`  "${nodeId}" [label="${name}"];`);
+        }
+    }
+    graph.forEachEdge((_edgeId, attributes, source, target) => {
+        if (attributes.dependency_type !== "internal") {
+            lines.push(`  "${source}" -> "${target}";`);
+        }
+    });
+    lines.push("}");
+    return lines.join("\n");
+}
+function exportGraphGexf(graph) {
+    const nodes = [];
+    const edges = [];
+    graph.forEachNode((nodeId, attributes) => {
+        nodes.push({
+            id: nodeId,
+            label: attributes.name || nodeId,
+        });
+    });
+    graph.forEachEdge((_edgeId, _attributes, source, target) => {
+        edges.push({ source, target });
+    });
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<gexf xmlns="http://www.gexf.net/1.2draft" version="1.2">
+  <graph mode="static" defaultedgetype="directed">
+    <nodes>
+${nodes.map((n) => `      <node id="${n.id}" label="${n.label}"/>`).join("\n")}
+    </nodes>
+    <edges>
+${edges.map((e, i) => `      <edge id="${i}" source="${e.source}" target="${e.target}"/>`).join("\n")}
+    </edges>
+  </graph>
+</gexf>`;
+}
+function writeGraphOutput(output, outputPath) {
+    if (outputPath) {
+        fs.writeFileSync(outputPath, output, "utf-8");
+        console.log(`Graph exported to ${outputPath}`);
+    }
+    else {
+        console.log(output);
+    }
+}

package/dist/formatting/output-formatter.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Check if stdout is a TTY
+ */
+export declare function isTTY(): boolean;
+/**
+ * Determine if output should be JSON
+ */
+export declare function shouldOutputJSON(forceJson?: boolean, forceNoJson?: boolean): boolean;
+/**
+ * Format output as JSON or human-readable based on context
+ */
+export declare function formatOutput(data: unknown, forceJson?: boolean, forceNoJson?: boolean): string;
+/**
+ * Format summary command output
+ */
+export declare function formatSummary(summary: {
+    total_nodes: number;
+    total_edges: number;
+    has_cycles: boolean;
+    nodes_by_type: Record<string, number>;
+}): string;
+/**
+ * Format deps command output (flat or tree)
+ */
+export declare function formatDeps(result: {
+    resource_id: string;
+    direction: "upstream" | "downstream";
+    dependencies: Array<{
+        unique_id: string;
+        resource_type: string;
+        name: string;
+        package_name: string;
+        depth?: number;
+        dependencies?: unknown[];
+        [key: string]: unknown;
+    }>;
+    count: number;
+}, format?: "flat" | "tree"): string;
+/**
+ * Bottleneck node for formatting
+ */
+export interface BottleneckNodeForFormat {
+    unique_id: string;
+    name?: string;
+    execution_time: number;
+    rank: number;
+    pct_of_total: number;
+    status: string;
+}
+/**
+ * Format bottleneck section for human-readable output
+ */
+export declare function formatBottlenecks(bottlenecks: {
+    nodes: BottleneckNodeForFormat[];
+    total_execution_time: number;
+    criteria_used: "top_n" | "threshold";
+}, topLabel?: string): string;
+/**
+ * Format run-report command output
+ */
+export declare function formatRunReport(summary: {
+    total_execution_time: number;
+    total_nodes: number;
+    nodes_by_status: Record<string, number>;
+    critical_path?: {
+        path: string[];
+        total_time: number;
+    };
+}, bottlenecks?: {
+    nodes: BottleneckNodeForFormat[];
+    total_execution_time: number;
+    criteria_used: "top_n" | "threshold";
+}, bottlenecksTopLabel?: string): string;
+/**
+ * Format human-readable output for a specific command type
+ */
+export declare function formatHumanReadable(data: unknown, format: "summary" | "deps" | "run-report"): string;

package/dist/formatting/output-formatter.js

@@ -0,0 +1,160 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTTY = isTTY;
+exports.shouldOutputJSON = shouldOutputJSON;
+exports.formatOutput = formatOutput;
+exports.formatSummary = formatSummary;
+exports.formatDeps = formatDeps;
+exports.formatBottlenecks = formatBottlenecks;
+exports.formatRunReport = formatRunReport;
+exports.formatHumanReadable = formatHumanReadable;
+function formatDepsTreeNode(node, prefix, isLast, lines) {
+    var _a;
+    const depthStr = typeof node.depth === "number" ? ` [depth ${node.depth}]` : "";
+    const connector = isLast ? "└── " : "├── ";
+    lines.push(`${prefix}${connector}${node.unique_id} (${node.resource_type}) - ${node.name}${depthStr}`);
+    const children = ((_a = node.dependencies) !== null && _a !== void 0 ? _a : []);
+    const childPrefix = prefix + (isLast ? "    " : "│   ");
+    for (let i = 0; i < children.length; i++) {
+        formatDepsTreeNode(children[i], childPrefix, i === children.length - 1, lines);
+    }
+}
+function formatDepsTree(result) {
+    var _a;
+    const rootName = (_a = result.resource_id.split(".").pop()) !== null && _a !== void 0 ? _a : result.resource_id;
+    const lines = [];
+    lines.push(`${rootName} (${result.direction})`);
+    lines.push(`Count: ${result.count}`);
+    lines.push("");
+    for (let i = 0; i < result.dependencies.length; i++) {
+        formatDepsTreeNode(result.dependencies[i], "", i === result.dependencies.length - 1, lines);
+    }
+    return lines.join("\n");
+}
+/**
+ * Check if stdout is a TTY
+ */
+function isTTY() {
+    return process.stdout.isTTY === true;
+}
+/**
+ * Determine if output should be JSON
+ */
+function shouldOutputJSON(forceJson, forceNoJson) {
+    if (forceNoJson === true) {
+        return false;
+    }
+    if (forceJson === true) {
+        return true;
+    }
+    return !isTTY();
+}
+/**
+ * Format output as JSON or human-readable based on context
+ */
+function formatOutput(data, forceJson, forceNoJson) {
+    const useJson = shouldOutputJSON(forceJson, forceNoJson);
+    if (useJson) {
+        return JSON.stringify(data, null, 2);
+    }
+    return String(data);
+}
+/**
+ * Format summary command output
+ */
+function formatSummary(summary) {
+    const lines = [];
+    lines.push("dbt Project Summary");
+    lines.push("===================");
+    lines.push(`Total Nodes: ${summary.total_nodes}`);
+    lines.push(`Total Edges: ${summary.total_edges}`);
+    lines.push(`Has Cycles: ${summary.has_cycles ? "Yes" : "No"}`);
+    lines.push("\nNodes by Type:");
+    for (const [type, count] of Object.entries(summary.nodes_by_type)) {
+        lines.push(`  ${type}: ${count}`);
+    }
+    return lines.join("\n");
+}
+/**
+ * Format deps command output (flat or tree)
+ */
+function formatDeps(result, format) {
+    if (format === "tree") {
+        return formatDepsTree(result);
+    }
+    const lines = [];
+    lines.push(`Dependencies for ${result.resource_id}`);
+    lines.push(`Direction: ${result.direction}`);
+    lines.push(`Count: ${result.count}`);
+    lines.push("\nDependencies:");
+    if (result.dependencies.length === 0) {
+        lines.push("  (none)");
+    }
+    else {
+        for (const dep of result.dependencies) {
+            const depthStr = typeof dep.depth === "number" ? ` [depth ${dep.depth}]` : "";
+            lines.push(`  - ${dep.unique_id} (${dep.resource_type}) - ${dep.name}${depthStr}`);
+        }
+    }
+    return lines.join("\n");
+}
+/**
+ * Format bottleneck section for human-readable output
+ */
+function formatBottlenecks(bottlenecks, topLabel) {
+    var _a;
+    if (bottlenecks.nodes.length === 0) {
+        return "\nBottlenecks: (none)\n";
+    }
+    const criteriaLabel = topLabel !== null && topLabel !== void 0 ? topLabel : (bottlenecks.criteria_used === "top_n" ? "top N" : "threshold");
+    const lines = [];
+    lines.push(`\nBottlenecks (${criteriaLabel} by execution time):`);
+    lines.push("  Rank  Node                              Time (s)  % of Total");
+    const maxIdLen = 34;
+    for (const node of bottlenecks.nodes) {
+        const label = (_a = node.name) !== null && _a !== void 0 ? _a : node.unique_id;
+        const idDisplay = label.length > maxIdLen ? label.slice(0, maxIdLen - 3) + "..." : label;
+        const padded = idDisplay.padEnd(maxIdLen);
+        const timeStr = node.execution_time.toFixed(2).padStart(8);
+        lines.push(`  ${String(node.rank).padStart(2)}     ${padded}  ${timeStr}    ${node.pct_of_total.toFixed(1)}%`);
+    }
+    return lines.join("\n") + "\n";
+}
+/**
+ * Format run-report command output
+ */
+function formatRunReport(summary, bottlenecks, bottlenecksTopLabel) {
+    const lines = [];
+    lines.push("dbt Execution Report");
+    lines.push("===================");
+    lines.push(`Total Execution Time: ${summary.total_execution_time.toFixed(2)}s`);
+    lines.push(`Total Nodes: ${summary.total_nodes}`);
+    lines.push("\nNodes by Status:");
+    for (const [status, count] of Object.entries(summary.nodes_by_status)) {
+        lines.push(`  ${status}: ${count}`);
+    }
+    if (summary.critical_path) {
+        lines.push("\nCritical Path:");
+        lines.push(`  Path: ${summary.critical_path.path.join(" -> ")}`);
+        lines.push(`  Total Time: ${summary.critical_path.total_time.toFixed(2)}s`);
+    }
+    if (bottlenecks) {
+        lines.push(formatBottlenecks(bottlenecks, bottlenecksTopLabel));
+    }
+    return lines.join("\n");
+}
+/**
+ * Format human-readable output for a specific command type
+ */
+function formatHumanReadable(data, format) {
+    switch (format) {
+        case "summary":
+            return formatSummary(data);
+        case "deps":
+            return formatDeps(data);
+        case "run-report":
+            return formatRunReport(data);
+        default:
+            return String(data);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+export * from "./analysis/manifest-graph";
+export * from "./analysis/execution-analyzer";
+export * from "./analysis/dependency-service";
+export * from "./analysis/sql-analyzer";
+export * from "./analysis/run-results-search";
+export * from "./analysis/analysis-snapshot";
+export * from "./io/artifact-loader";
+export * from "./validation/input-validator";
+export * from "./formatting/output-formatter";
+export * from "./formatting/field-filter";
+export * from "./formatting/graph-export";
+export * from "./errors/error-handler";
+export * from "./introspection/schema-generator";
+export * from "./types";
+export * from "./version";

package/dist/index.js

@@ -0,0 +1,38 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Analysis exports
+__exportStar(require("./analysis/manifest-graph"), exports);
+__exportStar(require("./analysis/execution-analyzer"), exports);
+__exportStar(require("./analysis/dependency-service"), exports);
+__exportStar(require("./analysis/sql-analyzer"), exports);
+__exportStar(require("./analysis/run-results-search"), exports);
+__exportStar(require("./analysis/analysis-snapshot"), exports);
+// I/O exports
+__exportStar(require("./io/artifact-loader"), exports);
+// Validation exports
+__exportStar(require("./validation/input-validator"), exports);
+// Formatting exports
+__exportStar(require("./formatting/output-formatter"), exports);
+__exportStar(require("./formatting/field-filter"), exports);
+__exportStar(require("./formatting/graph-export"), exports);
+// Error handling exports
+__exportStar(require("./errors/error-handler"), exports);
+// Introspection exports
+__exportStar(require("./introspection/schema-generator"), exports);
+// Shared types and utilities
+__exportStar(require("./types"), exports);
+__exportStar(require("./version"), exports);

package/dist/introspection/schema-generator.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Command schema definition for runtime introspection
+ */
+export interface CommandSchema {
+    command: string;
+    description: string;
+    arguments: Array<{
+        name: string;
+        required: boolean;
+        description: string;
+    }>;
+    options: Array<{
+        name: string;
+        type: string;
+        values?: string[];
+        default?: string;
+        description: string;
+    }>;
+    output_format: string;
+    example: string;
+}
+/**
+ * Get schema for a specific command
+ */
+export declare function getCommandSchema(command: string): CommandSchema | null;
+/**
+ * Get all command schemas
+ */
+export declare function getAllSchemas(): Record<string, CommandSchema>;