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

avrae_ls/__main__.py

@@ -42,6 +42,11 @@ def main(argv: list[str] | None = None) -> None:
         const=".",
         help="Run alias tests in PATH (defaults to current directory)",
     )
+    parser.add_argument(
+        "--silent-gvar-fetch",
+        action="store_true",
+        help="Silently ignore gvar fetch failures and treat them as None",
+    )
     parser.add_argument("--token", help="Avrae API token (overrides config)")
     parser.add_argument("--base-url", help="Avrae API base URL (overrides config)")
     parser.add_argument("--version", action="store_true", help="Print version and exit")
@@ -58,12 +63,26 @@ def main(argv: list[str] | None = None) -> None:
             parser.error("--run-tests cannot be combined with --tcp")
         if args.analyze:
             parser.error("--run-tests cannot be combined with --analyze")
-        sys.exit(_run_alias_tests(Path(args.run_tests), token_override=args.token, base_url_override=args.base_url))
+        sys.exit(
+            _run_alias_tests(
+                Path(args.run_tests),
+                token_override=args.token,
+                base_url_override=args.base_url,
+                silent_gvar_fetch=args.silent_gvar_fetch,
+            )
+        )
 
     if args.analyze:
         if args.tcp:
             parser.error("--analyze cannot be combined with --tcp")
-        sys.exit(_run_analysis(Path(args.analyze), token_override=args.token, base_url_override=args.base_url))
+        sys.exit(
+            _run_analysis(
+                Path(args.analyze),
+                token_override=args.token,
+                base_url_override=args.base_url,
+                silent_gvar_fetch=args.silent_gvar_fetch,
+            )
+        )
 
     server = create_server()
     if args.tcp:
@@ -82,7 +101,13 @@ def _configure_logging(level: str) -> None:
     )
 
 
-def _run_analysis(path: Path, *, token_override: str | None = None, base_url_override: str | None = None) -> int:
+def _run_analysis(
+    path: Path,
+    *,
+    token_override: str | None = None,
+    base_url_override: str | None = None,
+    silent_gvar_fetch: bool = False,
+) -> int:
     if not path.exists():
         print(f"File not found: {path}", file=sys.stderr)
         return 2
@@ -96,6 +121,8 @@ def _run_analysis(path: Path, *, token_override: str | None = None, base_url_ove
         config.service.token = token_override
     if base_url_override:
         config.service.base_url = base_url_override
+    if silent_gvar_fetch:
+        config.silent_gvar_fetch = True
     for warning in warnings:
         log.warning(warning)
 
@@ -111,7 +138,11 @@ def _run_analysis(path: Path, *, token_override: str | None = None, base_url_ove
 
 
 def _run_alias_tests(
-    target: Path, *, token_override: str | None = None, base_url_override: str | None = None
+    target: Path,
+    *,
+    token_override: str | None = None,
+    base_url_override: str | None = None,
+    silent_gvar_fetch: bool = False,
 ) -> int:
     if not target.exists():
         print(f"Test path not found: {target}", file=sys.stderr)
@@ -126,6 +157,8 @@ def _run_alias_tests(
         config.service.token = token_override
     if base_url_override:
         config.service.base_url = base_url_override
+    if silent_gvar_fetch:
+        config.silent_gvar_fetch = True
     for warning in warnings:
         log.warning(warning)
 
@@ -169,7 +202,17 @@ def _print_test_results(results: Iterable[AliasTestResult], workspace_root: Path
             passed += 1
             continue
         if res.error:
-            print(f"  Error: {res.error}")
+            if res.error_line is not None and res.error_col is not None:
+                label = f"  Execution Error (line {res.error_line} col {res.error_col})"
+            elif res.error_line is not None:
+                label = f"  Execution Error (line {res.error_line})"
+            else:
+                label = "  Execution Error"
+            print(_colorize_error_line(label))
+            print(f"    {res.error}")
+            if res.stdout:
+                print(f"  Stdout: {res.stdout.strip()}")
+            continue
         if res.details:
             print(f"  {res.details}")
         expected_val, actual_val = _summarize_mismatch(res.case.expected, res.actual)
@@ -225,6 +268,12 @@ def _colorize_diff_line(line: str) -> str:
     return line
 
 
+def _colorize_error_line(line: str) -> str:
+    if not sys.stdout.isatty():
+        return line
+    return f"\x1b[31m{line}\x1b[0m"
+
+
 def _print_labeled_value(label: str, value: str) -> None:
     lines = value.splitlines() or [""]
     if len(lines) == 1:

avrae_ls/alias_preview.py

@@ -17,6 +17,8 @@ class RenderedAlias:
     stdout: str
     error: Optional[BaseException]
     last_value: Any | None = None
+    error_line: int | None = None
+    error_col: int | None = None
 
 
 @dataclass
@@ -58,7 +60,7 @@ class SimulatedCommand:
     embed: EmbedPreview | None = None
 
 
-def _strip_alias_header(text: str) -> str:
+def _strip_alias_header_with_offset(text: str) -> tuple[str, int]:
     lines = text.splitlines()
     if lines and lines[0].lstrip().startswith("!alias"):
         first = lines[0].lstrip()
@@ -66,9 +68,57 @@ def _strip_alias_header(text: str) -> str:
         remainder = parts[2] if len(parts) > 2 else ""
         body = "\n".join(lines[1:])
         if remainder:
-            return remainder + ("\n" + body if body else "")
-        return body
-    return text
+            return remainder + ("\n" + body if body else ""), 0
+        return body, 1
+    return text, 0
+
+
+def _strip_alias_header(text: str) -> str:
+    body, _ = _strip_alias_header_with_offset(text)
+    return body
+
+
+def _line_index_for_offset(text: str, offset: int) -> int:
+    return text.count("\n", 0, offset)
+
+
+def _error_position_for_match(
+    body: str, match: re.Match[str], error: BaseException, line_offset: int
+) -> tuple[int | None, int | None]:
+    base_line = _line_index_for_offset(body, match.start(1))
+    base_line_start = body.rfind("\n", 0, match.start(1))
+    base_col = match.start(1) - (base_line_start + 1 if base_line_start != -1 else 0)
+    line_in_code: int | None = None
+    col_in_code: int | None = None
+    node = getattr(error, "node", None)
+    if node is not None:
+        node_line = getattr(node, "lineno", None)
+        if isinstance(node_line, int) and node_line > 0:
+            line_in_code = node_line
+        node_col = getattr(node, "col_offset", None)
+        if isinstance(node_col, int) and node_col >= 0:
+            col_in_code = node_col
+    if line_in_code is None:
+        lineno = getattr(error, "lineno", None)
+        if isinstance(lineno, int) and lineno > 0:
+            line_in_code = lineno
+        offset = getattr(error, "offset", None)
+        if isinstance(offset, int) and offset > 0:
+            col_in_code = offset - 1
+    if line_in_code is not None:
+        line_index = base_line + (line_in_code - 1)
+    else:
+        code = match.group(1)
+        leading_newlines = len(code) - len(code.lstrip("\n"))
+        line_index = base_line + leading_newlines
+        col_in_code = 0 if col_in_code is None else col_in_code
+    if col_in_code is None:
+        col_in_code = 0
+    if line_in_code is None or line_in_code == 1:
+        col_index = base_col + col_in_code
+    else:
+        col_index = col_in_code
+    return line_index + line_offset + 1, col_index + 1
 
 
 async def render_alias_command(
@@ -79,12 +129,14 @@ async def render_alias_command(
     args: list[str] | None = None,
 ) -> RenderedAlias:
     """Replace <drac2> blocks with their evaluated values and return final command."""
-    body = _strip_alias_header(text)
+    body, line_offset = _strip_alias_header_with_offset(text)
     body = apply_argument_parsing(body, args)
     stdout_parts: list[str] = []
     parts: list[str] = []
     last_value = None
     error: BaseException | None = None
+    error_line: int | None = None
+    error_col: int | None = None
 
     pos = 0
     matches: list[tuple[str, re.Match[str]]] = []
@@ -109,6 +161,7 @@ async def render_alias_command(
                 stdout_parts.append(result.stdout)
             if result.error:
                 error = result.error
+                error_line, error_col = _error_position_for_match(body, match, result.error, line_offset)
                 break
             last_value = result.value
             if result.value is not None:
@@ -124,7 +177,14 @@ async def render_alias_command(
         parts.append(body[pos:])
 
     final_command = "".join(parts)
-    return RenderedAlias(command=final_command, stdout="".join(stdout_parts), error=error, last_value=last_value)
+    return RenderedAlias(
+        command=final_command,
+        stdout="".join(stdout_parts),
+        error=error,
+        last_value=last_value,
+        error_line=error_line,
+        error_col=error_col,
+    )
 
 
 def validate_embed_payload(payload: str) -> Tuple[bool, str | None]:

avrae_ls/alias_tests.py

@@ -42,6 +42,8 @@ class AliasTestResult:
     embed: dict[str, Any] | None = None
     error: str | None = None
     details: str | None = None
+    error_line: int | None = None
+    error_col: int | None = None
 
 
 def discover_test_files(
@@ -159,6 +161,8 @@ async def run_alias_test(case: AliasTestCase, builder: ContextBuilder, executor:
             actual=None,
             stdout=rendered.stdout,
             error=str(rendered.error),
+            error_line=rendered.error_line,
+            error_col=rendered.error_col,
         )
 
     preview = simulate_command(rendered.command)
@@ -171,7 +175,15 @@ async def run_alias_test(case: AliasTestCase, builder: ContextBuilder, executor:
             error=preview.validation_error,
         )
 
-    actual = preview.preview if preview.preview is not None else rendered.last_value
+    if preview.preview is not None:
+        actual = preview.preview
+    else:
+        if rendered.command.strip() == "" and rendered.last_value is None:
+            actual = None
+        elif rendered.last_value is not None and rendered.command.strip() == str(rendered.last_value):
+            actual = rendered.last_value
+        else:
+            actual = rendered.command
     embed_dict = preview.embed.to_dict() if preview.embed else None
 
     if embed_dict is not None and isinstance(case.expected, dict):

avrae_ls/ast_utils.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+import ast
+from typing import Iterable, List
+
+
+def collect_target_names(targets: Iterable[ast.AST]) -> List[str]:
+    names: list[str] = []
+    for target in targets:
+        if isinstance(target, ast.Name):
+            names.append(target.id)
+        elif isinstance(target, (ast.Tuple, ast.List)):
+            names.extend(collect_target_names(target.elts))
+    return names

avrae_ls/code_actions.py

@@ -10,7 +10,8 @@ from typing import Iterable, List, Sequence
 from lsprotocol import types
 
 from .codes import MISSING_GVAR_CODE, UNDEFINED_NAME_CODE, UNSUPPORTED_IMPORT_CODE
-from .parser import DraconicBlock, find_draconic_blocks
+from .parser import DraconicBlock
+from .source_context import build_source_context
 
 log = logging.getLogger(__name__)
 
@@ -42,10 +43,13 @@ def code_actions_for_document(
     source: str,
     params: types.CodeActionParams,
     workspace_root: Path,
+    *,
+    treat_as_module: bool = False,
 ) -> List[types.CodeAction]:
     """Collect code actions for a document without requiring a running server."""
     actions: list[types.CodeAction] = []
-    blocks = find_draconic_blocks(source)
+    source_ctx = build_source_context(source, treat_as_module, apply_args=False)
+    blocks = source_ctx.blocks
     snippets = _load_snippets(workspace_root)
     only_kinds = list(params.context.only or [])