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

avrae_ls/diagnostics.py

@@ -1,14 +1,15 @@
 from __future__ import annotations
 
+import inspect
 import ast
 import logging
-import inspect
-from typing import Iterable, List, Sequence, Set
+from typing import Dict, Iterable, List, Sequence, Set
 
 import draconic
 from lsprotocol import types
 
 from .argument_parsing import apply_argument_parsing
+from .completions import _infer_type_map, _resolve_type_name, _type_meta
 from .config import DiagnosticSettings
 from .context import ContextData, GVarResolver
 from .parser import find_draconic_blocks
@@ -78,6 +79,9 @@ class DiagnosticProvider:
         diagnostics.extend(_check_imports(body, self._settings.semantic_level))
         diagnostics.extend(_check_call_args(body, self._builtin_signatures, self._settings.semantic_level))
         diagnostics.extend(_check_private_method_calls(body))
+        diagnostics.extend(
+            _check_api_misuse(body, code, ctx_data, self._settings.semantic_level)
+        )
         if line_shift:
             diagnostics = _shift_diagnostics(diagnostics, line_shift, 0)
         return diagnostics
@@ -282,6 +286,207 @@ def _check_private_method_calls(body: Sequence[ast.AST]) -> List[types.Diagnosti
     return diagnostics
 
 
+def _check_api_misuse(
+    body: Sequence[ast.AST],
+    code: str,
+    ctx_data: ContextData,
+    severity_level: str,
+) -> List[types.Diagnostic]:
+    """Heuristics for common API mistakes (list vs scalar, missing context, property calls)."""
+    diagnostics: list[types.Diagnostic] = []
+    module = ast.Module(body=list(body), type_ignores=[])
+    parent_map = _build_parent_map(module)
+    assigned_names = _collect_assigned_names(module)
+    type_map = _diagnostic_type_map(code)
+    context_seen: set[str] = set()
+
+    for node in ast.walk(module):
+        if isinstance(node, ast.Call):
+            diagnostics.extend(_context_call_diagnostics(node, ctx_data, severity_level, context_seen))
+            diagnostics.extend(_property_call_diagnostics(node, type_map, code, severity_level))
+        if isinstance(node, ast.Attribute):
+            diagnostics.extend(_uncalled_context_attr_diagnostics(node, assigned_names, severity_level))
+            diagnostics.extend(_iterable_attr_diagnostics(node, parent_map, type_map, code, severity_level))
+    return diagnostics
+
+
+def _context_call_diagnostics(
+    node: ast.Call,
+    ctx_data: ContextData,
+    severity_level: str,
+    seen: set[str],
+) -> List[types.Diagnostic]:
+    diagnostics: list[types.Diagnostic] = []
+    if isinstance(node.func, ast.Name):
+        if node.func.id == "character" and not ctx_data.character and "character" not in seen:
+            seen.add("character")
+            diagnostics.append(
+                _make_diagnostic(
+                    node.func,
+                    "No character context configured; character() will raise at runtime.",
+                    severity_level,
+                )
+            )
+        elif node.func.id == "combat" and not ctx_data.combat and "combat" not in seen:
+            seen.add("combat")
+            diagnostics.append(
+                _make_diagnostic(
+                    node.func,
+                    "No combat context configured; combat() will return None.",
+                    severity_level,
+                )
+            )
+    return diagnostics
+
+
+def _property_call_diagnostics(
+    node: ast.Call,
+    type_map: Dict[str, str],
+    code: str,
+    severity_level: str,
+) -> List[types.Diagnostic]:
+    if not isinstance(node.func, ast.Attribute):
+        return []
+    base_type = _resolve_expr_type(node.func.value, type_map, code)
+    if not base_type:
+        return []
+    meta = _type_meta(base_type)
+    attr = node.func.attr
+    if attr in meta.methods or attr not in meta.attrs:
+        return []
+    receiver = _expr_to_str(node.func.value) or base_type
+    return [
+        _make_diagnostic(
+            node.func,
+            f"'{attr}' on {receiver} is a property; drop the parentheses.",
+            severity_level,
+        )
+    ]
+
+
+def _uncalled_context_attr_diagnostics(
+    node: ast.Attribute,
+    assigned_names: Set[str],
+    severity_level: str,
+) -> List[types.Diagnostic]:
+    if isinstance(node.value, ast.Name) and node.value.id in {"character", "combat"} and node.value.id not in assigned_names:
+        call_hint = f"{node.value.id}()"
+        return [
+            _make_diagnostic(
+                node.value,
+                f"Call {call_hint} before accessing '{node.attr}'.",
+                severity_level,
+            )
+        ]
+    return []
+
+
+def _iterable_attr_diagnostics(
+    node: ast.Attribute,
+    parent_map: Dict[ast.AST, ast.AST],
+    type_map: Dict[str, str],
+    code: str,
+    severity_level: str,
+) -> List[types.Diagnostic]:
+    parent = parent_map.get(node)
+    if parent is None:
+        return []
+    if isinstance(parent, ast.Subscript) and parent.value is node:
+        return []
+
+    base_type = _resolve_expr_type(node.value, type_map, code)
+    if not base_type:
+        return []
+    meta = _type_meta(base_type)
+    attr_meta = meta.attrs.get(node.attr)
+    if not attr_meta:
+        return []
+
+    is_collection = bool(attr_meta.element_type) or attr_meta.type_name in {"list", "dict"}
+    if not is_collection:
+        return []
+
+    expr_label = _expr_to_str(node) or node.attr
+    element_label = attr_meta.element_type or "items"
+    container_label = attr_meta.type_name or "collection"
+
+    if isinstance(parent, ast.Attribute) and parent.value is node:
+        next_attr = parent.attr
+        message = f"'{expr_label}' is a {container_label} of {element_label}; index or iterate before accessing '{next_attr}'."
+        return [_make_diagnostic(node, message, severity_level)]
+
+    if isinstance(parent, ast.Call) and parent.func is node:
+        message = f"'{expr_label}' is a {container_label} of {element_label}; index or iterate before calling it."
+        return [_make_diagnostic(node, message, severity_level)]
+
+    return []
+
+
+def _diagnostic_type_map(code: str) -> Dict[str, str]:
+    mapping = _infer_type_map(code)
+    if mapping:
+        return mapping
+    wrapped, _ = _wrap_draconic(code)
+    return _infer_type_map(wrapped)
+
+
+def _resolve_expr_type(expr: ast.AST, type_map: Dict[str, str], code: str) -> str:
+    expr_text = _expr_to_str(expr)
+    if not expr_text:
+        return ""
+    return _resolve_type_name(expr_text, code, type_map)
+
+
+def _expr_to_str(expr: ast.AST) -> str:
+    try:
+        return ast.unparse(expr)
+    except Exception:
+        return ""
+
+
+def _collect_assigned_names(module: ast.Module) -> Set[str]:
+    assigned: set[str] = set()
+
+    class Collector(ast.NodeVisitor):
+        def visit_Assign(self, node: ast.Assign):
+            for target in node.targets:
+                assigned.update(_names_in_target(target))
+            self.generic_visit(node)
+
+        def visit_AnnAssign(self, node: ast.AnnAssign):
+            assigned.update(_names_in_target(node.target))
+            self.generic_visit(node)
+
+        def visit_For(self, node: ast.For):
+            assigned.update(_names_in_target(node.target))
+            self.generic_visit(node)
+
+        def visit_AsyncFor(self, node: ast.AsyncFor):
+            assigned.update(_names_in_target(node.target))
+            self.generic_visit(node)
+
+        def visit_FunctionDef(self, node: ast.FunctionDef):
+            assigned.add(node.name)
+            for arg in node.args.args:
+                assigned.add(arg.arg)
+            self.generic_visit(node)
+
+        def visit_ClassDef(self, node: ast.ClassDef):
+            assigned.add(node.name)
+            self.generic_visit(node)
+
+    Collector().visit(module)
+    return assigned
+
+
+def _build_parent_map(root: ast.AST) -> Dict[ast.AST, ast.AST]:
+    parents: dict[ast.AST, ast.AST] = {}
+    for parent in ast.walk(root):
+        for child in ast.iter_child_nodes(parent):
+            parents[child] = parent
+    return parents
+
+
 def _make_diagnostic(node: ast.AST, message: str, level: str) -> types.Diagnostic:
     severity = SEVERITY.get(level, types.DiagnosticSeverity.Warning)
     if hasattr(node, "lineno"):

avrae_ls/parser.py

@@ -22,12 +22,17 @@ def find_draconic_blocks(source: str) -> List[DraconicBlock]:
         raw = match.group(1)
         prefix = source[: match.start()]
         line_offset = prefix.count("\n")
-        line_count = raw.count("\n") + 1 if raw else 1
+        # Column where draconic content starts on its first line
+        last_nl = prefix.rfind("\n")
+        start_col = match.start(1) - (last_nl + 1 if last_nl != -1 else 0)
+        char_offset = start_col
         # Trim leading blank lines inside the block while tracking the line shift
         while raw.startswith("\n"):
             raw = raw[1:]
             line_offset += 1
-        blocks.append(DraconicBlock(code=raw, line_offset=line_offset, char_offset=0, line_count=line_count))
+            char_offset = 0
+        line_count = raw.count("\n") + 1 if raw else 1
+        blocks.append(DraconicBlock(code=raw, line_offset=line_offset, char_offset=char_offset, line_count=line_count))
     return blocks
 
 

avrae_ls/runtime.py

@@ -6,6 +6,7 @@ import json
 import logging
 import math
 import random
+import re
 import time
 from types import SimpleNamespace
 try:  # optional dependency
@@ -98,7 +99,66 @@ def _vroll_dice(dice: str, multiply: int = 1, add: int = 0) -> SimpleRollResult
     return SimpleRollResult(rolled)
 
 
-def _parse_coins(args: str):
+@dataclass
+class _CoinsArgs:
+    pp: int = 0
+    gp: int = 0
+    ep: int = 0
+    sp: int = 0
+    cp: int = 0
+    explicit: bool = False
+
+    @property
+    def total(self) -> float:
+        return (self.pp * 10) + self.gp + (self.ep * 0.5) + (self.sp * 0.1) + (self.cp * 0.01)
+
+
+def _parse_coin_args(args: str) -> _CoinsArgs:
+    cleaned = str(args).replace(",", "")
+    try:
+        return _parse_coin_args_float(float(cleaned))
+    except ValueError:
+        return _parse_coin_args_re(cleaned)
+
+
+def _parse_coin_args_float(coins: float) -> _CoinsArgs:
+    total_copper = int(round(coins * 100, 1))
+    if coins < 0:
+        return _CoinsArgs(cp=total_copper)
+    return _CoinsArgs(
+        gp=total_copper // 100,
+        sp=(total_copper % 100) // 10,
+        cp=total_copper % 10,
+    )
+
+
+def _parse_coin_args_re(args: str) -> _CoinsArgs:
+    is_valid = re.fullmatch(r"(([+-]?\d+)\s*([pgesc]p)\s*)+", args, re.IGNORECASE)
+    if not is_valid:
+        raise avrae_argparser.InvalidArgument(
+            "Coins must be a number or a currency string, e.g. `+101.2` or `10cp +101gp -2sp`."
+        )
+
+    out = _CoinsArgs(explicit=True)
+    for coin_match in re.finditer(r"(?P<amount>[+-]?\d+)\s*(?P<currency>[pgesc]p)", args, re.IGNORECASE):
+        amount = int(coin_match["amount"])
+        currency = coin_match["currency"].lower()
+
+        if currency == "pp":
+            out.pp += amount
+        elif currency == "gp":
+            out.gp += amount
+        elif currency == "ep":
+            out.ep += amount
+        elif currency == "sp":
+            out.sp += amount
+        else:
+            out.cp += amount
+
+    return out
+
+
+def _parse_coins(args: str, include_total: bool = True):
     try:
         from avrae.aliasing.api.functions import parse_coins as avrae_parse_coins
     except Exception:
@@ -106,16 +166,21 @@ def _parse_coins(args: str):
 
     if avrae_parse_coins:
         try:
-            return avrae_parse_coins(str(args))
+            return avrae_parse_coins(str(args), include_total=include_total)
         except Exception:
             pass
 
-    # Fallback: accept numeric as gp, otherwise empty mapping.
-    try:
-        gp = float(str(args))
-        return {"pp": 0, "gp": gp, "ep": 0, "sp": 0, "cp": 0, "total": gp}
-    except Exception:
-        return {"pp": 0, "gp": 0, "ep": 0, "sp": 0, "cp": 0, "total": 0}
+    coin_args = _parse_coin_args(str(args))
+    parsed = {
+        "pp": coin_args.pp,
+        "gp": coin_args.gp,
+        "ep": coin_args.ep,
+        "sp": coin_args.sp,
+        "cp": coin_args.cp,
+    }
+    if include_total:
+        parsed["total"] = coin_args.total
+    return parsed
 
 
 def _default_builtins() -> Dict[str, Any]:
@@ -129,12 +194,9 @@ def _default_builtins() -> Dict[str, Any]:
         "abs": abs,
         "range": range,
         "enumerate": enumerate,
-        "sorted": sorted,
-        "reversed": reversed,
         "int": int,
         "float": float,
         "str": str,
-        "bool": bool,
         "round": round,
         "ceil": math.ceil,
         "floor": math.floor,
@@ -417,6 +479,9 @@ class MockExecutor:
             verify_cache_sig = sig_str
             verify_cache_error = None
             verify_cache_result = None
+            timeout = float(service_cfg.verify_timeout if service_cfg else AvraeServiceConfig.verify_timeout)
+            retries = int(service_cfg.verify_retries if service_cfg else AvraeServiceConfig.verify_retries)
+            retries = max(0, retries)
 
             def _call_verify_api(signature: str) -> Dict[str, Any]:
                 base_url = (service_cfg.base_url if service_cfg else AvraeServiceConfig.base_url).rstrip("/")
@@ -424,10 +489,18 @@ class MockExecutor:
                 headers = {"Content-Type": "application/json"}
                 if service_cfg and service_cfg.token:
                     headers["Authorization"] = str(service_cfg.token)
-                try:
-                    resp = httpx.post(url, json={"signature": signature}, headers=headers, timeout=5)
-                except Exception as exc:
-                    raise ValueError(f"Failed to verify signature: {exc}") from exc
+                last_exc: Exception | None = None
+                for attempt in range(retries + 1):
+                    try:
+                        resp = httpx.post(url, json={"signature": signature}, headers=headers, timeout=timeout)
+                        break
+                    except Exception as exc:
+                        last_exc = exc
+                        if attempt >= retries:
+                            raise ValueError(f"Failed to verify signature: {exc}") from exc
+                        continue
+                else:  # pragma: no cover - defensive
+                    raise ValueError(f"Failed to verify signature: {last_exc}") from last_exc
 
                 try:
                     payload = resp.json()
@@ -435,14 +508,17 @@ class MockExecutor:
                     raise ValueError("Failed to verify signature: invalid response body") from exc
 
                 if resp.status_code != 200:
-                    message = payload.get("error") if isinstance(payload, dict) else None
-                    raise ValueError(message or f"Failed to verify signature: HTTP {resp.status_code}")
+                    message = None
+                    if isinstance(payload, dict):
+                        message = payload.get("error") or payload.get("message")
+                    detail = f"{message} (HTTP {resp.status_code})" if message else f"HTTP {resp.status_code}"
+                    raise ValueError(f"Failed to verify signature: {detail}")
 
                 if not isinstance(payload, dict):
                     raise ValueError("Failed to verify signature: invalid response")
                 if payload.get("success") is not True:
                     message = payload.get("error")
-                    raise ValueError(message or "Failed to verify signature: unsuccessful response")
+                    raise ValueError(f"Failed to verify signature: {message or 'unsuccessful response'}")
 
                 data = payload.get("data")
                 if not isinstance(data, dict):

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] = []