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

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

@@ -1,21 +1,41 @@
 Metadata-Version: 2.4
 Name: avrae-ls
-Version: 0.4.0
+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.0.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,180 +0,0 @@
-from __future__ import annotations
-
-import re
-import shlex
-from dataclasses import dataclass
-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
-
-
-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 _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 simulate_command(command: str) -> tuple[str | None, str | None, str | None]:
-    """Very small shim to preview common commands."""
-    text = command.strip()
-    if not text:
-        return None, None, None
-    head, *rest = text.split(maxsplit=1)
-    payload = rest[0] if rest else ""
-    lowered = head.lower()
-    if lowered == "echo":
-        return payload, "echo", None
-    if lowered == "embed":
-        valid, error = validate_embed_payload(payload)
-        return payload, "embed", error
-    return None, head, None