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

avrae_ls/argparser.py

@@ -2,7 +2,7 @@ import collections
 import itertools
 import re
 import string
-from typing import Iterator
+from typing import ClassVar, Iterator
 
 
 class BadArgument(Exception):
@@ -169,6 +169,19 @@ def argparse(args, character=None, splitter=argsplit, parse_ephem=True) -> "Pars
 
 
 class ParsedArguments:
+    ATTRS: ClassVar[list[str]] = []
+    METHODS: ClassVar[list[str]] = [
+        "get",
+        "last",
+        "adv",
+        "join",
+        "ignore",
+        "update",
+        "update_nx",
+        "set_context",
+        "add_context",
+    ]
+
     def __init__(self, args: list[Argument]):
         self._parsed = collections.defaultdict(lambda: [])
         for arg in args:
@@ -299,7 +312,7 @@ class ParsedArguments:
     def __contains__(self, item):
         return item in self._parsed and self._parsed[item]
 
-    def __len__(self):
+    def __len__(self) -> int:
         return len(self._parsed)
 
     def __setitem__(self, key, value):
@@ -317,7 +330,7 @@ class ParsedArguments:
         if arg in self._parsed:
             del self._parsed[arg]
 
-    def __iter__(self):
+    def __iter__(self) -> Iterator[str]:
         return iter(self._parsed.keys())
 
     def __repr__(self):

avrae_ls/completions.py

@@ -11,6 +11,7 @@ from typing import Any, ClassVar, Dict, Iterable, List, Optional
 from lsprotocol import types
 
 from .context import ContextData, GVarResolver
+from .argparser import ParsedArguments
 from .runtime import _default_builtins
 from .api import (
     AliasAction,
@@ -147,6 +148,7 @@ TYPE_MAP: Dict[str, object] = {
     "list": _BuiltinList,
     "dict": _BuiltinDict,
     "str": _BuiltinStr,
+    "ParsedArguments": ParsedArguments,
 }
 
 
@@ -498,6 +500,8 @@ def _infer_type_map(code: str) -> Dict[str, str]:
                     return value.func.id, None
                 if value.func.id == "vroll":
                     return "SimpleRollResult", None
+                if value.func.id == "argparse":
+                    return "ParsedArguments", None
                 if value.func.id in {"list", "dict", "str"}:
                     return value.func.id, None
             if isinstance(value, ast.List):

avrae_ls/config.py

@@ -3,12 +3,15 @@ from __future__ import annotations
 import json
 import logging
 import math
+import os
+import re
 from dataclasses import dataclass, field
 from pathlib import Path
-from typing import Any, Dict, Iterable, Tuple
+from typing import Any, Dict, Iterable, Mapping, Tuple
 
 CONFIG_FILENAME = ".avraels.json"
 log = logging.getLogger(__name__)
+_ENV_VAR_PATTERN = re.compile(r"\$(\w+)|\$\{([^}]+)\}")
 
 
 class ConfigError(Exception):
@@ -25,6 +28,8 @@ class DiagnosticSettings:
 class AvraeServiceConfig:
     base_url: str = "https://api.avrae.io"
     token: str | None = None
+    verify_timeout: float = 5.0
+    verify_retries: int = 0
 
 
 @dataclass
@@ -360,6 +365,30 @@ class AvraeLSConfig:
         )
 
 
+def _expand_env_vars(data: Any, env: Mapping[str, str], missing_vars: set[str]) -> Any:
+    if isinstance(data, dict):
+        return {key: _expand_env_vars(value, env, missing_vars) for key, value in data.items()}
+    if isinstance(data, list):
+        return [_expand_env_vars(value, env, missing_vars) for value in data]
+    if isinstance(data, str):
+        def _replace(match: re.Match[str]) -> str:
+            var = match.group(1) or match.group(2) or ""
+            if var in env:
+                return env[var]
+            missing_vars.add(var)
+            return ""
+
+        return _ENV_VAR_PATTERN.sub(_replace, data)
+    return data
+
+
+def _coerce_optional_str(value: Any) -> str | None:
+    if value is None:
+        return None
+    value_str = str(value)
+    return value_str if value_str.strip() else None
+
+
 def load_config(workspace_root: Path) -> Tuple[AvraeLSConfig, Iterable[str]]:
     """Load `.avraels.json` from the workspace root, returning config and warnings."""
     path = workspace_root / CONFIG_FILENAME
@@ -374,12 +403,42 @@ def load_config(workspace_root: Path) -> Tuple[AvraeLSConfig, Iterable[str]]:
         return AvraeLSConfig.default(workspace_root), [warning]
 
     warnings: list[str] = []
+    env_missing: set[str] = set()
+    env = dict(os.environ)
+    env.setdefault("workspaceRoot", str(workspace_root))
+    env.setdefault("workspaceFolder", str(workspace_root))
+    raw = _expand_env_vars(raw, env, env_missing)
+    for var in sorted(env_missing):
+        warning = f"{CONFIG_FILENAME}: environment variable '{var}' is not set; substituting an empty string."
+        warnings.append(warning)
+        log.warning(warning)
+
     enable_gvar_fetch = bool(raw.get("enableGvarFetch", False))
 
     service_cfg = raw.get("avraeService") or {}
+    def _get_service_timeout(raw_timeout) -> float:
+        try:
+            timeout = float(raw_timeout)
+            if timeout > 0:
+                return timeout
+        except Exception:
+            pass
+        return AvraeServiceConfig.verify_timeout
+
+    def _get_service_retries(raw_retries) -> int:
+        try:
+            retries = int(raw_retries)
+            if retries >= 0:
+                return retries
+        except Exception:
+            pass
+        return AvraeServiceConfig.verify_retries
+
     service = AvraeServiceConfig(
         base_url=str(service_cfg.get("baseUrl") or AvraeServiceConfig.base_url),
-        token=service_cfg.get("token"),
+        token=_coerce_optional_str(service_cfg.get("token")),
+        verify_timeout=_get_service_timeout(service_cfg.get("verifySignatureTimeout")),
+        verify_retries=_get_service_retries(service_cfg.get("verifySignatureRetries")),
     )
 
     diag_cfg = raw.get("diagnostics") or {}

avrae_ls/context.py

@@ -33,11 +33,12 @@ class ContextBuilder:
 
     def build(self, profile_name: str | None = None) -> ContextData:
         profile = self._select_profile(profile_name)
+        combat = self._ensure_me_combatant(profile)
         merged_vars = self._merge_character_cvars(profile.character, self._load_var_files().merge(profile.vars))
         self._gvar_resolver.seed(merged_vars.gvars)
         return ContextData(
             ctx=dict(profile.ctx),
-            combat=dict(profile.combat),
+            combat=combat,
             character=dict(profile.character),
             vars=merged_vars,
         )
@@ -69,6 +70,66 @@ class ContextBuilder:
             merged = merged.merge(VarSources(cvars=builtin_cvars))
         return merged
 
+    def _ensure_me_combatant(self, profile: ContextProfile) -> Dict[str, Any]:
+        combat = dict(profile.combat or {})
+        combatants = list(combat.get("combatants") or [])
+        me = combat.get("me")
+        author_id = (profile.ctx.get("author") or {}).get("id")
+
+        def _matches_author(combatant: Dict[str, Any]) -> bool:
+            try:
+                return author_id is not None and str(combatant.get("controller")) == str(author_id)
+            except Exception:
+                return False
+
+        # Use an existing combatant controlled by the author if me is missing.
+        if me is None:
+            for existing in combatants:
+                if _matches_author(existing):
+                    me = existing
+                    break
+
+        # If still missing, synthesize a combatant from the character sheet.
+        if me is None and profile.character:
+            me = {
+                "name": profile.character.get("name", "Player"),
+                "id": "cmb_player",
+                "controller": author_id,
+                "group": None,
+                "race": profile.character.get("race"),
+                "monster_name": None,
+                "is_hidden": False,
+                "init": profile.character.get("stats", {}).get("dexterity", 10),
+                "initmod": 0,
+                "type": "combatant",
+                "note": "Mock combatant for preview",
+                "effects": [],
+                "stats": profile.character.get("stats") or {},
+                "levels": profile.character.get("levels") or profile.character.get("class_levels") or {},
+                "skills": profile.character.get("skills") or {},
+                "saves": profile.character.get("saves") or {},
+                "resistances": profile.character.get("resistances") or {},
+                "spellbook": profile.character.get("spellbook") or {},
+                "attacks": profile.character.get("attacks") or [],
+                "max_hp": profile.character.get("max_hp"),
+                "hp": profile.character.get("hp"),
+                "temp_hp": profile.character.get("temp_hp"),
+                "ac": profile.character.get("ac"),
+                "creature_type": profile.character.get("creature_type"),
+            }
+
+        if me is not None:
+            combat["me"] = me
+            if not any(c is me for c in combatants) and not any(_matches_author(c) for c in combatants):
+                combatants.insert(0, me)
+            combat["combatants"] = combatants
+            if "current" not in combat or combat.get("current") is None:
+                combat["current"] = me
+        else:
+            combat["combatants"] = combatants
+
+        return combat
+
 
 class GVarResolver:
     def __init__(self, config: AvraeLSConfig):

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]:
@@ -414,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("/")
@@ -421,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()
@@ -432,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):