fix(dbt-tools): move to dbt-integration 0.3.15 so the dbt adapter starts under Bun

.github/workflows/release.yml

@@ -286,9 +286,19 @@ jobs:
             echo "::error::dbt-tools bundle contains hardcoded absolute path in __dirname"
             exit 1
           fi
-          # Verify __dirname was patched to runtime resolution
-          if ! grep -q 'import.meta.dirname' packages/dbt-tools/dist/index.js; then
-            echo "::error::dbt-tools bundle missing import.meta.dirname patch"
+          # The bridge path is built at runtime from the bundle's own URL
+          if ! grep -q 'fileURLToPath(import.meta.url)' packages/dbt-tools/dist/index.js; then
+            echo "::error::dbt-tools bundle lacks fileURLToPath(import.meta.url), which the bridge path is built from"
+            exit 1
+          fi
+          # ...joined with the bare script name, not a literal path ending in it
+          if ! grep -qF '"node_python_bridge.py"' packages/dbt-tools/dist/index.js; then
+            echo "::error::dbt-tools bundle lacks the \"node_python_bridge.py\" name the bridge path is joined from"
+            exit 1
+          fi
+          # No path from this checkout baked into the bundle
+          if [ -z "$GITHUB_WORKSPACE" ] || grep -qF "$GITHUB_WORKSPACE" packages/dbt-tools/dist/index.js; then
+            echo "::error::dbt-tools bundle contains the build checkout path, or GITHUB_WORKSPACE is unset"
             exit 1
           fi
           echo "dbt-tools smoke test passed"

packages/dbt-tools/package.json

@@ -9,11 +9,11 @@
   "scripts": {
     "build": "bun build src/index.ts --outdir dist --target node --format esm && bun run script/copy-python.ts",
     "typecheck": "tsc --noEmit",
-    "test": "bun test test/cli.test.ts test/config.test.ts test/dbt-cli.test.ts test/dbt-resolve.test.ts test/build-integrity.test.ts --timeout 30000",
+    "test": "bun test test/cli.test.ts test/config.test.ts test/dbt-cli.test.ts test/dbt-resolve.test.ts test/adapter-bun.test.ts test/build-integrity.test.ts --timeout 30000",
     "test:e2e": "bun test test/e2e/ --timeout 300000"
   },
   "dependencies": {
-    "@altimateai/dbt-integration": "^0.2.2"
+    "@altimateai/dbt-integration": "^0.3.15"
   },
   "devDependencies": {
     "@tsconfig/bun": "catalog:",

packages/dbt-tools/script/copy-python.ts

@@ -1,4 +1,4 @@
-import { cpSync, existsSync, readFileSync, writeFileSync } from "fs"
+import { cpSync, existsSync, readFileSync } from "fs"
 import { dirname, join } from "path"
 
 const dist = join(import.meta.dir, "..", "dist")
@@ -20,23 +20,18 @@ if (!existsSync(bridgePy)) {
 cpSync(bridgePy, join(dist, "node_python_bridge.py"))
 console.log(`Copied node_python_bridge.py → dist/`)
 
-// 3. Fix the hardcoded __dirname that bun bakes at compile time.
-//    Replace it with a runtime resolution so the bridge script is found
-//    relative to the built index.js, not the CI runner's node_modules.
+// 3. dbt-integration resolves node_python_bridge.py at runtime from its own
+//    location (`fileURLToPath(import.meta.url)`), which in this bundle is dist/,
+//    where step 2 put the script. This only checks that the bundle still has
+//    the references that path is built from and no path baked in at build time;
+//    test/build-integrity.test.ts runs the packaged CLI from another directory
+//    to check where the script is found.
 const indexPath = join(dist, "index.js")
-let code = readFileSync(indexPath, "utf8")
-const pattern = /var __dirname\s*=\s*"[^"]*python-bridge[^"]*"/
-if (pattern.test(code)) {
-  // import.meta.dirname is supported by Bun and Node >= 20.11.0.
-  // Fallback via __require handles older runtimes where import.meta.dirname is unavailable.
-  const replacement = `var __dirname = typeof import.meta.dirname === "string" ? import.meta.dirname : __require("path").dirname(__require("url").fileURLToPath(import.meta.url))`
-  code = code.replace(pattern, replacement)
-  writeFileSync(indexPath, code)
-  console.log(`Patched __dirname in dist/index.js`)
-} else {
-  const found = code.match(/var __dirname[^;]*/)?.[0] ?? "(not found)"
-  console.error(`ERROR: could not find python-bridge __dirname to patch — the bundle format may have changed`)
-  console.error(`  Pattern: ${pattern}`)
-  console.error(`  Nearest match: ${found}`)
+const code = readFileSync(indexPath, "utf8")
+const baked = /var __dirname\s*=\s*"(?:[A-Za-z]:\\\\|\/)/
+if (!code.includes("fileURLToPath(import.meta.url)") || !code.includes(`"node_python_bridge.py"`) || baked.test(code)) {
+  console.error(`ERROR: dist/index.js lacks the references the bridge path is built from, or has a build-time path`)
+  console.error(`  Has the @altimateai/dbt-integration bundle format changed?`)
   process.exit(1)
 }
+console.log(`Checked dist/index.js: bridge path references present, no build-time path`)

packages/dbt-tools/src/adapter.ts

@@ -15,6 +15,8 @@ import {
   GraphParser,
   SourceParser,
   TestParser,
+  UnitTestParser,
+  SemanticModelParser,
   ExposureParser,
   FunctionParser,
   DocParser,
@@ -141,6 +143,8 @@ export async function create(cfg: Config): Promise<DBTProjectIntegrationAdapter>
       defer,
       changed,
       cloudVariantDetector,
+      // Every variant but fusion-stable runs on a dbt Core command engine, which needs these.
+      { pythonDBTCommandExecutionStrategy: python, dbtConfiguration: config, dbtIntegrationClient: client },
     )
 
   const command = (
@@ -170,19 +174,7 @@ export async function create(cfg: Config): Promise<DBTProjectIntegrationAdapter>
     defer: DeferConfig,
     changed: () => void,
   ): DBTProjectIntegration =>
-    new DBTFusionCommandProjectIntegration(
-      infra,
-      factory,
-      cli,
-      runtime,
-      provider,
-      term,
-      root,
-      diag,
-      defer,
-      changed,
-      cloudVariantDetector,
-    )
+    new DBTFusionCommandProjectIntegration(infra, factory, cli, runtime, provider, term, root, diag, defer, changed)
 
   const adapter = new DBTProjectIntegrationAdapter(
     config,
@@ -200,11 +192,13 @@ export async function create(cfg: Config): Promise<DBTProjectIntegrationAdapter>
     new GraphParser(term),
     new SourceParser(term),
     new TestParser(term),
+    new UnitTestParser(term),
     new ExposureParser(term),
     new FunctionParser(term),
     new DocParser(term),
     term,
     new ModelDepthParser(term, client, config),
+    new SemanticModelParser(term),
   )
 
   await adapter.initialize()

packages/dbt-tools/src/index.ts

@@ -37,12 +37,6 @@ function flag(args: string[], name: string): string | undefined {
 
 function diagnose(err: Error): { error: string; fix?: string } {
   const msg = err.message || String(err)
-  if (msg.includes("private field") || msg.includes("#stdin") || msg.includes("#stdout")) {
-    return {
-      error: "Internal error: Bun runtime incompatibility with python-bridge. Please report this issue.",
-      fix: "Try updating: bun install, or file a bug at https://github.com/AltimateAI/altimate-code/issues",
-    }
-  }
   if (msg.includes("IPC channel") || msg.includes("ERR_IPC_CHANNEL_CLOSED")) {
     return {
       error: "Failed to start Python bridge. The dbt Python process exited unexpectedly.",
@@ -109,7 +103,7 @@ function bail(err: unknown): never {
   process.exit(1)
 }
 
-// Catch unhandled rejections (bluebird throws outside normal promise chains)
+// An error that escapes main() still ends as a JSON error on stdout
 process.on("unhandledRejection", bail)
 process.on("uncaughtException", bail)
 
@@ -142,7 +136,7 @@ async function main() {
   const { configure } = await import("./dbt-cli")
   configure({ pythonPath: cfg.pythonPath, projectRoot: cfg.projectRoot })
 
-  // Lazy import to avoid loading python-bridge until needed
+  // Lazy import: the adapter loads dbt-integration, which commands above don't need
   let adapter
   try {
     const { create } = await import("./adapter")

packages/dbt-tools/test/adapter-bun.test.ts

@@ -0,0 +1,50 @@
+import { describe, test, expect } from "bun:test"
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "fs"
+import { tmpdir } from "os"
+import { dirname, join } from "path"
+import { $ } from "bun"
+import { standInPython } from "./stand-in-python"
+
+const pkg = join(import.meta.dir, "..")
+
+// The published-package tests run the bundle under Node. The TUI and the compiled
+// binary run the adapter under Bun, the runtime the bridge used to fail on, so this
+// runs the CLI from source under Bun. HOME is a temp dir from the start, so no
+// ~/.dbt/dbt_cloud.yml on this machine picks dbt Cloud mode's variant.
+describe.skipIf(process.platform === "win32")("the adapter under Bun", () => {
+  const script = join(dirname(require.resolve("@altimateai/dbt-integration")), "node_python_bridge.py")
+
+  // The stand-in fails the bridge run. The dbt Core modes then exit 1 with the bridge's
+  // report of that exit; `info` in dbt Cloud mode still answers from the project. A
+  // failure before the spawn shows its own message in the comparison.
+  test.each([
+    ["core", { exitCode: 1, output: expect.stringContaining("Python process closed with exit code 3") }],
+    ["corecommand", { exitCode: 1, output: expect.stringContaining("Python process closed with exit code 3") }],
+    ["cloud", { exitCode: 0 }],
+  ])("%s mode spawns the bridge script", async (dbtIntegration, expected) => {
+    const root = mkdtempSync(join(tmpdir(), "dbt-tools-bun-"))
+    try {
+      const { python, runs } = standInPython(root)
+      const project = join(root, "project")
+      mkdirSync(project)
+      writeFileSync(join(project, "dbt_project.yml"), "name: p\nversion: '1.0'\nprofile: p\n")
+      const home = join(root, "home")
+      mkdirSync(join(home, ".altimate-code"), { recursive: true })
+      writeFileSync(
+        join(home, ".altimate-code", "dbt.json"),
+        JSON.stringify({ projectRoot: project, pythonPath: python, dbtIntegration, queryLimit: 500 }),
+      )
+
+      const cli = await $`${process.execPath} ${join(pkg, "src/index.ts")} info`
+        .cwd(root)
+        .env({ ...process.env, HOME: home })
+        .quiet()
+        .nothrow()
+
+      expect({ exitCode: cli.exitCode, output: cli.stdout.toString() }).toMatchObject(expected)
+      expect(runs()).toContain(script)
+    } finally {
+      rmSync(root, { recursive: true, force: true })
+    }
+  })
+})