From fddd6a18c37427b90154a5bbca8f16e44fa7ace1 Mon Sep 17 00:00:00 2001
From: Ben King <9087625+benfdking@users.noreply.github.com>
Date: Mon, 11 Aug 2025 16:36:40 +0200
Subject: [PATCH] chore(vscode): removing legacy format methods

---
 vscode/extension/src/commands/format.ts       |  38 +------
 .../src/utilities/sqlmesh/sqlmesh.ts          | 103 ------------------
 2 files changed, 6 insertions(+), 135 deletions(-)

diff --git a/vscode/extension/src/commands/format.ts b/vscode/extension/src/commands/format.ts
index bedeaa16be..f01435523a 100644
--- a/vscode/extension/src/commands/format.ts
+++ b/vscode/extension/src/commands/format.ts
@@ -1,10 +1,8 @@
 import { traceLog } from '../utilities/common/log'
-import { sqlmeshExec } from '../utilities/sqlmesh/sqlmesh'
 import { err, isErr, ok, Result } from '@bus/result'
 import * as vscode from 'vscode'
 import { ErrorType, handleError } from '../utilities/errors'
 import { AuthenticationProviderTobikoCloud } from '../auth/auth'
-import { execAsync } from '../utilities/exec'
 import { LSPClient } from '../lsp/lsp'
 
 export const format =
@@ -30,39 +28,15 @@ export const format =
 const internalFormat = async (
   lsp: LSPClient | undefined,
 ): Promise<Result<undefined, ErrorType>> => {
-  try {
-    // Try LSP method first
-    if (lsp) {
-      const response = await lsp.call_custom_method(
-        'sqlmesh/format_project',
-        {},
-      )
-      if (isErr(response)) {
-        return response
-      }
-      return ok(undefined)
-    }
-  } catch (error) {
-    traceLog(`LSP format failed, falling back to CLI: ${JSON.stringify(error)}`)
-  }
-
-  // Fallback to CLI method if LSP is not available
-  // TODO This is a solution in order to be backwards compatible in the cases
-  //  where the LSP method is not implemented yet. This should be removed at
-  //  some point in the future.
-  const exec = await sqlmeshExec()
-  if (isErr(exec)) {
-    return exec
-  }
-  const result = await execAsync(`${exec.value.bin}`, ['format'], {
-    cwd: exec.value.workspacePath,
-    env: exec.value.env,
-  })
-  if (result.exitCode !== 0) {
+  if (lsp === undefined) {
     return err({
       type: 'generic',
-      message: `Error executing sqlmesh format: ${result.stderr}`,
+      message: 'LSP is not available',
     })
   }
+  const response = await lsp.call_custom_method('sqlmesh/format_project', {})
+  if (isErr(response)) {
+    return response
+  }
   return ok(undefined)
 }
diff --git a/vscode/extension/src/utilities/sqlmesh/sqlmesh.ts b/vscode/extension/src/utilities/sqlmesh/sqlmesh.ts
index 104869192b..649c57fd77 100644
--- a/vscode/extension/src/utilities/sqlmesh/sqlmesh.ts
+++ b/vscode/extension/src/utilities/sqlmesh/sqlmesh.ts
@@ -262,109 +262,6 @@ export const ensureSqlmeshEnterpriseInstalled = async (): Promise<
   return installationLock
 }
 
-/**
- * Get the sqlmesh executable for the current workspace.
- *
- * @deprecated Use LSP instead of direct sqlmesh execution for any new functionality.
- */
-export const sqlmeshExec = async (): Promise<
-  Result<SqlmeshExecInfo, ErrorType>
-> => {
-  const sqlmesh = IS_WINDOWS ? 'sqlmesh.exe' : 'sqlmesh'
-  const projectRoot = await getProjectRoot()
-  const resolvedPath = resolveProjectPath(projectRoot)
-  if (isErr(resolvedPath)) {
-    return err({
-      type: 'generic',
-      message: resolvedPath.error,
-    })
-  }
-  const envVariables = await getPythonEnvVariables()
-  if (isErr(envVariables)) {
-    return err({
-      type: 'generic',
-      message: envVariables.error,
-    })
-  }
-  const workspacePath = resolvedPath.value
-  const interpreterDetails = await getInterpreterDetails()
-  traceLog(`Interpreter details: ${JSON.stringify(interpreterDetails)}`)
-  if (interpreterDetails.path) {
-    traceVerbose(
-      `Using interpreter from Python extension: ${interpreterDetails.path.join(
-        ' ',
-      )}`,
-    )
-  }
-  if (interpreterDetails.isVirtualEnvironment) {
-    traceLog('Using virtual environment')
-    const isTcloudInstalled = await isTcloudProject()
-    if (isErr(isTcloudInstalled)) {
-      return err({
-        type: 'generic',
-        message: isTcloudInstalled.error,
-      })
-    }
-    if (isTcloudInstalled.value) {
-      const tcloudBin = await getTcloudBin()
-      if (isErr(tcloudBin)) {
-        return tcloudBin
-      }
-      const isSignedIn = await isSignedIntoTobikoCloud()
-      if (!isSignedIn) {
-        return err({
-          type: 'not_signed_in',
-        })
-      }
-      const ensured = await ensureSqlmeshEnterpriseInstalled()
-      if (isErr(ensured)) {
-        return ensured
-      }
-      return ok({
-        bin: tcloudBin.value.bin,
-        workspacePath,
-        env: tcloudBin.value.env,
-        args: ["sqlmesh"],
-      })
-    }
-    const binPath = path.join(interpreterDetails.binPath!, sqlmesh)
-    traceLog(`Bin path: ${binPath}`)
-    const env = await getSqlmeshEnvironment()
-    if (isErr(env)) {
-      return err({
-        type: 'generic',
-        message: env.error,
-      })
-    }
-    return ok({
-      bin: binPath,
-      workspacePath,
-      env: env.value,
-      args: [],
-    })
-  } else {
-    const exists = await doesExecutableExist(sqlmesh)
-    if (!exists) {
-      return err({
-        type: 'sqlmesh_not_found',
-      })
-    }
-    const env = await getSqlmeshEnvironment()
-    if (isErr(env)) {
-      return err({
-        type: 'generic',
-        message: env.error,
-      })
-    }
-    return ok({
-      bin: sqlmesh,
-      workspacePath,
-      env: env.value,
-      args: [],
-    })
-  }
-}
-
 /**
  * Ensure that the sqlmesh_lsp dependencies are installed.
  *