opencode-sql-lsp-server 0.1.0__tar.gz → 0.1.1__tar.gz

opencode_sql_lsp_server-0.1.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

{opencode_sql_lsp_server-0.1.0 → opencode_sql_lsp_server-0.1.1}/PKG-INFO

@@ -1,22 +1,24 @@
 Metadata-Version: 2.4
 Name: opencode-sql-lsp-server
-Version: 0.1.0
+Version: 0.1.1
 Summary: SQL Language Server for OpenCode with Trino/StarRocks dialect support
 Author: OpenCode SQL LSP port
-License: MIT
+License-Expression: MIT
+Project-URL: Homepage, https://opencode.ai
 Keywords: opencode,lsp,sql,sqlfluff,trino,starrocks
 Classifier: Development Status :: 3 - Alpha
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Topic :: Software Development :: Quality Assurance
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
+License-File: LICENSE
 Requires-Dist: pygls>=1.3.1
 Requires-Dist: lsprotocol>=2023.0.1
 Requires-Dist: sqlfluff>=3.0.0
+Dynamic: license-file
 
 # opencode-sql-lsp-server
 

{opencode_sql_lsp_server-0.1.0 → opencode_sql_lsp_server-0.1.1}/pyproject.toml

@@ -4,28 +4,33 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "opencode-sql-lsp-server"
-version = "0.1.0"
+version = "0.1.1"
 description = "SQL Language Server for OpenCode with Trino/StarRocks dialect support"
 readme = "README.md"
 requires-python = ">=3.10"
-license = { text = "MIT" }
+license = "MIT"
 authors = [{ name = "OpenCode SQL LSP port" }]
 keywords = ["opencode", "lsp", "sql", "sqlfluff", "trino", "starrocks"]
 classifiers = [
   "Development Status :: 3 - Alpha",
   "Environment :: Console",
   "Intended Audience :: Developers",
-  "License :: OSI Approved :: MIT License",
   "Programming Language :: Python :: 3",
   "Programming Language :: Python :: 3 :: Only",
   "Topic :: Software Development :: Quality Assurance",
 ]
+
+license-files = ["LICENSE"]
+
 dependencies = [
   "pygls>=1.3.1",
   "lsprotocol>=2023.0.1",
   "sqlfluff>=3.0.0",
 ]
 
+[project.urls]
+Homepage = "https://opencode.ai"
+
 [project.scripts]
 opencode-sql-lsp = "opencode_sql_lsp_server.cli:main"
 

{opencode_sql_lsp_server-0.1.0 → opencode_sql_lsp_server-0.1.1}/src/opencode_sql_lsp_server/__init__.py

@@ -1,2 +1,2 @@
 __all__ = ["__version__"]
-__version__ = "0.1.0"
+__version__ = "0.1.1"

{opencode_sql_lsp_server-0.1.0 → opencode_sql_lsp_server-0.1.1}/src/opencode_sql_lsp_server/cli.py

@@ -23,7 +23,6 @@ def main() -> None:
     if not args.stdio:
         raise SystemExit("Only --stdio transport is supported")
 
-    # pygls gets rootUri from initialize; we optionally allow an override.
     if args.workspace:
         server.set_workspace_root(args.workspace)
 

{opencode_sql_lsp_server-0.1.0 → opencode_sql_lsp_server-0.1.1}/src/opencode_sql_lsp_server/config.py

@@ -7,17 +7,29 @@ from pathlib import Path
 from typing import Any
 
 
+class SqlLspConfigLoadError(RuntimeError):
+    pass
+
+
 @dataclass(frozen=True)
 class SqlLspConfig:
     default_dialect: str
     overrides: dict[str, str]
 
+    @staticmethod
+    def default() -> "SqlLspConfig":
+        return SqlLspConfig(default_dialect="starrocks", overrides={})
+
     @staticmethod
     def load(root: Path) -> "SqlLspConfig":
         cfg_path = root / ".opencode" / "sql-lsp.json"
         if not cfg_path.exists():
-            return SqlLspConfig(default_dialect="starrocks", overrides={})
-        data: Any = json.loads(cfg_path.read_text(encoding="utf-8"))
+            return SqlLspConfig.default()
+
+        try:
+            data: Any = json.loads(cfg_path.read_text(encoding="utf-8"))
+        except Exception as e:
+            raise SqlLspConfigLoadError(f"Failed to load config {cfg_path}: {e}") from e
         default_dialect = data.get("defaultDialect")
         if not isinstance(default_dialect, str) or not default_dialect.strip():
             default_dialect = "starrocks"
@@ -35,7 +47,9 @@ class SqlLspConfig:
         return SqlLspConfig(default_dialect=default_dialect, overrides=overrides)
 
     def dialect_for_path(self, relative_path: str) -> str:
+        relative_path_posix = relative_path.replace("\\", "/")
         for pattern, dialect in self.overrides.items():
-            if fnmatch(relative_path, pattern):
+            pattern_posix = pattern.replace("\\", "/")
+            if fnmatch(relative_path_posix, pattern_posix):
                 return dialect
         return self.default_dialect

opencode_sql_lsp_server-0.1.1/src/opencode_sql_lsp_server/server.py

@@ -0,0 +1,361 @@
+from __future__ import annotations
+
+import asyncio
+from dataclasses import dataclass
+from pathlib import Path
+
+from lsprotocol.types import (
+    Diagnostic,
+    DiagnosticSeverity,
+    DocumentFormattingParams,
+    InitializeParams,
+    INITIALIZE,
+    PublishDiagnosticsParams,
+    TEXT_DOCUMENT_DID_CHANGE,
+    TEXT_DOCUMENT_DID_OPEN,
+    TEXT_DOCUMENT_DID_SAVE,
+    TEXT_DOCUMENT_FORMATTING,
+    Position,
+    Range,
+    TextEdit,
+)
+from pygls.lsp.server import LanguageServer
+from pygls.uris import to_fs_path
+
+from pygls.exceptions import PyglsError
+
+from .config import SqlLspConfig
+from .sqlfluff_adapter import format_sql, lint_issues
+
+
+_DID_CHANGE_DEBOUNCE_S = 0.25
+_MAX_LINT_LINES = 5_000
+_MAX_LINT_BYTES = 200_000
+
+
+@dataclass
+class _ConfigCacheEntry:
+    mtime_ns: int | None
+    config: SqlLspConfig
+    last_error_mtime_ns: int | None = None
+
+
+@dataclass
+class _DocState:
+    version: int | None = None
+    pending_timer: asyncio.TimerHandle | None = None
+    pending_task: asyncio.Task[None] | None = None
+
+
+class OpenCodeSqlLanguageServer(LanguageServer):
+    def __init__(self) -> None:
+        super().__init__("opencode-sql-lsp", "0.1.1", max_workers=2)
+        self._workspace_roots: list[Path] = []
+        self._config_cache: dict[Path, _ConfigCacheEntry] = {}
+        self._doc_state: dict[str, _DocState] = {}
+
+    def set_workspace_root(self, root: str | None) -> None:
+        self.set_workspace_roots([root] if root else [])
+
+    def set_workspace_roots(self, roots: list[str]) -> None:
+        self._workspace_roots = [Path(r).resolve() for r in roots if r]
+        self._config_cache.clear()
+
+    def _best_root_for_uri(self, doc_uri: str) -> Path | None:
+        if not self._workspace_roots:
+            return None
+        try:
+            fs_path = to_fs_path(doc_uri)
+            if not fs_path:
+                return None
+            p = Path(fs_path).resolve()
+        except Exception:
+            return None
+
+        best: Path | None = None
+        best_len = -1
+        for r in self._workspace_roots:
+            try:
+                p.relative_to(r)
+            except Exception:
+                continue
+            l = len(str(r))
+            if l > best_len:
+                best = r
+                best_len = l
+        return best
+
+    def _config_for_root(self, root: Path) -> SqlLspConfig:
+        cfg_path = root / ".opencode" / "sql-lsp.json"
+        try:
+            st = cfg_path.stat()
+            mtime_ns: int | None = st.st_mtime_ns
+        except FileNotFoundError:
+            mtime_ns = None
+        except Exception as e:
+            self.report_server_error(e, PyglsError)
+            return SqlLspConfig.default()
+
+        cached = self._config_cache.get(root)
+        if cached and cached.mtime_ns == mtime_ns:
+            return cached.config
+
+        if mtime_ns is None:
+            cfg = SqlLspConfig.default()
+            self._config_cache[root] = _ConfigCacheEntry(mtime_ns=None, config=cfg)
+            return cfg
+
+        try:
+            cfg = SqlLspConfig.load(root)
+        except Exception as e:
+            if cached and cached.config:
+                if cached.last_error_mtime_ns != mtime_ns:
+                    cached.last_error_mtime_ns = mtime_ns
+                    self.report_server_error(e, PyglsError)
+                return cached.config
+            self.report_server_error(e, PyglsError)
+            cfg = SqlLspConfig.default()
+
+        self._config_cache[root] = _ConfigCacheEntry(mtime_ns=mtime_ns, config=cfg)
+        return cfg
+
+    def dialect_for_document(self, doc_uri: str) -> str:
+        root = self._best_root_for_uri(doc_uri)
+        if not root:
+            return SqlLspConfig.default().default_dialect
+        cfg = self._config_for_root(root)
+        try:
+            fs_path = to_fs_path(doc_uri)
+            if not fs_path:
+                return cfg.default_dialect
+            p = Path(fs_path).resolve()
+            rel = p.relative_to(root)
+            return cfg.dialect_for_path(str(rel))
+        except Exception:
+            return cfg.default_dialect
+
+
+server = OpenCodeSqlLanguageServer()
+
+
+@server.feature(INITIALIZE)
+def initialize(ls: OpenCodeSqlLanguageServer, params: InitializeParams):
+    roots: list[str] = []
+    try:
+        wf = getattr(params, "workspace_folders", None)
+        if isinstance(wf, list):
+            for f in wf:
+                uri = getattr(f, "uri", None)
+                if isinstance(uri, str) and uri:
+                    try:
+                        fs_path = to_fs_path(uri)
+                        if fs_path:
+                            roots.append(fs_path)
+                    except Exception:
+                        continue
+    except Exception:
+        pass
+
+    root_uri = getattr(params, "root_uri", None)
+    if isinstance(root_uri, str) and root_uri:
+        try:
+            fs_path = to_fs_path(root_uri)
+            if fs_path:
+                roots.append(fs_path)
+        except Exception:
+            pass
+
+    deduped: list[str] = []
+    seen: set[str] = set()
+    for r in roots:
+        if r not in seen:
+            seen.add(r)
+            deduped.append(r)
+    ls.set_workspace_roots(deduped)
+
+
+def _is_large_document(source: str) -> bool:
+    if len(source.encode("utf-8", errors="ignore")) > _MAX_LINT_BYTES:
+        return True
+    return source.count("\n") > _MAX_LINT_LINES
+
+
+def _publish_skipped_diagnostics(ls: OpenCodeSqlLanguageServer, uri: str) -> None:
+    ls.text_document_publish_diagnostics(
+        PublishDiagnosticsParams(
+            uri=uri,
+            diagnostics=[
+                Diagnostic(
+                    range=Range(
+                        start=Position(line=0, character=0),
+                        end=Position(line=0, character=0),
+                    ),
+                    message="Lint skipped (file too large)",
+                    severity=DiagnosticSeverity.Warning,
+                    source="opencode-sql-lsp",
+                )
+            ],
+        )
+    )
+
+
+def _safe_position(doc, line_1: int, character: int) -> Position:
+    if not getattr(doc, "lines", None):
+        return Position(line=0, character=0)
+    max_line = max(0, len(doc.lines) - 1)
+    line_idx = min(max(0, line_1 - 1), max_line)
+    line_text = doc.lines[line_idx] if doc.lines else ""
+    char_idx = min(max(0, character), len(line_text))
+    return Position(line=line_idx, character=char_idx)
+
+
+def _issue_range(doc, issue) -> Range:
+    start = _safe_position(doc, issue.line, issue.character)
+    end_char = start.character + 1
+    if getattr(doc, "lines", None):
+        line_text = doc.lines[start.line]
+        end_char = min(end_char, len(line_text))
+    end = Position(line=start.line, character=end_char)
+    return Range(start=start, end=end)
+
+
+async def _run_lint_and_publish(
+    ls: OpenCodeSqlLanguageServer,
+    uri: str,
+    expected_version: int | None,
+) -> None:
+    state = ls._doc_state.setdefault(uri, _DocState())
+    try:
+        doc = ls.workspace.get_text_document(uri)
+    except Exception as e:
+        ls.report_server_error(e, PyglsError)
+        return
+
+    source = doc.source
+    dialect = ls.dialect_for_document(uri)
+    loop = asyncio.get_running_loop()
+
+    try:
+        issues = await loop.run_in_executor(
+            ls.thread_pool, lambda: lint_issues(source, dialect=dialect)
+        )
+    except Exception as e:
+        ls.report_server_error(e, PyglsError)
+        issues = []
+
+    if expected_version is not None and state.version != expected_version:
+        return
+
+    diagnostics: list[Diagnostic] = []
+    for issue in issues:
+        diagnostics.append(
+            Diagnostic(
+                range=_issue_range(doc, issue),
+                message=issue.message,
+                severity=DiagnosticSeverity.Error,
+                source="sqlfluff",
+            )
+        )
+
+    ls.text_document_publish_diagnostics(
+        PublishDiagnosticsParams(uri=uri, diagnostics=diagnostics)
+    )
+
+
+def _schedule_diagnostics(
+    ls: OpenCodeSqlLanguageServer,
+    uri: str,
+    version: int | None,
+    *,
+    debounce_s: float,
+) -> None:
+    state = ls._doc_state.setdefault(uri, _DocState())
+    state.version = version
+
+    if state.pending_timer is not None:
+        state.pending_timer.cancel()
+        state.pending_timer = None
+
+    if state.pending_task is not None and not state.pending_task.done():
+        pass
+
+    loop = asyncio.get_running_loop()
+
+    def kickoff() -> None:
+        state.pending_timer = None
+        state.pending_task = asyncio.create_task(
+            _run_lint_and_publish(ls, uri, expected_version=version)
+        )
+
+    if debounce_s <= 0:
+        kickoff()
+    else:
+        state.pending_timer = loop.call_later(debounce_s, kickoff)
+
+
+@server.feature(TEXT_DOCUMENT_DID_OPEN)
+def did_open(ls: OpenCodeSqlLanguageServer, params):
+    uri = params.text_document.uri
+    version = getattr(params.text_document, "version", None)
+    try:
+        doc = ls.workspace.get_text_document(uri)
+    except Exception as e:
+        ls.report_server_error(e, PyglsError)
+    else:
+        if _is_large_document(doc.source):
+            _publish_skipped_diagnostics(ls, uri)
+            return
+    _schedule_diagnostics(ls, uri, version, debounce_s=0.0)
+
+
+@server.feature(TEXT_DOCUMENT_DID_CHANGE)
+def did_change(ls: OpenCodeSqlLanguageServer, params):
+    uri = params.text_document.uri
+    version = getattr(params.text_document, "version", None)
+    try:
+        doc = ls.workspace.get_text_document(uri)
+    except Exception as e:
+        ls.report_server_error(e, PyglsError)
+    else:
+        if _is_large_document(doc.source):
+            _publish_skipped_diagnostics(ls, uri)
+            return
+    _schedule_diagnostics(ls, uri, version, debounce_s=_DID_CHANGE_DEBOUNCE_S)
+
+
+@server.feature(TEXT_DOCUMENT_DID_SAVE)
+def did_save(ls: OpenCodeSqlLanguageServer, params):
+    uri = params.text_document.uri
+    version = getattr(params.text_document, "version", None)
+    try:
+        doc = ls.workspace.get_text_document(uri)
+    except Exception as e:
+        ls.report_server_error(e, PyglsError)
+    else:
+        if _is_large_document(doc.source):
+            _publish_skipped_diagnostics(ls, uri)
+            return
+    _schedule_diagnostics(ls, uri, version, debounce_s=0.0)
+
+
+@server.feature(TEXT_DOCUMENT_FORMATTING)
+def formatting(ls: OpenCodeSqlLanguageServer, params: DocumentFormattingParams):
+    uri = params.text_document.uri
+    try:
+        doc = ls.workspace.get_text_document(uri)
+    except Exception as e:
+        ls.report_server_error(e, PyglsError)
+        return []
+
+    dialect = ls.dialect_for_document(uri)
+    try:
+        formatted = format_sql(doc.source, dialect=dialect)
+    except Exception:
+        return []
+    last_line = max(0, len(doc.lines) - 1)
+    last_char = len(doc.lines[last_line]) if doc.lines else 0
+    edit_range = Range(
+        start=Position(line=0, character=0),
+        end=Position(line=last_line, character=last_char),
+    )
+    return [TextEdit(range=edit_range, new_text=formatted)]

{opencode_sql_lsp_server-0.1.0 → opencode_sql_lsp_server-0.1.1}/src/opencode_sql_lsp_server.egg-info/PKG-INFO

@@ -1,22 +1,24 @@
 Metadata-Version: 2.4
 Name: opencode-sql-lsp-server
-Version: 0.1.0
+Version: 0.1.1
 Summary: SQL Language Server for OpenCode with Trino/StarRocks dialect support
 Author: OpenCode SQL LSP port
-License: MIT
+License-Expression: MIT
+Project-URL: Homepage, https://opencode.ai
 Keywords: opencode,lsp,sql,sqlfluff,trino,starrocks
 Classifier: Development Status :: 3 - Alpha
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Topic :: Software Development :: Quality Assurance
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
+License-File: LICENSE
 Requires-Dist: pygls>=1.3.1
 Requires-Dist: lsprotocol>=2023.0.1
 Requires-Dist: sqlfluff>=3.0.0
+Dynamic: license-file
 
 # opencode-sql-lsp-server
 

{opencode_sql_lsp_server-0.1.0 → opencode_sql_lsp_server-0.1.1}/src/opencode_sql_lsp_server.egg-info/SOURCES.txt

@@ -1,3 +1,4 @@
+LICENSE
 README.md
 pyproject.toml
 src/opencode_sql_lsp_server/__init__.py

opencode_sql_lsp_server-0.1.0/src/opencode_sql_lsp_server/server.py

@@ -1,108 +0,0 @@
-from __future__ import annotations
-
-from pathlib import Path
-from typing import Optional
-
-from lsprotocol.types import (
-    Diagnostic,
-    DiagnosticSeverity,
-    DocumentFormattingParams,
-    InitializeParams,
-    INITIALIZE,
-    PublishDiagnosticsParams,
-    TEXT_DOCUMENT_DID_CHANGE,
-    TEXT_DOCUMENT_DID_OPEN,
-    TEXT_DOCUMENT_FORMATTING,
-    Position,
-    Range,
-    TextEdit,
-)
-from pygls.lsp.server import LanguageServer
-
-from .config import SqlLspConfig
-from .sqlfluff_adapter import format_sql, lint_issues
-
-
-class OpenCodeSqlLanguageServer(LanguageServer):
-    def __init__(self) -> None:
-        super().__init__("opencode-sql-lsp", "0.1.0")
-        self._workspace_root: Optional[Path] = None
-        self._config: Optional[SqlLspConfig] = None
-
-    def set_workspace_root(self, root: Optional[str]) -> None:
-        self._workspace_root = Path(root).resolve() if root else None
-        self._config = (
-            SqlLspConfig.load(self._workspace_root) if self._workspace_root else None
-        )
-
-    def dialect_for_document(self, doc_uri: str) -> str:
-        if not self._workspace_root or not self._config:
-            return "starrocks"
-        try:
-            p = Path(self.uri_to_path(doc_uri)).resolve()
-            rel = p.relative_to(self._workspace_root)
-            return self._config.dialect_for_path(str(rel))
-        except Exception:
-            return self._config.default_dialect
-
-
-server = OpenCodeSqlLanguageServer()
-
-
-@server.feature(INITIALIZE)
-def initialize(ls: OpenCodeSqlLanguageServer, params: InitializeParams):
-    root_uri = getattr(params, "root_uri", None)
-    if isinstance(root_uri, str) and root_uri:
-        try:
-            ls.set_workspace_root(ls.uri_to_path(root_uri))
-        except Exception:
-            pass
-
-
-def _publish_diagnostics(ls: OpenCodeSqlLanguageServer, uri: str) -> None:
-    doc = ls.workspace.get_text_document(uri)
-    dialect = ls.dialect_for_document(uri)
-    issues = lint_issues(doc.source, dialect=dialect)
-    diagnostics: list[Diagnostic] = []
-    for issue in issues:
-        start = Position(line=issue.line - 1, character=issue.character)
-        end = Position(line=issue.line - 1, character=issue.character + 1)
-        diagnostics.append(
-            Diagnostic(
-                range=Range(start=start, end=end),
-                message=issue.message,
-                severity=DiagnosticSeverity.Error,
-                source="sqlglot",
-            )
-        )
-    ls.text_document_publish_diagnostics(
-        PublishDiagnosticsParams(uri=uri, diagnostics=diagnostics)
-    )
-
-
-@server.feature(TEXT_DOCUMENT_DID_OPEN)
-def did_open(ls: OpenCodeSqlLanguageServer, params):
-    _publish_diagnostics(ls, params.text_document.uri)
-
-
-@server.feature(TEXT_DOCUMENT_DID_CHANGE)
-def did_change(ls: OpenCodeSqlLanguageServer, params):
-    _publish_diagnostics(ls, params.text_document.uri)
-
-
-@server.feature(TEXT_DOCUMENT_FORMATTING)
-def formatting(ls: OpenCodeSqlLanguageServer, params: DocumentFormattingParams):
-    doc = ls.workspace.get_text_document(params.text_document.uri)
-    dialect = ls.dialect_for_document(params.text_document.uri)
-    try:
-        formatted = format_sql(doc.source, dialect=dialect)
-    except Exception:
-        return []
-    # Replace entire document
-    last_line = max(0, len(doc.lines) - 1)
-    last_char = len(doc.lines[last_line]) if doc.lines else 0
-    edit_range = Range(
-        start=Position(line=0, character=0),
-        end=Position(line=last_line, character=last_char),
-    )
-    return [TextEdit(range=edit_range, new_text=formatted)]