feat: lightweight ref()-based DAG for static mode impact analysis

Static mode now builds a dependency graph by parsing {{ ref() }} calls
directly from SQL files — no manifest, CLI, or LLM needed.

Changes:
- New dbt-lightweight.ts: extractRefs, extractSources, buildLightweightDAG,
  analyzeLightweightImpact — scans all .sql files, builds parent→child edges
- Index.ts: falls back to lightweight DAG when manifest unavailable
- dbt.ts: replaced LLM-based dbt compile with direct subprocess call
- comment.ts: buildMermaidDAG uses explicit edges for precise rendering
- types.ts: added edges field to ImpactResult
- 22 new tests for lightweight DAG module

This means static mode PRs on dbt projects now show:
- Mermaid DAG blast radius diagram
- Downstream model count
- Impact score

370 tests, 0 failures.

Co-Authored-By: Claude Opus 4.6 (1M context) <[email protected]>

Author: anandgupta42

dist/index.js

@@ -44,6 +44,8 @@ export interface ImpactResult {
   affectedTests: string[];
   /** Aggregate impact score 0-100 (higher = more risk). */
   impactScore: number;
+  /** Explicit DAG edges for Mermaid rendering. */
+  edges?: Array<{ from: string; to: string }>;
 }
 
 /** Cost estimate for a single file or model. */

dist/index.js.map

@@ -0,0 +1,226 @@
+import { readFileSync, readdirSync, existsSync, statSync } from "node:fs";
+import { join, basename, relative } from "node:path";
+import * as core from "@actions/core";
+import type { ChangedFile, ImpactResult } from "../analysis/types.js";
+
+/**
+ * Extract model names from `{{ ref('model_name') }}` calls in SQL.
+ * Handles single and double quotes, optional whitespace.
+ */
+export function extractRefs(sql: string): string[] {
+  const refs: string[] = [];
+  const pattern = /\{\{\s*ref\s*\(\s*['"](\w+)['"]\s*\)\s*\}\}/gi;
+  let match;
+  while ((match = pattern.exec(sql)) !== null) {
+    refs.push(match[1]);
+  }
+  return [...new Set(refs)];
+}
+
+/**
+ * Extract source references from `{{ source('source_name', 'table_name') }}` calls.
+ * Returns "source_name.table_name" strings.
+ */
+export function extractSources(sql: string): string[] {
+  const sources: string[] = [];
+  const pattern =
+    /\{\{\s*source\s*\(\s*['"](\w+)['"]\s*,\s*['"](\w+)['"]\s*\)\s*\}\}/gi;
+  let match;
+  while ((match = pattern.exec(sql)) !== null) {
+    sources.push(`${match[1]}.${match[2]}`);
+  }
+  return [...new Set(sources)];
+}
+
+/**
+ * Recursively find all .sql files under `dir`.
+ */
+export function findSQLFiles(dir: string): string[] {
+  const results: string[] = [];
+  if (!existsSync(dir)) return results;
+
+  const entries = readdirSync(dir);
+  for (const entry of entries) {
+    const fullPath = join(dir, entry);
+    const stat = statSync(fullPath);
+    if (stat.isDirectory()) {
+      results.push(...findSQLFiles(fullPath));
+    } else if (entry.endsWith(".sql")) {
+      results.push(fullPath);
+    }
+  }
+  return results;
+}
+
+export interface LightweightNode {
+  name: string;
+  filePath: string;
+  refs: string[];
+  sources: string[];
+}
+
+export interface LightweightDAG {
+  /** Map of model name to node metadata. */
+  nodes: Map<string, LightweightNode>;
+  /** Map of model name to its direct children (models that ref it). */
+  childMap: Map<string, string[]>;
+}
+
+/**
+ * Build a lightweight DAG by scanning all .sql files in the dbt project's
+ * model directories and extracting ref() calls.
+ *
+ * This requires NO manifest, NO CLI, NO LLM.
+ */
+export function buildLightweightDAG(dbtProjectDir: string): LightweightDAG {
+  const nodes = new Map<string, LightweightNode>();
+  const childMap = new Map<string, string[]>();
+
+  // Find model directories — check common locations
+  const modelDirs = ["models", "dbt_models", "model"];
+  let sqlFiles: string[] = [];
+
+  for (const dir of modelDirs) {
+    const fullDir = join(dbtProjectDir, dir);
+    if (existsSync(fullDir)) {
+      sqlFiles.push(...findSQLFiles(fullDir));
+    }
+  }
+
+  // Fallback: scan entire project if no model dir found
+  if (sqlFiles.length === 0) {
+    sqlFiles = findSQLFiles(dbtProjectDir).filter(
+      (f) => !f.includes("target/") && !f.includes("dbt_packages/"),
+    );
+  }
+
+  // Build nodes
+  for (const filePath of sqlFiles) {
+    const modelName = basename(filePath, ".sql");
+    const sql = readFileSync(filePath, "utf-8");
+    const refs = extractRefs(sql);
+    const sources = extractSources(sql);
+
+    nodes.set(modelName, { name: modelName, filePath, refs, sources });
+  }
+
+  // Build childMap from ref() edges: if model B refs model A, then A -> B
+  for (const [modelName, node] of nodes) {
+    for (const parentName of node.refs) {
+      if (!childMap.has(parentName)) {
+        childMap.set(parentName, []);
+      }
+      childMap.get(parentName)!.push(modelName);
+    }
+  }
+
+  core.info(
+    `Lightweight DAG: ${nodes.size} models, ${[...childMap.values()].reduce((s, c) => s + c.length, 0)} edges`,
+  );
+
+  return { nodes, childMap };
+}
+
+/**
+ * Analyze impact using the lightweight DAG (no manifest needed).
+ *
+ * 1. Scans all .sql files in the project to build ref() edges
+ * 2. Maps changed files to model names
+ * 3. BFS from changed models to find all downstream
+ * 4. Builds explicit edges for Mermaid rendering
+ * 5. Returns ImpactResult
+ */
+export function analyzeLightweightImpact(
+  changedFiles: ChangedFile[],
+  dbtProjectDir: string,
+): ImpactResult | null {
+  const dag = buildLightweightDAG(dbtProjectDir);
+
+  if (dag.nodes.size === 0) {
+    core.info("Lightweight DAG: no models found — skipping impact analysis");
+    return null;
+  }
+
+  const workspace = process.env.GITHUB_WORKSPACE ?? process.cwd();
+
+  // Map changed files to model names
+  const modifiedModels: string[] = [];
+  for (const file of changedFiles) {
+    if (!file.filename.endsWith(".sql")) continue;
+    const modelName = basename(file.filename, ".sql");
+    if (dag.nodes.has(modelName)) {
+      modifiedModels.push(modelName);
+    } else {
+      // Try matching by file path
+      const absPath = join(workspace, file.filename);
+      for (const [name, node] of dag.nodes) {
+        const relFromProject = relative(dbtProjectDir, node.filePath);
+        const relFromWorkspace = relative(workspace, node.filePath);
+        if (
+          file.filename === relFromProject ||
+          file.filename === relFromWorkspace ||
+          absPath === node.filePath
+        ) {
+          modifiedModels.push(name);
+          break;
+        }
+      }
+    }
+  }
+
+  const uniqueModified = [...new Set(modifiedModels)];
+
+  if (uniqueModified.length === 0) {
+    core.info(
+      "Lightweight DAG: no changed files matched any models — skipping",
+    );
+    return {
+      modifiedModels: [],
+      downstreamModels: [],
+      affectedExposures: [],
+      affectedTests: [],
+      impactScore: 0,
+    };
+  }
+
+  // BFS to find downstream models
+  const visited = new Set<string>(uniqueModified);
+  const queue = [...uniqueModified];
+  const downstreamModels: string[] = [];
+  const edges: Array<{ from: string; to: string }> = [];
+
+  while (queue.length > 0) {
+    const current = queue.shift()!;
+    const children = dag.childMap.get(current) ?? [];
+
+    for (const child of children) {
+      edges.push({ from: current, to: child });
+      if (!visited.has(child)) {
+        visited.add(child);
+        downstreamModels.push(child);
+        queue.push(child);
+      }
+    }
+  }
+
+  // Compute a simple impact score
+  const totalModels = dag.nodes.size;
+  const affectedRatio =
+    (uniqueModified.length + downstreamModels.length) / totalModels;
+  const downstreamScore = Math.min(50, Math.round(affectedRatio * 100));
+  const modificationScore = Math.min(20, uniqueModified.length * 5);
+  const impactScore = Math.min(100, downstreamScore + modificationScore);
+
+  core.info(
+    `Lightweight impact: ${uniqueModified.length} modified, ${downstreamModels.length} downstream, score=${impactScore}`,
+  );
+
+  return {
+    modifiedModels: uniqueModified,
+    downstreamModels,
+    affectedExposures: [],
+    affectedTests: [],
+    impactScore,
+    edges,
+  };
+}

src/analysis/types.ts

@@ -2,7 +2,7 @@ import * as core from "@actions/core";
 import { readFile } from "node:fs/promises";
 import { join, relative } from "node:path";
 import { existsSync } from "node:fs";
-import { runCLIOrThrow } from "../util/cli.js";
+import { execFileSync } from "node:child_process";
 import type {
   ChangedFile,
   DBTManifest,
@@ -81,13 +81,13 @@ export async function getManifest(
     }
   }
 
-  // Attempt to compile dbt to generate manifest
-  core.info("No manifest found — attempting dbt compile via CLI...");
+  // Attempt to compile dbt directly to generate manifest
+  core.info("No manifest found — attempting dbt compile...");
   try {
-    await runCLIOrThrow(
-      ["run", "--format", "json", "--prompt", "run dbt compile"],
-      { cwd: dbtProjectDir, timeout: 120_000 },
-    );
+    execFileSync("dbt", ["compile", "--project-dir", dbtProjectDir], {
+      timeout: 120_000,
+      stdio: "pipe",
+    });
 
     const defaultPath = join(dbtProjectDir, "target", "manifest.json");
     if (existsSync(defaultPath)) {

src/context/dbt-lightweight.ts

@@ -16,6 +16,7 @@ import {
 import { parseCommand } from "./interactive/commands.js";
 import { handleCommand } from "./interactive/handler.js";
 import { detectDBTProject, getManifest } from "./context/dbt.js";
+import { analyzeLightweightImpact } from "./context/dbt-lightweight.js";
 import { analyzeSQLFiles } from "./analysis/sql-review.js";
 import { analyzeImpact } from "./analysis/impact.js";
 import { estimateCost, getTotalCostDelta } from "./analysis/cost.js";
@@ -194,9 +195,13 @@ async function runAnalyses(
       }
 
       const manifest = await getManifest(dbtProjectDir, config.manifestPath);
-      if (!manifest) return null;
+      if (manifest) {
+        return analyzeImpact(dbtFiles, manifest, dbtProjectDir);
+      }
 
-      return analyzeImpact(dbtFiles, manifest, dbtProjectDir);
+      // Lightweight fallback: parse ref() calls directly from SQL files
+      core.info("No manifest — using lightweight ref() parsing for impact analysis");
+      return analyzeLightweightImpact(dbtFiles, dbtProjectDir);
     })(),
 
     // Cost estimation

src/context/dbt.ts

@@ -270,30 +270,50 @@ export function buildMermaidDAG(impact: ImpactResult): string {
   const sanitize = (name: string): string =>
     name.replace(/[^a-zA-Z0-9_]/g, "_");
 
-  // Build edges: modified → downstream
-  for (const mod of impact.modifiedModels) {
-    const modId = sanitize(mod);
-    for (const ds of impact.downstreamModels) {
-      const dsId = sanitize(ds);
-      lines.push(`    ${modId}:::modified --> ${dsId}:::downstream`);
+  const modifiedSet = new Set(impact.modifiedModels);
+  const downstreamSet = new Set(impact.downstreamModels);
+  const exposureSet = new Set(impact.affectedExposures);
+
+  // Use explicit edges if available (from lightweight DAG), otherwise
+  // fall back to the cartesian product approach (modified → downstream).
+  if (impact.edges && impact.edges.length > 0) {
+    for (const edge of impact.edges) {
+      const fromId = sanitize(edge.from);
+      const toId = sanitize(edge.to);
+      const fromClass = modifiedSet.has(edge.from) ? "modified" : "downstream";
+      const toClass = exposureSet.has(edge.to)
+        ? "exposure"
+        : downstreamSet.has(edge.to)
+          ? "downstream"
+          : modifiedSet.has(edge.to)
+            ? "modified"
+            : "downstream";
+      lines.push(`    ${fromId}:::${fromClass} --> ${toId}:::${toClass}`);
     }
-    // modified → exposures
-    for (const exp of impact.affectedExposures) {
-      const expId = sanitize(exp);
-      lines.push(`    ${modId}:::modified --> ${expId}:::exposure`);
-    }
-  }
-
-  // If downstream also connects to exposures
-  if (
-    impact.downstreamModels.length > 0 &&
-    impact.affectedExposures.length > 0
-  ) {
-    for (const ds of impact.downstreamModels) {
-      const dsId = sanitize(ds);
+  } else {
+    // Legacy: cartesian product of modified → downstream
+    for (const mod of impact.modifiedModels) {
+      const modId = sanitize(mod);
+      for (const ds of impact.downstreamModels) {
+        const dsId = sanitize(ds);
+        lines.push(`    ${modId}:::modified --> ${dsId}:::downstream`);
+      }
       for (const exp of impact.affectedExposures) {
         const expId = sanitize(exp);
-        lines.push(`    ${dsId}:::downstream --> ${expId}:::exposure`);
+        lines.push(`    ${modId}:::modified --> ${expId}:::exposure`);
+      }
+    }
+
+    if (
+      impact.downstreamModels.length > 0 &&
+      impact.affectedExposures.length > 0
+    ) {
+      for (const ds of impact.downstreamModels) {
+        const dsId = sanitize(ds);
+        for (const exp of impact.affectedExposures) {
+          const expId = sanitize(exp);
+          lines.push(`    ${dsId}:::downstream --> ${expId}:::exposure`);
+        }
       }
     }
   }