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

avrae_ls/diagnostics.py

@@ -1,13 +1,15 @@
 from __future__ import annotations
 
-import inspect
 import ast
+import inspect
 import logging
-from typing import Dict, Iterable, List, Sequence, Set
+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
@@ -41,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
 
@@ -150,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},
                         )
                     )
 
@@ -237,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},
                     )
                 )
 
@@ -487,7 +497,14 @@ def _build_parent_map(root: ast.AST) -> Dict[ast.AST, ast.AST]:
     return parents
 
 
-def _make_diagnostic(node: ast.AST, message: str, level: str) -> types.Diagnostic:
+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(
@@ -506,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,
     )
 
 
@@ -666,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:
@@ -692,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/server.py

@@ -18,6 +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 .code_actions import code_actions_for_document
 from .symbols import build_symbol_table, document_symbols, find_definition_range, find_references, range_for_word
 from .argument_parsing import apply_argument_parsing
 
@@ -260,6 +261,12 @@ def on_hover(server: AvraeLanguageServer, params: types.HoverParams):
     return None
 
 
+@ls.feature(types.TEXT_DOCUMENT_CODE_ACTION)
+def on_code_action(server: AvraeLanguageServer, params: types.CodeActionParams):
+    doc = server.workspace.get_text_document(params.text_document.uri)
+    return code_actions_for_document(doc.source, params, server.workspace_root)
+
+
 @ls.command(RUN_ALIAS_COMMAND)
 async def run_alias(server: AvraeLanguageServer, *args: Any):
     payload = args[0] if args else {}
@@ -289,18 +296,20 @@ async def run_alias(server: AvraeLanguageServer, *args: Any):
         server.state.context_builder.gvar_resolver,
         args=alias_args,
     )
-    preview_output, command_name, validation_error = simulate_command(rendered.command)
+    preview = simulate_command(rendered.command)
 
     response: dict[str, Any] = {
         "stdout": rendered.stdout,
-        "result": preview_output if preview_output is not None else rendered.last_value,
+        "result": preview.preview if preview.preview is not None else rendered.last_value,
         "command": rendered.command,
-        "commandName": command_name,
+        "commandName": preview.command_name,
     }
     if rendered.error:
         response["error"] = _format_runtime_error(rendered.error)
-    if validation_error:
-        response["validationError"] = validation_error
+    if preview.validation_error:
+        response["validationError"] = preview.validation_error
+    if preview.embed:
+        response["embed"] = preview.embed.to_dict()
     if uri:
         extra = []
         if rendered.error:

avrae_ls/signature_help.py

@@ -157,15 +157,29 @@ def signature_help_for_code(code: str, line: int, character: int, sigs: Dict[str
         return None
 
     target_call: ast.Call | None = None
-    for node in ast.walk(tree):
-        if isinstance(node, ast.Call):
+    target_depth = -1
+
+    class Finder(ast.NodeVisitor):
+        def __init__(self):
+            self.stack: list[ast.AST] = []
+
+        def visit_Call(self, node: ast.Call):
+            nonlocal target_call, target_depth
             if hasattr(node, "lineno") and hasattr(node, "col_offset"):
                 start = (node.lineno - 1, node.col_offset)
                 end_line = getattr(node, "end_lineno", node.lineno) - 1
                 end_col = getattr(node, "end_col_offset", node.col_offset)
                 if _pos_within((line, character), start, (end_line, end_col)):
-                    target_call = node
-                    break
+                    depth = len(self.stack)
+                    # Prefer the most nested call covering the cursor
+                    if depth >= target_depth:
+                        target_call = node
+                        target_depth = depth
+            self.stack.append(node)
+            self.generic_visit(node)
+            self.stack.pop()
+
+    Finder().visit(tree)
 
     if not target_call:
         return None
@@ -184,7 +198,7 @@ def signature_help_for_code(code: str, line: int, character: int, sigs: Dict[str
         documentation=fsig.doc,
         parameters=[types.ParameterInformation(label=p) for p in fsig.params],
     )
-    active_param = min(len(target_call.args), max(len(fsig.params) - 1, 0))
+    active_param = _active_param_index(target_call, (line, character), fsig.params)
     return types.SignatureHelp(signatures=[sig_info], active_signature=0, active_parameter=active_param)
 
 
@@ -199,3 +213,40 @@ def _pos_within(pos: Tuple[int, int], start: Tuple[int, int], end: Tuple[int, in
     if line == el and col > ec:
         return False
     return True
+
+
+def _active_param_index(call: ast.Call, cursor: Tuple[int, int], params: List[str]) -> int:
+    if not params:
+        return 0
+
+    # Build spans for positional args and keywords in source order.
+    spans: list[tuple[Tuple[int, int], Tuple[int, int], ast.AST]] = []
+    for arg in call.args:
+        spans.append((_node_start(arg), _node_end(arg), arg))
+    for kw in call.keywords:
+        spans.append((_node_start(kw), _node_end(kw), kw))
+    spans.sort(key=lambda s: (s[0][0], s[0][1]))
+
+    def _clamp(idx: int) -> int:
+        return max(0, min(idx, max(len(params) - 1, 0)))
+
+    for idx, (start, end, node) in enumerate(spans):
+        if _pos_within(cursor, start, end):
+            if isinstance(node, ast.keyword) and node.arg and node.arg in params:
+                return _clamp(params.index(node.arg))
+            return _clamp(idx)
+
+    # If cursor is after some args but not inside one, infer next argument slot.
+    before_count = sum(1 for start, _, _ in spans if start <= cursor)
+    return _clamp(before_count)
+
+
+def _node_start(node: ast.AST) -> Tuple[int, int]:
+    return (getattr(node, "lineno", 1) - 1, getattr(node, "col_offset", 0))
+
+
+def _node_end(node: ast.AST) -> Tuple[int, int]:
+    return (
+        getattr(node, "end_lineno", getattr(node, "lineno", 1)) - 1,
+        getattr(node, "end_col_offset", getattr(node, "col_offset", 0)),
+    )

{avrae_ls-0.4.0.dist-info → avrae_ls-0.4.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: avrae-ls
-Version: 0.4.0
+Version: 0.4.1
 Summary: Language server for Avrae draconic aliases
 Author: 1drturtle
 Requires-Python: >=3.11

{avrae_ls-0.4.0.dist-info → avrae_ls-0.4.1.dist-info}/RECORD

@@ -1,21 +1,23 @@
 avrae_ls/__init__.py,sha256=BmjrnksGkbG7TPqwbyQvgYj9uei8pFSFpfkRpaGVdJU,63
 avrae_ls/__main__.py,sha256=ch287lWe11go5xHAE9OkVppixt0vRF401E4zTs2tqQ0,3557
-avrae_ls/alias_preview.py,sha256=Wy_ZNRq73ojPiLFf6P6fJ7rG7DeFFsFLkLlhFrAjkKI,6117
+avrae_ls/alias_preview.py,sha256=YFUiY36runNe6R0k-9YrbGff4l3evgEsoWbVc8WT5nU,11462
 avrae_ls/api.py,sha256=_AHvIEIlz34YeWdZDpXd1EwgdQUGk8-nqNIEN4qdNR8,65093
 avrae_ls/argparser.py,sha256=DRptXGyK4f0r7NsuV1Sg4apG-qihIClOX408jgk4HH4,13762
 avrae_ls/argument_parsing.py,sha256=ezKl65VwuNEDxt6KlYwVQcpy1110UDvf4BqZqgZTcqk,2122
-avrae_ls/completions.py,sha256=ht0J7JQX5QS8cz85itfozLBP9GPr1BjmNyttFEmJN-0,34514
+avrae_ls/code_actions.py,sha256=CYl3nMzCaE9k35p5fWAmzsTOVfcv2RrkA3SbtyCdcsI,9423
+avrae_ls/codes.py,sha256=iPRPQ6i9DZheae4_ra1y29vCw3Y4SEu6Udf5WiZj_RY,136
+avrae_ls/completions.py,sha256=CvwKp3f20RsPFPnjUv03xCbuaGKIyIF7VgVhYNbig4U,51180
 avrae_ls/config.py,sha256=ULEfWbzIO05cllHBLUeGY_CHLpX6tHyCJYIEQgKSoXc,17383
 avrae_ls/context.py,sha256=KcCKqzqJCG2xlEtou5HWz1OWISApGl8IfwOvVnNi9nc,8464
 avrae_ls/cvars.py,sha256=0tcVbUHx_CKJ6aou3kEsKX37LRWAjkUWlqqIuSRFlXk,3197
-avrae_ls/diagnostics.py,sha256=2wn9Gu5vDGWt32zap9rhduv4q4B9c_X3baI2_yDHGYg,23074
+avrae_ls/diagnostics.py,sha256=wq5sBjI11NyTNtnjoZTGm1vdcvOvW7OoPHbCDAbF308,24914
 avrae_ls/dice.py,sha256=DY7V7L-EwAXaCgddgVe9xU1s9lVtiw5Zc2reipNgdTk,874
 avrae_ls/parser.py,sha256=UQDwjupuJVU6KvoF4D8r3azPT7ksP_nTZsm5FUhGnWE,1395
 avrae_ls/runtime.py,sha256=PDnjZXcU5DqM9jKSc4S0jHObBE7SWKte17PWWXGQ34M,23356
-avrae_ls/server.py,sha256=jKypzveP2iRZjEdK0xJxfcn6QfbjrDe03XnXNhsga9Q,14709
-avrae_ls/signature_help.py,sha256=JheaEzINV4FO72t5U0AJfL2ZX15y3-gcA6xk3M1jHcY,6980
+avrae_ls/server.py,sha256=s3Cl6Ta0954FqBUh9pM326TwdUBLb7ZuyzR8vjQqs5c,15101
+avrae_ls/signature_help.py,sha256=sVQncCeLNCD3UBVPZu9ZFw0b-8wq64n3qFPLtWSy_Cs,8827
 avrae_ls/symbols.py,sha256=Lm5LH-F60JYNuAtSjRhHeyHEWAWxpnNb0w6KR0u1Zac,8422
-avrae_ls-0.4.0.dist-info/licenses/LICENSE,sha256=O-0zMbcEi6wXz1DiSdVgzMlQjJcNqNe5KDv08uYzqR0,1055
+avrae_ls-0.4.1.dist-info/licenses/LICENSE,sha256=O-0zMbcEi6wXz1DiSdVgzMlQjJcNqNe5KDv08uYzqR0,1055
 draconic/LICENSE,sha256=Fzvu32_DafLKKn2mzxhEdlmrKZzAsigDZ87O7uoVqZI,1067
 draconic/__init__.py,sha256=YPH420Pcn_nTkfB62hJy_YqC5kpJdzSa78jP8n4z_xY,109
 draconic/exceptions.py,sha256=siahnHIsumbaUhKBDSrw_DmLZ-0oZks8L5oytPH8hD4,3753
@@ -25,8 +27,8 @@ draconic/string.py,sha256=kGrRc6wNHRq1y5xw8Os-fBhfINDtIY2nBWQWkyLSfQI,2858
 draconic/types.py,sha256=1Lsr6z8bW5agglGI4hLt_nPtYuZOIf_ueSpPDB4WDrs,13686
 draconic/utils.py,sha256=D4vJ-txqS2-rlqsEpXAC46_j1sZX4UjY-9zIgElo96k,3122
 draconic/versions.py,sha256=CUEsgUWjAmjez0432WwiBwZlIzWPIObwZUf8Yld18EE,84
-avrae_ls-0.4.0.dist-info/METADATA,sha256=z-bp7Y2zrilkbNmLujQYnHOW6rRlAyPMdQpJBDUB4cU,4713
-avrae_ls-0.4.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-avrae_ls-0.4.0.dist-info/entry_points.txt,sha256=OtYXipMQzqmxpMoApgo0MeJYFmMbkbFN51Ibhpb8hF4,52
-avrae_ls-0.4.0.dist-info/top_level.txt,sha256=TL68uzGHmB2R2ID32_s2zocmcNnpMJVQ6_4NBvyo8a4,18
-avrae_ls-0.4.0.dist-info/RECORD,,
+avrae_ls-0.4.1.dist-info/METADATA,sha256=4kw6QJtVMqp_8pHBPra7sJXjchuCQdSOYiwj_dt7j1k,4713
+avrae_ls-0.4.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+avrae_ls-0.4.1.dist-info/entry_points.txt,sha256=OtYXipMQzqmxpMoApgo0MeJYFmMbkbFN51Ibhpb8hF4,52
+avrae_ls-0.4.1.dist-info/top_level.txt,sha256=TL68uzGHmB2R2ID32_s2zocmcNnpMJVQ6_4NBvyo8a4,18
+avrae_ls-0.4.1.dist-info/RECORD,,