feat(vscode): allow configuring project path

Author: benfdking

sqlmesh/lsp/main.py

@@ -69,10 +69,7 @@ def initialize(ls: LanguageServer, params: types.InitializeParams) -> None:
                                     # Use user-provided instantiator to build the context
                                     created_context = self.context_class(paths=[folder_path])
                                     self.lsp_context = LSPContext(created_context)
-                                    ls.show_message(
-                                        f"Loaded SQLMesh context from {config_path}",
-                                        types.MessageType.Info,
-                                    )
+                                    loaded_sqlmesh_message(ls, folder_path)
                                     return  # Exit after successfully loading any config
                                 except Exception as e:
                                     ls.show_message(
@@ -94,6 +91,9 @@ def all_models(ls: LanguageServer, params: AllModelsRequest) -> AllModelsRespons
         @self.server.feature(API_FEATURE)
         def api(ls: LanguageServer, request: ApiRequest) -> t.Dict[str, t.Any]:
             ls.log_trace(f"API request: {request}")
+            if self.lsp_context is None:
+                current_path = Path.cwd()
+                self._ensure_context_in_folder(current_path)
             if self.lsp_context is None:
                 raise RuntimeError("No context found")
 
@@ -291,6 +291,20 @@ def _context_get_or_load(self, document_uri: URI) -> LSPContext:
             raise RuntimeError("No context found")
         return self.lsp_context
 
+    def _ensure_context_in_folder(self, folder_uri: Path) -> None:
+        if self.lsp_context is not None:
+            return
+        for ext in ("py", "yml", "yaml"):
+            config_path = folder_uri / f"config.{ext}"
+            if config_path.exists():
+                try:
+                    created_context = self.context_class(paths=[folder_uri])
+                    self.lsp_context = LSPContext(created_context)
+                    loaded_sqlmesh_message(self.server, folder_uri)
+                    return
+                except Exception as e:
+                    self.server.show_message(f"Error loading context: {e}", types.MessageType.Error)
+
     def _ensure_context_for_document(
         self,
         document_uri: URI,
@@ -382,6 +396,13 @@ def start(self) -> None:
         self.server.start_io()
 
 
+def loaded_sqlmesh_message(ls: LanguageServer, folder: Path) -> None:
+    ls.show_message(
+        f"Loaded SQLMesh context from {folder}",
+        types.MessageType.Info,
+    )
+
+
 def main() -> None:
     # Example instantiator that just uses the same signature as your original `Context` usage.
     sqlmesh_server = SQLMeshLanguageServer(context_class=Context)

vscode/extension/package.json

@@ -34,7 +34,7 @@
         "sqlmesh.projectPath": {
           "type": "string",
           "default": "",
-          "markdownDescription": "The path to the SQLMesh project. If not set, the extension will try to find the project root automatically. If set, the extension will use the project root as the workspace path, e.g. it will run `sqlmesh` and `sqlmesh_lsp` in the project root. The path can be absolute or relative to the workspace root."
+          "markdownDescription": "The path to the SQLMesh project. If not set, the extension will try to find the project root automatically. If set, the extension will use the project root as the workspace path, e.g. it will run `sqlmesh` and `sqlmesh_lsp` in the project root. The path can be absolute `/Users/sqlmesh_user/sqlmesh_project/sushi` or relative `./project_folder/sushi` to the workspace root."
         }
       }
     },

vscode/extension/src/lsp/lsp.ts

@@ -8,7 +8,7 @@ import {
 import { sqlmeshLspExec } from '../utilities/sqlmesh/sqlmesh'
 import { err, isErr, ok, Result } from '@bus/result'
 import { getWorkspaceFolders } from '../utilities/common/vscodeapi'
-import { traceError } from '../utilities/common/log'
+import { traceError, traceInfo } from '../utilities/common/log'
 import { ErrorType } from '../utilities/errors'
 import { CustomLSPMethods } from './custom'
 
@@ -43,9 +43,6 @@ export class LSPClient implements Disposable {
         message: 'Invalid number of workspace folders',
       })
     }
-
-    const folder = workspaceFolders[0]
-    // Use the workspace path from sqlmesh config, which respects the projectPath setting
     const workspacePath = sqlmesh.value.workspacePath
     const serverOptions: ServerOptions = {
       run: {
@@ -67,11 +64,13 @@ export class LSPClient implements Disposable {
     }
     const clientOptions: LanguageClientOptions = {
       documentSelector: [{ scheme: 'file', pattern: `**/*.sql` }],
-      workspaceFolder: folder,
       diagnosticCollectionName: 'sqlmesh',
       outputChannel: outputChannel,
     }
 
+    traceInfo(
+      `Starting SQLMesh Language Server with workspace path: ${workspacePath} with server options ${JSON.stringify(serverOptions)} and client options ${JSON.stringify(clientOptions)}`,
+    )
     this.client = new LanguageClient(
       'sqlmesh-lsp',
       'SQLMesh Language Server',

vscode/extension/src/utilities/config.ts

@@ -16,7 +16,6 @@ export interface SqlmeshConfiguration {
 export function getSqlmeshConfiguration(): SqlmeshConfiguration {
   const config = workspace.getConfiguration('sqlmesh')
   const projectPath = config.get<string>('projectPath', '')
-
   return {
     projectPath,
   }

vscode/extension/tests/lineage.spec.ts

@@ -14,110 +14,106 @@ const SUSHI_SOURCE_PATH = path.join(__dirname, '..', '..', '..', 'examples', 'su
  * Helper function to launch VS Code and test lineage with given project path config
  */
 async function testLineageWithProjectPath(
-  workspaceDir: string,
-  projectDir: string,
-  projectPathConfig?: string
+  window: Page,
 ): Promise<void> {
-  const ciArgs = process.env.CI ? [
-    '--disable-gpu',
-    '--headless',
-    '--no-sandbox',
-    '--disable-dev-shm-usage',
-    '--window-position=-10000,0',
-  ] : [];
-  
-  const userDataDir = await fs.mkdtemp(path.join(os.tmpdir(), 'vscode-user-data-'));
-  
-  try {
-    // If projectPathConfig is provided, create .vscode/settings.json in the workspace
-    if (projectPathConfig !== undefined) {
-      const vscodeDir = path.join(workspaceDir, '.vscode');
-      await fs.ensureDir(vscodeDir);
-      const settings = {
-        "sqlmesh.projectPath": projectPathConfig
-      };
-      await fs.writeJson(path.join(vscodeDir, 'settings.json'), settings, { spaces: 2 });
-    }
-    
-    const args = [
-      ...ciArgs,
-      `--extensionDevelopmentPath=${EXT_PATH}`,
-      '--disable-workspace-trust',
-      '--disable-telemetry',
-      `--user-data-dir=${userDataDir}`,
-      workspaceDir,
-    ];
-    
-    const electronApp = await electron.launch({
-      executablePath: VS_CODE_EXE,
-      args,
-    });
-
-    const window = await electronApp.firstWindow();
-    await window.waitForLoadState('domcontentloaded');
-    await window.waitForLoadState('networkidle');
-    
-    // Wait a bit for the extension to fully initialize with the settings
-    await window.waitForTimeout(2000);
-
     // Trigger lineage command
     await window.keyboard.press(process.platform === 'darwin' ? 'Meta+Shift+P' : 'Control+Shift+P');
     await window.keyboard.type('Lineage: Focus On View');
     await window.keyboard.press('Enter');
 
     // Wait for "Loaded SQLmesh Context" text to appear
     const loadedContextText = window.locator('text=Loaded SQLMesh Context');
-    await expect(loadedContextText.first()).toBeVisible({ timeout: 15000 });
+    // TODO REVERT TIMINGS
+    await expect(loadedContextText.first()).toBeVisible({ timeout: 10_000 });
+}
 
+/**
+ * Launch VS Code and return the window and a function to close the app.
+ * @param workspaceDir The workspace directory to open.
+ * @returns The window and a function to close the app.
+ */
+export const startVSCode = async (workspaceDir: string): Promise<{
+  window: Page,
+  close: () => Promise<void>,
+}> => {
+  const userDataDir = await fs.mkdtemp(path.join(os.tmpdir(), 'vscode-user-data-'));
+  const ciArgs = process.env.CI ? [
+    '--disable-gpu',
+    '--headless',
+    '--no-sandbox',
+    '--disable-dev-shm-usage',
+    '--window-position=-10000,0',
+  ] : [];
+  const args = [
+    ...ciArgs,
+    `--extensionDevelopmentPath=${EXT_PATH}`,
+    '--disable-workspace-trust',
+    '--disable-telemetry',
+    `--user-data-dir=${userDataDir}`,
+    workspaceDir,
+  ];
+  const electronApp = await electron.launch({
+    executablePath: VS_CODE_EXE,
+    args,
+  });
+  const window = await electronApp.firstWindow();
+  await window.waitForLoadState('domcontentloaded');
+  await window.waitForLoadState('networkidle');
+  await window.waitForTimeout(2_000);
+  return { window, close: async () => {
     await electronApp.close();
-  } finally {
     await fs.remove(userDataDir);
-  }
-}
-
-export const startVSCode = async (workspaceDir: string) => {
-  
+  } };
 }
 
 test('Lineage panel renders correctly - no project path config (default)', async () => {
   const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'vscode-test-sushi-'));
   await fs.copy(SUSHI_SOURCE_PATH, tempDir);
-
   try {
-    await testLineageWithProjectPath(tempDir, tempDir);
-  } finally {
+  const { window, close } = await startVSCode(tempDir);
+  await testLineageWithProjectPath(window);
+    await close();
+  } finally { 
     await fs.remove(tempDir);
   }
 });
 
 test('Lineage panel renders correctly - relative project path', async () => {
-  // Create workspace directory with subdirectory containing the project
   const workspaceDir = await fs.mkdtemp(path.join(os.tmpdir(), 'vscode-test-workspace-'));
-  const projectSubdir = path.join(workspaceDir, 'projects', 'sushi');
-  await fs.ensureDir(path.dirname(projectSubdir));
-  await fs.copy(SUSHI_SOURCE_PATH, projectSubdir);
+  const projectDir = path.join(workspaceDir, 'projects', 'sushi');
+  await fs.copy(SUSHI_SOURCE_PATH, projectDir);
+
+  const settings = {
+    "sqlmesh.projectPath": path.relative(workspaceDir, projectDir),
+  };
+  await fs.ensureDir(path.join(workspaceDir, '.vscode'));
+  await fs.writeJson(path.join(workspaceDir, '.vscode', 'settings.json'), settings, { spaces: 2 });
 
   try {
-    // Test with relative path
-    await testLineageWithProjectPath(workspaceDir, projectSubdir, 'projects/sushi');
+    const { window, close } = await startVSCode(workspaceDir);
+    await testLineageWithProjectPath(window);
+    await close();
   } finally {
     await fs.remove(workspaceDir);
   }
 });
 
 test('Lineage panel renders correctly - absolute project path', async () => {
-  // Create workspace directory
   const workspaceDir = await fs.mkdtemp(path.join(os.tmpdir(), 'vscode-test-workspace-'));
-  
-  // Create project directory outside workspace
-  const projectDir = await fs.mkdtemp(path.join(os.tmpdir(), 'vscode-test-sushi-project-'));
+  const projectDir = path.join(workspaceDir, 'projects', 'sushi');
+  await fs.ensureDir(path.join(workspaceDir, '.vscode'));
   await fs.copy(SUSHI_SOURCE_PATH, projectDir);
+  await fs.ensureDir(path.join(workspaceDir, '.vscode'));
+  const settings = {
+    "sqlmesh.projectPath": projectDir,
+  };
+  await fs.writeJson(path.join(workspaceDir, '.vscode', 'settings.json'), settings, { spaces: 2 });
 
   try {
-    // Test with absolute path
-    await testLineageWithProjectPath(workspaceDir, projectDir, projectDir);
+    const { window, close } = await startVSCode(workspaceDir);
+    await testLineageWithProjectPath(window);
+    await close();
   } finally {
     await fs.remove(workspaceDir);
-    await fs.remove(projectDir);
   }
 });