feat: dbt integration improvements — lineage, profiles tool, + operator

- `dbt.lineage` bridge method: takes manifest path + model name, extracts
  compiled SQL + upstream schemas, computes column-level lineage
- `dbt_profiles` TS tool: exposes existing `dbt.profiles` bridge method
  so the agent can discover warehouse connections from profiles.yml
- `dbt_lineage` TS tool: agent-facing tool for dbt model lineage
- Auto-prepend `+` to dbt selectors for build/run/test commands to
  always include upstream dependencies (user preference)
- `lineage_check` tool: expose `schema_context` param (was in protocol
  but not in the tool definition)

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

Author: kulvirgit

packages/altimate-code/src/bridge/protocol.ts

@@ -904,6 +904,25 @@ export interface SqlGuardIsSafeParams {
   sql: string
 }
 
+// --- dbt Lineage ---
+
+export interface DbtLineageParams {
+  manifest_path: string
+  model: string
+  dialect?: string
+}
+
+export interface DbtLineageResult {
+  model_name: string
+  model_unique_id?: string
+  compiled_sql?: string
+  edges: LineageEdge[]
+  tables: string[]
+  columns: string[]
+  confidence: string
+  confidence_factors: string[]
+}
+
 // --- dbt Profile Discovery ---
 
 export interface DbtProfilesParams {
@@ -982,6 +1001,7 @@ export const BridgeMethods = {
   "lineage.check": {} as { params: LineageCheckParams; result: LineageCheckResult },
   "dbt.run": {} as { params: DbtRunParams; result: DbtRunResult },
   "dbt.manifest": {} as { params: DbtManifestParams; result: DbtManifestResult },
+  "dbt.lineage": {} as { params: DbtLineageParams; result: DbtLineageResult },
   "warehouse.list": {} as { params: WarehouseListParams; result: WarehouseListResult },
   "warehouse.test": {} as { params: WarehouseTestParams; result: WarehouseTestResult },
   "finops.query_history": {} as { params: QueryHistoryParams; result: QueryHistoryResult },

packages/altimate-code/src/tool/dbt-lineage.ts

@@ -0,0 +1,77 @@
+import z from "zod"
+import { Tool } from "./tool"
+import { Bridge } from "../bridge/client"
+import type { DbtLineageResult } from "../bridge/protocol"
+
+export const DbtLineageTool = Tool.define("dbt_lineage", {
+  description:
+    "Compute column-level lineage for a dbt model. Takes a manifest.json path and model name, extracts compiled SQL and upstream schemas, and traces how source columns flow to output columns.",
+  parameters: z.object({
+    manifest_path: z.string().describe("Path to dbt manifest.json file"),
+    model: z.string().describe("Model name or unique_id (e.g. 'my_model' or 'model.project.my_model')"),
+    dialect: z.string().optional().describe("SQL dialect override (auto-detected from manifest if omitted)"),
+  }),
+  async execute(args, ctx) {
+    try {
+      const result = await Bridge.call("dbt.lineage", {
+        manifest_path: args.manifest_path,
+        model: args.model,
+        dialect: args.dialect,
+      })
+
+      return {
+        title: `dbt Lineage: ${result.model_name} — ${result.edges.length} edge(s) [${result.confidence}]`,
+        metadata: {
+          model_name: result.model_name,
+          edgeCount: result.edges.length,
+          tableCount: result.tables.length,
+          confidence: result.confidence,
+        },
+        output: formatDbtLineage(result),
+      }
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e)
+      return {
+        title: "dbt Lineage: ERROR",
+        metadata: { model_name: args.model, edgeCount: 0, tableCount: 0, confidence: "unknown" },
+        output: `Failed: ${msg}`,
+      }
+    }
+  },
+})
+
+function formatDbtLineage(result: DbtLineageResult): string {
+  const lines: string[] = []
+
+  lines.push(`Model: ${result.model_name}`)
+  if (result.model_unique_id) lines.push(`ID: ${result.model_unique_id}`)
+  lines.push("")
+
+  if (result.confidence_factors.length > 0) {
+    lines.push(`Confidence: ${result.confidence}`)
+    lines.push(`  Note: ${result.confidence_factors.join("; ")}`)
+    lines.push("")
+  }
+
+  if (result.edges.length === 0) {
+    lines.push("No column-level lineage edges detected.")
+    if (!result.compiled_sql) {
+      lines.push("Run `dbt compile` first to generate compiled SQL.")
+    }
+    return lines.join("\n")
+  }
+
+  lines.push("Column Lineage:")
+  lines.push("Source → Target | Transform")
+  lines.push("".padEnd(60, "-"))
+
+  for (const edge of result.edges) {
+    const transform = edge.transform ? ` | ${edge.transform}` : ""
+    lines.push(`${edge.source_table}.${edge.source_column} → ${edge.target_table}.${edge.target_column}${transform}`)
+  }
+
+  lines.push("")
+  lines.push(`Tables: ${result.tables.join(", ")}`)
+
+  return lines.join("\n")
+}

packages/altimate-code/src/tool/dbt-profiles.ts

@@ -0,0 +1,64 @@
+import z from "zod"
+import { Tool } from "./tool"
+import { Bridge } from "../bridge/client"
+
+export const DbtProfilesTool = Tool.define("dbt_profiles", {
+  description:
+    "Discover dbt profiles from profiles.yml and map them to warehouse connections. Auto-detects Snowflake, BigQuery, Databricks, Postgres, Redshift, MySQL, DuckDB configurations.",
+  parameters: z.object({
+    path: z.string().optional().describe("Path to profiles.yml (defaults to ~/.dbt/profiles.yml)"),
+  }),
+  async execute(args, ctx) {
+    try {
+      const result = await Bridge.call("dbt.profiles", {
+        path: args.path,
+      })
+
+      if (!result.success) {
+        return {
+          title: "dbt Profiles: FAILED",
+          metadata: { success: false, connection_count: 0 },
+          output: result.error ?? "Failed to parse profiles.yml",
+        }
+      }
+
+      const connections = result.connections ?? []
+      if (connections.length === 0) {
+        return {
+          title: "dbt Profiles: No connections found",
+          metadata: { success: true, connection_count: 0 },
+          output: "No dbt profiles found. Ensure ~/.dbt/profiles.yml exists with valid configurations.",
+        }
+      }
+
+      return {
+        title: `dbt Profiles: ${connections.length} connection(s)`,
+        metadata: { success: true, connection_count: connections.length },
+        output: formatConnections(connections),
+      }
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e)
+      return {
+        title: "dbt Profiles: ERROR",
+        metadata: { success: false, connection_count: 0 },
+        output: `Failed: ${msg}`,
+      }
+    }
+  },
+})
+
+function formatConnections(connections: Array<{ name: string; type: string; config: Record<string, unknown> }>): string {
+  const lines: string[] = []
+  for (const conn of connections) {
+    lines.push(`${conn.name} (${conn.type})`)
+    for (const [key, val] of Object.entries(conn.config)) {
+      if (key === "password" || key === "private_key_passphrase" || key === "access_token") {
+        lines.push(`  ${key}: ****`)
+      } else {
+        lines.push(`  ${key}: ${val}`)
+      }
+    }
+    lines.push("")
+  }
+  return lines.join("\n")
+}

packages/altimate-code/src/tool/lineage-check.ts

@@ -13,12 +13,17 @@ export const LineageCheckTool = Tool.define("lineage_check", {
       .optional()
       .default("snowflake")
       .describe("SQL dialect (snowflake, postgres, bigquery, duckdb, etc.)"),
+    schema_context: z
+      .record(z.string(), z.array(z.object({ name: z.string(), data_type: z.string() })))
+      .optional()
+      .describe("Schema context mapping table names to column definitions for accurate lineage"),
   }),
   async execute(args, ctx) {
     try {
       const result = await Bridge.call("lineage.check", {
         sql: args.sql,
         dialect: args.dialect,
+        schema_context: args.schema_context,
       })
 
       return {

packages/altimate-code/src/tool/registry.ts

@@ -36,6 +36,8 @@ import { SqlRecordFeedbackTool } from "./sql-record-feedback"
 import { SqlPredictCostTool } from "./sql-predict-cost"
 import { DbtRunTool } from "./dbt-run"
 import { DbtManifestTool } from "./dbt-manifest"
+import { DbtProfilesTool } from "./dbt-profiles"
+import { DbtLineageTool } from "./dbt-lineage"
 import { SchemaIndexTool } from "./schema-index"
 import { SchemaSearchTool } from "./schema-search"
 import { SchemaCacheStatusTool } from "./schema-cache-status"
@@ -192,6 +194,8 @@ export namespace ToolRegistry {
       SqlPredictCostTool,
       DbtRunTool,
       DbtManifestTool,
+      DbtProfilesTool,
+      DbtLineageTool,
       SchemaIndexTool,
       SchemaSearchTool,
       SchemaCacheStatusTool,