fix: pass warehouse dialect to altimate-core tools instead of hardcoding snowflake

packages/opencode/src/altimate/native/altimate-core.ts

@@ -88,7 +88,7 @@ export function registerAll(): void {
   // 1. altimate_core.validate
   register("altimate_core.validate", async (params) => {
     try {
-      const schema = schemaOrEmpty(params.schema_path, params.schema_context)
+      const schema = schemaOrEmpty(params.schema_path, params.schema_context, params.dialect)
       const raw = await core.validate(params.sql, schema)
       const data = toData(raw)
       return ok(true, data)
@@ -167,7 +167,7 @@ export function registerAll(): void {
   // 6. altimate_core.check — composite: validate + lint + scan_sql
   register("altimate_core.check", async (params) => {
     try {
-      const schema = schemaOrEmpty(params.schema_path, params.schema_context)
+      const schema = schemaOrEmpty(params.schema_path, params.schema_context, params.dialect)
       const validation = await core.validate(params.sql, schema)
       const lintResult = core.lint(params.sql, schema)
       const safety = core.scanSql(params.sql)
@@ -185,7 +185,7 @@ export function registerAll(): void {
   // 7. altimate_core.fix
   register("altimate_core.fix", async (params) => {
     try {
-      const schema = schemaOrEmpty(params.schema_path, params.schema_context)
+      const schema = schemaOrEmpty(params.schema_path, params.schema_context, params.dialect)
       const raw = await core.fix(params.sql, schema, params.max_iterations ?? undefined)
       const data = toData(raw)
       return ok(true, data)
@@ -197,7 +197,7 @@ export function registerAll(): void {
   // 8. altimate_core.policy
   register("altimate_core.policy", async (params) => {
     try {
-      const schema = schemaOrEmpty(params.schema_path, params.schema_context)
+      const schema = schemaOrEmpty(params.schema_path, params.schema_context, params.dialect)
       const raw = await core.checkPolicy(params.sql, schema, params.policy_json)
       const data = toData(raw)
       return ok(true, data)
@@ -209,7 +209,7 @@ export function registerAll(): void {
   // 9. altimate_core.semantics
   register("altimate_core.semantics", async (params) => {
     try {
-      const schema = schemaOrEmpty(params.schema_path, params.schema_context)
+      const schema = schemaOrEmpty(params.schema_path, params.schema_context, params.dialect)
       const raw = await core.checkSemantics(params.sql, schema)
       const data = toData(raw)
       return ok(true, data)
@@ -232,7 +232,7 @@ export function registerAll(): void {
   // 11. altimate_core.equivalence
   register("altimate_core.equivalence", async (params) => {
     try {
-      const schema = schemaOrEmpty(params.schema_path, params.schema_context)
+      const schema = schemaOrEmpty(params.schema_path, params.schema_context, params.dialect)
       const raw = await core.checkEquivalence(params.sql1, params.sql2, schema)
       const data = toData(raw)
       return ok(true, data)
@@ -280,7 +280,7 @@ export function registerAll(): void {
   // 15. altimate_core.correct
   register("altimate_core.correct", async (params) => {
     try {
-      const schema = schemaOrEmpty(params.schema_path, params.schema_context)
+      const schema = schemaOrEmpty(params.schema_path, params.schema_context, params.dialect)
       const raw = await core.correct(params.sql, schema)
       const data = toData(raw)
       return ok(true, data)

packages/opencode/src/altimate/native/schema-resolver.ts

@@ -111,12 +111,15 @@ export function resolveSchema(
 /**
  * Resolve a Schema, falling back to a minimal empty schema when none is provided.
  * Use this for functions that require a non-null Schema argument.
+ * When a dialect is provided, it is passed to Schema.fromDdl() so the fallback
+ * empty schema uses the correct SQL dialect for validation/analysis.
  */
 export function schemaOrEmpty(
   schemaPath?: string,
   schemaContext?: Record<string, any>,
+  dialect?: string,
 ): Schema {
   const s = resolveSchema(schemaPath, schemaContext)
   if (s !== null) return s
-  return Schema.fromDdl("CREATE TABLE _empty_ (id INT);")
+  return Schema.fromDdl("CREATE TABLE _empty_ (id INT);", dialect || undefined)
 }

packages/opencode/src/altimate/native/types.ts

@@ -680,6 +680,7 @@ export interface SchemaDiffResult {
 
 export interface AltimateCoreValidateParams {
   sql: string
+  dialect?: string
   schema_path?: string
   schema_context?: Record<string, any>
 }
@@ -708,6 +709,7 @@ export interface AltimateCoreExplainParams {
 
 export interface AltimateCoreCheckParams {
   sql: string
+  dialect?: string
   schema_path?: string
   schema_context?: Record<string, any>
 }
@@ -722,20 +724,23 @@ export interface AltimateCoreResult {
 
 export interface AltimateCoreFixParams {
   sql: string
+  dialect?: string
   schema_path?: string
   schema_context?: Record<string, any>
   max_iterations?: number
 }
 
 export interface AltimateCorePolicyParams {
   sql: string
+  dialect?: string
   policy_json: string
   schema_path?: string
   schema_context?: Record<string, any>
 }
 
 export interface AltimateCoreSemanticsParams {
   sql: string
+  dialect?: string
   schema_path?: string
   schema_context?: Record<string, any>
 }
@@ -751,6 +756,7 @@ export interface AltimateCoreTestgenParams {
 export interface AltimateCoreEquivalenceParams {
   sql1: string
   sql2: string
+  dialect?: string
   schema_path?: string
   schema_context?: Record<string, any>
 }
@@ -776,6 +782,7 @@ export interface AltimateCoreRewriteParams {
 
 export interface AltimateCoreCorrectParams {
   sql: string
+  dialect?: string
   schema_path?: string
   schema_context?: Record<string, any>
 }

packages/opencode/src/altimate/tools/altimate-core-check.ts

@@ -8,6 +8,11 @@ export const AltimateCoreCheckTool = Tool.define("altimate_core_check", {
     "Run full analysis pipeline: validate + lint + safety scan + PII check. Single call for comprehensive SQL analysis. Provide schema_context or schema_path for accurate table/column resolution.",
   parameters: z.object({
     sql: z.string().describe("SQL query to analyze"),
+    dialect: z
+      .string()
+      .optional()
+      .default("snowflake")
+      .describe("SQL dialect (snowflake, postgres, bigquery, duckdb, etc.)"),
     schema_path: z.string().optional().describe("Path to YAML/JSON schema file"),
     schema_context: z.record(z.string(), z.any()).optional().describe("Inline schema definition"),
   }),
@@ -16,6 +21,7 @@ export const AltimateCoreCheckTool = Tool.define("altimate_core_check", {
     try {
       const result = await Dispatcher.call("altimate_core.check", {
         sql: args.sql,
+        dialect: args.dialect,
         schema_path: args.schema_path ?? "",
         schema_context: args.schema_context,
       })
@@ -40,6 +46,7 @@ export const AltimateCoreCheckTool = Tool.define("altimate_core_check", {
         title: `Check: ${formatCheckTitle(data)}`,
         metadata: {
           success: result.success,
+          dialect: args.dialect,
           has_schema: hasSchema,
           ...(error && { error }),
           ...(findings.length > 0 && { findings }),
@@ -50,7 +57,7 @@ export const AltimateCoreCheckTool = Tool.define("altimate_core_check", {
       const msg = e instanceof Error ? e.message : String(e)
       return {
         title: "Check: ERROR",
-        metadata: { success: false, has_schema: hasSchema, error: msg },
+        metadata: { success: false, dialect: args.dialect, has_schema: hasSchema, error: msg },
         output: `Failed: ${msg}`,
       }
     }

packages/opencode/src/altimate/tools/altimate-core-correct.ts

@@ -8,6 +8,11 @@ export const AltimateCoreCorrectTool = Tool.define("altimate_core_correct", {
     "Iteratively correct SQL using a propose-verify-refine loop. More thorough than fix — applies multiple correction rounds to produce valid SQL. Provide schema_context or schema_path for accurate table/column resolution.",
   parameters: z.object({
     sql: z.string().describe("SQL query to correct"),
+    dialect: z
+      .string()
+      .optional()
+      .default("snowflake")
+      .describe("SQL dialect (snowflake, postgres, bigquery, duckdb, etc.)"),
     schema_path: z.string().optional().describe("Path to YAML/JSON schema file"),
     schema_context: z.record(z.string(), z.any()).optional().describe("Inline schema definition"),
   }),
@@ -16,6 +21,7 @@ export const AltimateCoreCorrectTool = Tool.define("altimate_core_correct", {
     try {
       const result = await Dispatcher.call("altimate_core.correct", {
         sql: args.sql,
+        dialect: args.dialect,
         schema_path: args.schema_path ?? "",
         schema_context: args.schema_context,
       })
@@ -32,6 +38,7 @@ export const AltimateCoreCorrectTool = Tool.define("altimate_core_correct", {
         metadata: {
           success: result.success,
           iterations: data.iterations,
+          dialect: args.dialect,
           has_schema: hasSchema,
           ...(error && { error }),
           ...(findings.length > 0 && { findings }),
@@ -42,7 +49,7 @@ export const AltimateCoreCorrectTool = Tool.define("altimate_core_correct", {
       const msg = e instanceof Error ? e.message : String(e)
       return {
         title: "Correct: ERROR",
-        metadata: { success: false, iterations: 0, has_schema: hasSchema, error: msg },
+        metadata: { success: false, iterations: 0, dialect: args.dialect, has_schema: hasSchema, error: msg },
         output: `Failed: ${msg}`,
       }
     }

packages/opencode/src/altimate/tools/altimate-core-equivalence.ts

@@ -9,6 +9,11 @@ export const AltimateCoreEquivalenceTool = Tool.define("altimate_core_equivalenc
   parameters: z.object({
     sql1: z.string().describe("First SQL query"),
     sql2: z.string().describe("Second SQL query"),
+    dialect: z
+      .string()
+      .optional()
+      .default("snowflake")
+      .describe("SQL dialect (snowflake, postgres, bigquery, duckdb, etc.)"),
     schema_path: z.string().optional().describe("Path to YAML/JSON schema file"),
     schema_context: z.record(z.string(), z.any()).optional().describe("Inline schema definition"),
   }),
@@ -19,14 +24,15 @@ export const AltimateCoreEquivalenceTool = Tool.define("altimate_core_equivalenc
         "No schema provided. Provide schema_context or schema_path so table/column references can be resolved."
       return {
         title: "Equivalence: NO SCHEMA",
-        metadata: { success: false, equivalent: false, has_schema: false, error },
+        metadata: { success: false, equivalent: false, dialect: args.dialect, has_schema: false, error },
         output: `Error: ${error}`,
       }
     }
     try {
       const result = await Dispatcher.call("altimate_core.equivalence", {
         sql1: args.sql1,
         sql2: args.sql2,
+        dialect: args.dialect,
         schema_path: args.schema_path ?? "",
         schema_context: args.schema_context,
       })
@@ -48,6 +54,7 @@ export const AltimateCoreEquivalenceTool = Tool.define("altimate_core_equivalenc
         metadata: {
           success: !isRealFailure,
           equivalent: data.equivalent,
+          dialect: args.dialect,
           has_schema: hasSchema,
           ...(error && { error }),
           ...(findings.length > 0 && { findings }),
@@ -58,7 +65,7 @@ export const AltimateCoreEquivalenceTool = Tool.define("altimate_core_equivalenc
       const msg = e instanceof Error ? e.message : String(e)
       return {
         title: "Equivalence: ERROR",
-        metadata: { success: false, equivalent: false, has_schema: hasSchema, error: msg },
+        metadata: { success: false, equivalent: false, dialect: args.dialect, has_schema: hasSchema, error: msg },
         output: `Failed: ${msg}`,
       }
     }

packages/opencode/src/altimate/tools/altimate-core-fix.ts

@@ -8,6 +8,11 @@ export const AltimateCoreFixTool = Tool.define("altimate_core_fix", {
     "Auto-fix SQL errors using fuzzy matching and iterative re-validation. Corrects syntax errors, typos, and schema reference issues. IMPORTANT: Provide schema_context or schema_path — without schema, table/column references cannot be resolved or fixed.",
   parameters: z.object({
     sql: z.string().describe("SQL query to fix"),
+    dialect: z
+      .string()
+      .optional()
+      .default("snowflake")
+      .describe("SQL dialect (snowflake, postgres, bigquery, duckdb, etc.)"),
     schema_path: z.string().optional().describe("Path to YAML/JSON schema file"),
     schema_context: z.record(z.string(), z.any()).optional().describe("Inline schema definition"),
     max_iterations: z.number().optional().describe("Maximum fix iterations (default: 5)"),
@@ -17,6 +22,7 @@ export const AltimateCoreFixTool = Tool.define("altimate_core_fix", {
     try {
       const result = await Dispatcher.call("altimate_core.fix", {
         sql: args.sql,
+        dialect: args.dialect,
         schema_path: args.schema_path ?? "",
         schema_context: args.schema_context,
         max_iterations: args.max_iterations ?? 5,
@@ -40,6 +46,7 @@ export const AltimateCoreFixTool = Tool.define("altimate_core_fix", {
         metadata: {
           success,
           fixed: !!data.fixed_sql,
+          dialect: args.dialect,
           has_schema: hasSchema,
           ...(error && { error }),
           ...(findings.length > 0 && { findings }),
@@ -50,7 +57,7 @@ export const AltimateCoreFixTool = Tool.define("altimate_core_fix", {
       const msg = e instanceof Error ? e.message : String(e)
       return {
         title: "Fix: ERROR",
-        metadata: { success: false, fixed: false, has_schema: hasSchema, error: msg },
+        metadata: { success: false, fixed: false, dialect: args.dialect, has_schema: hasSchema, error: msg },
         output: `Failed: ${msg}`,
       }
     }

packages/opencode/src/altimate/tools/altimate-core-policy.ts

@@ -8,6 +8,11 @@ export const AltimateCorePolicyTool = Tool.define("altimate_core_policy", {
     "Check SQL against YAML-based governance policy guardrails. Validates compliance with custom rules like allowed tables, forbidden operations, and data access restrictions. Provide schema_context or schema_path for accurate table/column resolution.",
   parameters: z.object({
     sql: z.string().describe("SQL query to check against policy"),
+    dialect: z
+      .string()
+      .optional()
+      .default("snowflake")
+      .describe("SQL dialect (snowflake, postgres, bigquery, duckdb, etc.)"),
     policy_json: z.string().describe("JSON string defining the policy rules"),
     schema_path: z.string().optional().describe("Path to YAML/JSON schema file"),
     schema_context: z.record(z.string(), z.any()).optional().describe("Inline schema definition"),
@@ -17,6 +22,7 @@ export const AltimateCorePolicyTool = Tool.define("altimate_core_policy", {
     try {
       const result = await Dispatcher.call("altimate_core.policy", {
         sql: args.sql,
+        dialect: args.dialect,
         policy_json: args.policy_json,
         schema_path: args.schema_path ?? "",
         schema_context: args.schema_context,
@@ -34,6 +40,7 @@ export const AltimateCorePolicyTool = Tool.define("altimate_core_policy", {
         metadata: {
           success: true, // engine ran — violations are findings, not failures
           pass: data.pass,
+          dialect: args.dialect,
           has_schema: hasSchema,
           ...(error && { error }),
           ...(findings.length > 0 && { findings }),
@@ -44,7 +51,7 @@ export const AltimateCorePolicyTool = Tool.define("altimate_core_policy", {
       const msg = e instanceof Error ? e.message : String(e)
       return {
         title: "Policy: ERROR",
-        metadata: { success: false, pass: false, has_schema: hasSchema, error: msg },
+        metadata: { success: false, pass: false, dialect: args.dialect, has_schema: hasSchema, error: msg },
         output: `Failed: ${msg}`,
       }
     }

packages/opencode/src/altimate/tools/altimate-core-semantics.ts

@@ -8,6 +8,11 @@ export const AltimateCoreSemanticsTool = Tool.define("altimate_core_semantics",
     "Run semantic validation rules against SQL. Detects logical issues like cartesian products, wrong JOIN conditions, NULL misuse, and type mismatches that syntax checking alone misses. Provide schema_context or schema_path for accurate table/column resolution.",
   parameters: z.object({
     sql: z.string().describe("SQL query to validate semantically"),
+    dialect: z
+      .string()
+      .optional()
+      .default("snowflake")
+      .describe("SQL dialect (snowflake, postgres, bigquery, duckdb, etc.)"),
     schema_path: z.string().optional().describe("Path to YAML/JSON schema file"),
     schema_context: z.record(z.string(), z.any()).optional().describe("Inline schema definition"),
   }),
@@ -18,13 +23,14 @@ export const AltimateCoreSemanticsTool = Tool.define("altimate_core_semantics",
         "No schema provided. Provide schema_context or schema_path so table/column references can be resolved."
       return {
         title: "Semantics: NO SCHEMA",
-        metadata: { success: false, valid: false, issue_count: 0, has_schema: false, error },
+        metadata: { success: false, valid: false, issue_count: 0, dialect: args.dialect, has_schema: false, error },
         output: `Error: ${error}`,
       }
     }
     try {
       const result = await Dispatcher.call("altimate_core.semantics", {
         sql: args.sql,
+        dialect: args.dialect,
         schema_path: args.schema_path ?? "",
         schema_context: args.schema_context,
       })
@@ -44,6 +50,7 @@ export const AltimateCoreSemanticsTool = Tool.define("altimate_core_semantics",
           success: true, // engine ran — semantic issues are findings, not failures
           valid: data.valid,
           issue_count: issueCount,
+          dialect: args.dialect,
           has_schema: hasSchema,
           ...(error && { error }),
           ...(findings.length > 0 && { findings }),
@@ -54,7 +61,7 @@ export const AltimateCoreSemanticsTool = Tool.define("altimate_core_semantics",
       const msg = e instanceof Error ? e.message : String(e)
       return {
         title: "Semantics: ERROR",
-        metadata: { success: false, valid: false, issue_count: 0, has_schema: hasSchema, error: msg },
+        metadata: { success: false, valid: false, issue_count: 0, dialect: args.dialect, has_schema: hasSchema, error: msg },
         output: `Failed: ${msg}`,
       }
     }