avrae-ls 0.4.0__tar.gz → 0.4.1__tar.gz

{avrae_ls-0.4.0/src/avrae_ls.egg-info → avrae_ls-0.4.1}/PKG-INFO

@@ -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 → avrae_ls-0.4.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "avrae-ls"
-version = "0.4.0"
+version = "0.4.1"
 description = "Language server for Avrae draconic aliases"
 authors = [
   { name = "1drturtle" }

{avrae_ls-0.4.0 → avrae_ls-0.4.1}/src/avrae_ls/alias_preview.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import re
 import shlex
-from dataclasses import dataclass
+from dataclasses import asdict, dataclass, field
 from typing import Any, Optional, Tuple
 
 from .parser import DRACONIC_RE
@@ -19,6 +19,45 @@ class RenderedAlias:
     last_value: Any | None = None
 
 
+@dataclass
+class EmbedFieldPreview:
+    name: str
+    value: str
+    inline: bool = False
+
+
+@dataclass
+class EmbedPreview:
+    title: str | None = None
+    description: str | None = None
+    footer: str | None = None
+    thumbnail: str | None = None
+    image: str | None = None
+    color: str | None = None
+    timeout: int | None = None
+    fields: list[EmbedFieldPreview] = field(default_factory=list)
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "title": self.title,
+            "description": self.description,
+            "footer": self.footer,
+            "thumbnail": self.thumbnail,
+            "image": self.image,
+            "color": self.color,
+            "timeout": self.timeout,
+            "fields": [asdict(f) for f in self.fields],
+        }
+
+
+@dataclass
+class SimulatedCommand:
+    preview: str | None
+    command_name: str | None
+    validation_error: str | None
+    embed: EmbedPreview | None = None
+
+
 def _strip_alias_header(text: str) -> str:
     lines = text.splitlines()
     if lines and lines[0].lstrip().startswith("!alias"):
@@ -82,6 +121,58 @@ def validate_embed_payload(payload: str) -> Tuple[bool, str | None]:
     return _validate_embed_flags(text)
 
 
+def parse_embed_payload(payload: str) -> EmbedPreview:
+    """Parse an embed payload into a structured preview object."""
+    tokens = shlex.split(payload.strip())
+    preview = EmbedPreview()
+
+    i = 0
+    while i < len(tokens):
+        tok = tokens[i]
+        if not tok.startswith("-"):
+            i += 1
+            continue
+        key = tok.lower()
+        next_val = tokens[i + 1] if i + 1 < len(tokens) else None
+        if key == "-title":
+            preview.title = next_val or ""
+            i += 2
+            continue
+        if key == "-desc":
+            preview.description = next_val or ""
+            i += 2
+            continue
+        if key == "-footer":
+            preview.footer = next_val or ""
+            i += 2
+            continue
+        if key == "-thumb":
+            preview.thumbnail = next_val or ""
+            i += 2
+            continue
+        if key == "-image":
+            preview.image = next_val or ""
+            i += 2
+            continue
+        if key == "-color":
+            preview.color = _normalize_color(next_val)
+            i += 2 if next_val is not None else 1
+            continue
+        if key == "-t":
+            preview.timeout = _parse_timeout(next_val)
+            i += 2
+            continue
+        if key == "-f":
+            field = _parse_field_value(next_val)
+            if field:
+                preview.fields.append(field)
+            i += 2
+            continue
+        i += 1
+
+    return preview
+
+
 def _validate_embed_flags(text: str) -> Tuple[bool, str | None]:
     """Validate embed flags according to Avrae's help text."""
     if not text:
@@ -164,17 +255,92 @@ def _validate_timeout_arg(value: str | None) -> Tuple[bool, str | None, int]:
     return True, None, consumed
 
 
-def simulate_command(command: str) -> tuple[str | None, str | None, str | None]:
+def _parse_timeout(value: str | None) -> int | None:
+    if value is None:
+        return None
+    try:
+        return int(value)
+    except (TypeError, ValueError):
+        return None
+
+
+def _normalize_color(value: str | None) -> str | None:
+    if value is None:
+        return None
+    if not value:
+        return None
+    match = re.match(r"^(?:#|0x)?([0-9a-fA-F]{6})$", value)
+    if not match:
+        return value
+    return f"#{match.group(1)}"
+
+
+def _parse_field_value(value: str | None) -> EmbedFieldPreview | None:
+    if value is None:
+        return None
+    parts = value.split("|")
+    if len(parts) < 2:
+        return None
+    inline_flag = parts[2].lower() == "inline" if len(parts) == 3 else False
+    return EmbedFieldPreview(name=parts[0], value=parts[1], inline=inline_flag)
+
+
+def simulate_command(command: str) -> SimulatedCommand:
     """Very small shim to preview common commands."""
-    text = command.strip()
+    text = _strip_alias_header(command).strip()
     if not text:
-        return None, None, None
-    head, *rest = text.split(maxsplit=1)
-    payload = rest[0] if rest else ""
+        return SimulatedCommand(None, None, None, None)
+    head, payload = _extract_command_head_and_payload(text)
+    if not head:
+        return SimulatedCommand(None, None, None, None)
     lowered = head.lower()
     if lowered == "echo":
-        return payload, "echo", None
+        return SimulatedCommand(payload, "echo", None, None)
     if lowered == "embed":
         valid, error = validate_embed_payload(payload)
-        return payload, "embed", error
-    return None, head, None
+        embed_preview = parse_embed_payload(payload) if valid else None
+        return SimulatedCommand(payload, "embed", error, embed_preview)
+    if head.startswith("-") and _is_embed_flag(head):
+        payload = text
+        valid, error = validate_embed_payload(payload)
+        embed_preview = parse_embed_payload(payload) if valid else None
+        return SimulatedCommand(payload, "embed", error, embed_preview)
+    return SimulatedCommand(None, head, None, None)
+
+
+def _extract_command_head_and_payload(text: str) -> tuple[str | None, str]:
+    """Prefer the first non-empty line; fall back to any embed line later."""
+    lines = [ln.strip() for ln in text.splitlines() if ln.strip()]
+    if not lines:
+        return None, ""
+    head, payload = _split_head_and_payload_from_line(lines[0])
+    if _is_embed_flag(head):
+        # Treat the entire payload (including the head line) as embed flags so multiple lines are preserved.
+        return head, "\n".join(lines)
+    if head and head.lower() in ("embed", "echo"):
+        return head, _merge_payload(payload, lines[1:])
+    for idx, line in enumerate(lines[1:], start=1):
+        possible_head, possible_payload = _split_head_and_payload_from_line(line)
+        if possible_head and (possible_head.lower() == "embed" or _is_embed_flag(possible_head)):
+            return possible_head, _merge_payload(possible_payload, lines[idx + 1 :])
+    return head, _merge_payload(payload, lines[1:])
+
+
+def _split_head_and_payload_from_line(line: str) -> tuple[str | None, str]:
+    if not line:
+        return None, ""
+    parts = line.split(maxsplit=1)
+    head = parts[0]
+    payload = parts[1] if len(parts) > 1 else ""
+    return head, payload
+
+
+def _merge_payload(first_payload: str, trailing_lines: list[str]) -> str:
+    payload = first_payload
+    if trailing_lines:
+        payload = (payload + "\n" if payload else "") + "\n".join(trailing_lines)
+    return payload
+
+
+def _is_embed_flag(flag: str) -> bool:
+    return flag.lower() in {"-title", "-desc", "-thumb", "-image", "-footer", "-f", "-color", "-t"}

avrae_ls-0.4.1/src/avrae_ls/code_actions.py

@@ -0,0 +1,282 @@
+from __future__ import annotations
+
+import json
+import logging
+import re
+from dataclasses import dataclass
+from pathlib import Path
+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
+
+log = logging.getLogger(__name__)
+
+# Workspace-relative file that can extend snippet-based code actions without touching code.
+SNIPPET_FILENAME = ".avraels.snippets.json"
+
+
+@dataclass
+class Snippet:
+    key: str
+    title: str
+    body: str
+    description: str | None = None
+    kind: str = types.CodeActionKind.RefactorRewrite
+
+
+DEFAULT_SNIPPETS: tuple[Snippet, ...] = (
+    Snippet(
+        key="drac2Wrapper",
+        title="Wrap in <drac2>…</drac2>",
+        body="<drac2>\n{content}\n</drac2>\n",
+        description="Wrap the current selection or file in a draconic block.",
+        kind=types.CodeActionKind.RefactorRewrite,
+    ),
+)
+
+
+def code_actions_for_document(
+    source: str,
+    params: types.CodeActionParams,
+    workspace_root: Path,
+) -> List[types.CodeAction]:
+    """Collect code actions for a document without requiring a running server."""
+    actions: list[types.CodeAction] = []
+    blocks = find_draconic_blocks(source)
+    snippets = _load_snippets(workspace_root)
+    only_kinds = list(params.context.only or [])
+
+    actions.extend(_snippet_actions(source, params, snippets, only_kinds, blocks))
+    actions.extend(_diagnostic_actions(source, params, blocks, only_kinds))
+    return actions
+
+
+def _diagnostic_actions(
+    source: str,
+    params: types.CodeActionParams,
+    blocks: list[DraconicBlock],
+    only_kinds: Sequence[str],
+) -> Iterable[types.CodeAction]:
+    for diag in params.context.diagnostics or []:
+        if diag.code == UNDEFINED_NAME_CODE and _kind_allowed(types.CodeActionKind.QuickFix, only_kinds):
+            name = (diag.data or {}).get("name") if isinstance(diag.data, dict) else None
+            if name:
+                yield _stub_variable_action(source, params.text_document.uri, blocks, diag, name)
+        if diag.code == MISSING_GVAR_CODE and _kind_allowed(types.CodeActionKind.QuickFix, only_kinds):
+            gvar_id = (diag.data or {}).get("gvar") if isinstance(diag.data, dict) else None
+            if gvar_id:
+                yield _using_stub_action(source, params.text_document.uri, blocks, diag, gvar_id)
+        if diag.code == UNSUPPORTED_IMPORT_CODE and _kind_allowed(types.CodeActionKind.QuickFix, only_kinds):
+            module = (diag.data or {}).get("module") if isinstance(diag.data, dict) else None
+            yield _rewrite_import_action(source, params.text_document.uri, diag, module)
+
+
+def _snippet_actions(
+    source: str,
+    params: types.CodeActionParams,
+    snippets: Sequence[Snippet],
+    only_kinds: Sequence[str],
+    blocks: list[DraconicBlock],
+) -> Iterable[types.CodeAction]:
+    # Skip wrapper suggestions when a draconic block already exists.
+    has_draconic = bool(blocks)
+    selection_text = _text_in_range(source, params.range)
+    for snippet in snippets:
+        if not _kind_allowed(snippet.kind, only_kinds):
+            continue
+        if snippet.key == "drac2Wrapper" and has_draconic:
+            continue
+        rendered = _render_snippet(snippet, selection_text or source)
+        edit_range = params.range
+        if not selection_text:
+            edit_range = _full_range(source)
+        edit = types.TextEdit(range=edit_range, new_text=rendered)
+        action = types.CodeAction(
+            title=snippet.title,
+            kind=snippet.kind,
+            edit=types.WorkspaceEdit(changes={params.text_document.uri: [edit]}),
+        )
+        if snippet.description:
+            action.diagnostics = None
+            action.command = None
+        yield action
+
+
+def _stub_variable_action(
+    source: str,
+    uri: str,
+    blocks: list[DraconicBlock],
+    diag: types.Diagnostic,
+    name: str,
+) -> types.CodeAction:
+    insertion_line, indent = _block_insertion(blocks, diag.range.start.line, source)
+    edit = types.TextEdit(
+        range=types.Range(
+            start=types.Position(line=insertion_line, character=indent),
+            end=types.Position(line=insertion_line, character=indent),
+        ),
+        new_text=f"{' ' * indent}{name} = None\n",
+    )
+    return types.CodeAction(
+        title=f"Create stub variable '{name}'",
+        kind=types.CodeActionKind.QuickFix,
+        diagnostics=[diag],
+        edit=types.WorkspaceEdit(changes={uri: [edit]}),
+    )
+
+
+def _using_stub_action(
+    source: str,
+    uri: str,
+    blocks: list[DraconicBlock],
+    diag: types.Diagnostic,
+    gvar_id: str,
+) -> types.CodeAction:
+    alias = _sanitize_symbol(gvar_id)
+    insertion_line, indent = _block_insertion(blocks, diag.range.start.line, source)
+    text = f"{' ' * indent}using({alias}=\"{gvar_id}\")\n"
+    edit = types.TextEdit(
+        range=types.Range(
+            start=types.Position(line=insertion_line, character=indent),
+            end=types.Position(line=insertion_line, character=indent),
+        ),
+        new_text=text,
+    )
+    return types.CodeAction(
+        title=f"Add using() stub for gvar '{gvar_id}'",
+        kind=types.CodeActionKind.QuickFix,
+        diagnostics=[diag],
+        edit=types.WorkspaceEdit(changes={uri: [edit]}),
+    )
+
+
+def _rewrite_import_action(
+    source: str,
+    uri: str,
+    diag: types.Diagnostic,
+    module: str | None,
+) -> types.CodeAction:
+    target = module or "module"
+    replacement = f"using({target}=\"<gvar-id>\")"
+    edit = types.TextEdit(range=diag.range, new_text=replacement)
+    return types.CodeAction(
+        title="Replace import with using()",
+        kind=types.CodeActionKind.QuickFix,
+        diagnostics=[diag],
+        edit=types.WorkspaceEdit(changes={uri: [edit]}),
+    )
+
+
+def _block_insertion(blocks: list[DraconicBlock], line: int, source: str) -> tuple[int, int]:
+    for block in blocks:
+        start = block.line_offset
+        end = block.line_offset + block.line_count
+        if start <= line <= end:
+            indent = _line_indent(source, start, default=block.char_offset)
+            return start, indent
+    return 0, _line_indent(source, 0, default=0)
+
+
+def _line_indent(source: str, line: int, default: int = 0) -> int:
+    lines = source.splitlines()
+    if 0 <= line < len(lines):
+        match = re.match(r"(\s*)", lines[line])
+        if match:
+            return len(match.group(1))
+    return default
+
+
+def _sanitize_symbol(label: str) -> str:
+    cleaned = re.sub(r"\W+", "_", str(label))
+    if cleaned and cleaned[0].isdigit():
+        cleaned = f"gvar_{cleaned}"
+    return cleaned or "gvar_import"
+
+
+def _kind_allowed(kind: str, only: Sequence[str]) -> bool:
+    if not only:
+        return True
+    for requested in only:
+        if kind.startswith(requested) or requested.startswith(kind):
+            return True
+    return False
+
+
+def _text_in_range(source: str, rng: types.Range) -> str:
+    if rng.start == rng.end:
+        return ""
+    start = _offset_at_position(source, rng.start)
+    end = _offset_at_position(source, rng.end)
+    return source[start:end]
+
+
+def _offset_at_position(source: str, pos: types.Position) -> int:
+    if pos.line < 0:
+        return 0
+    lines = source.splitlines(keepends=True)
+    if not lines:
+        return 0
+    if pos.line >= len(lines):
+        return len(source)
+    offset = sum(len(line) for line in lines[: pos.line])
+    return min(offset + pos.character, offset + len(lines[pos.line]))
+
+
+def _render_snippet(snippet: Snippet, selection: str) -> str:
+    if "{content}" in snippet.body:
+        return snippet.body.replace("{content}", selection)
+    return snippet.body
+
+
+def _full_range(source: str) -> types.Range:
+    lines = source.splitlines()
+    if not lines:
+        return types.Range(start=types.Position(line=0, character=0), end=types.Position(line=0, character=0))
+    end_line = len(lines) - 1
+    end_char = len(lines[-1])
+    return types.Range(
+        start=types.Position(line=0, character=0),
+        end=types.Position(line=end_line, character=end_char),
+    )
+
+
+def _load_snippets(root: Path) -> List[Snippet]:
+    snippets: list[Snippet] = list(DEFAULT_SNIPPETS)
+    user_file = root / SNIPPET_FILENAME
+    if not user_file.exists():
+        return snippets
+    try:
+        raw = json.loads(user_file.read_text())
+    except Exception as exc:  # pragma: no cover - best-effort load
+        log.warning("Failed to read snippet file %s: %s", user_file, exc)
+        return snippets
+
+    def _coerce(entry) -> Snippet | None:
+        if not isinstance(entry, dict):
+            return None
+        key = str(entry.get("key") or entry.get("title") or "")
+        body = entry.get("body")
+        title = entry.get("title") or key
+        if not key or not isinstance(body, str):
+            return None
+        return Snippet(
+            key=key,
+            title=str(title),
+            body=body,
+            description=str(entry.get("description") or ""),
+            kind=str(entry.get("kind") or types.CodeActionKind.RefactorRewrite),
+        )
+
+    entries: Iterable[dict] = []
+    if isinstance(raw, dict):
+        entries = raw.values()
+    elif isinstance(raw, list):
+        entries = raw
+    for entry in entries:
+        coerced = _coerce(entry)
+        if coerced:
+            snippets.append(coerced)
+    return snippets

avrae_ls-0.4.1/src/avrae_ls/codes.py

@@ -0,0 +1,3 @@
+UNDEFINED_NAME_CODE = "avrae.undefinedName"
+MISSING_GVAR_CODE = "avrae.missingGvar"
+UNSUPPORTED_IMPORT_CODE = "avrae.unsupportedImport"