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

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

@@ -1,21 +1,41 @@
 Metadata-Version: 2.4
 Name: avrae-ls
-Version: 0.4.1
+Version: 0.5.0
 Summary: Language server for Avrae draconic aliases
 Author: 1drturtle
-Requires-Python: >=3.11
-Description-Content-Type: text/markdown
+License: MIT License
+        
+        Copyright (c) 2025
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
 License-File: LICENSE
-Requires-Dist: pygls>=1.3.1
-Requires-Dist: lsprotocol>=2023.0.1
-Requires-Dist: httpx>=0.27
+Requires-Python: >=3.11
 Requires-Dist: d20>=1.1.2
+Requires-Dist: httpx>=0.27
+Requires-Dist: lsprotocol>=2023.0.1
+Requires-Dist: pygls>=1.3.1
 Provides-Extra: dev
-Requires-Dist: pytest>=8.3; extra == "dev"
-Requires-Dist: pytest-asyncio>=0.23; extra == "dev"
-Requires-Dist: pytest-cov>=7.0.0; extra == "dev"
-Requires-Dist: ruff>=0.6; extra == "dev"
-Dynamic: license-file
+Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
+Requires-Dist: pytest-cov>=7.0.0; extra == 'dev'
+Requires-Dist: pytest>=8.3; extra == 'dev'
+Requires-Dist: ruff>=0.6; extra == 'dev'
+Description-Content-Type: text/markdown
 
 # Avrae Draconic Alias Language Server
 

avrae_ls-0.5.0.dist-info/RECORD

@@ -0,0 +1,6 @@
+draconic/LICENSE,sha256=Fzvu32_DafLKKn2mzxhEdlmrKZzAsigDZ87O7uoVqZI,1067
+avrae_ls-0.5.0.dist-info/METADATA,sha256=Cl5rYWKuTLOoom3cjo4BV9ah4dMurBJ39nwJMsKBO4s,5916
+avrae_ls-0.5.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+avrae_ls-0.5.0.dist-info/entry_points.txt,sha256=OtYXipMQzqmxpMoApgo0MeJYFmMbkbFN51Ibhpb8hF4,52
+avrae_ls-0.5.0.dist-info/licenses/LICENSE,sha256=O-0zMbcEi6wXz1DiSdVgzMlQjJcNqNe5KDv08uYzqR0,1055
+avrae_ls-0.5.0.dist-info/RECORD,,

{avrae_ls-0.4.1.dist-info → avrae_ls-0.5.0.dist-info}/WHEEL

@@ -1,5 +1,4 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: hatchling 1.27.0
 Root-Is-Purelib: true
 Tag: py3-none-any
-

avrae_ls/__init__.py

@@ -1,3 +0,0 @@
-from .server import create_server
-
-__all__ = ["create_server"]

avrae_ls/__main__.py

@@ -1,108 +0,0 @@
-from __future__ import annotations
-
-import argparse
-import asyncio
-import logging
-import sys
-from pathlib import Path
-from typing import Iterable
-
-from lsprotocol import types
-
-from .config import CONFIG_FILENAME, load_config
-from .context import ContextBuilder
-from .diagnostics import DiagnosticProvider
-from .runtime import MockExecutor
-from .server import create_server
-
-
-def main(argv: list[str] | None = None) -> None:
-    parser = argparse.ArgumentParser(description="Avrae draconic alias language server")
-    parser.add_argument("--tcp", action="store_true", help="Run in TCP mode instead of stdio")
-    parser.add_argument("--host", default="127.0.0.1", help="TCP host (when --tcp is set)")
-    parser.add_argument("--port", type=int, default=2087, help="TCP port (when --tcp is set)")
-    parser.add_argument("--stdio", action="store_true", help="Accept stdio flag for VS Code clients (ignored)")
-    parser.add_argument("--log-level", default="WARNING", help="Logging level (DEBUG, INFO, WARNING, ERROR)")
-    parser.add_argument("--analyze", metavar="FILE", help="Run diagnostics for a file and print them to stdout")
-    args = parser.parse_args(argv)
-
-    _configure_logging(args.log_level)
-
-    if args.analyze:
-        if args.tcp:
-            parser.error("--analyze cannot be combined with --tcp")
-        sys.exit(_run_analysis(Path(args.analyze)))
-
-    server = create_server()
-    if args.tcp:
-        server.start_tcp(args.host, args.port)
-    else:
-        server.start_io()
-
-
-def _configure_logging(level: str) -> None:
-    numeric = getattr(logging, level.upper(), logging.WARNING)
-    if not isinstance(numeric, int):
-        numeric = logging.WARNING
-    logging.basicConfig(
-        level=numeric,
-        format="%(levelname)s %(name)s: %(message)s",
-    )
-
-
-def _run_analysis(path: Path) -> int:
-    if not path.exists():
-        print(f"File not found: {path}", file=sys.stderr)
-        return 2
-
-    workspace_root = _discover_workspace_root(path)
-    log = logging.getLogger(__name__)
-    log.info("Analyzing %s (workspace root: %s)", path, workspace_root)
-
-    config, warnings = load_config(workspace_root)
-    for warning in warnings:
-        log.warning(warning)
-
-    builder = ContextBuilder(config)
-    ctx_data = builder.build()
-    executor = MockExecutor(config.service)
-    diagnostics = DiagnosticProvider(executor, config.diagnostics)
-
-    source = path.read_text()
-    results = asyncio.run(diagnostics.analyze(source, ctx_data, builder.gvar_resolver))
-    _print_diagnostics(path, results)
-    return 1 if results else 0
-
-
-def _discover_workspace_root(target: Path) -> Path:
-    current = target if target.is_dir() else target.parent
-    for folder in [current, *current.parents]:
-        if (folder / CONFIG_FILENAME).exists():
-            return folder
-    return current
-
-
-def _print_diagnostics(path: Path, diagnostics: Iterable[types.Diagnostic]) -> None:
-    diags = list(diagnostics)
-    if not diags:
-        print(f"{path}: no issues found")
-        return
-
-    for diag in diags:
-        start = diag.range.start
-        severity = _severity_label(diag.severity)
-        source = diag.source or "avrae-ls"
-        print(f"{path}:{start.line + 1}:{start.character + 1}: {severity} [{source}] {diag.message}")
-
-
-def _severity_label(severity: types.DiagnosticSeverity | None) -> str:
-    if severity is None:
-        return "info"
-    try:
-        return types.DiagnosticSeverity(severity).name.lower()
-    except Exception:
-        return str(severity).lower()
-
-
-if __name__ == "__main__":
-    main()

avrae_ls/alias_preview.py

@@ -1,346 +0,0 @@
-from __future__ import annotations
-
-import re
-import shlex
-from dataclasses import asdict, dataclass, field
-from typing import Any, Optional, Tuple
-
-from .parser import DRACONIC_RE
-from .runtime import ExecutionResult, MockExecutor
-from .context import ContextData, GVarResolver
-from .argument_parsing import apply_argument_parsing
-
-
-@dataclass
-class RenderedAlias:
-    command: str
-    stdout: str
-    error: Optional[BaseException]
-    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"):
-        first = lines[0].lstrip()
-        parts = first.split(maxsplit=2)
-        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
-
-
-async def render_alias_command(
-    text: str,
-    executor: MockExecutor,
-    ctx_data: ContextData,
-    resolver: GVarResolver,
-    args: list[str] | None = None,
-) -> RenderedAlias:
-    """Replace <drac2> blocks with their evaluated values and return final command."""
-    body = _strip_alias_header(text)
-    body = apply_argument_parsing(body, args)
-    stdout_parts: list[str] = []
-    parts: list[str] = []
-    last_value = None
-    error: BaseException | None = None
-
-    pos = 0
-    for match in DRACONIC_RE.finditer(body):
-        parts.append(body[pos: match.start()])
-        code = match.group(1)
-        result: ExecutionResult = await executor.run(code, ctx_data, resolver)
-        if result.stdout:
-            stdout_parts.append(result.stdout)
-        if result.error:
-            error = result.error
-            break
-        last_value = result.value
-        parts.append("" if result.value is None else str(result.value))
-        pos = match.end()
-
-    if error is None:
-        parts.append(body[pos:])
-
-    final_command = "".join(parts)
-    return RenderedAlias(command=final_command, stdout="".join(stdout_parts), error=error, last_value=last_value)
-
-
-def validate_embed_payload(payload: str) -> Tuple[bool, str | None]:
-    """
-    Light validation for embed previews using Avrae-style flags.
-
-    Accepts strings such as "-title Foo -f \"T|Body\"" and validates arguments.
-    Returns (is_valid, error_message) without attempting to parse JSON objects.
-    """
-    text = payload.strip()
-    if not text:
-        return False, "Embed payload is empty."
-
-    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:
-        return False, "Embed payload is empty."
-
-    try:
-        tokens = shlex.split(text)
-    except ValueError as exc:  # pragma: no cover - defensive only
-        return False, f"Embed payload could not be parsed: {exc}"
-
-    flag_handlers = {
-        "-title": lambda val: _require_value("-title", val),
-        "-desc": lambda val: _require_value("-desc", val),
-        "-thumb": lambda val: _require_value("-thumb", val),
-        "-image": lambda val: _require_value("-image", val),
-        "-footer": lambda val: _require_value("-footer", val),
-        "-f": _validate_field_arg,
-        "-color": _validate_color_arg,
-        "-t": _validate_timeout_arg,
-    }
-
-    i = 0
-    while i < len(tokens):
-        tok = tokens[i]
-        key = tok.lower()
-        if not tok.startswith("-"):
-            i += 1
-            continue
-        if key not in flag_handlers:
-            return False, f"Embed payload contains unknown flag '{tok}'."
-        next_val = tokens[i + 1] if i + 1 < len(tokens) else None
-        ok, err, consumed = flag_handlers[key](next_val)
-        if not ok:
-            return False, err
-        i += consumed + 1
-    return True, None
-
-
-def _require_value(flag: str, value: str | None) -> Tuple[bool, str | None, int]:
-    if value is None or value.startswith("-"):
-        return False, f"Embed flag '{flag}' requires a value.", 0
-    return True, None, 1
-
-
-def _validate_field_arg(value: str | None) -> Tuple[bool, str | None, int]:
-    ok, err, consumed = _require_value("-f", value)
-    if not ok:
-        return ok, err, consumed
-    assert value is not None  # for type checker
-    parts = value.split("|")
-    if len(parts) < 2 or len(parts) > 3:
-        return False, "Embed field must be in the form \"Title|Text[|inline]\".", consumed
-    if not parts[0] or not parts[1]:
-        return False, "Embed field title and text cannot be empty.", consumed
-    if len(parts) == 3 and parts[2].lower() not in ("inline", ""):
-        return False, "Embed field inline value must be 'inline' or omitted.", consumed
-    return True, None, consumed
-
-
-def _validate_color_arg(value: str | None) -> Tuple[bool, str | None, int]:
-    if value is None or value.startswith("-"):
-        # Random color is allowed when omitted
-        return True, None, 0
-    if not re.match(r"^(?:#|0x)?[0-9a-fA-F]{6}$", value):
-        return False, "Embed color must be a 6-hex value (e.g. #ff00ff).", 1
-    return True, None, 1
-
-
-def _validate_timeout_arg(value: str | None) -> Tuple[bool, str | None, int]:
-    ok, err, consumed = _require_value("-t", value)
-    if not ok:
-        return ok, err, consumed
-    assert value is not None  # for type checker
-    try:
-        num = int(value)
-    except ValueError:
-        return False, "Embed timeout (-t) must be an integer.", consumed
-    if num < 0 or num > 600:
-        return False, "Embed timeout (-t) must be between 0 and 600 seconds.", consumed
-    return True, None, consumed
-
-
-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 = _strip_alias_header(command).strip()
-    if not text:
-        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 SimulatedCommand(payload, "echo", None, None)
-    if lowered == "embed":
-        valid, error = validate_embed_payload(payload)
-        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"}