@ddt-tools/cli 0.2.0 → 0.2.5

package/dist/lineage-C5CGVP36.js

@@ -0,0 +1,555 @@
+import {
+  attachExplainFlag,
+  runExplain
+} from "./chunk-XFXG347C.js";
+import "./chunk-DGUM43GV.js";
+
+// src/commands/lineage.ts
+import { promises as fs } from "fs";
+import { randomUUID } from "crypto";
+import path from "path";
+import { Command } from "commander";
+import {
+  loadProject,
+  pac,
+  parseProjectModel,
+  lineage,
+  columnLineage
+} from "@ddt-tools/core";
+var VALID_OL_EVENT_TYPES = /* @__PURE__ */ new Set([
+  "START",
+  "RUNNING",
+  "COMPLETE",
+  "ABORT",
+  "FAIL",
+  "OTHER"
+]);
+function validateEventType(raw) {
+  const upper = raw.toUpperCase();
+  if (!VALID_OL_EVENT_TYPES.has(upper)) {
+    throw new Error(
+      `--emit-openlineage-event-type ${JSON.stringify(raw)} is not a valid OpenLineage event type. Use one of: ${[...VALID_OL_EVENT_TYPES].join(", ")}.`
+    );
+  }
+  return upper;
+}
+var AUTO_MODE_THRESHOLD = 10;
+function resolveAutoMode(mode, eventCount) {
+  if (mode !== "auto") return mode;
+  return eventCount <= AUTO_MODE_THRESHOLD ? "per-event" : "batch";
+}
+function validateMode(raw) {
+  const lower = raw.toLowerCase();
+  if (lower !== "per-event" && lower !== "batch" && lower !== "auto") {
+    throw new Error(
+      `--emit-openlineage-mode ${JSON.stringify(raw)} is not valid. Use one of: per-event, batch, auto.`
+    );
+  }
+  return lower;
+}
+function validateEventsOutFormat(raw) {
+  const lower = raw.toLowerCase();
+  if (lower !== "json" && lower !== "jsonl") {
+    throw new Error(
+      `--emit-openlineage-events-out-format ${JSON.stringify(raw)} is not valid. Use one of: json, jsonl.`
+    );
+  }
+  return lower;
+}
+function validateEventTime(raw) {
+  const parsed = new Date(raw);
+  if (Number.isNaN(parsed.getTime())) {
+    throw new Error(
+      `--emit-openlineage-event-time ${JSON.stringify(raw)} is not a valid ISO 8601 timestamp. Examples: 2026-05-18T20:00:00Z, 2026-05-18T16:00:00-04:00.`
+    );
+  }
+  return parsed.toISOString();
+}
+function parseHeaderArgs(args, stderr = () => {
+}) {
+  const out = {};
+  if (!args || args.length === 0) return out;
+  for (const raw of args) {
+    const eq = raw.indexOf("=");
+    if (eq <= 0) {
+      stderr(
+        `Ignoring malformed --emit-openlineage-header value ${JSON.stringify(raw)} (expected name=value).
+`
+      );
+      continue;
+    }
+    const name = raw.slice(0, eq).trim();
+    const value = raw.slice(eq + 1);
+    if (!name) {
+      stderr(`Ignoring --emit-openlineage-header with empty name.
+`);
+      continue;
+    }
+    out[name] = value;
+  }
+  return out;
+}
+async function emitOpenLineageFromCli(inputs, deps = {}) {
+  const stdout = deps.stdout ?? ((c) => process.stdout.write(c));
+  const stderr = deps.stderr ?? ((c) => process.stderr.write(c));
+  const readFile = deps.readFile ?? ((p) => fs.readFile(p, "utf8"));
+  const writeFile = deps.writeFile ?? (async (p, data) => {
+    await fs.mkdir(path.dirname(p), { recursive: true });
+    await fs.writeFile(p, data, "utf8");
+  });
+  const env = deps.env ?? process.env;
+  const now = deps.now ?? (() => /* @__PURE__ */ new Date());
+  const uuid = deps.uuid ?? (() => randomUUID());
+  let loaded;
+  const configPath = inputs.configPath ?? columnLineage.DEFAULT_OPENLINEAGE_CONFIG_FILE_REL;
+  try {
+    const raw = await readFile(configPath);
+    const json = JSON.parse(raw);
+    const parsed = columnLineage.parseOpenLineageConfig(json);
+    if (!parsed.config) {
+      const lines = parsed.errors.map((e) => `  - ${e.path}: ${e.message}`);
+      stderr(`Failed to parse ${configPath}:
+${lines.join("\n")}
+`);
+      return {
+        ok: false,
+        events: 0,
+        error: { code: "CONFIG_PARSE_FAILED", message: `${configPath} did not validate` }
+      };
+    }
+    loaded = parsed.config;
+  } catch (err) {
+    const code = err.code;
+    if (code !== "ENOENT") {
+      stderr(`Failed reading ${configPath}: ${err.message}
+`);
+      return {
+        ok: false,
+        events: 0,
+        error: { code: "CONFIG_READ_FAILED", message: err.message }
+      };
+    }
+  }
+  const overrides = {};
+  if (inputs.endpointFlag) overrides.endpoint = inputs.endpointFlag;
+  if (inputs.namespace) overrides.datasetNamespace = inputs.namespace;
+  if (inputs.jobNamespace) overrides.jobNamespace = inputs.jobNamespace;
+  if (inputs.job) overrides.jobName = inputs.job;
+  if (inputs.mode && inputs.mode !== "auto") overrides.mode = inputs.mode;
+  if (typeof inputs.timeoutMs === "number" && Number.isFinite(inputs.timeoutMs) && inputs.timeoutMs > 0) {
+    overrides.timeoutMs = Math.floor(inputs.timeoutMs);
+  }
+  if (inputs.token) overrides.bearerToken = inputs.token;
+  if (inputs.producer && inputs.producer.trim().length > 0)
+    overrides.producer = inputs.producer.trim();
+  const cliHeaders = parseHeaderArgs(inputs.headerArgs, stderr);
+  if (Object.keys(cliHeaders).length > 0) overrides.headers = cliHeaders;
+  const merged = columnLineage.mergeOpenLineageCliOverrides(loaded, overrides);
+  const validated = columnLineage.validateOpenLineageConfig(merged);
+  if (!validated.ok) {
+    const lines = validated.errors.map((e) => `  - ${e.path}: ${e.message}`);
+    stderr(`OpenLineage emit refused:
+${lines.join("\n")}
+`);
+    return {
+      ok: false,
+      events: 0,
+      error: { code: "CONFIG_INCOMPLETE", message: validated.errors[0].message }
+    };
+  }
+  const resolved = columnLineage.resolveEnvPlaceholders(validated.resolved, env);
+  if (!resolved.ok) {
+    const lines = resolved.missing.map((m) => `  - ${m.path}: missing env var ${m.envKey}`);
+    stderr(`OpenLineage env placeholders unresolved:
+${lines.join("\n")}
+`);
+    return {
+      ok: false,
+      events: 0,
+      error: { code: "ENV_UNRESOLVED", message: resolved.missing[0].envKey }
+    };
+  }
+  const final = resolved.resolved;
+  const jobName = final.jobName ?? inputs.sourceHint ?? "ddt-lineage";
+  const eventType = inputs.eventType ?? "COMPLETE";
+  const events = columnLineage.buildOpenLineageEvents(inputs.dag, {
+    runId: inputs.runId ?? uuid(),
+    jobName,
+    jobNamespace: final.jobNamespace ?? columnLineage.DEFAULT_OPENLINEAGE_JOB_NAMESPACE,
+    ...final.datasetNamespace ? { datasetNamespace: final.datasetNamespace } : {},
+    ...final.producer ? { producer: final.producer } : {},
+    eventTime: inputs.eventTime ?? now().toISOString(),
+    eventType
+  });
+  if (inputs.eventsOutPath) {
+    const format = inputs.eventsOutFormat ?? "json";
+    const payload = format === "jsonl" ? events.map((e) => JSON.stringify(e)).join("\n") + "\n" : JSON.stringify({ events }, null, 2) + "\n";
+    await writeFile(inputs.eventsOutPath, payload);
+    stderr(
+      `OpenLineage: wrote ${events.length} event(s) to ${inputs.eventsOutPath} (${format}).
+`
+    );
+  }
+  if (typeof inputs.minEvents === "number" && Number.isFinite(inputs.minEvents) && inputs.minEvents > 0 && events.length < inputs.minEvents) {
+    stderr(
+      `OpenLineage: built ${events.length} event(s), below --emit-openlineage-min-events=${inputs.minEvents}; refusing to emit.
+`
+    );
+    return {
+      ok: false,
+      events: events.length,
+      error: {
+        code: "MIN_EVENTS_NOT_MET",
+        message: `built ${events.length} events, expected >= ${inputs.minEvents}`
+      }
+    };
+  }
+  if (inputs.dryRun) {
+    stdout(JSON.stringify({ events }, null, 2) + "\n");
+    return { ok: true, events: events.length };
+  }
+  if (events.length === 0 && inputs.skipEmpty) {
+    stderr(
+      "OpenLineage: 0 events to emit (DAG empty) and --emit-openlineage-skip-empty set; skipping POST.\n"
+    );
+    return { ok: true, events: 0, succeeded: 0, failed: 0 };
+  }
+  const concreteMode = inputs.mode === "auto" ? resolveAutoMode("auto", events.length) : final.mode ?? "per-event";
+  if (inputs.mode === "auto") {
+    stderr(
+      `OpenLineage: --emit-openlineage-mode=auto resolved to ${concreteMode} (${events.length} event(s), threshold=${AUTO_MODE_THRESHOLD}).
+`
+    );
+  }
+  const result = await columnLineage.emitOpenLineageEvents(events, final.endpoint, {
+    ...final.bearerToken ? { bearerToken: final.bearerToken } : {},
+    ...final.headers ? { headers: final.headers } : {},
+    mode: concreteMode,
+    ...typeof final.timeoutMs === "number" ? { timeoutMs: final.timeoutMs } : {},
+    ...deps.fetchImpl ? { fetchImpl: deps.fetchImpl } : {}
+  });
+  stderr(
+    `OpenLineage: ${result.succeeded}/${result.totalEvents} events delivered to ${final.endpoint} (${result.failed} failed).
+`
+  );
+  return {
+    ok: result.failed === 0,
+    events: result.totalEvents,
+    succeeded: result.succeeded,
+    failed: result.failed
+  };
+}
+function lineageCommand() {
+  const cmd = new Command("lineage");
+  cmd.description("Extract data-flow lineage from a .ddtproj, .ddtpac, or dbt manifest.json.").option("--source <path>", ".ddtproj or .ddtpac to analyze.").option(
+    "--dbt-manifest <path>",
+    "Extract column-level lineage from a dbt target/manifest.json (or project root)."
+  ).option(
+    "--fqn <name>",
+    "Focus on this fully-qualified name; restrict the graph to its upstream + downstream slice."
+  ).option(
+    "--direction <kind>",
+    "When --fqn is set, restrict to upstream | downstream | both. Default both.",
+    "both"
+  ).option(
+    "--depth <n>",
+    "Max traversal depth from --fqn. Default unbounded.",
+    (v) => parseInt(v, 10)
+  ).option("--format <fmt>", "mermaid | dot | json | markdown. Default mermaid.", "mermaid").option("--columns", "Include best-effort column-level lineage for view SELECT lists.", false).option(
+    "--column-dag",
+    "Build a true per-column DAG via the CLL.1/2/3 substrate. Walks every VIEW / MATERIALIZED_VIEW / STREAMING_TABLE body in the project model, extracts column-level lineage, assembles the DAG, and emits Mermaid (default) or JSON. Composes with --fqn (focus to one object) and --out.",
+    false
+  ).option("--max-edges <n>", "Truncate large graphs at this edge count.", (v) => parseInt(v, 10)).option("-o, --out <path>", "Output file path. Defaults to stdout.").option(
+    "--emit-openlineage [endpoint]",
+    "CLL.7-followup: emit the column DAG as OpenLineage RunEvents to the given collector URL. When the flag is given without a value, the endpoint from .ddt/lineage.json is used. Requires --column-dag (or --dbt-manifest)."
+  ).option(
+    "--emit-openlineage-config <path>",
+    "Override the config-file location (default .ddt/lineage.json)."
+  ).option(
+    "--emit-openlineage-namespace <ns>",
+    "Override the OpenLineage dataset namespace (default databricks)."
+  ).option(
+    "--emit-openlineage-job-namespace <ns>",
+    "Override the OpenLineage job.namespace (default ddt). Groups jobs across deployments in Marquez/OpenMetadata."
+  ).option(
+    "--emit-openlineage-job <name>",
+    "Override the OpenLineage job.name (default derived from --source)."
+  ).option(
+    "--emit-openlineage-mode <mode>",
+    "OpenLineage emit mode: per-event (default) | batch | auto. `auto` resolves to per-event when the DAG has \u226410 events (easier to debug in Marquez UI) and batch when >10 (amortizes HTTP overhead)."
+  ).option(
+    "--emit-openlineage-timeout-ms <ms>",
+    "Override per-request timeout (positive integer, default 10000ms).",
+    (v) => parseInt(v, 10)
+  ).option(
+    "--emit-openlineage-token <token>",
+    "Override bearer token (supports env:VAR_NAME for indirection)."
+  ).option(
+    "--emit-openlineage-header <k=v>",
+    "Extra HTTP header attached to every OpenLineage POST (repeatable). Format: name=value. Values support env:VAR_NAME for indirection.",
+    (val, prev) => [...prev, val],
+    []
+  ).option(
+    "--emit-openlineage-producer <url>",
+    "Override the OpenLineage producer URL (identifies the emitting tool to the collector). Default: https://github.com/GVOrganization/SDT."
+  ).option(
+    "--emit-openlineage-event-type <type>",
+    "OpenLineage event type: COMPLETE (default), START, RUNNING, ABORT, FAIL, or OTHER. Use START + COMPLETE pairs (sharing --emit-openlineage-run-id) for run-lifecycle modelling."
+  ).option(
+    "--emit-openlineage-event-time <iso>",
+    'Override the OpenLineage eventTime (ISO 8601). Default: now() at emit time. Use for backfill \u2014 replay historical pipeline runs into Marquez/OpenMetadata with their original timestamps instead of "now".'
+  ).option(
+    "--emit-openlineage-run-id <id>",
+    "Stable runId (UUID v4). Default: generated per invocation."
+  ).option(
+    "--emit-openlineage-dry-run",
+    "Build OpenLineage events but do not POST \u2014 print the events JSON to stdout instead.",
+    false
+  ).option(
+    "--emit-openlineage-events-out <path>",
+    "Also write the built events JSON to <path> (audit / replay). Independent of --dry-run; combined yields write-only-no-POST."
+  ).option(
+    "--emit-openlineage-events-out-format <fmt>",
+    "Output format for --emit-openlineage-events-out: json (default, `{events: [...]}` wrapper) or jsonl (newline-delimited, one event per line). Use jsonl for streaming-ingest pipelines (Vector, Fluent Bit, OpenTelemetry collectors, Databricks Auto Loader)."
+  ).option(
+    "--emit-openlineage-skip-empty",
+    "Skip the POST when the built events array is empty (default behavior is to still hit the collector with 0 events in batch mode). Useful in CI when lineage extraction may produce an empty DAG and noisy 0-event traffic is undesirable.",
+    false
+  ).option(
+    "--emit-openlineage-min-events <n>",
+    "CI assertion: refuse to emit (exit 2) when the built events count is below this threshold. Catches silent lineage gaps after a refactor that bypasses column-lineage extraction. Skip-empty composes naturally \u2014 set min-events=1 to force every run to produce \u22651 event.",
+    (v) => parseInt(v, 10)
+  ).action(async (opts) => {
+    if (opts.emitOpenlineage && !opts.columnDag && !opts.dbtManifest) {
+      process.stderr.write(
+        "--emit-openlineage requires --column-dag (CLL.2 DAG) or --dbt-manifest. The default FQN-level lineage path has no column-level facet to emit. Re-run with --column-dag --source <path> or --dbt-manifest <path>.\n"
+      );
+      process.exitCode = 2;
+      return;
+    }
+    if (opts.columnDag) {
+      if (!opts.source) throw new Error("--column-dag requires --source <path>.");
+      const model2 = await loadModel(String(opts.source));
+      const inputs = collectColumnLineageInputs(model2);
+      const dag = columnLineage.buildColumnLineageDag(inputs);
+      let renderedDag = dag;
+      if (opts.fqn) {
+        const focus2 = String(opts.fqn);
+        const direction2 = String(opts.direction ?? "both").toLowerCase();
+        renderedDag = columnLineage.sliceColumnDag(dag, focus2, direction2);
+      }
+      const fmt2 = String(opts.format ?? "mermaid").toLowerCase();
+      if (!["mermaid", "json"].includes(fmt2)) {
+        throw new Error(`--column-dag only supports --format mermaid|json (got ${fmt2}).`);
+      }
+      const payload2 = fmt2 === "json" ? JSON.stringify(columnLineage.renderDagJson(renderedDag), null, 2) : columnLineage.renderDagMermaid(renderedDag);
+      if (opts.out) {
+        const out = path.resolve(String(opts.out));
+        await fs.mkdir(path.dirname(out), { recursive: true });
+        await fs.writeFile(out, payload2 + "\n", "utf8");
+        console.error(
+          `Wrote ${out} (${renderedDag.nodes.size} nodes, ${renderedDag.edges.length} edges).`
+        );
+      } else if (!opts.emitOpenlineage) {
+        process.stdout.write(payload2 + "\n");
+      }
+      if (opts.emitOpenlineage) {
+        const endpointFlag = typeof opts.emitOpenlineage === "string" && opts.emitOpenlineage.length > 0 ? String(opts.emitOpenlineage) : void 0;
+        const sourceHint = opts.source ? path.basename(String(opts.source)).replace(/\.(ddtproj|ddtpac)$/i, "") : void 0;
+        const outcome = await emitOpenLineageFromCli({
+          dag: renderedDag,
+          ...endpointFlag ? { endpointFlag } : {},
+          ...opts.emitOpenlineageConfig ? { configPath: String(opts.emitOpenlineageConfig) } : {},
+          ...opts.emitOpenlineageNamespace ? { namespace: String(opts.emitOpenlineageNamespace) } : {},
+          ...opts.emitOpenlineageJobNamespace ? { jobNamespace: String(opts.emitOpenlineageJobNamespace) } : {},
+          ...opts.emitOpenlineageJob ? { job: String(opts.emitOpenlineageJob) } : {},
+          ...opts.emitOpenlineageMode ? { mode: validateMode(String(opts.emitOpenlineageMode)) } : {},
+          ...opts.emitOpenlineageEventType ? { eventType: validateEventType(String(opts.emitOpenlineageEventType)) } : {},
+          ...opts.emitOpenlineageEventTime ? { eventTime: validateEventTime(String(opts.emitOpenlineageEventTime)) } : {},
+          ...typeof opts.emitOpenlineageTimeoutMs === "number" ? { timeoutMs: opts.emitOpenlineageTimeoutMs } : {},
+          ...opts.emitOpenlineageToken ? { token: String(opts.emitOpenlineageToken) } : {},
+          ...opts.emitOpenlineageProducer ? { producer: String(opts.emitOpenlineageProducer) } : {},
+          ...Array.isArray(opts.emitOpenlineageHeader) && opts.emitOpenlineageHeader.length > 0 ? { headerArgs: opts.emitOpenlineageHeader } : {},
+          ...opts.emitOpenlineageRunId ? { runId: String(opts.emitOpenlineageRunId) } : {},
+          ...opts.emitOpenlineageDryRun ? { dryRun: true } : {},
+          ...opts.emitOpenlineageEventsOut ? { eventsOutPath: String(opts.emitOpenlineageEventsOut) } : {},
+          ...opts.emitOpenlineageEventsOutFormat ? {
+            eventsOutFormat: validateEventsOutFormat(
+              String(opts.emitOpenlineageEventsOutFormat)
+            )
+          } : {},
+          ...opts.emitOpenlineageSkipEmpty ? { skipEmpty: true } : {},
+          ...typeof opts.emitOpenlineageMinEvents === "number" && opts.emitOpenlineageMinEvents > 0 ? { minEvents: opts.emitOpenlineageMinEvents } : {},
+          ...sourceHint ? { sourceHint } : {}
+        });
+        if (!outcome.ok) {
+          process.exitCode = 2;
+        }
+      }
+      return;
+    }
+    if (opts.dbtManifest) {
+      const result = await columnLineage.extractDbtManifestLineage(String(opts.dbtManifest));
+      const fmt2 = String(opts.format ?? "mermaid").toLowerCase();
+      const payload2 = fmt2 === "json" ? columnLineage.renderDbtLineageJson(result) : columnLineage.renderDbtLineageMermaid(result);
+      if (result.skipped.length > 0) {
+        for (const s of result.skipped) console.error(`Skipped ${s.nodeId}: ${s.reason}`);
+      }
+      if (opts.out) {
+        const out = path.resolve(String(opts.out));
+        await fs.mkdir(path.dirname(out), { recursive: true });
+        await fs.writeFile(out, payload2 + "\n", "utf8");
+        console.error(
+          `Wrote ${out} (${result.models.length} models, ${result.skipped.length} skipped).`
+        );
+      } else if (!opts.emitOpenlineage) {
+        process.stdout.write(payload2 + "\n");
+      }
+      if (opts.emitOpenlineage) {
+        const dag = columnLineage.buildColumnLineageDag(
+          result.models.map((m) => ({ objectFqn: m.fqn, lineage: m.lineage }))
+        );
+        const endpointFlag = typeof opts.emitOpenlineage === "string" && opts.emitOpenlineage.length > 0 ? String(opts.emitOpenlineage) : void 0;
+        const sourceHint = `dbt:${path.basename(String(opts.dbtManifest)).replace(/\.json$/i, "")}`;
+        const outcome = await emitOpenLineageFromCli({
+          dag,
+          ...endpointFlag ? { endpointFlag } : {},
+          ...opts.emitOpenlineageConfig ? { configPath: String(opts.emitOpenlineageConfig) } : {},
+          ...opts.emitOpenlineageNamespace ? { namespace: String(opts.emitOpenlineageNamespace) } : {},
+          ...opts.emitOpenlineageJobNamespace ? { jobNamespace: String(opts.emitOpenlineageJobNamespace) } : {},
+          ...opts.emitOpenlineageJob ? { job: String(opts.emitOpenlineageJob) } : {},
+          ...opts.emitOpenlineageMode ? { mode: validateMode(String(opts.emitOpenlineageMode)) } : {},
+          ...opts.emitOpenlineageEventType ? { eventType: validateEventType(String(opts.emitOpenlineageEventType)) } : {},
+          ...opts.emitOpenlineageEventTime ? { eventTime: validateEventTime(String(opts.emitOpenlineageEventTime)) } : {},
+          ...typeof opts.emitOpenlineageTimeoutMs === "number" ? { timeoutMs: opts.emitOpenlineageTimeoutMs } : {},
+          ...opts.emitOpenlineageToken ? { token: String(opts.emitOpenlineageToken) } : {},
+          ...opts.emitOpenlineageProducer ? { producer: String(opts.emitOpenlineageProducer) } : {},
+          ...Array.isArray(opts.emitOpenlineageHeader) && opts.emitOpenlineageHeader.length > 0 ? { headerArgs: opts.emitOpenlineageHeader } : {},
+          ...opts.emitOpenlineageRunId ? { runId: String(opts.emitOpenlineageRunId) } : {},
+          ...opts.emitOpenlineageDryRun ? { dryRun: true } : {},
+          ...opts.emitOpenlineageEventsOut ? { eventsOutPath: String(opts.emitOpenlineageEventsOut) } : {},
+          ...opts.emitOpenlineageEventsOutFormat ? {
+            eventsOutFormat: validateEventsOutFormat(
+              String(opts.emitOpenlineageEventsOutFormat)
+            )
+          } : {},
+          ...opts.emitOpenlineageSkipEmpty ? { skipEmpty: true } : {},
+          ...typeof opts.emitOpenlineageMinEvents === "number" && opts.emitOpenlineageMinEvents > 0 ? { minEvents: opts.emitOpenlineageMinEvents } : {},
+          sourceHint
+        });
+        if (!outcome.ok) {
+          process.exitCode = 2;
+        }
+      }
+      return;
+    }
+    if (!opts.source) throw new Error("Either --source or --dbt-manifest is required.");
+    const model = await loadModel(String(opts.source));
+    const fullGraph = lineage.buildLineageGraph(model);
+    const direction = String(opts.direction ?? "both").toLowerCase();
+    let graph = fullGraph;
+    let focus;
+    if (opts.fqn) {
+      focus = String(opts.fqn);
+      const depth = typeof opts.depth === "number" ? opts.depth : Infinity;
+      if (direction === "upstream") {
+        const keep = /* @__PURE__ */ new Set([focus, ...lineage.upstreamOf(fullGraph, focus, depth)]);
+        graph = subsetGraph(fullGraph, keep);
+      } else if (direction === "downstream") {
+        const keep = /* @__PURE__ */ new Set([focus, ...lineage.downstreamOf(fullGraph, focus, depth)]);
+        graph = subsetGraph(fullGraph, keep);
+      } else {
+        graph = lineage.sliceAround(fullGraph, focus, depth);
+      }
+    }
+    const fmt = String(opts.format ?? "mermaid").toLowerCase();
+    if (!["mermaid", "dot", "json", "markdown"].includes(fmt)) {
+      throw new Error(`Unknown --format: ${fmt}. Use mermaid | dot | json | markdown.`);
+    }
+    const renderOpts = {
+      ...focus ? { focus } : {},
+      ...typeof opts.maxEdges === "number" ? { maxEdges: opts.maxEdges } : {},
+      ...opts.columns ? { includeColumns: true } : {}
+    };
+    const payload = lineage.renderLineage(graph, fmt, renderOpts);
+    if (opts.out) {
+      const out = path.resolve(String(opts.out));
+      await fs.mkdir(path.dirname(out), { recursive: true });
+      await fs.writeFile(out, payload + (payload.endsWith("\n") ? "" : "\n"), "utf8");
+      console.error(
+        `Wrote ${out} (${payload.length} bytes, ${graph.nodes.length} nodes, ${graph.edges.length} edges).`
+      );
+    } else {
+      process.stdout.write(payload + (payload.endsWith("\n") ? "" : "\n"));
+    }
+    await runExplain(
+      {
+        feature: "lineage.explain",
+        systemPrompt: "You are a Databricks data-platform architect explaining a lineage graph. Describe the dominant data-flow shape, point out hot or fragile nodes, and recommend any decomposition / sharding the graph suggests."
+      },
+      opts,
+      () => {
+        const focused = focus ? ` (focused on ${focus}, direction=${direction})` : "";
+        const summary = `Lineage graph${focused}: ${graph.nodes.length} nodes, ${graph.edges.length} edges.`;
+        const sample = graph.edges.slice(0, 40).map((e) => `  - ${e.from} ${e.kind === "READS_FROM" ? "->" : "=>"} ${e.to}`);
+        return [
+          summary,
+          "",
+          "Edges (up to 40):",
+          ...sample,
+          "",
+          "Narrate this graph in plain English."
+        ].join("\n");
+      }
+    );
+  });
+  attachExplainFlag(cmd);
+  return cmd;
+}
+function subsetGraph(graph, keep) {
+  return {
+    nodes: graph.nodes.filter((n) => keep.has(n.fqn)),
+    edges: graph.edges.filter((e) => keep.has(e.from) && keep.has(e.to))
+  };
+}
+async function loadModel(sourcePath) {
+  if (sourcePath.endsWith(".ddtpac")) {
+    const c = await pac.readPac(sourcePath);
+    return c.model;
+  }
+  const loaded = await loadProject(sourcePath);
+  return await parseProjectModel(loaded);
+}
+function collectColumnLineageInputs(model) {
+  const inputs = [];
+  const matchTypes = /* @__PURE__ */ new Set(["VIEW", "MATERIALIZED_VIEW", "STREAMING_TABLE"]);
+  for (const obj of model) {
+    if (!matchTypes.has(obj.objectType)) continue;
+    const query = obj.query;
+    if (typeof query !== "string" || query.length === 0) continue;
+    const fqn = formatFqn(obj.fqn);
+    const lineage2 = columnLineage.extractColumnLineage(query);
+    inputs.push({ objectFqn: fqn, lineage: lineage2 });
+  }
+  return inputs;
+}
+function formatFqn(fqn) {
+  if (typeof fqn === "string") return fqn;
+  if (fqn && typeof fqn === "object") {
+    const f = fqn;
+    return [f.catalog ?? f.database, f.schema, f.name].filter(Boolean).join(".");
+  }
+  return "<unknown>";
+}
+export {
+  AUTO_MODE_THRESHOLD,
+  emitOpenLineageFromCli,
+  lineageCommand,
+  parseHeaderArgs,
+  resolveAutoMode,
+  validateEventTime,
+  validateEventType,
+  validateEventsOutFormat,
+  validateMode
+};
+//# sourceMappingURL=lineage-C5CGVP36.js.map