avrae-ls 0.6.4__py3-none-any.whl → 0.7.0__py3-none-any.whl

avrae_ls/config.py

@@ -82,6 +82,7 @@ class ContextProfile:
 class AvraeLSConfig:
     workspace_root: Path
     enable_gvar_fetch: bool = False
+    silent_gvar_fetch: bool = False
     service: AvraeServiceConfig = field(default_factory=AvraeServiceConfig)
     var_files: Tuple[Path, ...] = field(default_factory=tuple)
     default_profile: str = "default"

avrae_ls/context.py

@@ -145,6 +145,19 @@ class GVarResolver:
         self._config = config
         self._cache: Dict[str, Any] = {}
 
+    def _silent_failure(self, key: str) -> bool:
+        if not self._config.silent_gvar_fetch:
+            return False
+        self._cache[str(key)] = None
+        return True
+
+    def _silent_failure_many(self, keys: Iterable[str]) -> bool:
+        if not self._config.silent_gvar_fetch:
+            return False
+        for key in keys:
+            self._cache[str(key)] = None
+        return True
+
     def reset(self, gvars: Dict[str, Any] | None = None) -> None:
         self._cache = {}
         if gvars:
@@ -176,10 +189,18 @@ class GVarResolver:
         if not missing:
             return results
         if not self._config.enable_gvar_fetch:
-            log.warning("GVAR fetch disabled; skipping %s", missing)
+            if not self._config.silent_gvar_fetch:
+                log.warning("GVAR fetch disabled; skipping %s", missing)
+            if self._silent_failure_many(missing):
+                for key in missing:
+                    results[key] = True
             return results
         if not self._config.service.token:
-            log.debug("GVAR fetch skipped for %s: no token configured", missing)
+            if not self._config.silent_gvar_fetch:
+                log.debug("GVAR fetch skipped for %s: no token configured", missing)
+            if self._silent_failure_many(missing):
+                for key in missing:
+                    results[key] = True
             return results
 
         sem = asyncio.Semaphore(self._CONCURRENCY)
@@ -191,8 +212,9 @@ class GVarResolver:
             try:
                 ensured = await self._fetch_remote(key, client=client, sem=sem)
             except Exception as exc:  # pragma: no cover - defensive
-                log.error("GVAR fetch failed for %s: %s", key, exc)
-                ensured = False
+                if not self._config.silent_gvar_fetch:
+                    log.error("GVAR fetch failed for %s: %s", key, exc)
+                ensured = self._silent_failure(key)
             results[key] = ensured
 
         async with httpx.AsyncClient(timeout=5) as client:
@@ -205,11 +227,13 @@ class GVarResolver:
             log.debug("GVAR ensure_blocking cache hit for %s", key)
             return True
         if not self._config.enable_gvar_fetch:
-            log.warning("GVAR fetch disabled; skipping %s", key)
-            return False
+            if not self._config.silent_gvar_fetch:
+                log.warning("GVAR fetch disabled; skipping %s", key)
+            return self._silent_failure(key)
         if not self._config.service.token:
-            log.debug("GVAR fetch skipped for %s: no token configured", key)
-            return False
+            if not self._config.silent_gvar_fetch:
+                log.debug("GVAR fetch skipped for %s: no token configured", key)
+            return self._silent_failure(key)
 
         base_url = self._config.service.base_url.rstrip("/")
         url = f"{base_url}/customizations/gvars/{key}"
@@ -219,17 +243,19 @@ class GVarResolver:
             with httpx.Client(timeout=5) as client:
                 resp = client.get(url, headers=headers)
         except Exception as exc:
-            log.error("GVAR blocking fetch failed for %s: %s", key, exc)
-            return False
+            if not self._config.silent_gvar_fetch:
+                log.error("GVAR blocking fetch failed for %s: %s", key, exc)
+            return self._silent_failure(key)
 
         if resp.status_code != 200:
-            log.warning(
-                "GVAR blocking fetch returned %s for %s (body: %s)",
-                resp.status_code,
-                key,
-                (resp.text or "").strip(),
-            )
-            return False
+            if not self._config.silent_gvar_fetch:
+                log.warning(
+                    "GVAR blocking fetch returned %s for %s (body: %s)",
+                    resp.status_code,
+                    key,
+                    (resp.text or "").strip(),
+                )
+            return self._silent_failure(key)
 
         value: Any = None
         try:
@@ -241,8 +267,9 @@ class GVarResolver:
             value = payload["value"]
 
         if value is None:
-            log.error("GVAR %s payload missing value", key)
-            return False
+            if not self._config.silent_gvar_fetch:
+                log.error("GVAR %s payload missing value", key)
+            return self._silent_failure(key)
         self._cache[key] = value
         return True
 
@@ -262,9 +289,9 @@ class GVarResolver:
         if key in self._cache:
             return True
         if not self._config.enable_gvar_fetch:
-            return False
+            return self._silent_failure(key)
         if not self._config.service.token:
-            return False
+            return self._silent_failure(key)
 
         base_url = self._config.service.base_url.rstrip("/")
         url = f"{base_url}/customizations/gvars/{key}"
@@ -286,21 +313,23 @@ class GVarResolver:
             log.debug("GVAR fetching %s from %s", key, url)
             resp = await _do_request(session)
         except Exception as exc:
-            log.error("GVAR fetch failed for %s: %s", key, exc)
+            if not self._config.silent_gvar_fetch:
+                log.error("GVAR fetch failed for %s: %s", key, exc)
             if close_client:
                 await session.aclose()
-            return False
+            return self._silent_failure(key)
         if close_client:
             await session.aclose()
 
         if resp.status_code != 200:
-            log.warning(
-                "GVAR fetch returned %s for %s (body: %s)",
-                resp.status_code,
-                key,
-                (resp.text or "").strip(),
-            )
-            return False
+            if not self._config.silent_gvar_fetch:
+                log.warning(
+                    "GVAR fetch returned %s for %s (body: %s)",
+                    resp.status_code,
+                    key,
+                    (resp.text or "").strip(),
+                )
+            return self._silent_failure(key)
 
         value: Any = None
         try:
@@ -314,8 +343,9 @@ class GVarResolver:
         log.debug("GVAR fetch parsed value for %s (type=%s)", key, type(value).__name__)
 
         if value is None:
-            log.error("GVAR %s payload missing value", key)
-            return False
+            if not self._config.silent_gvar_fetch:
+                log.error("GVAR %s payload missing value", key)
+            return self._silent_failure(key)
         self._cache[key] = value
         return True
 

avrae_ls/diagnostics.py

@@ -10,11 +10,14 @@ 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 .source_context import build_source_context
+from .type_inference import infer_type_map, resolve_type_name
+from .type_system import type_meta
 from .config import DiagnosticSettings
 from .context import ContextData, GVarResolver
-from .parser import find_draconic_blocks
+from .parser import wrap_draconic
+from .lsp_utils import range_from_positions, shift_range
+from .ast_utils import collect_target_names
 from .runtime import MockExecutor, _default_builtins
 
 log = logging.getLogger(__name__)
@@ -37,17 +40,19 @@ class DiagnosticProvider:
         source: str,
         ctx_data: ContextData,
         gvar_resolver: GVarResolver,
+        *,
+        treat_as_module: bool = False,
     ) -> List[types.Diagnostic]:
         diagnostics: list[types.Diagnostic] = []
 
-        source = apply_argument_parsing(source)
-        blocks = find_draconic_blocks(source)
+        source_ctx = build_source_context(source, treat_as_module)
+        blocks = source_ctx.blocks
         if not blocks:
-            plain = _plain_command_diagnostics(source)
+            plain = _plain_command_diagnostics(source_ctx.prepared)
             if plain is not None:
                 diagnostics.extend(plain)
                 return diagnostics
-            diagnostics.extend(await self._analyze_code(source, ctx_data, gvar_resolver))
+            diagnostics.extend(await self._analyze_code(source_ctx.prepared, ctx_data, gvar_resolver))
             return diagnostics
 
         for block in blocks:
@@ -67,7 +72,7 @@ class DiagnosticProvider:
         try:
             body = parser.parse(code)
         except draconic.DraconicSyntaxError as exc:
-            wrapped, added = _wrap_draconic(code)
+            wrapped, added = wrap_draconic(code)
             try:
                 body = parser.parse(wrapped)
                 line_shift = -added
@@ -252,11 +257,12 @@ class DiagnosticProvider:
 
 
 def _syntax_diagnostic(exc: draconic.DraconicSyntaxError) -> types.Diagnostic:
-    rng = _range_from_positions(
+    rng = range_from_positions(
         exc.lineno,
         exc.offset,
         exc.end_lineno,
         exc.end_offset,
+        one_based=True,
     )
     return types.Diagnostic(
         message=exc.msg,
@@ -268,7 +274,13 @@ def _syntax_diagnostic(exc: draconic.DraconicSyntaxError) -> types.Diagnostic:
 
 def _syntax_from_std(exc: SyntaxError) -> types.Diagnostic:
     lineno, offset = exc.lineno, exc.offset
-    rng = _range_from_positions(lineno, offset, getattr(exc, "end_lineno", None), getattr(exc, "end_offset", None))
+    rng = range_from_positions(
+        lineno,
+        offset,
+        getattr(exc, "end_lineno", None),
+        getattr(exc, "end_offset", None),
+        one_based=True,
+    )
     return types.Diagnostic(
         message=exc.msg,
         range=rng,
@@ -278,16 +290,7 @@ def _syntax_from_std(exc: SyntaxError) -> types.Diagnostic:
 
 
 def _names_in_target(target: ast.AST) -> Set[str]:
-    names: set[str] = set()
-    if isinstance(target, ast.Name):
-        names.add(target.id)
-    elif isinstance(target, ast.Tuple):
-        for elt in target.elts:
-            names.update(_names_in_target(elt))
-    elif isinstance(target, ast.List):
-        for elt in target.elts:
-            names.update(_names_in_target(elt))
-    return names
+    return set(collect_target_names([target]))
 
 
 async def _check_gvars(
@@ -437,7 +440,7 @@ def _property_call_diagnostics(
     base_type = _resolve_expr_type(node.func.value, type_map, code)
     if not base_type:
         return []
-    meta = _type_meta(base_type)
+    meta = type_meta(base_type)
     attr = node.func.attr
     if attr in meta.methods or attr not in meta.attrs:
         return []
@@ -484,7 +487,7 @@ def _iterable_attr_diagnostics(
     base_type = _resolve_expr_type(node.value, type_map, code)
     if not base_type:
         return []
-    meta = _type_meta(base_type)
+    meta = type_meta(base_type)
     attr_meta = meta.attrs.get(node.attr)
     if not attr_meta:
         return []
@@ -510,18 +513,18 @@ def _iterable_attr_diagnostics(
 
 
 def _diagnostic_type_map(code: str) -> Dict[str, str]:
-    mapping = _infer_type_map(code)
+    mapping = infer_type_map(code)
     if mapping:
         return mapping
-    wrapped, _ = _wrap_draconic(code)
-    return _infer_type_map(wrapped)
+    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)
+    return resolve_type_name(expr_text, code, type_map)
 
 
 def _expr_to_str(expr: ast.AST) -> str:
@@ -584,11 +587,12 @@ def _make_diagnostic(
 ) -> types.Diagnostic:
     severity = SEVERITY.get(level, types.DiagnosticSeverity.Warning)
     if hasattr(node, "lineno"):
-        rng = _range_from_positions(
+        rng = range_from_positions(
             getattr(node, "lineno", 1),
             getattr(node, "col_offset", 0) + 1,
             getattr(node, "end_lineno", None),
             getattr(node, "end_col_offset", None),
+            one_based=True,
         )
     else:
         rng = types.Range(
@@ -611,7 +615,7 @@ def _shift_diagnostics(diags: List[types.Diagnostic], line_offset: int, char_off
         shifted.append(
             types.Diagnostic(
                 message=diag.message,
-                range=_shift_range(diag.range, line_offset, char_offset),
+                range=shift_range(diag.range, line_offset, char_offset),
                 severity=diag.severity,
                 source=diag.source,
                 code=diag.code,
@@ -624,20 +628,6 @@ def _shift_diagnostics(diags: List[types.Diagnostic], line_offset: int, char_off
     return shifted
 
 
-def _shift_range(rng: types.Range, line_offset: int, char_offset: int) -> types.Range:
-    def _shift_pos(pos: types.Position) -> types.Position:
-        return types.Position(
-            line=max(pos.line + line_offset, 0),
-            character=max(pos.character + (char_offset if pos.line == 0 else 0), 0),
-        )
-
-    return types.Range(start=_shift_pos(rng.start), end=_shift_pos(rng.end))
-
-
-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 _build_builtin_signatures() -> dict[str, inspect.Signature]:
@@ -788,23 +778,6 @@ def _check_imports(body: Sequence[ast.AST], severity_level: str) -> List[types.D
     return diagnostics
 
 
-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),
-    )
-    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)
@@ -815,7 +788,7 @@ def _plain_command_diagnostics(source: str) -> list[types.Diagnostic] | None:
             return [
                 types.Diagnostic(
                     message=simulated.validation_error,
-                    range=_range_from_positions(1, 1, 1, 1),
+                    range=range_from_positions(1, 1, 1, 1, one_based=True),
                     severity=SEVERITY["warning"],
                     source="avrae-ls",
                 )

avrae_ls/lsp_utils.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+from lsprotocol import types
+
+
+def range_from_positions(
+    lineno: int | None,
+    col_offset: int | None,
+    end_lineno: int | None,
+    end_col_offset: int | None,
+    *,
+    one_based: bool = False,
+    ensure_nonempty: bool = False,
+) -> types.Range:
+    start_line = max((lineno or 1) - 1, 0)
+    if one_based:
+        start_char = max((col_offset or 1) - 1, 0)
+    else:
+        start_char = max(col_offset or 0, 0)
+    end_line = max(((end_lineno or lineno or 1) - 1), 0)
+    if one_based:
+        end_char = max(((end_col_offset or col_offset or 1) - 1), 0)
+    else:
+        raw_end_char = end_col_offset if end_col_offset is not None else col_offset
+        end_char = max(raw_end_char if raw_end_char is not None else start_char, start_char)
+    if ensure_nonempty and 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),
+    )
+
+
+def shift_range(rng: types.Range, line_offset: int, char_offset: int) -> types.Range:
+    def _shift_pos(pos: types.Position) -> types.Position:
+        return types.Position(
+            line=max(pos.line + line_offset, 0),
+            character=max(pos.character + (char_offset if pos.line == 0 else 0), 0),
+        )
+
+    return types.Range(start=_shift_pos(rng.start), end=_shift_pos(rng.end))

avrae_ls/parser.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import re
 from dataclasses import dataclass
+from pathlib import Path
 from typing import List
 
 
@@ -17,9 +18,29 @@ class DraconicBlock:
 DRACONIC_RE = re.compile(r"<drac2>([\s\S]*?)</drac2>", re.IGNORECASE)
 INLINE_DRACONIC_RE = re.compile(r"\{\{([\s\S]*?)\}\}", re.DOTALL)
 INLINE_ROLL_RE = re.compile(r"(?<!\{)\{(?!\{)([\s\S]*?)(?<!\})\}(?!\})", re.DOTALL)
+ALIAS_MODULE_SUFFIX = ".alias-module"
 
 
-def find_draconic_blocks(source: str) -> List[DraconicBlock]:
+def is_alias_module_path(path: str | Path | None) -> bool:
+    if path is None:
+        return False
+    return str(path).endswith(ALIAS_MODULE_SUFFIX)
+
+
+def _full_source_block(source: str) -> DraconicBlock:
+    line_count = source.count("\n") + 1 if source else 1
+    return DraconicBlock(
+        code=source,
+        line_offset=0,
+        char_offset=0,
+        line_count=line_count,
+        inline=False,
+    )
+
+
+def find_draconic_blocks(source: str, *, treat_as_module: bool = False) -> List[DraconicBlock]:
+    if treat_as_module:
+        return [_full_source_block(source)]
     matches: list[tuple[int, DraconicBlock]] = []
 
     def _block_from_match(match: re.Match[str], inline: bool = False) -> tuple[int, int, DraconicBlock]:
@@ -60,9 +81,15 @@ def find_draconic_blocks(source: str) -> List[DraconicBlock]:
     return blocks
 
 
-def primary_block_or_source(source: str) -> tuple[str, int, int]:
-    blocks = find_draconic_blocks(source)
+def primary_block_or_source(source: str, *, treat_as_module: bool = False) -> tuple[str, int, int]:
+    blocks = find_draconic_blocks(source, treat_as_module=treat_as_module)
     if not blocks:
         return source, 0, 0
     block = blocks[0]
     return block.code, block.line_offset, block.char_offset
+
+
+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