sqlmesh 0.186.1.dev6__tar.gz → 0.186.1.dev7__tar.gz

{sqlmesh-0.186.1.dev6 → sqlmesh-0.186.1.dev7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlmesh
-Version: 0.186.1.dev6
+Version: 0.186.1.dev7
 Summary: Next-generation data transformation framework
 Author-email: "TobikoData Inc." <engineering@tobikodata.com>
 License:                                  Apache License

{sqlmesh-0.186.1.dev6 → sqlmesh-0.186.1.dev7}/sqlmesh/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.186.1.dev6'
-__version_tuple__ = version_tuple = (0, 186, 1, 'dev6')
+__version__ = version = '0.186.1.dev7'
+__version_tuple__ = version_tuple = (0, 186, 1, 'dev7')

{sqlmesh-0.186.1.dev6 → sqlmesh-0.186.1.dev7}/sqlmesh/lsp/main.py

@@ -69,10 +69,7 @@ class SQLMeshLanguageServer:
                                     # 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 @@ class SQLMeshLanguageServer:
         @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 @@ class SQLMeshLanguageServer:
             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 @@ class SQLMeshLanguageServer:
         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)

{sqlmesh-0.186.1.dev6 → sqlmesh-0.186.1.dev7}/sqlmesh.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlmesh
-Version: 0.186.1.dev6
+Version: 0.186.1.dev7
 Summary: Next-generation data transformation framework
 Author-email: "TobikoData Inc." <engineering@tobikodata.com>
 License:                                  Apache License

{sqlmesh-0.186.1.dev6 → sqlmesh-0.186.1.dev7}/sqlmesh.egg-info/SOURCES.txt

@@ -693,6 +693,7 @@ vscode/extension/src/commands/signout.ts
 vscode/extension/src/completion/completion.ts
 vscode/extension/src/lsp/custom.ts
 vscode/extension/src/lsp/lsp.ts
+vscode/extension/src/utilities/config.ts
 vscode/extension/src/utilities/errors.ts
 vscode/extension/src/utilities/exec.ts
 vscode/extension/src/utilities/isCodespaces.ts

{sqlmesh-0.186.1.dev6 → sqlmesh-0.186.1.dev7}/vscode/extension/package.json

@@ -27,6 +27,17 @@
     "ms-python.python"
   ],
   "contributes": {
+    "configuration": {
+      "type": "object",
+      "title": "SQLMesh",
+      "properties": {
+        "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 `/Users/sqlmesh_user/sqlmesh_project/sushi` or relative `./project_folder/sushi` to the workspace root."
+        }
+      }
+    },
     "viewsContainers": {
       "panel": [
         {

{sqlmesh-0.186.1.dev6 → sqlmesh-0.186.1.dev7}/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,7 @@ export class LSPClient implements Disposable {
         message: 'Invalid number of workspace folders',
       })
     }
-
-    const folder = workspaceFolders[0]
-    const workspacePath = workspaceFolders[0].uri.fsPath
+    const workspacePath = sqlmesh.value.workspacePath
     const serverOptions: ServerOptions = {
       run: {
         command: sqlmesh.value.bin,
@@ -66,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',

sqlmesh-0.186.1.dev7/vscode/extension/src/utilities/config.ts

@@ -0,0 +1,77 @@
+import { workspace, WorkspaceFolder } from 'vscode'
+import path from 'path'
+import fs from 'fs'
+import { Result, err, ok } from '@bus/result'
+import { traceVerbose, traceInfo } from './common/log'
+
+export interface SqlmeshConfiguration {
+  projectPath: string
+}
+
+/**
+ * Get the SQLMesh configuration from VS Code settings.
+ *
+ * @returns The SQLMesh configuration
+ */
+export function getSqlmeshConfiguration(): SqlmeshConfiguration {
+  const config = workspace.getConfiguration('sqlmesh')
+  const projectPath = config.get<string>('projectPath', '')
+  return {
+    projectPath,
+  }
+}
+
+/**
+ * Validate and resolve the project path from configuration.
+ * If no project path is configured, use the workspace folder.
+ * If the project path is configured, it must be a directory that contains a SQLMesh project.
+ *
+ * @param workspaceFolder The current workspace folder
+ * @returns A Result containing the resolved project path or an error
+ */
+export function resolveProjectPath(
+  workspaceFolder: WorkspaceFolder,
+): Result<string, string> {
+  const config = getSqlmeshConfiguration()
+
+  if (!config.projectPath) {
+    // If no project path is configured, use the workspace folder
+    traceVerbose('No project path configured, using workspace folder')
+    return ok(workspaceFolder.uri.fsPath)
+  }
+  let resolvedPath: string
+
+  // Check if the path is absolute
+  if (path.isAbsolute(config.projectPath)) {
+    resolvedPath = config.projectPath
+  } else {
+    // Resolve relative path from workspace root
+    resolvedPath = path.join(workspaceFolder.uri.fsPath, config.projectPath)
+  }
+
+  // Normalize the path
+  resolvedPath = path.normalize(resolvedPath)
+
+  // Validate that the path exists
+  if (!fs.existsSync(resolvedPath)) {
+    return err(`Configured project path does not exist: ${resolvedPath}`)
+  }
+
+  // Validate that it's a directory
+  const stats = fs.statSync(resolvedPath)
+  if (!stats.isDirectory()) {
+    return err(`Configured project path is not a directory: ${resolvedPath}`)
+  }
+
+  // Check if it contains SQLMesh project files (config.yaml, config.yml, or config.py)
+  const configFiles = ['config.yaml', 'config.yml', 'config.py']
+  const hasConfigFile = configFiles.some(file =>
+    fs.existsSync(path.join(resolvedPath, file)),
+  )
+  if (!hasConfigFile) {
+    traceInfo(`Warning: No SQLMesh configuration file found in ${resolvedPath}`)
+  }
+
+  traceVerbose(`Using project path: ${resolvedPath}`)
+  return ok(resolvedPath)
+}

{sqlmesh-0.186.1.dev6 → sqlmesh-0.186.1.dev7}/vscode/extension/src/utilities/sqlmesh/sqlmesh.ts

@@ -11,6 +11,7 @@ import { execAsync } from '../exec'
 import z from 'zod'
 import { ProgressLocation, window } from 'vscode'
 import { IS_WINDOWS } from '../isWindows'
+import { resolveProjectPath } from '../config'
 
 export interface SqlmeshExecInfo {
   workspacePath: string
@@ -28,8 +29,12 @@ export interface SqlmeshExecInfo {
  */
 export const isTcloudProject = async (): Promise<Result<boolean, string>> => {
   const projectRoot = await getProjectRoot()
-  const tcloudYamlPath = path.join(projectRoot.uri.fsPath, 'tcloud.yaml')
-  const tcloudYmlPath = path.join(projectRoot.uri.fsPath, 'tcloud.yml')
+  const resolvedPath = resolveProjectPath(projectRoot)
+  if (isErr(resolvedPath)) {
+    return err(resolvedPath.error)
+  }
+  const tcloudYamlPath = path.join(resolvedPath.value, 'tcloud.yaml')
+  const tcloudYmlPath = path.join(resolvedPath.value, 'tcloud.yml')
   const isTcloudYamlFilePresent = fs.existsSync(tcloudYamlPath)
   const isTcloudYmlFilePresent = fs.existsSync(tcloudYmlPath)
   if (isTcloudYamlFilePresent || isTcloudYmlFilePresent) {
@@ -83,8 +88,15 @@ export const isSqlmeshEnterpriseInstalled = async (): Promise<
     return tcloudBin
   }
   const projectRoot = await getProjectRoot()
+  const resolvedPath = resolveProjectPath(projectRoot)
+  if (isErr(resolvedPath)) {
+    return err({
+      type: 'generic',
+      message: resolvedPath.error,
+    })
+  }
   const called = await execAsync(tcloudBin.value, ['is_sqlmesh_installed'], {
-    cwd: projectRoot.uri.fsPath,
+    cwd: resolvedPath.value,
   })
   if (called.exitCode !== 0) {
     return err({
@@ -183,7 +195,14 @@ export const sqlmeshExec = async (): Promise<
 > => {
   const sqlmesh = IS_WINDOWS ? 'sqlmesh.exe' : 'sqlmesh'
   const projectRoot = await getProjectRoot()
-  const workspacePath = projectRoot.uri.fsPath
+  const resolvedPath = resolveProjectPath(projectRoot)
+  if (isErr(resolvedPath)) {
+    return err({
+      type: 'generic',
+      message: resolvedPath.error,
+    })
+  }
+  const workspacePath = resolvedPath.value
   const interpreterDetails = await getInterpreterDetails()
   traceLog(`Interpreter details: ${JSON.stringify(interpreterDetails)}`)
   if (interpreterDetails.path) {
@@ -300,7 +319,14 @@ export const sqlmeshLspExec = async (): Promise<
 > => {
   const sqlmeshLSP = IS_WINDOWS ? 'sqlmesh_lsp.exe' : 'sqlmesh_lsp'
   const projectRoot = await getProjectRoot()
-  const workspacePath = projectRoot.uri.fsPath
+  const resolvedPath = resolveProjectPath(projectRoot)
+  if (isErr(resolvedPath)) {
+    return err({
+      type: 'generic',
+      message: resolvedPath.error,
+    })
+  }
+  const workspacePath = resolvedPath.value
   const interpreterDetails = await getInterpreterDetails()
   traceLog(`Interpreter details: ${JSON.stringify(interpreterDetails)}`)
   if (interpreterDetails.path) {

sqlmesh-0.186.1.dev7/vscode/extension/tests/lineage.spec.ts

@@ -0,0 +1,165 @@
+import { test, _electron as electron, expect, ElectronApplication, Page } from '@playwright/test';
+import path from 'path';
+import fs from 'fs-extra';
+import os from 'os';
+
+// Absolute path to the VS Code executable you downloaded in step 1.
+const VS_CODE_EXE = fs.readJsonSync('.vscode-test/paths.json').executablePath;
+// Where your extension lives on disk
+const EXT_PATH = path.resolve(__dirname, '..');
+// Where the sushi project lives which we copy from
+const SUSHI_SOURCE_PATH = path.join(__dirname, '..', '..', '..', 'examples', 'sushi');
+
+/**
+ * Helper function to launch VS Code and test lineage with given project path config
+ */
+async function testLineageWithProjectPath(
+  window: Page,
+): Promise<void> {
+    // 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: 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();
+    await fs.remove(userDataDir);
+  } };
+}
+
+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 {
+  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 () => {
+  const workspaceDir = await fs.mkdtemp(path.join(os.tmpdir(), 'vscode-test-workspace-'));
+  const projectDir = path.join(workspaceDir, 'projects', 'sushi');
+  await fs.copy(SUSHI_SOURCE_PATH, projectDir);
+
+  const settings = {
+    "sqlmesh.projectPath": "./projects/sushi",
+  };
+  await fs.ensureDir(path.join(workspaceDir, '.vscode'));
+  await fs.writeJson(path.join(workspaceDir, '.vscode', 'settings.json'), settings, { spaces: 2 });
+
+  try {
+    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 () => {
+  const workspaceDir = await fs.mkdtemp(path.join(os.tmpdir(), 'vscode-test-workspace-'));
+  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 {
+    const { window, close } = await startVSCode(workspaceDir);
+    await testLineageWithProjectPath(window);
+    await close();
+  } finally {
+    await fs.remove(workspaceDir);
+  }
+});
+
+
+test("Lineage panel renders correctly - relative project outside of workspace", async () => {
+  const tempFolder = await fs.mkdtemp(path.join(os.tmpdir(), 'vscode-test-workspace-'));
+  const projectDir = path.join(tempFolder, 'projects', 'sushi');
+  await fs.copy(SUSHI_SOURCE_PATH, projectDir);
+
+  const workspaceDir = path.join(tempFolder, 'workspace');
+  await fs.ensureDir(workspaceDir);
+
+  const settings = {
+    "sqlmesh.projectPath": "./../projects/sushi",
+  };
+  await fs.ensureDir(path.join(workspaceDir, '.vscode'));
+  await fs.writeJson(path.join(workspaceDir, '.vscode', 'settings.json'), settings, { spaces: 2 });
+
+  try {
+    const { window, close } = await startVSCode(workspaceDir);
+    await testLineageWithProjectPath(window);
+    await close();
+  } finally {
+    await fs.remove(tempFolder);
+  }
+});
+
+test("Lineage panel renders correctly - absolute path project outside of workspace", async () => {
+  const tempFolder = await fs.mkdtemp(path.join(os.tmpdir(), 'vscode-test-workspace-'));
+  const projectDir = path.join(tempFolder, 'projects', 'sushi');
+  await fs.copy(SUSHI_SOURCE_PATH, projectDir);
+
+  const workspaceDir = path.join(tempFolder, 'workspace');
+  await fs.ensureDir(workspaceDir);
+
+  const settings = {
+    "sqlmesh.projectPath": projectDir,
+  };
+  await fs.ensureDir(path.join(workspaceDir, '.vscode'));
+  await fs.writeJson(path.join(workspaceDir, '.vscode', 'settings.json'), settings, { spaces: 2 });
+
+  try {
+    const { window, close } = await startVSCode(workspaceDir);
+    await testLineageWithProjectPath(window);
+    await close();
+  } finally {
+    await fs.remove(tempFolder);
+  }
+});

sqlmesh-0.186.1.dev6/vscode/extension/tests/lineage.spec.ts

@@ -1,60 +0,0 @@
-import { test, _electron as electron, expect } from '@playwright/test';
-import path from 'path';
-import fs from 'fs-extra';
-import os from 'os';
-
-// Absolute path to the VS Code executable you downloaded in step 1.
-const VS_CODE_EXE = fs.readJsonSync('.vscode-test/paths.json').executablePath;
-// Where your extension lives on disk
-const EXT_PATH = path.resolve(__dirname, '..');
-// Where the sushi project lives which we copy from
-const SUSHI_SOURCE_PATH = path.join(__dirname, '..', '..', '..', 'examples', 'sushi');
-
-test('Lineage panel renders correctly', async () => {
-  // Create a temporary directory and copy sushi example into it
-  const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'vscode-test-sushi-'));
-  await fs.copy(SUSHI_SOURCE_PATH, tempDir);
-
-  try {
-    const ciArgs = process.env.CI ? [
-      '--disable-gpu',
-      '--headless',
-      '--no-sandbox',
-      '--disable-dev-shm-usage',  // Prevents memory issues in Docker/CI
-      '--window-position=-10000,0', // Ensures window is off-screen
-    ] : [];
-    const args = [
-      ...ciArgs,
-      `--extensionDevelopmentPath=${EXT_PATH}`,
-      '--disable-workspace-trust',          // no modal prompt
-      '--disable-telemetry',
-      '--user-data-dir=/tmp/vscode-test',   // throwaway profile
-      `${tempDir}`,  // Use the temporary directory instead of PROJECT_PATH
-    ];
-    const electronApp = await electron.launch({
-      executablePath: VS_CODE_EXE,
-      args,
-    });
-
-    // ➋ Grab the first window that appears (the Workbench)
-    const window = await electronApp.firstWindow();
-
-    // Wait for VS Code to be ready
-    await window.waitForLoadState('domcontentloaded');
-    await window.waitForLoadState('networkidle');
-
-    // ➌ Trigger our command exactly like a user would
-    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: 10000 });
-
-    await electronApp.close();
-  } finally {
-    // Clean up the temporary directory
-    await fs.remove(tempDir);
-  }
-});