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

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,17 @@
 from __future__ import annotations
 
 import ast
-import logging
 import inspect
-from typing import Iterable, List, Sequence, Set
+import logging
+from typing import Any, Dict, Iterable, List, Sequence, Set
 
 import draconic
 from lsprotocol import types
 
+from .alias_preview import simulate_command
+from .codes import MISSING_GVAR_CODE, UNDEFINED_NAME_CODE, UNSUPPORTED_IMPORT_CODE
 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
@@ -40,6 +43,10 @@ class DiagnosticProvider:
         source = apply_argument_parsing(source)
         blocks = find_draconic_blocks(source)
         if not blocks:
+            plain = _plain_command_diagnostics(source)
+            if plain is not None:
+                diagnostics.extend(plain)
+                return diagnostics
             diagnostics.extend(await self._analyze_code(source, ctx_data, gvar_resolver))
             return diagnostics
 
@@ -78,6 +85,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
@@ -146,6 +156,8 @@ class DiagnosticProvider:
                             node,
                             f"'{node.id}' may be undefined in this scope",
                             severity_level,
+                            code=UNDEFINED_NAME_CODE,
+                            data={"name": node.id},
                         )
                     )
 
@@ -233,6 +245,8 @@ async def _check_gvars(
                         arg_node,
                         f"Unknown gvar '{gvar_id}'",
                         settings.semantic_level,
+                        code=MISSING_GVAR_CODE,
+                        data={"gvar": gvar_id},
                     )
                 )
 
@@ -282,7 +296,215 @@ def _check_private_method_calls(body: Sequence[ast.AST]) -> List[types.Diagnosti
     return diagnostics
 
 
-def _make_diagnostic(node: ast.AST, message: str, level: str) -> types.Diagnostic:
+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,
+    *,
+    code: str | None = None,
+    data: Dict[str, Any] | None = None,
+) -> types.Diagnostic:
     severity = SEVERITY.get(level, types.DiagnosticSeverity.Warning)
     if hasattr(node, "lineno"):
         rng = _range_from_positions(
@@ -301,6 +523,8 @@ def _make_diagnostic(node: ast.AST, message: str, level: str) -> types.Diagnosti
         range=rng,
         severity=severity,
         source="avrae-ls",
+        code=code,
+        data=data,
     )
 
 
@@ -461,10 +685,27 @@ def _check_imports(body: Sequence[ast.AST], severity_level: str) -> List[types.D
 
     class Visitor(ast.NodeVisitor):
         def visit_Import(self, node: ast.Import):
-            diagnostics.append(_make_diagnostic(node, "Imports are not supported in draconic aliases", severity_level))
+            module = node.names[0].name if node.names else None
+            diagnostics.append(
+                _make_diagnostic(
+                    node,
+                    "Imports are not supported in draconic aliases",
+                    severity_level,
+                    code=UNSUPPORTED_IMPORT_CODE,
+                    data={"module": module} if module else None,
+                )
+            )
 
         def visit_ImportFrom(self, node: ast.ImportFrom):
-            diagnostics.append(_make_diagnostic(node, "Imports are not supported in draconic aliases", severity_level))
+            diagnostics.append(
+                _make_diagnostic(
+                    node,
+                    "Imports are not supported in draconic aliases",
+                    severity_level,
+                    code=UNSUPPORTED_IMPORT_CODE,
+                    data={"module": node.module},
+                )
+            )
 
     visitor = Visitor()
     for stmt in body:
@@ -487,3 +728,24 @@ def _range_from_positions(
         character=max(((end_col_offset or col_offset or 1) - 1), 0),
     )
     return types.Range(start=start, end=end)
+
+
+def _plain_command_diagnostics(source: str) -> list[types.Diagnostic] | None:
+    """Handle simple commands (embed/echo) without draconic blocks."""
+    simulated = simulate_command(source)
+    if not simulated.command_name:
+        return None
+    if simulated.command_name == "embed":
+        if simulated.validation_error:
+            return [
+                types.Diagnostic(
+                    message=simulated.validation_error,
+                    range=_range_from_positions(1, 1, 1, 1),
+                    severity=SEVERITY["warning"],
+                    source="avrae-ls",
+                )
+            ]
+        return []
+    if simulated.command_name == "echo":
+        return []
+    return None

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