feat(dbt-tools): auto-discover config, expose ALTIMATE_CODE_* env vars for vscode integration

- config.ts: add findProjectRoot() and discoverPython() (exported), update read() to auto-discover
  projectRoot and pythonPath at runtime when no config file exists — removes requirement to run
  `altimate-dbt init` before using any command
- discoverPython() prioritises ALTIMATE_CODE_VIRTUAL_ENV (injected by vscode-altimate-mcp-server)
  over project-local venvs; tries python3 before python in each candidate location
- dbt-resolve.ts: add tier 2 (ALTIMATE_CODE_PYTHON_PATH sibling) and tier 6 (ALTIMATE_CODE_VIRTUAL_ENV)
  so the dbt binary is found when altimate serve is spawned with a vscode-activated Python environment
- init.ts: remove duplicated find()/python() helpers; import from config.ts
- tests: add config.test.ts coverage for auto-discovery, findProjectRoot, discoverPython; add
  dbt-resolve.test.ts scenarios for ALTIMATE_CODE_PYTHON_PATH and ALTIMATE_CODE_VIRTUAL_ENV priority

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: mdesmet

packages/dbt-tools/src/commands/init.ts

@@ -1,74 +1,21 @@
-import { join, resolve } from "path"
+import { resolve, join } from "path"
 import { existsSync } from "fs"
-import { execFileSync } from "child_process"
-import { write, type Config } from "../config"
+import { write, findProjectRoot, discoverPython, type Config } from "../config"
 import { all } from "../check"
 
-function find(start: string): string | null {
-  let dir = resolve(start)
-  while (true) {
-    if (existsSync(join(dir, "dbt_project.yml"))) return dir
-    const parent = resolve(dir, "..")
-    if (parent === dir) return null
-    dir = parent
-  }
-}
-
-/**
- * Discover the Python binary, checking multiple environment managers.
- *
- * Priority:
- *  1. Project-local .venv/bin/python (uv, pdm, venv, poetry in-project)
- *  2. VIRTUAL_ENV/bin/python (activated venv)
- *  3. CONDA_PREFIX/bin/python (conda)
- *  4. `which python3` / `which python` (system PATH)
- *  5. Fallback "python3" (hope for the best)
- */
-function python(projectRoot?: string): string {
-  // Check project-local venvs first (most reliable for dbt projects)
-  if (projectRoot) {
-    for (const venvDir of [".venv", "venv", "env"]) {
-      const py = join(projectRoot, venvDir, "bin", "python")
-      if (existsSync(py)) return py
-    }
-  }
-
-  // Check VIRTUAL_ENV (set by activate scripts)
-  const virtualEnv = process.env.VIRTUAL_ENV
-  if (virtualEnv) {
-    const py = join(virtualEnv, "bin", "python")
-    if (existsSync(py)) return py
-  }
-
-  // Check CONDA_PREFIX (set by conda activate)
-  const condaPrefix = process.env.CONDA_PREFIX
-  if (condaPrefix) {
-    const py = join(condaPrefix, "bin", "python")
-    if (existsSync(py)) return py
-  }
-
-  // Fall back to PATH-based discovery
-  for (const cmd of ["python3", "python"]) {
-    try {
-      return execFileSync("which", [cmd], { encoding: "utf-8" }).trim()
-    } catch {}
-  }
-  return "python3"
-}
-
 export async function init(args: string[]) {
   const idx = args.indexOf("--project-root")
   const root = idx >= 0 ? args[idx + 1] : undefined
   const pidx = args.indexOf("--python-path")
   const py = pidx >= 0 ? args[pidx + 1] : undefined
 
-  const project = root ? resolve(root) : find(process.cwd())
+  const project = root ? resolve(root) : findProjectRoot(process.cwd())
   if (!project) return { error: "No dbt_project.yml found. Use --project-root to specify." }
   if (!existsSync(join(project, "dbt_project.yml"))) return { error: `No dbt_project.yml in ${project}` }
 
   const cfg: Config = {
     projectRoot: project,
-    pythonPath: py ?? python(project),
+    pythonPath: py ?? discoverPython(project),
     dbtIntegration: "corecommand",
     queryLimit: 500,
   }

packages/dbt-tools/src/config.ts

@@ -1,7 +1,8 @@
 import { homedir } from "os"
-import { join } from "path"
+import { join, resolve } from "path"
 import { readFile, writeFile, mkdir } from "fs/promises"
 import { existsSync } from "fs"
+import { execFileSync } from "child_process"
 
 type Config = {
   projectRoot: string
@@ -18,11 +19,84 @@ function configPath() {
   return join(configDir(), "dbt.json")
 }
 
+/**
+ * Walk up from `start` to find the nearest directory containing dbt_project.yml.
+ * Returns null if none found.
+ */
+export function findProjectRoot(start = process.cwd()): string | null {
+  let dir = resolve(start)
+  while (true) {
+    if (existsSync(join(dir, "dbt_project.yml"))) return dir
+    const parent = resolve(dir, "..")
+    if (parent === dir) return null
+    dir = parent
+  }
+}
+
+/**
+ * Discover the Python binary for a given project root.
+ * Priority: ALTIMATE_CODE_VIRTUAL_ENV → project-local .venv → VIRTUAL_ENV → CONDA_PREFIX → which python3
+ */
+export function discoverPython(projectRoot: string): string {
+  // ALTIMATE_CODE_VIRTUAL_ENV (injected by vscode-altimate-mcp-server — explicit user selection wins)
+  const altVenv = process.env.ALTIMATE_CODE_VIRTUAL_ENV
+  if (altVenv) {
+    for (const bin of ["python3", "python"]) {
+      const py = join(altVenv, "bin", bin)
+      if (existsSync(py)) return py
+    }
+  }
+
+  // Project-local venvs (uv, pdm, venv, poetry in-project, rye)
+  for (const venvDir of [".venv", "venv", "env"]) {
+    for (const bin of ["python3", "python"]) {
+      const py = join(projectRoot, venvDir, "bin", bin)
+      if (existsSync(py)) return py
+    }
+  }
+
+  // VIRTUAL_ENV (set by activate scripts)
+  const virtualEnv = process.env.VIRTUAL_ENV
+  if (virtualEnv) {
+    for (const bin of ["python3", "python"]) {
+      const py = join(virtualEnv, "bin", bin)
+      if (existsSync(py)) return py
+    }
+  }
+
+  // CONDA_PREFIX
+  const condaPrefix = process.env.CONDA_PREFIX
+  if (condaPrefix) {
+    for (const bin of ["python3", "python"]) {
+      const py = join(condaPrefix, "bin", bin)
+      if (existsSync(py)) return py
+    }
+  }
+
+  // PATH-based discovery
+  for (const cmd of ["python3", "python"]) {
+    try {
+      return execFileSync("which", [cmd], { encoding: "utf-8" }).trim()
+    } catch {}
+  }
+  return "python3"
+}
+
 async function read(): Promise<Config | null> {
   const p = configPath()
-  if (!existsSync(p)) return null
-  const raw = await readFile(p, "utf-8")
-  return JSON.parse(raw) as Config
+  if (existsSync(p)) {
+    const raw = await readFile(p, "utf-8")
+    return JSON.parse(raw) as Config
+  }
+  // No config file — auto-discover from cwd so `altimate-dbt init` isn't required
+  const projectRoot = findProjectRoot()
+  if (!projectRoot) return null
+  return {
+    projectRoot,
+    pythonPath: discoverPython(projectRoot),
+    dbtIntegration: "corecommand",
+    queryLimit: 500,
+  }
 }
 
 async function write(cfg: Config) {

packages/dbt-tools/src/dbt-resolve.ts

@@ -43,13 +43,15 @@ export interface ResolvedDbt {
  *
  * Priority:
  *  1. ALTIMATE_DBT_PATH env var (explicit user override)
- *  2. Sibling of configured pythonPath (same venv/bin)
- *  3. Project-local .venv/bin/dbt (uv, pdm, venv, rye, poetry in-project)
- *  4. CONDA_PREFIX/bin/dbt (conda environments)
- *  5. VIRTUAL_ENV/bin/dbt (activated venv)
- *  6. Pyenv real path resolution (follow shims)
- *  7. `which dbt` on current PATH
- *  8. Common known locations (~/.local/bin/dbt for pipx, etc.)
+ *  2. Sibling of ALTIMATE_CODE_PYTHON_PATH (set by vscode-altimate-mcp-server)
+ *  3. Sibling of configured pythonPath (same venv/bin)
+ *  4. Project-local .venv/bin/dbt (uv, pdm, venv, rye, poetry in-project)
+ *  5. CONDA_PREFIX/bin/dbt (conda environments)
+ *  6. ALTIMATE_CODE_VIRTUAL_ENV/bin/dbt (set by vscode-altimate-mcp-server)
+ *  7. VIRTUAL_ENV/bin/dbt (activated venv)
+ *  8. Pyenv real path resolution (follow shims)
+ *  9. `which dbt` on current PATH
+ * 10. Common known locations (~/.local/bin/dbt for pipx, etc.)
  *
  * Each candidate is validated by checking it exists and is executable.
  */
@@ -62,7 +64,14 @@ export function resolveDbt(pythonPath?: string, projectRoot?: string): ResolvedD
     candidates.push({ path: envOverride, source: "ALTIMATE_DBT_PATH env var" })
   }
 
-  // 2. Sibling of configured pythonPath (most common: venv, conda, pyenv real path)
+  // 2. Sibling of ALTIMATE_CODE_PYTHON_PATH (injected by vscode-altimate-mcp-server)
+  const altPython = process.env.ALTIMATE_CODE_PYTHON_PATH
+  if (altPython) {
+    const binDir = dirname(altPython)
+    candidates.push({ path: join(binDir, "dbt"), source: "sibling of ALTIMATE_CODE_PYTHON_PATH", binDir })
+  }
+
+  // 3. Sibling of configured pythonPath (most common: venv, conda, pyenv real path)
   if (pythonPath && existsSync(pythonPath)) {
     const binDir = dirname(pythonPath)
     const siblingDbt = join(binDir, "dbt")
@@ -87,7 +96,7 @@ export function resolveDbt(pythonPath?: string, projectRoot?: string): ResolvedD
     }
   }
 
-  // 4. CONDA_PREFIX (conda/mamba/micromamba — set after `conda activate`)
+  // 5. CONDA_PREFIX (conda/mamba/micromamba — set after `conda activate`)
   const condaPrefix = process.env.CONDA_PREFIX
   if (condaPrefix) {
     candidates.push({
@@ -97,7 +106,17 @@ export function resolveDbt(pythonPath?: string, projectRoot?: string): ResolvedD
     })
   }
 
-  // 5. VIRTUAL_ENV (set by venv/virtualenv activate scripts)
+  // 6. ALTIMATE_CODE_VIRTUAL_ENV (injected by vscode-altimate-mcp-server, avoids conflicts with user's VIRTUAL_ENV)
+  const altVenv = process.env.ALTIMATE_CODE_VIRTUAL_ENV
+  if (altVenv) {
+    candidates.push({
+      path: join(altVenv, "bin", "dbt"),
+      source: `ALTIMATE_CODE_VIRTUAL_ENV (${altVenv})`,
+      binDir: join(altVenv, "bin"),
+    })
+  }
+
+  // 7. VIRTUAL_ENV (set by venv/virtualenv activate scripts)
   const virtualEnv = process.env.VIRTUAL_ENV
   if (virtualEnv) {
     candidates.push({
@@ -110,7 +129,7 @@ export function resolveDbt(pythonPath?: string, projectRoot?: string): ResolvedD
   // Helper: current process env (for subprocess calls that need to inherit it)
   const currentEnv = { ...process.env }
 
-  // 6. Pyenv: resolve through shim to real binary
+  // 8. Pyenv: resolve through shim to real binary
   const pyenvRoot = process.env.PYENV_ROOT ?? join(process.env.HOME ?? "", ".pyenv")
   if (existsSync(join(pyenvRoot, "shims", "dbt"))) {
     try {
@@ -128,7 +147,7 @@ export function resolveDbt(pythonPath?: string, projectRoot?: string): ResolvedD
     }
   }
 
-  // 7. asdf/mise shim resolution
+  // 9. asdf/mise shim resolution
   const asdfDataDir = process.env.ASDF_DATA_DIR ?? join(process.env.HOME ?? "", ".asdf")
   if (existsSync(join(asdfDataDir, "shims", "dbt"))) {
     try {