pseudocode-i18n-languageserver 0.9.1__py3-none-any.whl

pseudocode_i18n_languageserver/__init__.py

@@ -0,0 +1,3 @@
+"""Language Server Protocol implementation for pseudocode-i18n."""
+
+__version__ = "0.9.1"

pseudocode_i18n_languageserver/cli.py

@@ -0,0 +1,48 @@
+"""Command-line entry point for ``pseudo-lsp``."""
+
+from __future__ import annotations
+
+import argparse
+import logging
+from pathlib import Path
+
+from . import __version__
+from .server import server
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="pseudo-lsp",
+        description="Language Server Protocol server for pseudocode-i18n.",
+    )
+    transport = parser.add_mutually_exclusive_group()
+    transport.add_argument("--stdio", action="store_true", help="Use stdin/stdout (default).")
+    transport.add_argument(
+        "--tcp",
+        metavar="HOST:PORT",
+        help="Listen on TCP instead of stdin/stdout; useful for debugging and some IDEs.",
+    )
+    parser.add_argument("--log-file", type=Path, help="Write server logs to this file.")
+    parser.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
+    return parser
+
+
+def main() -> None:
+    args = _parser().parse_args()
+    if args.log_file:
+        logging.basicConfig(
+            filename=args.log_file,
+            level=logging.INFO,
+            format="%(asctime)s %(levelname)s %(name)s: %(message)s",
+        )
+    if args.tcp:
+        host, separator, port_text = args.tcp.rpartition(":")
+        if not separator or not host or not port_text.isdigit():
+            _parser().error("--tcp must use HOST:PORT, for example 127.0.0.1:2087")
+        server.start_tcp(host, int(port_text))
+        return
+    server.start_io()
+
+
+if __name__ == "__main__":
+    main()

pseudocode_i18n_languageserver/compat.py

@@ -0,0 +1,22 @@
+"""Compatibility helpers for third-party runtime dependencies."""
+
+from __future__ import annotations
+
+import asyncio
+import inspect
+import sys
+
+
+def prepare_pygls_runtime() -> None:
+    """Keep pygls 2.1.x compatible with Python 3.14+ coroutine introspection.
+
+    Python 3.14 deprecates ``asyncio.iscoroutinefunction`` and Python 3.16
+    removes it. pygls 2.1.x still calls that alias while registering feature
+    handlers. Redirecting the alias to its stdlib replacement avoids the
+    deprecation today and preserves the expected API for pygls on Python 3.16.
+
+    Remove this shim once the minimum supported pygls release no longer uses
+    ``asyncio.iscoroutinefunction``.
+    """
+    if sys.version_info >= (3, 14):
+        asyncio.iscoroutinefunction = inspect.iscoroutinefunction

pseudocode_i18n_languageserver/model.py

@@ -0,0 +1,229 @@
+"""Editor-independent document model used by the LSP transport layer."""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from pathlib import Path
+
+from pseudocode_i18n import (
+    SemanticIndex,
+    build_semantic_index,
+    help_at_position,
+    help_for_token,
+    lint,
+    snippets_for_language,
+)
+from pseudocode_i18n.config import (
+    fallback_language,
+    find_config,
+    language_overrides,
+    load_config,
+    project_language,
+)
+from pseudocode_i18n.diagnostics import LintResult
+from pseudocode_i18n.formatter import format_pseudocode
+from pseudocode_i18n.language import load_language, resolve_language
+
+_CALL_RE = re.compile(r"(?u)(?P<name>(?:[^\W\d]|_)\w*)\s*\((?P<args>[^()]*)$")
+_SNIPPET_DEFAULT_RE = re.compile(r"\$\{\d+:([^}]*)\}")
+_SNIPPET_EMPTY_RE = re.compile(r"\$\{\d+\}|\$\d+")
+
+
+def snippet_to_plain_text(text: str) -> str:
+    """Return a readable insertion for LSP clients without snippet support."""
+    text = _SNIPPET_DEFAULT_RE.sub(lambda match: match.group(1), text)
+    return _SNIPPET_EMPTY_RE.sub("", text)
+
+
+@dataclass(frozen=True, slots=True)
+class CompletionCandidate:
+    label: str
+    kind: str
+    insert_text: str | None = None
+    detail: str | None = None
+    documentation: str | None = None
+    snippet: bool = False
+
+
+@dataclass(frozen=True, slots=True)
+class SignatureContext:
+    name: str
+    signature: str
+    parameters: tuple[str, ...]
+    active_parameter: int
+
+
+@dataclass(slots=True)
+class DocumentModel:
+    source: str
+    path: Path | None
+    language: str
+    config: dict
+    index: SemanticIndex
+    lint_result: LintResult
+
+    @classmethod
+    def build(cls, source: str, path: Path | None = None) -> DocumentModel:
+        config_path = find_config(path.parent if path is not None else None)
+        config = load_config(config_path)
+        configured = project_language(config)
+        fallback = fallback_language(config)
+        overrides = config.get("languages") if isinstance(config.get("languages"), dict) else {}
+        language = resolve_language(
+            source,
+            configured=configured,
+            fallback=fallback,
+            overrides_by_language=overrides,
+        )
+        override = language_overrides(config, language)
+        lint_result = lint(
+            source,
+            language,
+            override,
+            fallback_language=fallback,
+            source_path=path,
+            project_root=config_path.parent if config_path is not None else None,
+        )
+        try:
+            index = build_semantic_index(
+                source,
+                language=language,
+                configured=configured,
+                fallback=fallback,
+                overrides_by_language=overrides,
+            )
+        except (SyntaxError, ValueError):
+            index = SemanticIndex(language=language, symbols=(), references=())
+        return cls(source, path, language, config, index, lint_result)
+
+    def formatted(self) -> str:
+        override = language_overrides(self.config, self.language)
+        return format_pseudocode(self.source, self.language, override, self.config)
+
+    def completions(self) -> tuple[CompletionCandidate, ...]:
+        override = language_overrides(self.config, self.language)
+        spec = load_language(self.language, override)
+        items: list[CompletionCandidate] = []
+        for snippet in snippets_for_language(self.language, override):
+            items.append(
+                CompletionCandidate(
+                    label=snippet.label,
+                    kind="snippet",
+                    insert_text=snippet.insert_text,
+                    detail=f"Pseudocode ({self.language}) · {snippet.key}",
+                    documentation=(
+                        help_for_token(snippet.label.split()[0], self.language, override).markdown
+                        if help_for_token(snippet.label.split()[0], self.language, override)
+                        else None
+                    ),
+                    snippet=True,
+                )
+            )
+        seen = {item.label for item in items}
+        for symbol in self.index.symbols:
+            if symbol.name in seen:
+                continue
+            seen.add(symbol.name)
+            items.append(
+                CompletionCandidate(
+                    label=symbol.name,
+                    kind=symbol.kind,
+                    detail=symbol.signature,
+                    documentation=(
+                        f"**{symbol.kind}** `{symbol.signature}`"
+                        + (f"\n\nContainer: `{symbol.container}`" if symbol.container else "")
+                    ),
+                )
+            )
+        for name, semantic in spec.semantic_functions.items():
+            if name in seen:
+                continue
+            seen.add(name)
+            items.append(
+                CompletionCandidate(
+                    label=name,
+                    kind="function",
+                    detail=f"built-in · {semantic}",
+                    documentation=(
+                        help_for_token(name, self.language, override).markdown
+                        if help_for_token(name, self.language, override)
+                        else None
+                    ),
+                )
+            )
+        for key in spec.types:
+            name = spec.canonical_type(key)
+            if name in seen:
+                continue
+            seen.add(name)
+            help_item = help_for_token(name, self.language, override)
+            items.append(
+                CompletionCandidate(
+                    label=name,
+                    kind="type",
+                    detail=f"type · {key}",
+                    documentation=help_item.markdown if help_item else None,
+                )
+            )
+        for name in spec.values:
+            if name in seen:
+                continue
+            seen.add(name)
+            help_item = help_for_token(name, self.language, override)
+            items.append(
+                CompletionCandidate(
+                    label=name,
+                    kind="constant",
+                    detail="constant",
+                    documentation=help_item.markdown if help_item else None,
+                )
+            )
+        return tuple(items)
+
+    def help_at(self, line: int, column: int):
+        override = language_overrides(self.config, self.language)
+        return help_at_position(self.source, self.language, line, column, override)
+
+    def signature_at(self, line: int, column: int) -> SignatureContext | None:
+        lines = self.source.splitlines()
+        if line < 1 or line > len(lines):
+            return None
+        prefix = lines[line - 1][: max(0, column - 1)]
+        match = _CALL_RE.search(prefix)
+        if match is None:
+            return None
+        name = match.group("name")
+        candidates = [
+            item
+            for item in self.index.symbols
+            if item.name == name
+            and item.kind in {"function", "method", "constructor", "process", "subprocess"}
+        ]
+        active_parameter = 0 if not match.group("args").strip() else match.group("args").count(",")
+        if candidates:
+            symbol = candidates[0]
+            parameters = tuple(item.display for item in symbol.parameters)
+            return SignatureContext(
+                name=name,
+                signature=symbol.signature,
+                parameters=parameters,
+                active_parameter=min(active_parameter, max(0, len(parameters) - 1)),
+            )
+
+        override = language_overrides(self.config, self.language)
+        help_item = help_for_token(name, self.language, override)
+        if help_item is None or help_item.kind != "builtin" or not help_item.syntax:
+            return None
+        signature = help_item.syntax[0]
+        match_params = re.search(r"\((.*)\)$", signature)
+        if match_params is None or "…" in match_params.group(1):
+            return None
+        raw = match_params.group(1).strip()
+        parameters = tuple(item.strip() for item in raw.split(",") if item.strip())
+        return SignatureContext(
+            name=name,
+            signature=signature,
+            parameters=parameters,
+            active_parameter=min(active_parameter, max(0, len(parameters) - 1)),
+        )

pseudocode_i18n_languageserver/server.py

@@ -0,0 +1,346 @@
+"""pygls transport layer for the Pseudocode language server."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from lsprotocol import types
+from pseudocode_i18n import SourceRange
+from pseudocode_i18n.diagnostics import DiagnosticSeverity as CoreSeverity
+from pygls.lsp.server import LanguageServer
+from pygls.uris import to_fs_path
+
+from .compat import prepare_pygls_runtime
+from .model import DocumentModel, snippet_to_plain_text
+
+prepare_pygls_runtime()
+
+SERVER_NAME = "pseudocode-i18n-languageserver"
+SERVER_VERSION = "0.9.1"
+
+
+class PseudocodeLanguageServer(LanguageServer):
+    def __init__(self) -> None:
+        super().__init__(SERVER_NAME, SERVER_VERSION)
+        self.models: dict[str, DocumentModel] = {}
+
+    def model(self, uri: str, *, refresh: bool = False) -> DocumentModel:
+        if not refresh and uri in self.models:
+            return self.models[uri]
+        document = self.workspace.get_text_document(uri)
+        model = DocumentModel.build(document.source, _path_from_uri(uri))
+        self.models[uri] = model
+        return model
+
+    def refresh_and_publish(self, uri: str, version: int | None = None) -> None:
+        document = self.workspace.get_text_document(uri)
+        model = self.model(uri, refresh=True)
+        diagnostics = [_diagnostic(item, document) for item in model.lint_result.diagnostics]
+        self.text_document_publish_diagnostics(
+            types.PublishDiagnosticsParams(uri=uri, version=version, diagnostics=diagnostics)
+        )
+
+
+server = PseudocodeLanguageServer()
+
+
+def _path_from_uri(uri: str) -> Path | None:
+    value = to_fs_path(uri)
+    return Path(value) if value is not None else None
+
+
+def _source_offset(source: str, line: int, column: int) -> int:
+    """Convert a one-based core position into a Python code-point offset."""
+    lines = source.splitlines(keepends=True)
+    if not lines:
+        return 0
+    line_index = min(max(line - 1, 0), len(lines) - 1)
+    prefix = sum(len(item) for item in lines[:line_index])
+    text = lines[line_index]
+    visible_length = len(text.rstrip("\r\n"))
+    column_index = min(max(column - 1, 0), visible_length)
+    return prefix + column_index
+
+
+def _core_position(document, position: types.Position) -> tuple[int, int]:
+    """Convert an LSP client position into one-based Python code-point units."""
+    offset = document.offset_at_position(position)
+    server_position = document.server_position_at_offset(offset)
+    return server_position.line + 1, server_position.character + 1
+
+
+def _range(document, value: SourceRange) -> types.Range:
+    """Convert a core range into the position encoding negotiated with the client."""
+    return types.Range(
+        start=document.client_position_at_offset(
+            _source_offset(document.source, value.start_line, value.start_column)
+        ),
+        end=document.client_position_at_offset(
+            _source_offset(document.source, value.end_line, value.end_column)
+        ),
+    )
+
+
+def _diagnostic(item, document) -> types.Diagnostic:
+    severity = {
+        CoreSeverity.ERROR: types.DiagnosticSeverity.Error,
+        CoreSeverity.WARNING: types.DiagnosticSeverity.Warning,
+        CoreSeverity.INFORMATION: types.DiagnosticSeverity.Information,
+    }[item.severity]
+    range_ = SourceRange(
+        item.line,
+        item.column,
+        item.end_line or item.line,
+        item.end_column or max(item.column + 1, item.column),
+    )
+    return types.Diagnostic(
+        range=_range(document, range_),
+        message=item.message,
+        severity=severity,
+        code=item.code,
+        source="pseudocode-i18n",
+    )
+
+
+def _symbol_kind(kind: str) -> types.SymbolKind:
+    return {
+        "class": types.SymbolKind.Class,
+        "function": types.SymbolKind.Function,
+        "method": types.SymbolKind.Method,
+        "constructor": types.SymbolKind.Constructor,
+        "process": types.SymbolKind.Function,
+        "subprocess": types.SymbolKind.Function,
+        "algorithm": types.SymbolKind.Namespace,
+        "parameter": types.SymbolKind.Variable,
+        "attribute": types.SymbolKind.Field,
+        "module": types.SymbolKind.Module,
+        "import": types.SymbolKind.Module,
+        "variable": types.SymbolKind.Variable,
+    }.get(kind, types.SymbolKind.Variable)
+
+
+def _supports_snippets(ls: PseudocodeLanguageServer) -> bool:
+    text_document = getattr(ls.client_capabilities, "text_document", None)
+    completion = getattr(text_document, "completion", None)
+    completion_item = getattr(completion, "completion_item", None)
+    return bool(getattr(completion_item, "snippet_support", False))
+
+
+def _completion_kind(kind: str) -> types.CompletionItemKind:
+    return {
+        "snippet": types.CompletionItemKind.Snippet,
+        "class": types.CompletionItemKind.Class,
+        "function": types.CompletionItemKind.Function,
+        "method": types.CompletionItemKind.Method,
+        "constructor": types.CompletionItemKind.Constructor,
+        "process": types.CompletionItemKind.Function,
+        "subprocess": types.CompletionItemKind.Function,
+        "parameter": types.CompletionItemKind.Variable,
+        "attribute": types.CompletionItemKind.Field,
+        "variable": types.CompletionItemKind.Variable,
+        "type": types.CompletionItemKind.TypeParameter,
+        "constant": types.CompletionItemKind.Constant,
+    }.get(kind, types.CompletionItemKind.Text)
+
+
+@server.feature(types.TEXT_DOCUMENT_DID_OPEN)
+def did_open(ls: PseudocodeLanguageServer, params: types.DidOpenTextDocumentParams) -> None:
+    ls.refresh_and_publish(params.text_document.uri, params.text_document.version)
+
+
+@server.feature(types.TEXT_DOCUMENT_DID_CHANGE)
+def did_change(ls: PseudocodeLanguageServer, params: types.DidChangeTextDocumentParams) -> None:
+    ls.refresh_and_publish(params.text_document.uri, params.text_document.version)
+
+
+@server.feature(types.TEXT_DOCUMENT_DID_SAVE)
+def did_save(ls: PseudocodeLanguageServer, params: types.DidSaveTextDocumentParams) -> None:
+    ls.refresh_and_publish(params.text_document.uri)
+
+
+@server.feature(types.TEXT_DOCUMENT_DID_CLOSE)
+def did_close(ls: PseudocodeLanguageServer, params: types.DidCloseTextDocumentParams) -> None:
+    uri = params.text_document.uri
+    ls.models.pop(uri, None)
+    ls.text_document_publish_diagnostics(types.PublishDiagnosticsParams(uri=uri, diagnostics=[]))
+
+
+@server.feature(types.TEXT_DOCUMENT_COMPLETION, types.CompletionOptions(resolve_provider=False))
+def completion(
+    ls: PseudocodeLanguageServer, params: types.CompletionParams
+) -> types.CompletionList:
+    model = ls.model(params.text_document.uri)
+    snippet_support = _supports_snippets(ls)
+    items = [
+        types.CompletionItem(
+            label=item.label,
+            kind=_completion_kind(item.kind),
+            detail=item.detail,
+            documentation=(
+                types.MarkupContent(kind=types.MarkupKind.Markdown, value=item.documentation)
+                if item.documentation
+                else None
+            ),
+            insert_text=(
+                item.insert_text
+                if not item.snippet or snippet_support or item.insert_text is None
+                else snippet_to_plain_text(item.insert_text)
+            ),
+            insert_text_format=(
+                types.InsertTextFormat.Snippet
+                if item.snippet and snippet_support
+                else types.InsertTextFormat.PlainText
+            ),
+            sort_text=("0-" if item.snippet else "1-") + item.label.casefold(),
+        )
+        for item in model.completions()
+    ]
+    return types.CompletionList(is_incomplete=False, items=items)
+
+
+@server.feature(types.TEXT_DOCUMENT_HOVER)
+def hover(ls: PseudocodeLanguageServer, params: types.HoverParams) -> types.Hover | None:
+    document = ls.workspace.get_text_document(params.text_document.uri)
+    model = ls.model(params.text_document.uri)
+    line, column = _core_position(document, params.position)
+    symbol = model.index.symbol_at(line, column)
+    if symbol is not None:
+        details = [f"**{symbol.kind}** `{symbol.signature}`", "", f"Language: `{model.language}`"]
+        if symbol.container:
+            details.extend(["", f"Container: `{symbol.container}`"])
+        return types.Hover(
+            contents=types.MarkupContent(kind=types.MarkupKind.Markdown, value="\n".join(details)),
+            range=_range(document, symbol.range),
+        )
+
+    help_item = model.help_at(line, column)
+    if help_item is None:
+        return None
+    return types.Hover(
+        contents=types.MarkupContent(kind=types.MarkupKind.Markdown, value=help_item.markdown),
+    )
+
+
+@server.feature(
+    types.TEXT_DOCUMENT_SIGNATURE_HELP,
+    types.SignatureHelpOptions(trigger_characters=["(", ","]),
+)
+def signature_help(
+    ls: PseudocodeLanguageServer, params: types.SignatureHelpParams
+) -> types.SignatureHelp | None:
+    document = ls.workspace.get_text_document(params.text_document.uri)
+    model = ls.model(params.text_document.uri)
+    line, column = _core_position(document, params.position)
+    context = model.signature_at(line, column)
+    if context is None:
+        return None
+    return types.SignatureHelp(
+        signatures=[
+            types.SignatureInformation(
+                label=context.signature,
+                parameters=[types.ParameterInformation(label=item) for item in context.parameters],
+            )
+        ],
+        active_signature=0,
+        active_parameter=context.active_parameter,
+    )
+
+
+@server.feature(types.TEXT_DOCUMENT_DEFINITION)
+def definition(
+    ls: PseudocodeLanguageServer, params: types.DefinitionParams
+) -> types.Location | None:
+    document = ls.workspace.get_text_document(params.text_document.uri)
+    model = ls.model(params.text_document.uri)
+    line, column = _core_position(document, params.position)
+    symbol = model.index.definition_at(line, column)
+    if symbol is None:
+        return None
+    return types.Location(uri=params.text_document.uri, range=_range(document, symbol.range))
+
+
+@server.feature(types.TEXT_DOCUMENT_REFERENCES)
+def references(ls: PseudocodeLanguageServer, params: types.ReferenceParams) -> list[types.Location]:
+    document = ls.workspace.get_text_document(params.text_document.uri)
+    model = ls.model(params.text_document.uri)
+    line, column = _core_position(document, params.position)
+    refs = model.index.references_at(
+        line,
+        column,
+        include_definition=params.context.include_declaration,
+    )
+    return [
+        types.Location(uri=params.text_document.uri, range=_range(document, item.range))
+        for item in refs
+    ]
+
+
+@server.feature(types.TEXT_DOCUMENT_PREPARE_RENAME)
+def prepare_rename(
+    ls: PseudocodeLanguageServer, params: types.PrepareRenameParams
+) -> types.Range | None:
+    document = ls.workspace.get_text_document(params.text_document.uri)
+    model = ls.model(params.text_document.uri)
+    line, column = _core_position(document, params.position)
+    reference = model.index.reference_at(line, column)
+    if reference is not None:
+        return _range(document, reference.range)
+    symbol = model.index.symbol_at(line, column)
+    return _range(document, symbol.range) if symbol is not None else None
+
+
+@server.feature(types.TEXT_DOCUMENT_RENAME)
+def rename(ls: PseudocodeLanguageServer, params: types.RenameParams) -> types.WorkspaceEdit | None:
+    document = ls.workspace.get_text_document(params.text_document.uri)
+    model = ls.model(params.text_document.uri)
+    line, column = _core_position(document, params.position)
+    refs = model.index.references_at(
+        line,
+        column,
+        include_definition=True,
+    )
+    if not refs:
+        return None
+    edits = [
+        types.TextEdit(range=_range(document, item.range), new_text=params.new_name)
+        for item in refs
+    ]
+    return types.WorkspaceEdit(changes={params.text_document.uri: edits})
+
+
+@server.feature(types.TEXT_DOCUMENT_DOCUMENT_SYMBOL)
+def document_symbols(
+    ls: PseudocodeLanguageServer, params: types.DocumentSymbolParams
+) -> list[types.DocumentSymbol]:
+    document = ls.workspace.get_text_document(params.text_document.uri)
+    model = ls.model(params.text_document.uri)
+    return [
+        types.DocumentSymbol(
+            name=item.name,
+            detail=item.signature,
+            kind=_symbol_kind(item.kind),
+            range=_range(document, item.range),
+            selection_range=_range(document, item.range),
+        )
+        for item in model.index.symbols
+    ]
+
+
+@server.feature(types.TEXT_DOCUMENT_FORMATTING)
+def formatting(
+    ls: PseudocodeLanguageServer, params: types.DocumentFormattingParams
+) -> list[types.TextEdit]:
+    document = ls.workspace.get_text_document(params.text_document.uri)
+    model = ls.model(params.text_document.uri)
+    formatted = model.formatted()
+    if formatted == model.source:
+        return []
+    return [
+        types.TextEdit(
+            range=types.Range(
+                start=document.client_position_at_offset(0),
+                end=document.client_position_at_offset(len(model.source)),
+            ),
+            new_text=formatted,
+        )
+    ]