skyforge-lsp 0.1.0__tar.gz

skyforge_lsp-0.1.0/PKG-INFO

@@ -0,0 +1,60 @@
+Metadata-Version: 2.4
+Name: skyforge-lsp
+Version: 0.1.0
+Summary: Language Server Protocol для языка SkyForge
+Author: SkyForge
+License: MIT
+Project-URL: Homepage, https://github.com/skytech-alt/SkyForge-Docs
+Project-URL: Repository, https://github.com/skytech-alt/SkyForge-Docs
+Keywords: skyforge,lsp,language-server,ide,editor
+Classifier: Programming Language :: Python :: 3
+Classifier: Natural Language :: Russian
+Classifier: Topic :: Software Development :: Interpreters
+Classifier: Topic :: Text Editors :: Integrated Development Environments (IDE)
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: pygls>=2.0.0
+Requires-Dist: skyforge-lang>=1.0.6
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+
+# skyforge-lsp
+
+Language Server Protocol для языка [SkyForge](https://github.com/skytech-alt/SkyForge-Docs).
+
+## Возможности
+
+- Диагностика — синтаксические ошибки подсвечиваются прямо при наборе
+- Автодополнение — ключевые слова, встроенные функции, символы текущего файла
+- Hover — сигнатура и описание при наведении
+- Переход к определению — F12 на функции, классы, переменные
+- Outline — структура файла в боковой панели (Ctrl+Shift+O)
+
+## Установка
+
+    pip install skyforge-lsp
+
+## Использование
+
+LSP-клиент в редакторе запускает skyforge-lsp --stdio как фоновый процесс.
+
+Ручной запуск для отладки:
+
+    skyforge-lsp --stdio
+    skyforge-lsp --tcp 2087
+
+## VS Code
+
+Расширение с этим сервером — в репозитории SkyForge-Docs.
+
+## Разработка
+
+    git clone https://github.com/skytech-alt/SkyForge-Docs
+    cd SkyForge-Docs/skyforge-lsp
+    pip install -e ".[dev]"
+    pytest
+
+## Лицензия
+
+MIT

skyforge_lsp-0.1.0/README.md

@@ -0,0 +1,39 @@
+# skyforge-lsp
+
+Language Server Protocol для языка [SkyForge](https://github.com/skytech-alt/SkyForge-Docs).
+
+## Возможности
+
+- Диагностика — синтаксические ошибки подсвечиваются прямо при наборе
+- Автодополнение — ключевые слова, встроенные функции, символы текущего файла
+- Hover — сигнатура и описание при наведении
+- Переход к определению — F12 на функции, классы, переменные
+- Outline — структура файла в боковой панели (Ctrl+Shift+O)
+
+## Установка
+
+    pip install skyforge-lsp
+
+## Использование
+
+LSP-клиент в редакторе запускает skyforge-lsp --stdio как фоновый процесс.
+
+Ручной запуск для отладки:
+
+    skyforge-lsp --stdio
+    skyforge-lsp --tcp 2087
+
+## VS Code
+
+Расширение с этим сервером — в репозитории SkyForge-Docs.
+
+## Разработка
+
+    git clone https://github.com/skytech-alt/SkyForge-Docs
+    cd SkyForge-Docs/skyforge-lsp
+    pip install -e ".[dev]"
+    pytest
+
+## Лицензия
+
+MIT

skyforge_lsp-0.1.0/pyproject.toml

@@ -0,0 +1,42 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "skyforge-lsp"
+version = "0.1.0"
+description = "Language Server Protocol для языка SkyForge"
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+authors = [{ name = "SkyForge" }]
+keywords = ["skyforge", "lsp", "language-server", "ide", "editor"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Natural Language :: Russian",
+    "Topic :: Software Development :: Interpreters",
+    "Topic :: Text Editors :: Integrated Development Environments (IDE)",
+    "License :: OSI Approved :: MIT License",
+]
+
+dependencies = [
+    "pygls>=2.0.0",
+    "skyforge-lang>=1.0.6",
+]
+
+[project.urls]
+Homepage = "https://github.com/skytech-alt/SkyForge-Docs"
+Repository = "https://github.com/skytech-alt/SkyForge-Docs"
+
+[project.scripts]
+skyforge-lsp = "skyforge_lsp.__main__:main"
+
+[project.optional-dependencies]
+dev = ["pytest>=7.0"]
+
+[tool.setuptools.packages.find]
+where = ["src"]
+include = ["skyforge_lsp*"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

skyforge_lsp-0.1.0/setup.cfg

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

skyforge_lsp-0.1.0/src/skyforge_lsp/__init__.py

@@ -0,0 +1,3 @@
+"""SkyForge Language Server."""
+
+__version__ = "0.1.0"

skyforge_lsp-0.1.0/src/skyforge_lsp/__main__.py

@@ -0,0 +1,50 @@
+"""Точка входа: skyforge-lsp [--stdio | --tcp PORT] [--version] [--help]"""
+
+import sys
+from . import __version__
+
+
+USAGE = """\
+skyforge-lsp — Language Server Protocol для SkyForge.
+
+Использование:
+    skyforge-lsp --stdio           Запуск через stdio (как ждёт большинство редакторов)
+    skyforge-lsp --tcp PORT        Запуск через TCP на 127.0.0.1:PORT (для отладки)
+    skyforge-lsp --version         Показать версию
+    skyforge-lsp --help            Показать эту справку
+"""
+
+
+def main(argv=None) -> int:
+    argv = list(sys.argv[1:] if argv is None else argv)
+
+    if "--help" in argv or "-h" in argv:
+        print(USAGE)
+        return 0
+
+    if "--version" in argv:
+        print(f"skyforge-lsp {__version__}")
+        return 0
+
+    from .server import create_server
+    server = create_server()
+
+    if "--tcp" in argv:
+        idx = argv.index("--tcp")
+        if idx + 1 >= len(argv):
+            print("Ошибка: --tcp требует номер порта", file=sys.stderr)
+            return 2
+        try:
+            port = int(argv[idx + 1])
+        except ValueError:
+            print(f"Ошибка: '{argv[idx + 1]}' не является номером порта", file=sys.stderr)
+            return 2
+        print(f"skyforge-lsp {__version__} — TCP 127.0.0.1:{port}", flush=True)
+        server.start_tcp("127.0.0.1", port)
+    else:
+        server.start_io()
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

skyforge_lsp-0.1.0/src/skyforge_lsp/documents.py

@@ -0,0 +1,68 @@
+"""Кэш открытых .skf с ленивым парсингом."""
+
+from typing import Dict, List, Optional
+
+
+class Document:
+    def __init__(self, uri: str, text: str, version: int = 0):
+        self.uri = uri
+        self.text = text
+        self.version = version
+        self._ast = self._tokens = self._parse_error = None
+        self._parsed_version = -1
+
+    def invalidate(self) -> None:
+        self._ast = self._tokens = self._parse_error = None
+        self._parsed_version = -1
+
+    @property
+    def ast(self):
+        self._ensure()
+        return self._ast
+
+    @property
+    def parse_error(self) -> Optional[Exception]:
+        self._ensure()
+        return self._parse_error
+
+    def _ensure(self) -> None:
+        if self._parsed_version == self.version:
+            return
+        try:
+            from skyforge.core import Lexer, Parser
+            self._tokens = Lexer(self.text).tokenize()
+            self._ast = Parser(self._tokens).parse()
+            self._parse_error = None
+        except Exception as e:
+            self._ast = self._tokens = None
+            self._parse_error = e
+        self._parsed_version = self.version
+
+
+class DocumentStore:
+    def __init__(self):
+        self._docs: Dict[str, Document] = {}
+
+    def open(self, uri: str, text: str, version: int = 0) -> Document:
+        d = Document(uri, text, version)
+        self._docs[uri] = d
+        return d
+
+    def apply_change(self, uri: str, text: str, version: int) -> Optional[Document]:
+        """Применить изменение. В режиме Full text — это полный текст файла."""
+        d = self._docs.get(uri)
+        if d is None:
+            return self.open(uri, text, version)
+        d.text = text
+        d.version = version
+        d.invalidate()
+        return d
+
+    def close(self, uri: str) -> None:
+        self._docs.pop(uri, None)
+
+    def get(self, uri: str) -> Optional[Document]:
+        return self._docs.get(uri)
+
+    def all(self) -> List[Document]:
+        return list(self._docs.values())

skyforge_lsp-0.1.0/src/skyforge_lsp/features/__init__.py

@@ -0,0 +1 @@
+"""LSP-фичи."""

skyforge_lsp-0.1.0/src/skyforge_lsp/features/completion.py

@@ -0,0 +1,76 @@
+"""Автодополнение."""
+
+from lsprotocol.types import (
+    CompletionItem, CompletionItemKind, CompletionList, Position, Range,
+)
+from .. import reference
+
+
+def _word(text: str, line: int, char: int):
+    lines = text.splitlines()
+    if line >= len(lines):
+        return "", char
+    src = lines[line]
+    char = min(char, len(src))
+    i = char
+    while i > 0 and (src[i - 1].isalnum() or src[i - 1] == "_"):
+        i -= 1
+    return src[i:char], i
+
+
+def _after_dot(text: str, line: int, char: int) -> bool:
+    lines = text.splitlines()
+    if line >= len(lines):
+        return False
+    src = lines[line]
+    char = min(char, len(src))
+    i = char - 1
+    while i >= 0 and src[i] in " \t":
+        i -= 1
+    return i >= 0 and src[i] == "."
+
+
+def complete(store, params) -> CompletionList:
+    doc = store.get(params.text_document.uri)
+    if doc is None:
+        return CompletionList(is_incomplete=False, items=[])
+    line, char = params.position.line, params.position.character
+    _, start = _word(doc.text, line, char)
+
+    items = []
+    if _after_dot(doc.text, line, char):
+        for r in reference.methods():
+            items.append(CompletionItem(
+                label=r.name,
+                kind=CompletionItemKind.Method,
+                detail=r.signature,
+                documentation=r.description or None,
+                sort_text="1_" + r.name,
+            ))
+    else:
+        for r in reference.keywords():
+            items.append(CompletionItem(
+                label=r.name,
+                kind=CompletionItemKind.Keyword,
+                detail=r.description or r.name,
+                sort_text="0_" + r.name,
+            ))
+        for r in reference.builtins():
+            items.append(CompletionItem(
+                label=r.name,
+                kind=CompletionItemKind.Function,
+                detail=r.description or r.name,
+                sort_text="2_" + r.name,
+            ))
+        from ..symbols import extract_symbols
+        for s in extract_symbols(doc.ast):
+            kind = {
+                "function": CompletionItemKind.Function,
+                "class": CompletionItemKind.Class,
+                "variable": CompletionItemKind.Variable,
+            }.get(s.kind, CompletionItemKind.Text)
+            items.append(CompletionItem(
+                label=s.name, kind=kind, detail=s.signature(),
+                sort_text="1_" + s.name,
+            ))
+    return CompletionList(is_incomplete=False, items=items)

skyforge_lsp-0.1.0/src/skyforge_lsp/features/definition.py

@@ -0,0 +1,98 @@
+"""Переход к определению (F12)."""
+
+import re
+from typing import List, Optional
+from lsprotocol.types import Location, Position, Range
+from ..symbols import extract_symbols
+
+
+def _word_at(text: str, line: int, char: int) -> Optional[str]:
+    lines = text.splitlines()
+    if line < 0 or line >= len(lines):
+        return None
+    src = lines[line]
+    char = min(char, len(src))
+    i = char
+    while i > 0 and (src[i - 1].isalnum() or src[i - 1] == "_"):
+        i -= 1
+    j = char
+    while j < len(src) and (src[j].isalnum() or src[j] == "_"):
+        j += 1
+    if i == j:
+        return None
+    return src[i:j]
+
+
+def _pos_from_offset(text: str, offset: int):
+    line = text.count("\n", 0, offset)
+    last_nl = text.rfind("\n", 0, offset)
+    col = offset - (last_nl + 1)
+    return line, col
+
+
+def _find_in_text(text: str, word: str) -> List[Location]:
+    """Regex-fallback: ищет объявления функции/класса/переменной в тексте.
+
+    Нужен, если AST не проставил _line/_col (в SkyForge 1.0.6 это часто так).
+    """
+    out = []
+    patterns = [
+        # функция имя(...)
+        rf"\bфункция\s+({re.escape(word)})\b",
+        # функ имя(...)
+        rf"\bфунк\s+({re.escape(word)})\b",
+        # класс Имя
+        rf"\bкласс\s+({re.escape(word)})\b",
+        # пусть имя = ...
+        rf"\bпусть\s+({re.escape(word)})\b",
+        # имя = ... (переприсваивание)
+        rf"(?<![\w]){re.escape(word)}(?=\s*=)",
+    ]
+    seen = set()
+    for pat in patterns:
+        for m in re.finditer(pat, text):
+            start = m.start(1)
+            if start in seen:
+                continue
+            seen.add(start)
+            line, col = _pos_from_offset(text, start)
+            out.append(Location(
+                uri=None,  # подставим ниже
+                range=Range(
+                    Position(line, col),
+                    Position(line, col + len(word)),
+                ),
+            ))
+    return out
+
+
+def goto_definition(store, params) -> List[Location]:
+    uri = params.text_document.uri
+    doc = store.get(uri)
+    if doc is None:
+        return []
+
+    word = _word_at(doc.text, params.position.line, params.position.character)
+    if not word:
+        return []
+
+    out: List[Location] = []
+
+    # Проход 1: через AST (если он есть и _line/_col корректные)
+    for s in extract_symbols(doc.ast):
+        if s.name == word:
+            out.append(Location(
+                uri=uri,
+                range=Range(
+                    Position(s.line, s.col),
+                    Position(s.end_line, s.end_col),
+                ),
+            ))
+
+    # Проход 2: regex по тексту — работает всегда, независимо от AST
+    if not out:
+        for loc in _find_in_text(doc.text, word):
+            loc.uri = uri  # type: ignore
+            out.append(loc)
+
+    return out

skyforge_lsp-0.1.0/src/skyforge_lsp/features/diagnostics.py

@@ -0,0 +1,58 @@
+"""Синтаксические ошибки → LSP diagnostics."""
+
+import re
+from typing import List
+from lsprotocol.types import (
+    Diagnostic, DiagnosticSeverity, Position, Range,
+    PublishDiagnosticsParams,
+)
+
+_POS = re.compile(r"на (\d+):(\d+)\s*$")
+
+
+def build_diagnostics(doc) -> List[Diagnostic]:
+    if doc.parse_error is None:
+        return []
+    msg = str(doc.parse_error)
+    m = _POS.search(msg)
+    line, col = (int(m.group(1)), int(m.group(2))) if m else (1, 1)
+    clean = _POS.sub("", msg).strip() or "Синтаксическая ошибка"
+    l, c = max(0, line - 1), max(0, col - 1)
+    return [Diagnostic(
+        range=Range(Position(l, c), Position(l, c + 1)),
+        message=clean,
+        severity=DiagnosticSeverity.Error,
+        source="skyforge",
+    )]
+
+
+def _send(server, params: PublishDiagnosticsParams) -> None:
+    """Отправить диагностику. Поддерживает pygls 1.x и 2.x."""
+    # pygls 2.x: у сервера есть .protocol с низкоуровневым notify
+    if hasattr(server, "protocol") and hasattr(server.protocol, "notify"):
+        server.protocol.notify("textDocument/publishDiagnostics", params)
+        return
+    # pygls 1.x: удобный метод publish_diagnostics
+    if hasattr(server, "publish_diagnostics"):
+        server.publish_diagnostics(
+            params.uri, params.diagnostics, version=params.version,
+        )
+        return
+    raise RuntimeError("Не могу отправить диагностику: сервер не поддерживает notify")
+
+
+def publish(server, store, uri: str) -> None:
+    doc = store.get(uri)
+    if doc is None:
+        return
+    params = PublishDiagnosticsParams(
+        uri=uri,
+        diagnostics=build_diagnostics(doc),
+        version=doc.version,
+    )
+    _send(server, params)
+
+
+def clear(server, uri: str) -> None:
+    params = PublishDiagnosticsParams(uri=uri, diagnostics=[], version=None)
+    _send(server, params)

skyforge_lsp-0.1.0/src/skyforge_lsp/features/document_symbols.py

@@ -0,0 +1,28 @@
+"""Outline документа."""
+
+from typing import List
+from lsprotocol.types import DocumentSymbol, SymbolKind, Range, Position
+from ..symbols import extract_symbols
+
+_KIND = {
+    "function": SymbolKind.Function,
+    "class": SymbolKind.Class,
+    "variable": SymbolKind.Variable,
+}
+
+
+def symbols(store, params) -> List[DocumentSymbol]:
+    doc = store.get(params.text_document.uri)
+    if doc is None:
+        return []
+    out = []
+    for s in extract_symbols(doc.ast):
+        rng = Range(Position(s.line, s.col), Position(s.end_line, s.end_col))
+        out.append(DocumentSymbol(
+            name=s.name,
+            kind=_KIND.get(s.kind, SymbolKind.Variable),
+            range=rng,
+            selection_range=rng,
+            detail=s.signature(),
+        ))
+    return out

skyforge_lsp-0.1.0/src/skyforge_lsp/features/hover.py

@@ -0,0 +1,54 @@
+"""Hover-документация."""
+
+from typing import Optional
+from lsprotocol.types import Hover, MarkupContent, MarkupKind, Position, Range
+from .. import reference
+
+
+def _word(text: str, line: int, char: int):
+    lines = text.splitlines()
+    if line >= len(lines):
+        return None, 0, 0
+    src = lines[line]
+    char = min(char, len(src))
+    i = char
+    while i > 0 and (src[i - 1].isalnum() or src[i - 1] == "_"):
+        i -= 1
+    j = char
+    while j < len(src) and (src[j].isalnum() or src[j] == "_"):
+        j += 1
+    return (src[i:j] if i != j else None), i, j
+
+
+def hover(store, params) -> Optional[Hover]:
+    doc = store.get(params.text_document.uri)
+    if doc is None:
+        return None
+    word, start, end = _word(doc.text, params.position.line, params.position.character)
+    if not word:
+        return None
+
+    rng = Range(
+        Position(params.position.line, start),
+        Position(params.position.line, end),
+    )
+
+    ref = reference.by_name().get(word)
+    if ref:
+        parts = [f"**{ref.name}**", "", ref.description or "_нет описания_"]
+        return Hover(
+            contents=MarkupContent(kind=MarkupKind.Markdown, value="\n".join(parts)),
+            range=rng,
+        )
+
+    from ..symbols import extract_symbols
+    for s in extract_symbols(doc.ast):
+        if s.name == word:
+            return Hover(
+                contents=MarkupContent(
+                    kind=MarkupKind.Markdown,
+                    value=f"**{s.signature()}**\n\nОпределено в этом файле",
+                ),
+                range=rng,
+            )
+    return None