opencode-sql-lsp-server 0.1.0__tar.gz

opencode_sql_lsp_server-0.1.0/PKG-INFO

@@ -0,0 +1,92 @@
+Metadata-Version: 2.4
+Name: opencode-sql-lsp-server
+Version: 0.1.0
+Summary: SQL Language Server for OpenCode with Trino/StarRocks dialect support
+Author: OpenCode SQL LSP port
+License: MIT
+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
+Requires-Dist: pygls>=1.3.1
+Requires-Dist: lsprotocol>=2023.0.1
+Requires-Dist: sqlfluff>=3.0.0
+
+# opencode-sql-lsp-server
+
+SQL LSP server (stdio) intended for OpenCode, with dialect-aware parsing/formatting.
+
+## Install
+
+### From PyPI (recommended)
+
+```bash
+pipx install opencode-sql-lsp-server
+```
+
+### From source
+
+Recommended: pipx (or a venv)
+
+```bash
+pipx install -e .
+```
+
+If you don't have pipx, use a virtualenv or `uv tool install`.
+
+Or pip:
+
+```bash
+python3 -m pip install -e .
+```
+
+## OpenCode config
+
+`opencode.json`:
+
+```json
+{
+  "$schema": "https://opencode.ai/config.json",
+  "lsp": {
+    "opencode-sql": {
+      "command": ["opencode-sql-lsp", "--stdio"],
+      "extensions": [".sql"]
+    }
+  }
+}
+```
+
+## Dialect config
+
+Create `.opencode/sql-lsp.json` in your project:
+
+```json
+{
+  "defaultDialect": "starrocks",
+  "overrides": {
+    "trino/**/*.sql": "trino"
+  }
+}
+```
+
+Dialect keys are sqlfluff dialect labels, e.g.:
+
+- `trino`
+- `starrocks`
+
+## Notes
+
+- Diagnostics and formatting are powered by `sqlfluff`.
+- Dialect keys (sqlfluff): `trino`, `starrocks`.
+
+## Verify dialects
+
+```bash
+sqlfluff dialects
+```

opencode_sql_lsp_server-0.1.0/README.md

@@ -0,0 +1,72 @@
+# opencode-sql-lsp-server
+
+SQL LSP server (stdio) intended for OpenCode, with dialect-aware parsing/formatting.
+
+## Install
+
+### From PyPI (recommended)
+
+```bash
+pipx install opencode-sql-lsp-server
+```
+
+### From source
+
+Recommended: pipx (or a venv)
+
+```bash
+pipx install -e .
+```
+
+If you don't have pipx, use a virtualenv or `uv tool install`.
+
+Or pip:
+
+```bash
+python3 -m pip install -e .
+```
+
+## OpenCode config
+
+`opencode.json`:
+
+```json
+{
+  "$schema": "https://opencode.ai/config.json",
+  "lsp": {
+    "opencode-sql": {
+      "command": ["opencode-sql-lsp", "--stdio"],
+      "extensions": [".sql"]
+    }
+  }
+}
+```
+
+## Dialect config
+
+Create `.opencode/sql-lsp.json` in your project:
+
+```json
+{
+  "defaultDialect": "starrocks",
+  "overrides": {
+    "trino/**/*.sql": "trino"
+  }
+}
+```
+
+Dialect keys are sqlfluff dialect labels, e.g.:
+
+- `trino`
+- `starrocks`
+
+## Notes
+
+- Diagnostics and formatting are powered by `sqlfluff`.
+- Dialect keys (sqlfluff): `trino`, `starrocks`.
+
+## Verify dialects
+
+```bash
+sqlfluff dialects
+```

opencode_sql_lsp_server-0.1.0/pyproject.toml

@@ -0,0 +1,36 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "opencode-sql-lsp-server"
+version = "0.1.0"
+description = "SQL Language Server for OpenCode with Trino/StarRocks dialect support"
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "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",
+]
+dependencies = [
+  "pygls>=1.3.1",
+  "lsprotocol>=2023.0.1",
+  "sqlfluff>=3.0.0",
+]
+
+[project.scripts]
+opencode-sql-lsp = "opencode_sql_lsp_server.cli:main"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]

opencode_sql_lsp_server-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

opencode_sql_lsp_server-0.1.0/src/opencode_sql_lsp_server/__init__.py

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

opencode_sql_lsp_server-0.1.0/src/opencode_sql_lsp_server/cli.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+import argparse
+
+from .server import server
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(prog="opencode-sql-lsp")
+    parser.add_argument(
+        "--stdio",
+        action="store_true",
+        help="Run the language server over stdio (recommended)",
+    )
+    parser.add_argument(
+        "--workspace",
+        type=str,
+        default=None,
+        help="Workspace root (used for .opencode/sql-lsp.json); if omitted, uses client rootUri when possible",
+    )
+    args = parser.parse_args()
+
+    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)
+
+    server.start_io()

opencode_sql_lsp_server-0.1.0/src/opencode_sql_lsp_server/config.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from fnmatch import fnmatch
+from pathlib import Path
+from typing import Any
+
+
+@dataclass(frozen=True)
+class SqlLspConfig:
+    default_dialect: str
+    overrides: dict[str, str]
+
+    @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"))
+        default_dialect = data.get("defaultDialect")
+        if not isinstance(default_dialect, str) or not default_dialect.strip():
+            default_dialect = "starrocks"
+        overrides_raw = data.get("overrides")
+        overrides: dict[str, str] = {}
+        if isinstance(overrides_raw, dict):
+            for k, v in overrides_raw.items():
+                if (
+                    isinstance(k, str)
+                    and isinstance(v, str)
+                    and k.strip()
+                    and v.strip()
+                ):
+                    overrides[k] = v
+        return SqlLspConfig(default_dialect=default_dialect, overrides=overrides)
+
+    def dialect_for_path(self, relative_path: str) -> str:
+        for pattern, dialect in self.overrides.items():
+            if fnmatch(relative_path, pattern):
+                return dialect
+        return self.default_dialect

opencode_sql_lsp_server-0.1.0/src/opencode_sql_lsp_server/server.py

@@ -0,0 +1,108 @@
+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)]

opencode_sql_lsp_server-0.1.0/src/opencode_sql_lsp_server/sqlfluff_adapter.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class SqlIssue:
+    message: str
+    line: int
+    character: int
+
+
+def lint_issues(sql: str, dialect: str) -> list[SqlIssue]:
+    try:
+        from sqlfluff.api.simple import get_simple_config
+        from sqlfluff.core import Linter
+    except Exception as e:
+        return [SqlIssue(message=f"sqlfluff not available: {e}", line=1, character=0)]
+
+    try:
+        config = get_simple_config(dialect=dialect)
+        linter = Linter(config=config)
+        result = linter.lint_string_wrapped(sql)
+        violations = result.get_violations()
+        issues: list[SqlIssue] = []
+        for v in violations:
+            line_no = getattr(v, "line_no", None)
+            line_pos = getattr(v, "line_pos", None)
+            if isinstance(line_no, int) and isinstance(line_pos, int):
+                issues.append(
+                    SqlIssue(
+                        message=str(
+                            getattr(v, "desc", None)
+                            or getattr(v, "description", None)
+                            or v
+                        ),
+                        line=max(1, line_no),
+                        character=max(0, line_pos - 1),
+                    )
+                )
+            else:
+                issues.append(SqlIssue(message=str(v), line=1, character=0))
+        return issues
+    except Exception as e:
+        return [SqlIssue(message=str(e), line=1, character=0)]
+
+
+def format_sql(sql: str, dialect: str) -> str:
+    try:
+        from sqlfluff.api.simple import fix
+    except Exception as e:
+        raise RuntimeError(f"sqlfluff not available: {e}")
+
+    return fix(sql, dialect=dialect)

opencode_sql_lsp_server-0.1.0/src/opencode_sql_lsp_server.egg-info/PKG-INFO

@@ -0,0 +1,92 @@
+Metadata-Version: 2.4
+Name: opencode-sql-lsp-server
+Version: 0.1.0
+Summary: SQL Language Server for OpenCode with Trino/StarRocks dialect support
+Author: OpenCode SQL LSP port
+License: MIT
+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
+Requires-Dist: pygls>=1.3.1
+Requires-Dist: lsprotocol>=2023.0.1
+Requires-Dist: sqlfluff>=3.0.0
+
+# opencode-sql-lsp-server
+
+SQL LSP server (stdio) intended for OpenCode, with dialect-aware parsing/formatting.
+
+## Install
+
+### From PyPI (recommended)
+
+```bash
+pipx install opencode-sql-lsp-server
+```
+
+### From source
+
+Recommended: pipx (or a venv)
+
+```bash
+pipx install -e .
+```
+
+If you don't have pipx, use a virtualenv or `uv tool install`.
+
+Or pip:
+
+```bash
+python3 -m pip install -e .
+```
+
+## OpenCode config
+
+`opencode.json`:
+
+```json
+{
+  "$schema": "https://opencode.ai/config.json",
+  "lsp": {
+    "opencode-sql": {
+      "command": ["opencode-sql-lsp", "--stdio"],
+      "extensions": [".sql"]
+    }
+  }
+}
+```
+
+## Dialect config
+
+Create `.opencode/sql-lsp.json` in your project:
+
+```json
+{
+  "defaultDialect": "starrocks",
+  "overrides": {
+    "trino/**/*.sql": "trino"
+  }
+}
+```
+
+Dialect keys are sqlfluff dialect labels, e.g.:
+
+- `trino`
+- `starrocks`
+
+## Notes
+
+- Diagnostics and formatting are powered by `sqlfluff`.
+- Dialect keys (sqlfluff): `trino`, `starrocks`.
+
+## Verify dialects
+
+```bash
+sqlfluff dialects
+```

opencode_sql_lsp_server-0.1.0/src/opencode_sql_lsp_server.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+README.md
+pyproject.toml
+src/opencode_sql_lsp_server/__init__.py
+src/opencode_sql_lsp_server/cli.py
+src/opencode_sql_lsp_server/config.py
+src/opencode_sql_lsp_server/server.py
+src/opencode_sql_lsp_server/sqlfluff_adapter.py
+src/opencode_sql_lsp_server.egg-info/PKG-INFO
+src/opencode_sql_lsp_server.egg-info/SOURCES.txt
+src/opencode_sql_lsp_server.egg-info/dependency_links.txt
+src/opencode_sql_lsp_server.egg-info/entry_points.txt
+src/opencode_sql_lsp_server.egg-info/requires.txt
+src/opencode_sql_lsp_server.egg-info/top_level.txt

opencode_sql_lsp_server-0.1.0/src/opencode_sql_lsp_server.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

opencode_sql_lsp_server-0.1.0/src/opencode_sql_lsp_server.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+opencode-sql-lsp = opencode_sql_lsp_server.cli:main

opencode_sql_lsp_server-0.1.0/src/opencode_sql_lsp_server.egg-info/requires.txt

@@ -0,0 +1,3 @@
+pygls>=1.3.1
+lsprotocol>=2023.0.1
+sqlfluff>=3.0.0

opencode_sql_lsp_server-0.1.0/src/opencode_sql_lsp_server.egg-info/top_level.txt

@@ -0,0 +1 @@
+opencode_sql_lsp_server