refactor: remove existing-tool improvements — scope to data-diff only

Author: suryaiyer95

packages/opencode/src/altimate/tools/altimate-core-column-lineage.ts

@@ -47,16 +47,7 @@ function formatColumnLineage(data: Record<string, any>): string {
   if (data.column_dict && Object.keys(data.column_dict).length > 0) {
     lines.push("Column Mappings:")
     for (const [target, sources] of Object.entries(data.column_dict)) {
-      const srcList = Array.isArray(sources)
-        ? sources
-            .map((s: any) => {
-              if (typeof s === "string") return s
-              if (s && s.source_table && s.source_column) return `${s.source_table}.${s.source_column}`
-              if (s && s.source) return String(s.source)
-              return JSON.stringify(s)
-            })
-            .join(", ")
-        : JSON.stringify(sources)
+      const srcList = Array.isArray(sources) ? (sources as string[]).join(", ") : JSON.stringify(sources)
       lines.push(`  ${target} ← ${srcList}`)
     }
     lines.push("")

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

@@ -20,22 +20,12 @@ export const LineageCheckTool = Tool.define("lineage_check", {
   }),
   async execute(args, ctx) {
     try {
-      const raw = await Dispatcher.call("lineage.check", {
+      const result = await Dispatcher.call("lineage.check", {
         sql: args.sql,
         dialect: args.dialect,
         schema_context: args.schema_context,
       })
 
-      // Guard against null/undefined/non-object responses
-      if (raw == null || typeof raw !== "object") {
-        return {
-          title: "Lineage: ERROR",
-          metadata: { success: false, error: "Unexpected response from lineage handler" },
-          output: "Lineage check failed: unexpected response format.",
-        }
-      }
-      const result = raw as LineageCheckResult
-
       const data = (result.data ?? {}) as Record<string, any>
       if (result.error) {
         return {

packages/opencode/src/altimate/tools/schema-inspect.ts

@@ -15,22 +15,11 @@ export const SchemaInspectTool = Tool.define("schema_inspect", {
   }),
   async execute(args, ctx) {
     try {
-      const raw = (await Dispatcher.call("schema.inspect", {
+      const result = await Dispatcher.call("schema.inspect", {
         table: args.table,
         schema_name: args.schema_name,
         warehouse: args.warehouse,
-      })) as any
-
-      // Surface dispatcher-level errors (e.g. { success: false, error: "..." })
-      if (!raw || raw.success === false || raw.error) {
-        const errorMsg = (raw?.error as string) ?? "Schema inspection failed"
-        return {
-          title: "Schema: ERROR",
-          metadata: { columnCount: 0, rowCount: undefined, error: errorMsg },
-          output: `Failed to inspect schema: ${errorMsg}\n\nEnsure the dispatcher is running and a warehouse connection is configured.`,
-        }
-      }
-      const result = raw as SchemaInspectResult
+      })
 
       // altimate_change start — progressive disclosure suggestions
       let output = formatSchema(result)

packages/opencode/src/altimate/tools/sql-analyze.ts

@@ -26,23 +26,13 @@ export const SqlAnalyzeTool = Tool.define("sql_analyze", {
   async execute(args, ctx) {
     const hasSchema = !!(args.schema_path || (args.schema_context && Object.keys(args.schema_context).length > 0))
     try {
-      const raw = await Dispatcher.call("sql.analyze", {
+      const result = await Dispatcher.call("sql.analyze", {
         sql: args.sql,
         dialect: args.dialect,
         schema_path: args.schema_path,
         schema_context: args.schema_context,
       })
 
-      // Guard against null/undefined/non-object responses
-      if (raw == null || typeof raw !== "object") {
-        return {
-          title: "Analyze: ERROR",
-          metadata: { success: false, issueCount: 0, confidence: "unknown", dialect: args.dialect, has_schema: hasSchema, error: "Unexpected response from analysis handler" },
-          output: "Analysis failed: unexpected response format.",
-        }
-      }
-      const result = raw
-
       // The handler returns success=true when analysis completes (issues are
       // reported via issues/issue_count). Only treat it as a failure when
       // there's an actual error (e.g. parse failure).