avrae-ls 0.3.1__py3-none-any.whl → 0.4.0__py3-none-any.whl

avrae_ls/server.py

@@ -18,7 +18,7 @@ from .alias_preview import render_alias_command, simulate_command
 from .parser import find_draconic_blocks
 from .signature_help import load_signatures, signature_help_for_code
 from .completions import gather_suggestions, completion_items_for_position, hover_for_position
-from .symbols import build_symbol_table, document_symbols, find_definition_range
+from .symbols import build_symbol_table, document_symbols, find_definition_range, find_references, range_for_word
 from .argument_parsing import apply_argument_parsing
 
 __version__ = "0.1.0"
@@ -142,6 +142,43 @@ def on_definition(server: AvraeLanguageServer, params: types.DefinitionParams):
     return types.Location(uri=params.text_document.uri, range=rng)
 
 
+@ls.feature(types.TEXT_DOCUMENT_REFERENCES)
+def on_references(server: AvraeLanguageServer, params: types.ReferenceParams):
+    doc = server.workspace.get_text_document(params.text_document.uri)
+    table = build_symbol_table(doc.source)
+    word = doc.word_at_position(params.position)
+    if not word or not table.lookup(word):
+        return []
+
+    ranges = find_references(table, doc.source, word, include_declaration=params.context.include_declaration)
+    return [types.Location(uri=params.text_document.uri, range=rng) for rng in ranges]
+
+
+@ls.feature(types.TEXT_DOCUMENT_PREPARE_RENAME)
+def on_prepare_rename(server: AvraeLanguageServer, params: types.PrepareRenameParams):
+    doc = server.workspace.get_text_document(params.text_document.uri)
+    table = build_symbol_table(doc.source)
+    word = doc.word_at_position(params.position)
+    if not word or not table.lookup(word):
+        return None
+    return range_for_word(doc.source, params.position)
+
+
+@ls.feature(types.TEXT_DOCUMENT_RENAME)
+def on_rename(server: AvraeLanguageServer, params: types.RenameParams):
+    doc = server.workspace.get_text_document(params.text_document.uri)
+    table = build_symbol_table(doc.source)
+    word = doc.word_at_position(params.position)
+    if not word or not table.lookup(word) or not params.new_name:
+        return None
+
+    ranges = find_references(table, doc.source, word, include_declaration=True)
+    if not ranges:
+        return None
+    edits = [types.TextEdit(range=rng, new_text=params.new_name) for rng in ranges]
+    return types.WorkspaceEdit(changes={params.text_document.uri: edits})
+
+
 @ls.feature(types.WORKSPACE_SYMBOL)
 def on_workspace_symbol(server: AvraeLanguageServer, params: types.WorkspaceSymbolParams):
     symbols: list[types.SymbolInformation] = []

avrae_ls/symbols.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import ast
 import logging
 from dataclasses import dataclass
-from typing import Dict, List, Optional
+from typing import Dict, Iterable, List, Optional
 
 import draconic
 from lsprotocol import types
@@ -40,10 +40,10 @@ def build_symbol_table(source: str) -> SymbolTable:
     parsed_source = apply_argument_parsing(source)
     blocks = find_draconic_blocks(parsed_source)
     if not blocks:
-        entries.extend(_symbols_from_code(parsed_source, 0))
+        entries.extend(_symbols_from_code(parsed_source, 0, 0))
     else:
         for block in blocks:
-            entries.extend(_symbols_from_code(block.code, block.line_offset))
+            entries.extend(_symbols_from_code(block.code, block.line_offset, block.char_offset))
     return SymbolTable(entries)
 
 
@@ -67,31 +67,72 @@ def find_definition_range(table: SymbolTable, name: str) -> types.Range | None:
     return None
 
 
-def _symbols_from_code(code: str, line_offset: int) -> List[SymbolEntry]:
-    parser = draconic.DraconicInterpreter()
-    local_offset = line_offset
-    try:
-        body = parser.parse(code)
-    except draconic.DraconicSyntaxError:
-        wrapped, added = _wrap_draconic(code)
-        try:
-            body = parser.parse(wrapped)
-            local_offset += -added
-        except draconic.DraconicSyntaxError:
-            return []
-    except Exception as exc:  # pragma: no cover - defensive
-        log.debug("Symbol extraction failed: %s", exc)
+def find_references(
+    table: SymbolTable, source: str, name: str, include_declaration: bool = True
+) -> List[types.Range]:
+    parsed_source = apply_argument_parsing(source)
+    ranges: list[types.Range] = []
+    entry = table.lookup(name)
+    include_stores = include_declaration and entry is None
+    if include_declaration:
+        if entry:
+            ranges.append(entry.selection_range)
+
+    blocks = find_draconic_blocks(parsed_source)
+    if not blocks:
+        ranges.extend(_references_from_code(parsed_source, name, 0, 0, include_stores))
+    else:
+        for block in blocks:
+            ranges.extend(
+                _references_from_code(block.code, name, block.line_offset, block.char_offset, include_stores)
+            )
+    return _dedupe_ranges(ranges)
+
+
+def range_for_word(source: str, position: types.Position) -> types.Range | None:
+    lines = source.splitlines()
+    if position.line >= len(lines):
+        return None
+    line = lines[position.line]
+    if position.character > len(line):
+        return None
+
+    def _is_ident(ch: str) -> bool:
+        return ch.isalnum() or ch == "_"
+
+    start_idx = position.character
+    while start_idx > 0 and _is_ident(line[start_idx - 1]):
+        start_idx -= 1
+
+    end_idx = position.character
+    while end_idx < len(line) and _is_ident(line[end_idx]):
+        end_idx += 1
+
+    if start_idx == end_idx:
+        return None
+
+    return types.Range(
+        start=types.Position(line=position.line, character=start_idx),
+        end=types.Position(line=position.line, character=end_idx),
+    )
+
+
+def _symbols_from_code(code: str, line_offset: int, char_offset: int) -> List[SymbolEntry]:
+    body, offset_adjust = _parse_draconic(code)
+    if not body:
         return []
 
+    local_offset = line_offset + offset_adjust
+
     entries: list[SymbolEntry] = []
     for node in body:
-        entry = _entry_from_node(node, local_offset)
+        entry = _entry_from_node(node, local_offset, char_offset)
         if entry:
             entries.append(entry)
     return entries
 
 
-def _entry_from_node(node: ast.AST, line_offset: int = 0) -> SymbolEntry | None:
+def _entry_from_node(node: ast.AST, line_offset: int = 0, char_offset: int = 0) -> SymbolEntry | None:
     if isinstance(node, ast.FunctionDef):
         kind = types.SymbolKind.Function
         name = node.name
@@ -103,6 +144,7 @@ def _entry_from_node(node: ast.AST, line_offset: int = 0) -> SymbolEntry | None:
         if isinstance(target, ast.Name):
             kind = types.SymbolKind.Variable
             name = target.id
+            node = target
         else:
             return None
     else:
@@ -110,37 +152,99 @@ def _entry_from_node(node: ast.AST, line_offset: int = 0) -> SymbolEntry | None:
 
     rng = _range_from_positions(
         getattr(node, "lineno", 1),
-        getattr(node, "col_offset", 0) + 1,
+        getattr(node, "col_offset", 0),
         getattr(node, "end_lineno", None),
         getattr(node, "end_col_offset", None),
     )
-    rng = _shift_range(rng, line_offset)
+    rng = _shift_range(rng, line_offset, char_offset)
     return SymbolEntry(name=name, kind=kind, range=rng, selection_range=rng)
 
 
+class _ReferenceCollector(ast.NodeVisitor):
+    def __init__(self, target: str, include_stores: bool):
+        super().__init__()
+        self._target = target
+        self._include_stores = include_stores
+        self.ranges: list[types.Range] = []
+
+    def visit_Name(self, node: ast.Name):  # type: ignore[override]
+        if node.id == self._target:
+            if isinstance(node.ctx, ast.Store) and not self._include_stores:
+                return
+            rng = _range_from_positions(
+                getattr(node, "lineno", 1),
+                getattr(node, "col_offset", 0),
+                getattr(node, "end_lineno", None),
+                getattr(node, "end_col_offset", None),
+            )
+            self.ranges.append(rng)
+        self.generic_visit(node)
+
+
+def _references_from_code(
+    code: str,
+    name: str,
+    line_offset: int,
+    char_offset: int,
+    include_stores: bool,
+) -> List[types.Range]:
+    body, offset_adjust = _parse_draconic(code)
+    if not body:
+        return []
+
+    collector = _ReferenceCollector(name, include_stores)
+    for node in body:
+        collector.visit(node)
+
+    local_offset = line_offset + offset_adjust
+    return [_shift_range(rng, local_offset, char_offset) for rng in collector.ranges]
+
+
+def _parse_draconic(code: str) -> tuple[list[ast.AST], int]:
+    parser = draconic.DraconicInterpreter()
+    try:
+        return parser.parse(code), 0
+    except draconic.DraconicSyntaxError:
+        wrapped, added = _wrap_draconic(code)
+        try:
+            return parser.parse(wrapped), -added
+        except draconic.DraconicSyntaxError:
+            return [], 0
+    except Exception as exc:  # pragma: no cover - defensive
+        log.debug("Symbol extraction failed: %s", exc)
+        return [], 0
+
+
 def _range_from_positions(
     lineno: int | None,
     col_offset: int | None,
     end_lineno: int | None,
     end_col_offset: int | None,
 ) -> types.Range:
-    start = types.Position(
-        line=max((lineno or 1) - 1, 0),
-        character=max((col_offset or 1) - 1, 0),
-    )
-    end = types.Position(
-        line=max(((end_lineno or lineno or 1) - 1), 0),
-        character=max(((end_col_offset or col_offset or 1) - 1), 0),
+    start_line = max((lineno or 1) - 1, 0)
+    start_char = max(col_offset or 0, 0)
+    end_line = max(((end_lineno or lineno or 1) - 1), 0)
+    raw_end_char = end_col_offset if end_col_offset is not None else col_offset
+    end_char = max(raw_end_char or start_char, start_char)
+    if end_char <= start_char:
+        end_char = start_char + 1
+    return types.Range(
+        start=types.Position(line=start_line, character=start_char),
+        end=types.Position(line=end_line, character=end_char),
     )
-    return types.Range(start=start, end=end)
 
 
-def _shift_range(rng: types.Range, line_offset: int) -> types.Range:
+def _shift_range(rng: types.Range, line_offset: int, char_offset: int = 0) -> types.Range:
+    start_char = rng.start.character + (char_offset if rng.start.line == 0 else 0)
+    end_char = rng.end.character + (char_offset if rng.end.line == 0 else 0)
     if line_offset == 0:
-        return rng
+        return types.Range(
+            start=types.Position(line=rng.start.line, character=start_char),
+            end=types.Position(line=rng.end.line, character=end_char),
+        )
     return types.Range(
-        start=types.Position(line=max(rng.start.line + line_offset, 0), character=rng.start.character),
-        end=types.Position(line=max(rng.end.line + line_offset, 0), character=rng.end.character),
+        start=types.Position(line=max(rng.start.line + line_offset, 0), character=max(start_char, 0)),
+        end=types.Position(line=max(rng.end.line + line_offset, 0), character=max(end_char, 0)),
     )
 
 
@@ -148,3 +252,15 @@ def _wrap_draconic(code: str) -> tuple[str, int]:
     indented = "\n".join(f"    {line}" for line in code.splitlines())
     wrapped = f"def __alias_main__():\n{indented}\n__alias_main__()"
     return wrapped, 1
+
+
+def _dedupe_ranges(ranges: Iterable[types.Range]) -> List[types.Range]:
+    seen = set()
+    unique: list[types.Range] = []
+    for rng in ranges:
+        key = (rng.start.line, rng.start.character, rng.end.line, rng.end.character)
+        if key in seen:
+            continue
+        seen.add(key)
+        unique.append(rng)
+    return unique

avrae_ls-0.4.0.dist-info/METADATA

@@ -0,0 +1,86 @@
+Metadata-Version: 2.4
+Name: avrae-ls
+Version: 0.4.0
+Summary: Language server for Avrae draconic aliases
+Author: 1drturtle
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pygls>=1.3.1
+Requires-Dist: lsprotocol>=2023.0.1
+Requires-Dist: httpx>=0.27
+Requires-Dist: d20>=1.1.2
+Provides-Extra: dev
+Requires-Dist: pytest>=8.3; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23; extra == "dev"
+Requires-Dist: pytest-cov>=7.0.0; extra == "dev"
+Requires-Dist: ruff>=0.6; extra == "dev"
+Dynamic: license-file
+
+# Avrae Draconic Alias Language Server
+
+Language Server Protocol (LSP) implementation targeting Avrae-style draconic aliases. It provides syntax/semantic diagnostics, a mocked execution command, and a thin configuration layer driven by a workspace `.avraels.json` file. Credit to Avrae team for all code yoinked!
+
+## Install (released package)
+
+- CLI/server via `uv tool` (preferred): `uv tool install avrae-ls` then `avrae-ls --help` to see stdio/TCP options (same as `python -m avrae_ls`). The VS Code extension uses this invocation by default. The draconic interpreter is vendored, so no Git deps are needed.
+
+## VS Code extension (released)
+
+- Install from VSIX: download `avrae-ls-client.vsix` from the GitHub releases page, then in VS Code run “Extensions: Install from VSIX” and select the file.
+- Open your alias workspace; commands like `Avrae: Show Alias Preview` and `Avrae: Run Alias` will be available.
+
+## Developing locally
+
+- Prereqs: [uv](https://github.com/astral-sh/uv) and Node.js.
+- Install deps: `uv sync --all-extras` then `make vscode-deps`.
+- Build everything locally: `make package` (wheel + VSIX in `dist/`).
+- Run tests/lint: `make check`.
+- Run via uv tool from source: `uv tool install --from . avrae-ls`.
+- Run diagnostics for a single file (stdout + stderr logs): `avrae-ls --analyze path/to/alias.txt --log-level DEBUG`.
+
+## How to test
+
+- Quick check (ruff + pytest): `make check` (uses `uv run ruff` and `uv run pytest` under the hood).
+- Lint only: `make lint` or `uv run ruff check src tests`.
+- Tests only (with coverage): `make test` or `uv run pytest tests --cov=src`.
+- CLI smoke test without installing: `uv run python -m avrae_ls --analyze path/to/alias.txt`.
+
+## Runtime differences (mock vs. live Avrae)
+
+- Mock execution never writes back to Avrae: cvar/uvar/gvar mutations only live for the current run and reset before the next.
+- Network is limited to gvar fetches (when `enableGvarFetch` is true) and `verify_signature`; other Avrae/Discord calls are replaced with mocked context data from `.avraels.json`.
+- `get_gvar`/`using` values are pulled from local var files first; remote fetches go to `https://api.avrae.io/customizations/gvars/<id>` (or your `avraeService.baseUrl`) using `avraeService.token` and are cached for the session.
+- `signature()` returns a mock string (`mock-signature:<int>`). `verify_signature()` POSTs to `/bot/signature/verify`, respects `verifySignatureTimeout`/`verifySignatureRetries`, reuses the last successful response per signature, and includes `avraeService.token` if present.
+
+## Troubleshooting gvar fetch / verify_signature
+
+- `get_gvar` returns `None` or `using(...)` raises `ModuleNotFoundError`: ensure the workspace `.avraels.json` sets `enableGvarFetch: true`, includes a valid `avraeService.token`, or seed the gvar in a var file referenced by `varFiles`.
+- HTTP 401/403/404 from fetch/verify calls: check the token (401/403) and the gvar/signature id (404). Override `avraeService.baseUrl` if you mirror the API.
+- Slow or flaky calls: tune `verifySignatureTimeout` / `verifySignatureRetries`, or disable remote fetches by flipping `enableGvarFetch` off to rely purely on local vars.
+
+## Other editors (stdio)
+
+- Any client can launch the server with stdio: `avrae-ls --stdio` (flag accepted for client compatibility) or `python -m avrae_ls`. The server will also auto-discover `.avraels.json` in parent folders.
+- Neovim (nvim-lspconfig example):
+  ```lua
+  require("lspconfig").avraels.setup({
+    cmd = { "avrae-ls", "--stdio" },
+    filetypes = { "avrae" },
+    root_dir = require("lspconfig.util").root_pattern(".avraels.json", ".git"),
+  })
+  ```
+- Emacs (lsp-mode snippet):
+  ```elisp
+  (lsp-register-client
+   (make-lsp-client
+    :new-connection (lsp-stdio-connection '("avrae-ls" "--stdio"))
+    :major-modes '(fundamental-mode)  ;; bind to your Avrae alias mode
+    :server-id 'avrae-ls))
+  ```
+- VS Code commands to mirror: `Avrae: Run Alias (Mock)`, `Avrae: Show Alias Preview`, and `Avrae: Reload Workspace Config` run against the same server binary.
+
+## Releasing (maintainers)
+
+1. Bump `pyproject.toml` / `package.json`
+2. Create Github release

{avrae_ls-0.3.1.dist-info → avrae_ls-0.4.0.dist-info}/RECORD

@@ -1,21 +1,21 @@
 avrae_ls/__init__.py,sha256=BmjrnksGkbG7TPqwbyQvgYj9uei8pFSFpfkRpaGVdJU,63
 avrae_ls/__main__.py,sha256=ch287lWe11go5xHAE9OkVppixt0vRF401E4zTs2tqQ0,3557
 avrae_ls/alias_preview.py,sha256=Wy_ZNRq73ojPiLFf6P6fJ7rG7DeFFsFLkLlhFrAjkKI,6117
-avrae_ls/api.py,sha256=sGbwWs5o6M49lyk3qZi6gNdSH_u_BMdghsTlAjpviqQ,64852
-avrae_ls/argparser.py,sha256=-6RKrXavbSjEyyEeaoz8hRamnB-MEmJt3Cw2smRbmdI,13483
+avrae_ls/api.py,sha256=_AHvIEIlz34YeWdZDpXd1EwgdQUGk8-nqNIEN4qdNR8,65093
+avrae_ls/argparser.py,sha256=DRptXGyK4f0r7NsuV1Sg4apG-qihIClOX408jgk4HH4,13762
 avrae_ls/argument_parsing.py,sha256=ezKl65VwuNEDxt6KlYwVQcpy1110UDvf4BqZqgZTcqk,2122
-avrae_ls/completions.py,sha256=WSyP967_t_oBhRMjLk-QQKyXWiNh4sJTH560VdMBQeg,34336
-avrae_ls/config.py,sha256=C51wfG6-82uX4dsffqcDLMiXbZZL9JQgfpulAr8eiqs,15267
-avrae_ls/context.py,sha256=w0uVSR6Pis3q1fF3kSPsqbTirKOE6n3k2XMO8UZI7sk,5719
+avrae_ls/completions.py,sha256=ht0J7JQX5QS8cz85itfozLBP9GPr1BjmNyttFEmJN-0,34514
+avrae_ls/config.py,sha256=ULEfWbzIO05cllHBLUeGY_CHLpX6tHyCJYIEQgKSoXc,17383
+avrae_ls/context.py,sha256=KcCKqzqJCG2xlEtou5HWz1OWISApGl8IfwOvVnNi9nc,8464
 avrae_ls/cvars.py,sha256=0tcVbUHx_CKJ6aou3kEsKX37LRWAjkUWlqqIuSRFlXk,3197
-avrae_ls/diagnostics.py,sha256=EAdbckvvWu0pswopaZ6JyVGCHXUl5ZvGBhP2PDVCrVw,16180
+avrae_ls/diagnostics.py,sha256=2wn9Gu5vDGWt32zap9rhduv4q4B9c_X3baI2_yDHGYg,23074
 avrae_ls/dice.py,sha256=DY7V7L-EwAXaCgddgVe9xU1s9lVtiw5Zc2reipNgdTk,874
-avrae_ls/parser.py,sha256=AuNxNkkfquN9dcyTpmzAZxWcAQ7CV3PQLHUDYLMz_7U,1148
-avrae_ls/runtime.py,sha256=sSN_C48TrF7F5NtsUpgHr_cZyYX6HCQHBfCpAYxsDJo,20792
-avrae_ls/server.py,sha256=L3qGTpCDOa64hWFmfWfoKbrDZ3262gmu5wYhHkdLBPY,13070
+avrae_ls/parser.py,sha256=UQDwjupuJVU6KvoF4D8r3azPT7ksP_nTZsm5FUhGnWE,1395
+avrae_ls/runtime.py,sha256=PDnjZXcU5DqM9jKSc4S0jHObBE7SWKte17PWWXGQ34M,23356
+avrae_ls/server.py,sha256=jKypzveP2iRZjEdK0xJxfcn6QfbjrDe03XnXNhsga9Q,14709
 avrae_ls/signature_help.py,sha256=JheaEzINV4FO72t5U0AJfL2ZX15y3-gcA6xk3M1jHcY,6980
-avrae_ls/symbols.py,sha256=8aMalHBDnRsRvhwdbmf0nOazio7G185qw9le45Xb5Mk,4449
-avrae_ls-0.3.1.dist-info/licenses/LICENSE,sha256=O-0zMbcEi6wXz1DiSdVgzMlQjJcNqNe5KDv08uYzqR0,1055
+avrae_ls/symbols.py,sha256=Lm5LH-F60JYNuAtSjRhHeyHEWAWxpnNb0w6KR0u1Zac,8422
+avrae_ls-0.4.0.dist-info/licenses/LICENSE,sha256=O-0zMbcEi6wXz1DiSdVgzMlQjJcNqNe5KDv08uYzqR0,1055
 draconic/LICENSE,sha256=Fzvu32_DafLKKn2mzxhEdlmrKZzAsigDZ87O7uoVqZI,1067
 draconic/__init__.py,sha256=YPH420Pcn_nTkfB62hJy_YqC5kpJdzSa78jP8n4z_xY,109
 draconic/exceptions.py,sha256=siahnHIsumbaUhKBDSrw_DmLZ-0oZks8L5oytPH8hD4,3753
@@ -25,8 +25,8 @@ draconic/string.py,sha256=kGrRc6wNHRq1y5xw8Os-fBhfINDtIY2nBWQWkyLSfQI,2858
 draconic/types.py,sha256=1Lsr6z8bW5agglGI4hLt_nPtYuZOIf_ueSpPDB4WDrs,13686
 draconic/utils.py,sha256=D4vJ-txqS2-rlqsEpXAC46_j1sZX4UjY-9zIgElo96k,3122
 draconic/versions.py,sha256=CUEsgUWjAmjez0432WwiBwZlIzWPIObwZUf8Yld18EE,84
-avrae_ls-0.3.1.dist-info/METADATA,sha256=TRJQs5mkNC4TPeYBkO2rXDnvkJhjf2jws1ginLXaXq4,2107
-avrae_ls-0.3.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-avrae_ls-0.3.1.dist-info/entry_points.txt,sha256=OtYXipMQzqmxpMoApgo0MeJYFmMbkbFN51Ibhpb8hF4,52
-avrae_ls-0.3.1.dist-info/top_level.txt,sha256=TL68uzGHmB2R2ID32_s2zocmcNnpMJVQ6_4NBvyo8a4,18
-avrae_ls-0.3.1.dist-info/RECORD,,
+avrae_ls-0.4.0.dist-info/METADATA,sha256=z-bp7Y2zrilkbNmLujQYnHOW6rRlAyPMdQpJBDUB4cU,4713
+avrae_ls-0.4.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+avrae_ls-0.4.0.dist-info/entry_points.txt,sha256=OtYXipMQzqmxpMoApgo0MeJYFmMbkbFN51Ibhpb8hF4,52
+avrae_ls-0.4.0.dist-info/top_level.txt,sha256=TL68uzGHmB2R2ID32_s2zocmcNnpMJVQ6_4NBvyo8a4,18
+avrae_ls-0.4.0.dist-info/RECORD,,

avrae_ls-0.3.1.dist-info/METADATA

@@ -1,47 +0,0 @@
-Metadata-Version: 2.4
-Name: avrae-ls
-Version: 0.3.1
-Summary: Language server for Avrae draconic aliases
-Author: 1drturtle
-Requires-Python: >=3.11
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: pygls>=1.3.1
-Requires-Dist: lsprotocol>=2023.0.1
-Requires-Dist: httpx>=0.27
-Requires-Dist: d20>=1.1.2
-Provides-Extra: dev
-Requires-Dist: pytest>=8.3; extra == "dev"
-Requires-Dist: pytest-asyncio>=0.23; extra == "dev"
-Requires-Dist: pytest-cov>=7.0.0; extra == "dev"
-Requires-Dist: ruff>=0.6; extra == "dev"
-Dynamic: license-file
-
-# Avrae Draconic Alias Language Server
-
-Language Server Protocol (LSP) implementation targeting Avrae-style draconic aliases. It provides syntax/semantic diagnostics, a mocked execution command, and a thin configuration layer driven by a workspace `.avraels.json` file. Credit to Avrae team for all code yoinked!
-
-## Install (released package)
-
-- CLI/server via `uv tool` (preferred): `uv tool install avrae-ls` then `avrae-ls --help` to see stdio/TCP options (same as `python -m avrae_ls`). The VS Code extension uses this invocation by default. The draconic interpreter is vendored, so no Git deps are needed.
-
-## VS Code extension (released)
-
-- Install from VSIX: download `avrae-ls-client.vsix` from the GitHub releases page, then in VS Code run “Extensions: Install from VSIX” and select the file.
-- Open your alias workspace; commands like `Avrae: Show Alias Preview` and `Avrae: Run Alias` will be available.
-
-## Developing locally
-
-- Prereqs: [uv](https://github.com/astral-sh/uv) and Node.js.
-- Install deps: `uv sync --all-extras` then `make vscode-deps`.
-- Build everything locally: `make package` (wheel + VSIX in `dist/`).
-- Run tests/lint: `make check`.
-- Run via uv tool from source: `uv tool install --from . avrae-ls`.
-- Run diagnostics for a single file (stdout + stderr logs): `avrae-ls --analyze path/to/alias.txt --log-level DEBUG`.
-
-## Releasing (maintainers)
-
-1. Bump `pyproject.toml` version.
-2. `make release` (clean, build, upload to PyPI).
-3. Build and attach the VSIX to the GitHub release (`make vsix`).
-4. Tag and push.