python-delphi-lsp 1.0.0__py3-none-any.whl

delphiast/source_reader.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+
+def read_source_text(path: Path) -> str:
+    data = path.read_bytes()
+    if data.startswith(b'\xff\xfe') or data.startswith(b'\xfe\xff'):
+        return data.decode('utf-16')
+    if data.startswith(b'\xef\xbb\xbf'):
+        return data.decode('utf-8-sig')
+    try:
+        return data.decode('utf-8')
+    except UnicodeDecodeError:
+        return data.decode('latin-1')

delphiast/workspace.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Iterable
+
+from .consts import AttributeName
+from .parser import DelphiParser
+from .semantic import Scope, ScopeKind, SymbolIndex
+from .semantic_builder import SemanticBuilder, SemanticModel
+
+
+@dataclass
+class WorkspaceSemanticResult:
+    models: dict[str, SemanticModel]
+    index: SymbolIndex
+
+
+def build_workspace_semantics(
+    sources: dict[str, str],
+    *,
+    include_paths: Iterable[str] = (),
+    defines: Iterable[str] = (),
+    preprocessor_options=None,
+    collect_references: bool = True,
+) -> WorkspaceSemanticResult:
+    parser = DelphiParser(
+        include_paths=include_paths,
+        defines=defines,
+        preprocessor_options=preprocessor_options,
+    )
+    roots: dict[str, object] = {}
+    for file_name, text in sources.items():
+        result = parser.parse(text, file_name, build_semantic=False)
+        roots[file_name] = result.root
+
+    index = SymbolIndex()
+    scopes: dict[str, Scope] = {}
+    for file_name, root in roots.items():
+        unit_name = root.get_attribute(AttributeName.anName) or file_name
+        unit_scope = Scope(kind=ScopeKind.UNIT, name=unit_name)
+        index.register_unit(unit_name, unit_scope, index_symbols=False)
+        scopes[file_name] = unit_scope
+
+    builder = SemanticBuilder(collect_references=collect_references)
+    for file_name, root in roots.items():
+        builder.declare(root, index=index, unit_scope=scopes[file_name], reset_state=False)
+
+    models: dict[str, SemanticModel] = {}
+    for file_name, root in roots.items():
+        model = builder.resolve(root, scopes[file_name])
+        models[file_name] = model
+
+    return WorkspaceSemanticResult(models=models, index=index)

delphiast/writer.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+from .consts import ATTRIBUTE_NAME_STRINGS, SYNTAX_NODE_NAMES
+from .nodes import CompoundSyntaxNode, SyntaxNode, ValuedSyntaxNode
+
+
+def _xml_encode(data: str) -> str:
+    result = []
+    for ch in data:
+        if ch == '<':
+            result.append('&lt;')
+        elif ch == '>':
+            result.append('&gt;')
+        elif ch == '&':
+            result.append('&amp;')
+        elif ch == '"':
+            result.append('&quot;')
+        elif ch == "'":
+            result.append('&apos;')
+        else:
+            result.append(ch)
+    return ''.join(result)
+
+
+class SyntaxTreeWriter:
+    @staticmethod
+    def to_xml(root: SyntaxNode, formatted: bool = False) -> str:
+        builder: list[str] = []
+        SyntaxTreeWriter._node_to_xml(builder, root, formatted, '')
+        return '<?xml version="1.0"?>\n' + ''.join(builder)
+
+    @staticmethod
+    def _node_to_xml(builder: list[str], node: SyntaxNode, formatted: bool, indent: str) -> None:
+        has_children = node.has_children
+        new_indent = indent + '  '
+        if formatted:
+            builder.append(indent)
+        builder.append('<' + SYNTAX_NODE_NAMES[node.typ].upper())
+
+        if isinstance(node, CompoundSyntaxNode):
+            builder.append(f' begin_line="{node.line}"')
+            builder.append(f' begin_col="{node.col}"')
+            builder.append(f' end_line="{node.end_line}"')
+            builder.append(f' end_col="{node.end_col}"')
+        else:
+            builder.append(f' line="{node.line}"')
+            builder.append(f' col="{node.col}"')
+
+        if node.file_name:
+            builder.append('  file="' + _xml_encode(node.file_name) + '"')
+
+        if isinstance(node, ValuedSyntaxNode):
+            builder.append(' value="' + _xml_encode(node.value) + '"')
+
+        for attr_key, attr_value in node.attributes:
+            builder.append(
+                ' ' + ATTRIBUTE_NAME_STRINGS[attr_key] + '="' + _xml_encode(attr_value) + '"'
+            )
+
+        if has_children:
+            builder.append('>')
+        else:
+            builder.append('/>')
+        if formatted:
+            builder.append('\n')
+        for child in node.child_nodes:
+            SyntaxTreeWriter._node_to_xml(builder, child, formatted, new_indent)
+        if has_children:
+            if formatted:
+                builder.append(indent)
+            builder.append('</' + SYNTAX_NODE_NAMES[node.typ].upper() + '>')
+            if formatted:
+                builder.append('\n')

python_delphi_lsp-1.0.0.dist-info/METADATA

@@ -0,0 +1,280 @@
+Metadata-Version: 2.4
+Name: python-delphi-lsp
+Version: 1.0.0
+Summary: Python Delphi/Object Pascal parser, semantic indexer, and language server.
+Author: Dark Light
+License-Expression: MPL-2.0
+Keywords: delphi,object-pascal,pascal,lsp,language-server,parser
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Compilers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: lark>=1.1.9
+Requires-Dist: pygls<2.0,>=1.3.0
+Requires-Dist: lsprotocol>=2023.0.1
+Provides-Extra: lsp
+Requires-Dist: pygls<2.0,>=1.3.0; extra == "lsp"
+Requires-Dist: lsprotocol>=2023.0.1; extra == "lsp"
+Provides-Extra: test
+Requires-Dist: pytest>=8.0.0; extra == "test"
+Provides-Extra: dev
+Requires-Dist: build>=1.2.0; extra == "dev"
+Requires-Dist: twine>=5.0.0; extra == "dev"
+Requires-Dist: pygls<2.0,>=1.3.0; extra == "dev"
+Requires-Dist: lsprotocol>=2023.0.1; extra == "dev"
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Dynamic: license-file
+
+# Python Delphi LSP
+
+Python Delphi LSP is a standalone Python package for Delphi/Object Pascal
+parsing, semantic indexing, diagnostics, and Language Server Protocol support.
+
+The distributable package is named `python-delphi-lsp`. The import package keeps
+the established `delphiast` name, and the language-server executable is
+`delphi-lsp`.
+
+## What It Provides
+
+- Parser support for `.pas`, `.dpr`, `.dpk`, and `.inc` files
+- Delphi preprocessor handling for include files, conditionals, and compiler
+  directives
+- Semantic symbols for units, types, methods, fields, properties, variables,
+  constants, and references
+- Workspace indexing across Delphi projects
+- LSP support for document symbols, workspace symbols, hover, definition,
+  references, rename, completion, and diagnostics
+- opencode integration through the experimental LSP tool
+
+## Installation
+
+Install the package from a built distribution or from PyPI once published:
+
+```bash
+python -m pip install python-delphi-lsp
+```
+
+For development from a checkout:
+
+```bash
+python -m venv .venv
+. .venv/bin/activate
+python -m pip install -e ".[dev]"
+python -m pytest -q
+```
+
+On Windows PowerShell:
+
+```powershell
+python -m venv .venv
+.\.venv\Scripts\Activate.ps1
+python -m pip install -e ".[dev]"
+python -m pytest -q
+```
+
+## Python API Example
+
+```python
+from delphiast import parse
+
+result = parse("unit Unit1; interface implementation end.", "Unit1.pas")
+print(result.root)
+```
+
+Enable semantic analysis when you need symbols or diagnostics:
+
+```python
+from delphiast import parse
+
+source = """
+unit Unit1;
+
+interface
+
+type
+  TGreeter = class
+  public
+    procedure SayHello;
+  end;
+
+implementation
+
+procedure TGreeter.SayHello;
+begin
+end;
+
+end.
+"""
+
+result = parse(source, "Unit1.pas", build_semantic=True)
+for symbol in result.semantic.symbols:
+    print(symbol.name, symbol.kind)
+```
+
+## Language Server Usage
+
+Start the LSP server over stdio:
+
+```bash
+delphi-lsp
+```
+
+From a checkout, the equivalent command is:
+
+```bash
+python -m delphiast.lsp_server
+```
+
+The server expects normal LSP JSON-RPC over stdio. Editors and tools should set
+the workspace root to the Delphi project directory and pass any include paths or
+compiler defines through LSP initialization options when needed.
+
+## opencode Usage
+
+This repository includes an `opencode.json` that registers the Delphi LSP tool
+and model aliases for local Ollama and vLLM endpoints.
+
+For normal local opencode work, use the Ollama alias with a larger context:
+
+```bash
+opencode run --dir . --model ollama/ornith-lspctx
+```
+
+For large Delphi files, prefer LSP operations over reading the file into the
+model prompt. The reduced `vllm-lsp` agent disables filesystem and shell tools
+and leaves only the LSP tool enabled:
+
+```bash
+OPENCODE_EXPERIMENTAL_LSP_TOOL=true \
+python scripts/run_opencode_lsp_probe.py \
+  --cwd output/mega_lsp_chain_project \
+  --model vllm/ornith-lspctx \
+  --agent vllm-lsp \
+  --require-tool lsp.workspaceSymbol:MegaProc02500 \
+  --forbid-tool bash --forbid-tool read --forbid-tool glob --forbid-tool grep \
+  --forbid-tool edit --forbid-tool write --forbid-tool task \
+  --forbid-tool webfetch --forbid-tool todowrite --forbid-tool skill \
+  'Use only the Delphi LSP tool. In file Mega100kUnit.pas, run workspaceSymbol with filePath "Mega100kUnit.pas", line 1, character 1, and query "MegaProc02500".'
+```
+
+For an LSP-first edit proof, use `vllm-lsp-edit`. It permits the opencode edit
+tool after LSP lookup while still forbidding shell and direct file-reading tools:
+
+```bash
+OPENCODE_EXPERIMENTAL_LSP_TOOL=true \
+python scripts/run_opencode_lsp_probe.py \
+  --cwd output/mega_lsp_chain_project \
+  --model vllm/ornith-lspctx \
+  --agent vllm-lsp-edit \
+  --require-tool lsp.workspaceSymbol:MegaProc02500 \
+  --require-tool 'edit:Edit applied successfully' \
+  --forbid-tool bash --forbid-tool read --forbid-tool glob --forbid-tool grep \
+  --forbid-tool write --forbid-tool task --forbid-tool webfetch \
+  --forbid-tool todowrite --forbid-tool skill \
+  'Use LSP first, then edit the exact MegaProc02500 block.'
+```
+
+## Reproducing the vLLM opencode Test
+
+The vLLM test is designed to prove that opencode can work on Delphi files larger
+than the model context by calling LSP instead of loading the source file into the
+prompt.
+
+The test does the following:
+
+1. Creates `output/mega_lsp_chain_project/Mega100kUnit.pas`, a generated Delphi
+   unit with more than 100,000 lines and the symbol `MegaProc02500`.
+2. Writes an opencode sandbox config with an absolute `delphi-lsp` command and
+   `PYTHONPATH` pointing at the checkout.
+3. Uses `vllm/ornith-lspctx` with the reduced `vllm-lsp` agent.
+4. Requires a completed `lsp.workspaceSymbol` tool call that returns
+   `MegaProc02500`.
+5. Fails immediately if opencode calls `read`, `bash`, `glob`, `grep`, `edit`,
+   `write`, `task`, `webfetch`, `todowrite`, or `skill`.
+
+On macOS, start the local vLLM helper and run the proof:
+
+```bash
+scripts/bootstrap_vllm_opencode_test.sh --start-vllm
+```
+
+By default the vLLM helper is offline-only. It checks the Hugging Face cache and
+does not download model shards. Pass `--allow-download` only when you explicitly
+want the helper to fill missing cache files.
+
+On Windows PowerShell, use an already running vLLM-compatible endpoint:
+
+```powershell
+.\scripts\bootstrap_vllm_opencode_test.ps1 -UseRunningServer
+```
+
+Use a custom endpoint when vLLM runs in WSL, Docker, or on another machine:
+
+```powershell
+.\scripts\bootstrap_vllm_opencode_test.ps1 -UseRunningServer -BaseUrl "http://127.0.0.1:8001/v1"
+```
+
+The macOS helper uses these defaults:
+
+- `MODEL_ID=deepreinforce-ai/Ornith-1.0-9B`
+- `SERVED_MODEL_NAME=ornith-vllm-metal`
+- `MAX_MODEL_LEN=44352`
+- `MAX_NUM_SEQS=1`
+- `VLLM_METAL_MEMORY_FRACTION=0.97`
+- `TOOL_CALL_PARSER=qwen3_xml`
+
+The release evidence from the local proof recorded:
+
+- default opencode request: 29,318 system-prompt characters and 10 tool schemas
+- reduced LSP-only request: 8,978 system-prompt characters and 1 tool schema
+- generated test unit: 117k lines
+- GitHub corpus file: 14,309 lines
+- `context_budget.status = "pass"`
+- `goal_audit.status = "pass"`
+
+## Verification
+
+Run the local test suite:
+
+```bash
+python -m pytest -q
+```
+
+Generate the Delphi language-feature matrix:
+
+```bash
+python scripts/audit_delphi_language_features.py
+```
+
+Build and check distributable artifacts:
+
+```bash
+python -m build
+python -m twine check dist/*
+```
+
+## Repository Layout
+
+- `delphiast/` - parser, preprocessor, semantic model, workspace indexer, and
+  LSP server
+- `scripts/` - release evidence, cache checks, opencode probes, and bootstrap
+  helpers
+- `tests/` - parser, semantic, workspace, diagnostics, packaging, and LSP tests
+- `tests/fixtures/` - Delphi/Object Pascal fixtures and legacy DelphiAST snippets
+
+## License
+
+This project is licensed under the Mozilla Public License 2.0. See
+[`LICENSE`](LICENSE).

python_delphi_lsp-1.0.0.dist-info/RECORD

@@ -0,0 +1,23 @@
+delphiast/__init__.py,sha256=_xUB7JH_ll0b5RSnpPPveDa82GMUeLW8P-Z8bQ7J_HY,3132
+delphiast/binary.py,sha256=40mEpE0SBYmifwEoNHwSU7IU_D2usVyWYWHJ73aDfoo,8529
+delphiast/comment_builder.py,sha256=XvFW7WTbYy7yGN3MG40gtabTvhGj1ea1MYkySDbVMDA,832
+delphiast/consts.py,sha256=qM40iwxXmvEileWHJVLMYlQSkLoLyQaqM-Zscz3VJbs,5958
+delphiast/grammar.py,sha256=QWEMSUKr0e1xlJOveZtp7K-MvhlkvDgxkD0iUKIyxKU,18577
+delphiast/lark_builder.py,sha256=KTXxr5WrLMvzdb0F71JMzFqExLiEPF1_cwGrZkurgqQ,118651
+delphiast/lark_tokens.py,sha256=xT_GES2z6p1IdN3EnoKE9RcUM6suu1RV3J-0FEJN2r8,4176
+delphiast/lsp_server.py,sha256=Gyj3Vyi2PK-llGDpbzXipN8Jh-k4nR9Z4gEIk7sqZFY,55848
+delphiast/nodes.py,sha256=LW8KUgNCg9MHK_2NmzrgCMMJNcBwa4C76XwKoS7kt4E,13556
+delphiast/parser.py,sha256=4hckHD_fsiiUe3oeSRJwqbY8bDWqJaYLsU10NYDIW6E,6025
+delphiast/preprocessor.py,sha256=X58ZUfI7Hifg-7KYomOF0BZEp-jl1NFGyNl9VCu6wtU,29935
+delphiast/project_indexer.py,sha256=DuEx9Nb8-DLHes9xis-G4fj9xxG3r0fbXziODzu95Bc,10946
+delphiast/semantic.py,sha256=egQ-_AjmnAATvL1hRUfjd4FDapFxdwi5rt8QExb0POc,9818
+delphiast/semantic_builder.py,sha256=ulA7xHJpltjc6cTo5wh9yTcYazuIykM-YLMXD1h-wzk,58680
+delphiast/source_reader.py,sha256=8QDSNfoVHw5yCGxyx9m8RnYK4TOuA60abA7zElv6pDg,434
+delphiast/workspace.py,sha256=fm7eoT-ydmnIIMnPg9i46EuIssRWLrdAnunByYRBeeA,1750
+delphiast/writer.py,sha256=j-cnyiHFNOTFECL7Ehm-m43ye7ev7qFeCCscFMjrAOY,2503
+python_delphi_lsp-1.0.0.dist-info/licenses/LICENSE,sha256=-rPda9qyJvHAhjCx3ZF-Efy07F4eAg4sFvg6ChOGPoU,16726
+python_delphi_lsp-1.0.0.dist-info/METADATA,sha256=Jwb5Y2dZI_JLi5eFZcRb9jfK_5F3eS8c4B4D-NMS-V8,8436
+python_delphi_lsp-1.0.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+python_delphi_lsp-1.0.0.dist-info/entry_points.txt,sha256=717MgJShYC9J2yZ7b-LCFdEnekxgzCYt5VcyoiGKxOI,57
+python_delphi_lsp-1.0.0.dist-info/top_level.txt,sha256=QN4e-RYdERIS9p1qljv_D2llVQtw0pOaN7tvIxZhLSU,10
+python_delphi_lsp-1.0.0.dist-info/RECORD,,

python_delphi_lsp-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

python_delphi_lsp-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+delphi-lsp = delphiast.lsp_server:main