python-fragments 0.1__py3-none-any.whl

fragments/lsp/file_state.py

@@ -0,0 +1,109 @@
+from __future__ import annotations
+
+import bisect
+from dataclasses import dataclass, field
+
+from lsprotocol import types
+
+from fragments.ast_nodes import ASTHTMLElement, ASTHTMLText, ASTInterpolation, ASTModule, ASTPython
+
+
+def _build_line_starts(source: str) -> list[int]:
+    starts = [0]
+    for i, character in enumerate(source):
+        if character == "\n":
+            starts.append(i + 1)
+    return starts
+
+
+def _position_to_offset(line_starts: list[int], line: int, character: int) -> int:
+    return line_starts[line] + character
+
+
+def _offset_to_position(line_starts: list[int], offset: int) -> types.Position:
+    line = bisect.bisect_right(line_starts, offset) - 1
+    return types.Position(line=line, character=offset - line_starts[line])
+
+
+@dataclass(slots=True)
+class _FileState:
+    original: str
+    transpiled: str
+    module: ASTModule
+    original_line_starts: list[int] = field(init=False)
+    transpiled_line_starts: list[int] = field(init=False)
+
+    def __post_init__(self) -> None:
+        self.original_line_starts = _build_line_starts(self.original)
+        self.transpiled_line_starts = _build_line_starts(self.transpiled)
+
+    def _interpolation_expression_start(self, interpolation: ASTInterpolation) -> int:
+        after = self.original[interpolation.source_start + 2 :]
+        return interpolation.source_start + 2 + (len(after) - len(after.lstrip()))
+
+    def _original_offset_to_transpiled_offset(self, original_offset: int) -> int | None:
+        for child in self.module.children:
+            if isinstance(child, ASTPython):
+                if child.source_start <= original_offset < child.source_end:
+                    return child.transpiled_start + (original_offset - child.source_start)
+            elif child.source_start <= original_offset < child.source_end:
+                return self._original_offset_in_nodes(original_offset, child.children)
+        return None
+
+    def _original_offset_in_nodes(self, original_offset: int, nodes: list[ASTHTMLElement | ASTHTMLText | ASTInterpolation]) -> int | None:
+        for node in nodes:
+            if not (node.source_start <= original_offset < node.source_end):
+                continue
+            if isinstance(node, ASTInterpolation):
+                expression_start = self._interpolation_expression_start(node)
+                return node.transpiled_start + (original_offset - expression_start) if original_offset >= expression_start else None
+            if isinstance(node, ASTHTMLElement):
+                for interpolation in [node.if_attribute, node.for_attribute, *(a.interpolation for a in node.attributes.values())]:
+                    if interpolation is not None and interpolation.source_start <= original_offset < interpolation.source_end:
+                        expression_start = self._interpolation_expression_start(interpolation)
+                        return interpolation.transpiled_start + (original_offset - expression_start) if original_offset >= expression_start else None
+                return self._original_offset_in_nodes(original_offset, list(node.children))
+        return None
+
+    def _transpiled_offset_to_original_offset(self, transpiled_offset: int) -> int | None:
+        for child in self.module.children:
+            if isinstance(child, ASTPython):
+                if child.transpiled_start <= transpiled_offset < child.transpiled_end:
+                    return child.source_start + (transpiled_offset - child.transpiled_start)
+            elif child.transpiled_start <= transpiled_offset < child.transpiled_end:
+                return self._transpiled_offset_in_nodes(transpiled_offset, child.children)
+        return None
+
+    def _transpiled_offset_in_nodes(self, transpiled_offset: int, nodes: list[ASTHTMLElement | ASTHTMLText | ASTInterpolation]) -> int | None:
+        for node in nodes:
+            if not (node.transpiled_start <= transpiled_offset < node.transpiled_end):
+                continue
+            if isinstance(node, ASTInterpolation):
+                return self._interpolation_expression_start(node) + (transpiled_offset - node.transpiled_start)
+            if isinstance(node, ASTHTMLElement):
+                for interpolation in [node.if_attribute, node.for_attribute, *(a.interpolation for a in node.attributes.values())]:
+                    if interpolation is not None and interpolation.transpiled_start <= transpiled_offset < interpolation.transpiled_end:
+                        return self._interpolation_expression_start(interpolation) + (transpiled_offset - interpolation.transpiled_start)
+                return self._transpiled_offset_in_nodes(transpiled_offset, list(node.children))
+        return None
+
+    def original_to_transpiled_position(self, position: types.Position) -> types.Position | None:
+        original_offset = _position_to_offset(self.original_line_starts, position.line, position.character)
+        transpiled_offset = self._original_offset_to_transpiled_offset(original_offset)
+        if transpiled_offset is None:
+            return None
+        return _offset_to_position(self.transpiled_line_starts, transpiled_offset)
+
+    def transpiled_to_original_position(self, position: types.Position) -> types.Position | None:
+        transpiled_offset = _position_to_offset(self.transpiled_line_starts, position.line, position.character)
+        original_offset = self._transpiled_offset_to_original_offset(transpiled_offset)
+        if original_offset is None:
+            return None
+        return _offset_to_position(self.original_line_starts, original_offset)
+
+    def transpiled_to_original_range(self, range_: types.Range) -> types.Range | None:
+        start = self.transpiled_to_original_position(range_.start)
+        end = self.transpiled_to_original_position(range_.end)
+        if start is None or end is None:
+            return None
+        return types.Range(start=start, end=end)

fragments/lsp/hover.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+from lsprotocol import types
+
+from fragments.lsp.server import FragmentsServer, _converter, server
+
+
+@server.feature(types.TEXT_DOCUMENT_HOVER)
+async def hover(language_server: FragmentsServer, params: types.HoverParams) -> types.Hover | None:
+    if language_server._pyright is None or params.text_document.uri not in language_server._files:
+        return None
+    state = language_server._files[params.text_document.uri]
+
+    if state is None:
+        result = await language_server._pyright.request(
+            "textDocument/hover",
+            {
+                "textDocument": {"uri": params.text_document.uri},
+                "position": {"line": params.position.line, "character": params.position.character},
+            },
+        )
+        raw_hover = result.get("result")
+        return _converter.structure(raw_hover, types.Hover) if raw_hover else None
+
+    transpiled_position = state.original_to_transpiled_position(params.position)
+    if transpiled_position is None:
+        return None
+
+    result = await language_server._pyright.request(
+        "textDocument/hover",
+        {
+            "textDocument": {"uri": params.text_document.uri},
+            "position": {"line": transpiled_position.line, "character": transpiled_position.character},
+        },
+    )
+
+    raw_hover = result.get("result")
+    if not raw_hover:
+        return None
+
+    hover_response = _converter.structure(raw_hover, types.Hover)
+    if hover_response.range is not None:
+        hover_response.range = state.transpiled_to_original_range(hover_response.range)
+    return hover_response

fragments/lsp/lifecycle.py

@@ -0,0 +1,116 @@
+from __future__ import annotations
+
+import asyncio
+
+from lsprotocol import types
+
+from fragments import grammar
+from fragments.lsp.pyright import PyrightClient
+from fragments.lsp.server import FragmentsServer, _TOKEN_MODIFIERS, _TOKEN_TYPES, _build_file_state, _parse_error_to_diagnostic, server
+
+_DEBOUNCE_SECONDS = 0.15
+
+
+@server.feature(types.INITIALIZED)
+async def initialized(language_server: FragmentsServer, _params: types.InitializedParams) -> None:
+    root_uri = language_server.workspace.root_uri
+    workspace_folders = [{"uri": folder.uri, "name": folder.name} for folder in language_server.workspace.folders.values()]
+
+    pyright = PyrightClient(language_server._on_pyright_notification, language_server._on_pyright_request)
+    language_server._pyright = pyright
+    await pyright.start()
+    await pyright.request(
+        "initialize",
+        {
+            "processId": None,
+            "rootUri": root_uri,
+            "workspaceFolders": workspace_folders or None,
+            "capabilities": {
+                "workspace": {"configuration": True},
+                "textDocument": {
+                    "hover": {"contentFormat": ["markdown", "plaintext"]},
+                    "rename": {"prepareSupport": True},
+                    "semanticTokens": {
+                        "requests": {"full": True},
+                        "tokenTypes": _TOKEN_TYPES,
+                        "tokenModifiers": _TOKEN_MODIFIERS,
+                        "formats": ["relative"],
+                    },
+                },
+            },
+        },
+    )
+    pyright.notify("initialized", {})
+
+
+@server.feature(types.TEXT_DOCUMENT_DID_OPEN)
+async def did_open(language_server: FragmentsServer, params: types.DidOpenTextDocumentParams) -> None:
+    document = params.text_document
+    try:
+        state, content_for_pyright = await asyncio.get_running_loop().run_in_executor(None, _build_file_state, document.text)
+        language_server._parse_errors[document.uri] = None
+    except grammar.ParsingError as error:
+        state = None
+        content_for_pyright = document.text
+        language_server._parse_errors[document.uri] = _parse_error_to_diagnostic(document.text, error)
+        language_server._republish_diagnostics(document.uri)
+    language_server._files[document.uri] = state
+
+    if language_server._pyright:
+        language_server._pyright.notify(
+            "textDocument/didOpen",
+            {
+                "textDocument": {
+                    "uri": document.uri,
+                    "languageId": document.language_id,
+                    "version": document.version,
+                    "text": content_for_pyright,
+                }
+            },
+        )
+
+
+@server.feature(types.TEXT_DOCUMENT_DID_CHANGE)
+def did_change(language_server: FragmentsServer, params: types.DidChangeTextDocumentParams) -> None:
+    uri = params.text_document.uri
+    text = params.content_changes[-1].text
+
+    existing = language_server._debounce_tasks.pop(uri, None)
+    if existing:
+        existing.cancel()
+
+    async def _apply_change() -> None:
+        await asyncio.sleep(_DEBOUNCE_SECONDS)
+        language_server._debounce_tasks.pop(uri, None)
+        try:
+            state, content_for_pyright = await asyncio.get_running_loop().run_in_executor(None, _build_file_state, text)
+            language_server._parse_errors[uri] = None
+            language_server._files[uri] = state
+            if language_server._pyright:
+                language_server._pyright.notify(
+                    "textDocument/didChange",
+                    {
+                        "textDocument": {"uri": uri, "version": params.text_document.version},
+                        "contentChanges": [{"text": content_for_pyright}],
+                    },
+                )
+        except grammar.ParsingError as error:
+            language_server._parse_errors[uri] = _parse_error_to_diagnostic(text, error)
+            language_server._republish_diagnostics(uri)
+
+    language_server._debounce_tasks[uri] = asyncio.ensure_future(_apply_change())
+
+
+@server.feature(types.TEXT_DOCUMENT_DID_CLOSE)
+def did_close(language_server: FragmentsServer, params: types.DidCloseTextDocumentParams) -> None:
+    uri = params.text_document.uri
+    language_server._files.pop(uri, None)
+    language_server._parse_errors.pop(uri, None)
+    language_server._pyright_diagnostics.pop(uri, None)
+
+    existing = language_server._debounce_tasks.pop(uri, None)
+    if existing:
+        existing.cancel()
+
+    if language_server._pyright:
+        language_server._pyright.notify("textDocument/didClose", {"textDocument": {"uri": uri}})

fragments/lsp/pyright.py

@@ -0,0 +1,94 @@
+import asyncio
+import json
+import os
+import sys
+from collections.abc import Awaitable, Callable
+from typing import Any
+
+
+class PyrightClient:
+    def __init__(
+        self,
+        on_notification: Callable[[dict[str, Any]], None],
+        on_request: Callable[[dict[str, Any]], Awaitable[object]] | None = None,
+    ) -> None:
+        self._on_notification = on_notification
+        self._on_request = on_request
+        self._proc: asyncio.subprocess.Process | None = None
+        self._pending: dict[int | str, asyncio.Future[dict[str, Any]]] = {}
+        self._next_id = 1
+
+    async def start(self) -> None:
+        bin_directory = os.path.dirname(sys.executable)
+        environment = dict(os.environ)
+        if sys.prefix != sys.base_prefix:
+            environment["VIRTUAL_ENV"] = sys.prefix
+        self._proc = await asyncio.create_subprocess_exec(
+            os.path.join(bin_directory, "basedpyright-langserver"),
+            "--stdio",
+            stdin=asyncio.subprocess.PIPE,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=sys.stderr.buffer,
+            env=environment,
+        )
+        asyncio.create_task(self._read_loop())
+
+    async def _read(self) -> dict[str, Any] | None:
+        assert self._proc and self._proc.stdout
+        headers: dict[str, str] = {}
+        while True:
+            line = await self._proc.stdout.readline()
+            if not line:
+                return None
+            line = line.decode().rstrip("\r\n")
+            if not line:
+                break
+            key, _, value = line.partition(":")
+            headers[key.strip()] = value.strip()
+        length = headers.get("Content-Length")
+        if length is None:
+            return None
+        body = await self._proc.stdout.readexactly(int(length))
+        return json.loads(body)
+
+    async def _read_once(self) -> None:
+        message = await self._read()
+        if message is None:
+            return
+        if "id" in message and "method" not in message:
+            future = self._pending.pop(message["id"], None)
+            if future and not future.done():
+                future.set_result(message)
+        elif "id" in message and "method" in message:
+            _ = asyncio.ensure_future(self._handle_request(message))
+        else:
+            self._on_notification(message)
+
+    async def _read_loop(self) -> None:
+        try:
+            while True:
+                await self._read_once()
+        except Exception as e:
+            print(f"[pyright] {e}", file=sys.stderr, flush=True)
+
+    async def _handle_request(self, message: dict[str, Any]) -> None:
+        result = await self._on_request(message) if self._on_request else None
+        self._send({"jsonrpc": "2.0", "id": message["id"], "result": result})
+
+    async def request(self, method: str, params: dict[str, Any]) -> dict[str, Any]:
+        assert self._proc and self._proc.stdin
+        message_id = self._next_id
+        self._next_id += 1
+        future: asyncio.Future[dict[str, Any]] = asyncio.get_event_loop().create_future()
+        self._pending[message_id] = future
+        self._send({"jsonrpc": "2.0", "id": message_id, "method": method, "params": params})
+        await self._proc.stdin.drain()
+        return await future
+
+    def notify(self, method: str, params: dict[str, Any]) -> None:
+        self._send({"jsonrpc": "2.0", "method": method, "params": params})
+
+    def _send(self, message: dict[str, Any]) -> None:
+        assert self._proc and self._proc.stdin
+        body = json.dumps(message, separators=(",", ":")).encode()
+        self._proc.stdin.write(f"Content-Length: {len(body)}\r\n\r\n".encode() + body)

fragments/lsp/rename.py

@@ -0,0 +1,106 @@
+from __future__ import annotations
+
+from lsprotocol import types
+
+from fragments.lsp.server import FragmentsServer, _converter, _remap_text_edits, server
+
+
+@server.feature(types.TEXT_DOCUMENT_PREPARE_RENAME)
+async def prepare_rename(language_server: FragmentsServer, params: types.PrepareRenameParams) -> types.Range | None:
+    if language_server._pyright is None or params.text_document.uri not in language_server._files:
+        return None
+    state = language_server._files[params.text_document.uri]
+
+    if state is None:
+        result = await language_server._pyright.request(
+            "textDocument/prepareRename",
+            {
+                "textDocument": {"uri": params.text_document.uri},
+                "position": {"line": params.position.line, "character": params.position.character},
+            },
+        )
+        raw_result = result.get("result")
+        if not raw_result:
+            return None
+        range_dict = raw_result.get("range", raw_result) if isinstance(raw_result, dict) else raw_result
+        if not isinstance(range_dict, dict) or "start" not in range_dict:
+            return None
+        return _converter.structure(range_dict, types.Range)
+
+    transpiled_position = state.original_to_transpiled_position(params.position)
+    if transpiled_position is None:
+        return None
+
+    result = await language_server._pyright.request(
+        "textDocument/prepareRename",
+        {
+            "textDocument": {"uri": params.text_document.uri},
+            "position": {"line": transpiled_position.line, "character": transpiled_position.character},
+        },
+    )
+
+    raw_result = result.get("result")
+    if not raw_result:
+        return None
+
+    range_dict = raw_result.get("range", raw_result) if isinstance(raw_result, dict) else raw_result
+    if not isinstance(range_dict, dict) or "start" not in range_dict:
+        return None
+
+    return state.transpiled_to_original_range(_converter.structure(range_dict, types.Range))
+
+
+@server.feature(types.TEXT_DOCUMENT_RENAME)
+async def rename(language_server: FragmentsServer, params: types.RenameParams) -> types.WorkspaceEdit | None:
+    if language_server._pyright is None or params.text_document.uri not in language_server._files:
+        return None
+    state = language_server._files[params.text_document.uri]
+
+    if state is None:
+        result = await language_server._pyright.request(
+            "textDocument/rename",
+            {
+                "textDocument": {"uri": params.text_document.uri},
+                "position": {"line": params.position.line, "character": params.position.character},
+                "newName": params.new_name,
+            },
+        )
+    else:
+        transpiled_position = state.original_to_transpiled_position(params.position)
+        if transpiled_position is None:
+            return None
+        result = await language_server._pyright.request(
+            "textDocument/rename",
+            {
+                "textDocument": {"uri": params.text_document.uri},
+                "position": {"line": transpiled_position.line, "character": transpiled_position.character},
+                "newName": params.new_name,
+            },
+        )
+
+    raw_result = result.get("result")
+    if not raw_result:
+        return None
+
+    edit = _converter.structure(raw_result, types.WorkspaceEdit)
+
+    if edit.changes:
+        for uri in list(edit.changes):
+            file_state = language_server._files.get(uri)
+            if file_state is not None:
+                edit.changes[uri] = _remap_text_edits(edit.changes[uri], file_state)
+
+    if edit.document_changes:
+        for change in edit.document_changes:
+            if isinstance(change, types.TextDocumentEdit):
+                file_state = language_server._files.get(change.text_document.uri)
+                if file_state is not None:
+                    remapped_edits: list[types.TextEdit | types.AnnotatedTextEdit] = []
+                    for text_edit in change.edits:
+                        remapped = file_state.transpiled_to_original_range(text_edit.range)
+                        if remapped is not None:
+                            text_edit.range = remapped
+                            remapped_edits.append(text_edit)
+                    change.edits = remapped_edits
+
+    return edit

fragments/lsp/semantic_tokens.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+from lsprotocol import types
+
+from fragments.lsp.server import FragmentsServer, _TOKEN_MODIFIERS, _TOKEN_TYPES, server
+
+
+@server.feature(
+    types.TEXT_DOCUMENT_SEMANTIC_TOKENS_FULL,
+    types.SemanticTokensLegend(token_types=_TOKEN_TYPES, token_modifiers=_TOKEN_MODIFIERS),
+)
+async def semantic_tokens_full(language_server: FragmentsServer, params: types.SemanticTokensParams) -> types.SemanticTokens:
+    if language_server._pyright is None or params.text_document.uri not in language_server._files:
+        return types.SemanticTokens(data=[])
+    state = language_server._files[params.text_document.uri]
+
+    result = await language_server._pyright.request(
+        "textDocument/semanticTokens/full",
+        {"textDocument": {"uri": params.text_document.uri}},
+    )
+    raw_data = (result.get("result") or {}).get("data") or []
+
+    if state is None:
+        return types.SemanticTokens(data=raw_data)
+
+    output: list[int] = []
+    transpiled_line = transpiled_character = previous_line = previous_character = 0
+    for i in range(0, len(raw_data), 5):
+        delta_line, delta_character, length, token_type, token_modifiers = raw_data[i : i + 5]
+        transpiled_line += delta_line
+        transpiled_character = delta_character if delta_line > 0 else transpiled_character + delta_character
+        if transpiled_line >= len(state.transpiled_line_starts):
+            continue
+        original_position = state.transpiled_to_original_position(types.Position(line=transpiled_line, character=transpiled_character))
+        if original_position is None:
+            continue
+        line, character = original_position.line, original_position.character
+        delta_line = line - previous_line
+        output.extend([delta_line, character if delta_line > 0 else character - previous_character, length, token_type, token_modifiers])
+        previous_line, previous_character = line, character
+
+    return types.SemanticTokens(data=output)

fragments/lsp/server.py

@@ -0,0 +1,129 @@
+from __future__ import annotations
+
+import asyncio
+import sys
+from typing import Any
+
+from lsprotocol import types
+from lsprotocol.converters import get_converter
+from pygls.server import LanguageServer
+
+from fragments import grammar
+from fragments.ast_nodes import ASTFragment
+from fragments.lsp.file_state import _FileState, _build_line_starts, _offset_to_position
+from fragments.lsp.pyright import PyrightClient
+from fragments.source import Source
+
+_converter = get_converter()
+
+_TOKEN_TYPES = ["namespace", "type", "class", "enum", "typeParameter", "parameter", "variable", "property", "enumMember", "function", "method", "keyword", "decorator", "selfParameter", "clsParameter"]
+_TOKEN_MODIFIERS = ["declaration", "definition", "readonly", "static", "async", "defaultLibrary", "builtin", "classMember", "parameter"]
+
+
+class FragmentsServer(LanguageServer):
+    def __init__(self) -> None:
+        super().__init__(
+            "fragments-lsp",
+            "v0.1",
+            text_document_sync_kind=types.TextDocumentSyncKind.Full,
+        )
+        self._pyright: PyrightClient | None = None
+        self._files: dict[str, _FileState | None] = {}
+        self._debounce_tasks: dict[str, asyncio.Task[None]] = {}
+        self._parse_errors: dict[str, types.Diagnostic | None] = {}
+        self._pyright_diagnostics: dict[str, list[types.Diagnostic]] = {}
+
+    def _on_pyright_notification(self, message: dict[str, Any]) -> None:
+        if message.get("method") == "textDocument/publishDiagnostics":
+            _ = asyncio.ensure_future(self._publish_diagnostics(message["params"]))
+
+    async def _on_pyright_request(self, message: dict[str, Any]) -> object:
+        if message["method"] == "workspace/configuration":
+            items = message["params"]["items"]
+            editor_configs = await self.get_configuration_async(
+                types.ConfigurationParams(items=[types.ConfigurationItem(scope_uri=item.get("scopeUri"), section=item.get("section", "")) for item in items])
+            )
+            result: list[dict[str, object] | None] = []
+            for item, config in zip(items, editor_configs):
+                if item.get("section") == "python":
+                    config = {**(config or {}), "pythonPath": sys.executable, "defaultInterpreterPath": sys.executable}
+                result.append(config)  # type: ignore[arg-type]
+            return result
+        return None
+
+    async def _publish_diagnostics(self, params: dict[str, Any]) -> None:
+        uri = params["uri"]
+        state = self._files.get(uri)
+        remapped: list[types.Diagnostic] = []
+
+        for raw_diagnostic in params["diagnostics"]:
+            diagnostic = _converter.structure(raw_diagnostic, types.Diagnostic)
+            if state is not None:
+                remapped_range = state.transpiled_to_original_range(diagnostic.range)
+                if remapped_range is None:
+                    continue
+                diagnostic = types.Diagnostic(
+                    range=remapped_range,
+                    message=diagnostic.message,
+                    severity=diagnostic.severity,
+                    code=diagnostic.code,
+                    source=diagnostic.source,
+                )
+            remapped.append(diagnostic)
+
+        self._pyright_diagnostics[uri] = remapped
+        self._republish_diagnostics(uri)
+
+    def _republish_diagnostics(self, uri: str) -> None:
+        diagnostics = list(self._pyright_diagnostics.get(uri, []))
+        parse_error = self._parse_errors.get(uri)
+        if parse_error is not None:
+            diagnostics.append(parse_error)
+        self.publish_diagnostics(uri, diagnostics)
+
+
+server = FragmentsServer()
+
+
+def _remap_text_edits(text_edits: list[types.TextEdit], state: _FileState) -> list[types.TextEdit]:
+    result: list[types.TextEdit] = []
+    for edit in text_edits:
+        remapped = state.transpiled_to_original_range(edit.range)
+        if remapped is not None:
+            edit.range = remapped
+            result.append(edit)
+    return result
+
+
+def _parse_error_to_diagnostic(text: str, error: grammar.ParsingError) -> types.Diagnostic:
+    line_starts = _build_line_starts(text)
+    position = _offset_to_position(line_starts, min(error.source_start, max(0, len(text) - 1)))
+    return types.Diagnostic(
+        range=types.Range(start=position, end=position),
+        message=str(error),
+        severity=types.DiagnosticSeverity.Error,
+        source="fragments",
+    )
+
+
+def _build_file_state(text: str) -> tuple[_FileState | None, str]:
+    """Parse text and return (state, content_for_pyright).
+
+    Returns (None, text) for pure Python files and (_FileState, transpiled) for fragment files.
+    """
+    if "<>" not in text:
+        return None, text
+    _, module = grammar.expect_module(Source.from_string(text))
+    if not any(isinstance(child, ASTFragment) for child in module.children):
+        return None, text
+    module.transpile()
+    return _FileState(text, module.transpiled_content, module), module.transpiled_content
+
+
+def main() -> None:
+    from fragments.lsp import completion, definition, hover, lifecycle, rename, semantic_tokens  # noqa: F401
+    server.start_io()
+
+
+if __name__ == "__main__":
+    main()

fragments/source.py

@@ -0,0 +1,26 @@
+from dataclasses import dataclass
+
+
+@dataclass(slots=True, frozen=True)
+class Source:
+    content: str
+    offset: int
+
+    def remaining(self) -> str:
+        return self.content[self.offset :]
+
+    def eat(self, chars: int) -> "Source":
+        return Source(self.content, self.offset + chars)
+
+    def eat_whitespace(self) -> "tuple[Source, str]":
+        new_content = self.remaining().lstrip()
+        num_whitespace_chars = len(self.remaining()) - len(new_content)
+        whitespace_chars = self.remaining()[:num_whitespace_chars]
+        return self.eat(num_whitespace_chars), whitespace_chars
+
+    def at_end(self) -> bool:
+        return self.offset == len(self.content)
+
+    @classmethod
+    def from_string(cls, string: str) -> "Source":
+        return Source(string, 0)

fragments/transpiler.py

@@ -0,0 +1,10 @@
+from fragments import grammar
+from fragments.source import Source
+
+
+def transpile(source_string: str) -> str:
+    """Python code up to a fragment."""
+    source: Source = Source.from_string(source_string)
+    source, module = grammar.expect_module(source)
+    module.transpile()
+    return module.transpiled_content