weavly 0.1.0__py3-none-any.whl

weavly/__init__.py

@@ -0,0 +1 @@
+

weavly/cli.py

@@ -0,0 +1,82 @@
+from importlib.metadata import version as package_version
+from pathlib import Path
+
+import typer
+
+from .parsing import (
+    WVL_SOURCE_EXTENSION,
+    build_all_files,
+)
+from .reporting import report_error
+
+SOURCE_DIR = Path("src")
+BUILD_DIR = Path("build")
+
+NODE_INIT_STRING = (
+    "@env\n"
+    "name: string = \"World\"\n"
+    "@endenv\n"
+    "\n"
+    "@node first_node\n"
+    "Hello $name!\n"
+    "@endnode\n"
+)
+
+app = typer.Typer(add_completion=False, pretty_exceptions_show_locals=False)
+
+
+def _print_version(value: bool) -> None:
+    if value:
+        typer.echo(f"weavly {package_version('weavly')}")
+        raise typer.Exit()
+
+
+@app.callback()
+def main(
+    version: bool = typer.Option(
+        False,
+        "--version",
+        callback=_print_version,
+        is_eager=True,
+        help="Show the version and exit.",
+    ),
+):
+    """Compiler for the Weavly dialog scripting language."""
+
+
+@app.command()
+def build(
+    pretty: bool = typer.Option(
+        False, "--pretty", help="Write indented, human-readable JSON."
+    ),
+):
+    """Compile src/**/*.wvl into build/."""
+    count = build_all_files(SOURCE_DIR, BUILD_DIR, pretty)
+    files = "file" if count == 1 else "files"
+    typer.echo(f"Built {count} {files} into {BUILD_DIR.as_posix()}/")
+
+
+@app.command()
+def init(
+    name: str = typer.Argument(
+        None, help="Directory to create. Defaults to the current directory."
+    ),
+):
+    """Create a new Weavly project with a starter src/nodes.wvl."""
+    if name:
+        base = Path(name)
+        if base.exists():
+            report_error(f"project '{name}' already exists")
+            raise typer.Exit(code=1)
+        base.mkdir()
+    else:
+        base = Path()
+
+    src: Path = base / "src"
+    if src.exists():
+        report_error(f"directory '{src.as_posix()}' already exists")
+        raise typer.Exit(code=1)
+    src.mkdir()
+    nodes_file = src / f"nodes{WVL_SOURCE_EXTENSION}"
+    nodes_file.write_text(NODE_INIT_STRING, encoding="utf-8")
+    typer.echo(f"Created {nodes_file.as_posix()}")

weavly/parsing/__init__.py

@@ -0,0 +1,7 @@
+from .parser import WVL_BUILD_EXTENSION, WVL_SOURCE_EXTENSION, build_all_files
+
+__all__ = [
+    "build_all_files",
+    "WVL_SOURCE_EXTENSION",
+    "WVL_BUILD_EXTENSION",
+]

weavly/parsing/parser.py

@@ -0,0 +1,254 @@
+import json
+import shutil
+from importlib import resources
+from pathlib import Path
+
+import typer
+from lark import Lark, Token, Transformer, Tree
+from lark.exceptions import UnexpectedInput, VisitError
+
+from ..reporting import report_error
+from .syntax_errors import describe_syntax_error, terminal_names
+from .wvl_transformer import InvalidStringError, WvlTransformer
+
+PARSER_TYPE = "lalr"
+ENCODING = "utf-8"
+SOURCE_ENCODING = "utf-8-sig"
+
+WVL_SOURCE_EXTENSION = ".wvl"
+WVL_BUILD_EXTENSION = ".wvl.json"
+WVL_GRAMMAR_FILE = "wvl-grammar.lark"
+ENV_BUILD_FILE = "env.json"
+
+_DECLARATION_RULES = frozenset(
+    {"number_declaration", "string_declaration", "flag_declaration"}
+)
+_NODE_RULES = frozenset({"node_start"})
+_GOTO_RULES = frozenset({"goto", "inline_goto"})
+
+Location = tuple[Path, int, int]
+
+
+def build_all_files(src_dir: Path, build_dir: Path, pretty: bool) -> int:
+    if not src_dir.is_dir():
+        report_error(
+            f"no '{src_dir.as_posix()}' directory found. Run 'weavly init' to create "
+            "a project or run the build from the project root."
+        )
+        raise typer.Exit(code=1)
+
+    grammar = _load_grammar(WVL_GRAMMAR_FILE)
+    parser = _build_parser(grammar, PARSER_TYPE)
+    names = terminal_names(parser)
+    transformer = WvlTransformer()
+
+    declarations: list[dict] = []
+    outputs: list[tuple[Path, dict]] = []
+    # name -> location of the first declaration seen with that name.
+    declared: dict[str, Location] = {}
+    node_ids: dict[str, Location] = {}
+    gotos: list[tuple[str, Location]] = []
+    validation_errors: list[tuple[Location, str]] = []
+    failed = False
+
+    for file in sorted(src_dir.rglob(f"*{WVL_SOURCE_EXTENSION}")):
+        if not file.is_file():
+            continue
+
+        relative_path = file.relative_to(src_dir)
+        out_file = relative_path.with_suffix(WVL_BUILD_EXTENSION)
+
+        try:
+            text = file.read_text(encoding=SOURCE_ENCODING)
+        except UnicodeDecodeError as e:
+            _report_encoding_error(e, file)
+            failed = True
+            continue
+
+        try:
+            tree = parser.parse(text)
+        except UnexpectedInput as e:
+            _report_parse_error(e, file, text, names)
+            failed = True
+            continue
+
+        try:
+            data = transformer.transform(tree)
+        except VisitError as e:
+            if not isinstance(e.orig_exc, InvalidStringError):
+                raise
+            _report_string_error(e.orig_exc, file)
+            failed = True
+            continue
+
+        # Source locations come from the raw tree; the transformed data has no
+        # line numbers.
+        _record_unique(
+            _id_locations(tree, _DECLARATION_RULES, file),
+            declared,
+            "variable",
+            validation_errors,
+        )
+        _record_unique(
+            _id_locations(tree, _NODE_RULES, file), node_ids, "node id", validation_errors
+        )
+        gotos.extend(_id_locations(tree, _GOTO_RULES, file))
+        validation_errors.extend(_number_range_errors(tree, file))
+        declarations.extend(data.get("declarations", []))
+
+        outputs.append((out_file, {"nodes": data["nodes"]}))
+
+    if failed:
+        raise typer.Exit(code=1)
+
+    validation_errors.extend(
+        (location, f"goto target '{target}' matches no node")
+        for target, location in gotos
+        if target not in node_ids
+    )
+    if validation_errors:
+        for (file, line, column), message in sorted(validation_errors):
+            report_error(message, file, line, column)
+        raise typer.Exit(code=1)
+
+    file_count = len(outputs)
+    outputs.append((Path(ENV_BUILD_FILE), {"declarations": declarations}))
+    _replace_build_dir(build_dir, outputs, pretty)
+    return file_count
+
+
+def _replace_build_dir(
+    build_dir: Path, outputs: list[tuple[Path, dict]], pretty: bool
+) -> None:
+    tmp_dir = build_dir.with_name(f".{build_dir.name}.tmp")
+    old_dir = build_dir.with_name(f".{build_dir.name}.old")
+    try:
+        for leftover in (tmp_dir, old_dir):
+            if leftover.exists():
+                shutil.rmtree(leftover)
+        for out_file, data in outputs:
+            _write_json(data, tmp_dir / out_file, pretty)
+        if build_dir.exists():
+            build_dir.rename(old_dir)
+        tmp_dir.rename(build_dir)
+    except OSError as e:
+        shutil.rmtree(tmp_dir, ignore_errors=True)
+        report_error(
+            f"could not update '{build_dir.as_posix()}': {e.strerror or e}. "
+            "Close any program using its files and build again."
+        )
+        raise typer.Exit(code=1)
+    shutil.rmtree(old_dir, ignore_errors=True)
+
+
+def _id_locations(
+    tree: Tree, rules: frozenset[str], file: Path
+) -> list[tuple[str, Location]]:
+    """Return (id, location) for the leading ID of every matching rule, in source order."""
+    locations = []
+    for subtree in tree.iter_subtrees_topdown():
+        if subtree.data in rules:
+            id_token = subtree.children[0]
+            locations.append((str(id_token), (file, id_token.line, id_token.column)))
+    return locations
+
+
+def _record_unique(
+    locations: list[tuple[str, Location]],
+    seen: dict[str, Location],
+    kind: str,
+    errors: list[tuple[Location, str]],
+) -> None:
+    for name, location in locations:
+        if name in seen:
+            prev_file, prev_line, _ = seen[name]
+            errors.append(
+                (
+                    location,
+                    f"duplicate {kind} '{name}', first declared at "
+                    f"{prev_file.as_posix()}:{prev_line}",
+                )
+            )
+        else:
+            seen[name] = location
+
+
+def _number_range_errors(tree: Tree, file: Path) -> list[tuple[Location, str]]:
+    errors = []
+    for declaration in tree.find_data("number_declaration"):
+        name_token, *numbers = declaration.children
+        minimum, maximum, value = (_number(child) for child in numbers)
+        location = (file, name_token.line, name_token.column)
+        name = str(name_token)
+
+        if minimum is not None and maximum is not None and minimum > maximum:
+            errors.append(
+                (location, f"number '{name}' has min {minimum:g} greater than max {maximum:g}")
+            )
+            continue
+
+        default = f"default {value:g}" if value is not None else "implicit default 0"
+        value = value or 0.0
+        if minimum is not None and value < minimum:
+            errors.append(
+                (location, f"number '{name}' has {default} below its min {minimum:g}")
+            )
+        elif maximum is not None and value > maximum:
+            errors.append(
+                (location, f"number '{name}' has {default} above its max {maximum:g}")
+            )
+    return errors
+
+
+def _number(child: Tree | Token | None) -> float | None:
+    if child is None:
+        return None
+    if isinstance(child, Tree):
+        return -float(child.children[0])
+    return float(child)
+
+
+def _write_json(data: dict, out_file: Path, pretty: bool) -> None:
+    out_file.parent.mkdir(parents=True, exist_ok=True)
+    if pretty:
+        out_file.write_text(json.dumps(data, indent=2), encoding=ENCODING)
+    else:
+        out_file.write_text(json.dumps(data, separators=(",", ":")), encoding=ENCODING)
+
+
+def _load_grammar(grammar_file: str) -> str:
+    grammar = (
+        resources.files("weavly.resources")
+        .joinpath(grammar_file)
+        .read_text(encoding=ENCODING)
+    )
+    return grammar
+
+
+def _build_parser(grammar: str, parser_type: str) -> Lark:
+    return Lark(grammar, parser=parser_type)
+
+
+def _parse(parser: Lark, text: str, transformer: Transformer) -> dict:
+    tree = parser.parse(text)
+    data = transformer.transform(tree)
+    return data
+
+
+def _report_encoding_error(error: UnicodeDecodeError, file: Path) -> None:
+    line = error.object[: error.start].count(b"\n") + 1
+    report_error("invalid encoding, files must be saved as UTF-8", file, line)
+
+
+def _report_string_error(error: InvalidStringError, file: Path) -> None:
+    token = error.token
+    report_error(
+        f"invalid string {token.value}: {error.reason}", file, token.line, token.column
+    )
+
+
+def _report_parse_error(
+    error: UnexpectedInput, file: Path, text: str, names: dict[str, str]
+) -> None:
+    message, details = describe_syntax_error(error, text, names)
+    report_error(message, file, error.line, error.column, details)

weavly/parsing/syntax_errors.py

@@ -0,0 +1,145 @@
+import re
+
+from lark import Lark, Token
+from lark.exceptions import UnexpectedCharacters, UnexpectedInput, UnexpectedToken
+from lark.lexer import PatternStr
+
+END = "$END"
+
+PATTERN_NAMES = {
+    "NUMBER": "a number",
+    "STRING": "a quoted string",
+    "ID": "a name",
+    "TEXT": "text",
+    "CHARACTER_NAME": "a character name",
+    "COMP_OP": "a comparison operator",
+    "MATCH_MODIFIER": "'first', 'last' or 'all'",
+    "_COMMAND": "a @command",
+    "_NEWLINE": "end of line",
+    "COMMENT": "a comment",
+    "WS_INLINE": "whitespace",
+}
+
+_BLOCKS = {
+    "@node": "@endnode",
+    "@env": "@endenv",
+    "@if": "@endif",
+    "@options": "@endoptions",
+    "@random": "@endrandom",
+    "@match": "@endmatch",
+}
+_OPENERS = {closer: opener for opener, closer in _BLOCKS.items()}
+_PARENTS = {
+    "@option": "@options",
+    "@hint": "@options",
+    "@case": "@random",
+    "@when": "@match",
+    "@elif": "@if",
+    "@else": "@if",
+}
+_KEYWORD = re.compile(r"\s*(@\w+)")
+_MAX_TOKEN_LENGTH = 40
+
+
+def terminal_names(parser: Lark) -> dict[str, str]:
+    names = {END: "end of file"}
+    for terminal in parser.terminals:
+        if isinstance(terminal.pattern, PatternStr):
+            names[terminal.name] = f"'{terminal.pattern.value}'"
+        else:
+            names[terminal.name] = PATTERN_NAMES.get(terminal.name, terminal.name)
+    return names
+
+
+def describe_syntax_error(
+    error: UnexpectedInput, text: str, names: dict[str, str]
+) -> tuple[str, list[str]]:
+    lines = text.splitlines()
+    details = _excerpt(lines, error.line, error.column)
+
+    if isinstance(error, UnexpectedToken):
+        message = f"unexpected {_describe_token(error.token, names)}"
+        hint = _block_hint(error.token, lines, error.line)
+    elif isinstance(error, UnexpectedCharacters):
+        message = f"unexpected character {error.char!r}"
+        hint = None
+    else:
+        return "syntax error", details
+
+    if hint:
+        details.append(f"hint: {hint}")
+    else:
+        expected = getattr(error, "expected", None) or getattr(error, "allowed", None)
+        if expected:
+            details.append(_expected(sorted({names.get(n, n) for n in expected})))
+    return message, details
+
+
+def _describe_token(token: Token, names: dict[str, str]) -> str:
+    if token.type in (END, "_NEWLINE"):
+        return names[token.type]
+    value = str(token.value).strip()
+    if token.type == "TEXT":
+        value = value.split()[0]
+    if len(value) > _MAX_TOKEN_LENGTH:
+        value = value[:_MAX_TOKEN_LENGTH] + "..."
+    return f"'{value}'"
+
+
+def _expected(names: list[str]) -> str:
+    if len(names) == 1:
+        return f"expected {names[0]}"
+    return f"expected one of: {', '.join(names)}"
+
+
+def _excerpt(lines: list[str], line: int, column: int) -> list[str]:
+    if not 1 <= line <= len(lines):
+        return []
+    source = lines[line - 1]
+    gutter = str(line)
+    pad = "".join("\t" if char == "\t" else " " for char in source[: column - 1])
+    return [f"{gutter} | {source}", f"{' ' * len(gutter)} | {pad}^"]
+
+
+def _block_hint(token: Token, lines: list[str], line: int) -> str | None:
+    if token.type == END:
+        stack = _open_blocks(lines)
+        if not stack:
+            return None
+        opener, opened_at = stack[-1]
+        return f"the {opener} block opened at line {opened_at} is missing its {_BLOCKS[opener]}"
+
+    keyword = str(token.value).strip()
+    stack = _open_blocks(lines[: line - 1])
+    if keyword in _PARENTS:
+        parent = _PARENTS[keyword]
+        if not stack or stack[-1][0] != parent:
+            return f"{keyword} can only be used inside an {parent} block"
+        return None
+    if keyword not in _OPENERS:
+        return None
+    closer = keyword
+    opener = _OPENERS[closer]
+    if all(open_block != opener for open_block, _ in stack):
+        return f"there is no open {opener} block for {closer} to close"
+    top, opened_at = stack[-1]
+    if top != opener:
+        return (
+            f"the {top} block opened at line {opened_at} must be closed with "
+            f"{_BLOCKS[top]} first"
+        )
+    return None
+
+
+def _open_blocks(lines: list[str]) -> list[tuple[str, int]]:
+    stack: list[tuple[str, int]] = []
+    for number, source in enumerate(lines, start=1):
+        match = _KEYWORD.match(source)
+        if not match:
+            continue
+        keyword = match.group(1)
+        if keyword in _BLOCKS:
+            stack.append((keyword, number))
+        elif keyword in _OPENERS and stack and stack[-1][0] == _OPENERS[keyword]:
+            stack.pop()
+    return stack

weavly/parsing/wvl_transformer.py

@@ -0,0 +1,282 @@
+import json
+from typing import Any
+
+from lark import Transformer, v_args
+from lark.visitors import Discard
+
+
+class InvalidStringError(ValueError):
+    def __init__(self, token: Any, reason: str) -> None:
+        super().__init__(reason)
+        self.token = token
+        self.reason = reason
+
+
+@v_args(inline=True)
+class WvlTransformer(Transformer):
+    # =====================
+    # Entry / Nodes
+    # =====================
+
+    def start(self, *children) -> dict[str, list]:
+        nodes = [child for child in children if isinstance(child, dict)]
+        declarations = [
+            decl for child in children if isinstance(child, list) for decl in child
+        ]
+        result: dict[str, list] = {"nodes": nodes}
+        if declarations:
+            result["declarations"] = declarations
+        return result
+
+    def node(self, node_start: str, body: list, _node_end: None) -> dict[str, Any]:
+        return {"id": node_start, "body": body}
+
+    # =====================
+    # Env Block
+    # =====================
+
+    def env_block(self, *declarations) -> list:
+        return list(declarations)
+
+    def string_declaration(self, name: str, value: str | None = None) -> dict[str, str]:
+        if value is None:
+            value = ""
+        return {"type": "string", "name": name, "value": str(value)}
+
+    def number_declaration(
+        self, name: str, min=None, max=None, value: float | None = None
+    ) -> dict[str, Any]:
+        if value is None:
+            value = 0.0
+        return {"type": "number", "name": name, "value": float(value), "min": min, "max": max}
+
+    def flag_declaration(self, name: str, value: bool | None = None) -> dict[str, Any]:
+        if value is None:
+            value = False
+        return {"type": "flag", "name": name, "value": bool(value)}
+
+    def node_start(self, id: str) -> str:
+        return id
+
+    def node_end(self) -> None:
+        return None
+
+    def body(self, *statements) -> list:
+        return list(statements)
+    
+    def inline_goto(self, id) -> dict[str, str]:
+        return self.goto(id)
+
+    # =====================
+    # Lines / Statements
+    # =====================
+
+    def narration_line(self, text: str) -> dict[str, str]:
+        return {"type": "narration", "text": text}
+
+    def character_line(self, var: dict, text: str) -> dict[str, str]:
+        return {"type": "character", "name": var["variable"], "id": True, "text": text}
+    
+    def named_character_line(self, name: str, text: str) -> dict[str, str]:
+        return {"type": "character", "name": name, "id": False, "text": text}
+
+    def blank_line(self) -> Any:
+        return Discard
+
+    def set(self, variable: dict, expression: Any) -> dict[str, Any]:
+        return {"type": "set", "id": variable["variable"], "expression": expression}
+
+    def increase(self, var: dict, number: float | None) -> dict[str, Any]:
+        if number is None:
+            number = 1.0
+        expression = {"op": "+", "left": {"variable": var["variable"]}, "right": number}
+        return self.set(var, expression)
+
+    def decrease(self, var: dict, number: float | None) -> dict[str, Any]:
+        if number is None:
+            number = 1.0
+        expression = {"op": "-", "left": {"variable": var["variable"]}, "right": number}
+        return self.set(var, expression)
+
+    def setflag(self, var: dict) -> dict[str, Any]:
+        return self.set(var, True)
+
+    def clearflag(self, var: dict) -> dict[str, Any]:
+        return self.set(var, False)
+
+    def goto(self, id: str) -> dict[str, str]:
+        return {"type": "goto", "id": id}
+
+    def finish(self) -> dict[str, str]:
+        return {"type": "finish"}
+
+    def command(self, id: str, text: str | None) -> dict[str, str]:
+        if text is None:
+            text = ""
+        return {"type": "command", "id": id, "text": text}
+
+    def continue_(self, text: str, statement: dict[str, Any] = None) -> dict[str, Any]:
+        if statement is None:
+            body = []
+        else:
+            body = [statement]
+        return self.option_block(self.option(True, text, body))
+
+    # =====================
+    # If Block
+    # =====================
+
+    def if_block(
+        self, if_: dict, elif_list: list | None, else_: dict | None
+    ) -> dict[str, Any]:
+        cases = [if_]
+        if elif_list is not None:
+            cases.extend(elif_list)
+        if else_ is not None:
+            cases.append(else_)
+        return {"type": "match", "modifier": "first", "cases": cases}
+
+    def if_(self, condition: Any, body: list) -> dict[str, Any]:
+        if not isinstance(body, list):
+            body = [body]
+        return {"condition": condition, "body": body}
+
+    def elif_(self, condition: Any, body: list) -> dict[str, Any]:
+        return self.if_(condition, body)
+
+    def else_(self, body: list) -> dict[str, Any]:
+        return self.if_(True, body)
+
+    def elif_list(self, *elifs) -> list:
+        return list(elifs)
+
+    # =====================
+    # Option Block
+    # =====================
+
+    def option_block(self, *items) -> dict[str, Any]:
+        return {"type": "option", "items": list(items)}
+
+    def option(self, condition: Any | None, text: str, body: list | dict, hint: bool = False) -> dict[str, Any]:
+        if condition is None:
+            condition = True
+        if not isinstance(body, list):
+            body = [body]
+        return {"condition": condition, "text": text, "body": body, "hint": hint}
+
+    def hint_option(self, condition: Any | None, text: str) -> dict[str, Any]:
+        return self.option(condition, text, [], hint=True)
+    
+    # =====================
+    # Random Block
+    # =====================
+
+    def random_block(self, *cases) -> dict[str, Any]:
+        return {"type": "random", "cases": list(cases)}
+
+    def case(self, condition: Any | None, weight: Any, body: list) -> dict[str, Any]:
+        if condition is None:
+            condition = True
+        if weight is None:
+            weight = 1.0
+        if not isinstance(body, list):
+            body = [body]
+        return {"condition": condition, "weight": weight, "body": body}
+
+    # =====================
+    # Match Block
+    # =====================
+
+    def match_block(self, modifier, *cases) -> dict[str, Any]:
+        if modifier is None:
+            modifier = "first"
+        return {"type": "match", "modifier": modifier, "cases": list(cases)}
+    
+    def MATCH_MODIFIER(self, token: Any) -> str:
+        return str(token).lstrip()
+
+    def when(self, condition: Any, body: list) -> dict[str, Any]:
+        if not isinstance(body, list):
+            body = [body]
+        return {"condition": condition, "body": body}
+
+    # =====================
+    # Expressions
+    # =====================
+
+    def condition(self, expression: Any) -> Any:
+        return expression
+
+    def or_(self, left: Any, right: Any) -> dict[str, Any]:
+        return {"op": "or", "left": left, "right": right}
+
+    def and_(self, left: Any, right: Any) -> dict[str, Any]:
+        return {"op": "and", "left": left, "right": right}
+
+    def not_(self, expression: Any) -> dict[str, Any]:
+        return {"op": "not", "expression": expression}
+
+    def compare(self, left: Any, operator: str, right: Any) -> dict[str, Any]:
+        return {"op": operator, "left": left, "right": right}
+
+    def add(self, left: Any, right: Any) -> dict[str, Any]:
+        return {"op": "+", "left": left, "right": right}
+
+    def sub(self, left: Any, right: Any) -> dict[str, Any]:
+        return {"op": "-", "left": left, "right": right}
+
+    def negative_number(self, number: float) -> float:
+        return -number
+
+    def neg(self, operand: Any) -> Any:
+        if isinstance(operand, float):
+            return -operand
+        return {"op": "-", "left": 0.0, "right": operand}
+
+    def mul(self, left: Any, right: Any) -> dict[str, Any]:
+        return {"op": "*", "left": left, "right": right}
+
+    def div(self, left: Any, right: Any) -> dict[str, Any]:
+        return {"op": "/", "left": left, "right": right}
+
+    def variable(self, id: str) -> dict[str, str]:
+        return {"variable": id}
+
+    # =====================
+    # Tokens
+    # =====================
+
+    def TEXT(self, token: Any) -> str:
+        return str(token).lstrip()
+    
+    def CHARACTER_NAME(self, token: Any) -> str:
+        return str(token).lstrip()
+
+    def COMP_OP(self, token: Any) -> str:
+        return str(token)
+
+    def TRUE(self, token: Any) -> bool:
+        return True
+
+    def FALSE(self, token: Any) -> bool:
+        return False
+
+    def ID(self, token: Any) -> str:
+        return str(token)
+
+    def NUMBER(self, token: Any) -> float:
+        return float(token)
+
+    def STRING(self, token: Any) -> str:
+        try:
+            return json.loads(str(token), strict=False)
+        except json.JSONDecodeError as e:
+            raise InvalidStringError(token, e.msg) from e
+
+    # =====================
+    # Default for debugging
+    # =====================
+
+    def __default__(self, data: str, children: list, meta: Any) -> None:
+        # raise here to catch unhandled rules early
+        raise ValueError(f"Unhandled rule: {data} children={children}")

weavly/reporting.py

@@ -0,0 +1,24 @@
+from pathlib import Path
+
+import typer
+
+
+def report_error(
+    message: str,
+    file: Path | None = None,
+    line: int | None = None,
+    column: int | None = None,
+    details: list[str] | None = None,
+) -> None:
+    """Print `file:line:column: error: message` to stderr, plus indented details."""
+    if file is not None:
+        location = file.as_posix()
+        if line is not None:
+            location += f":{line}"
+            if column is not None:
+                location += f":{column}"
+        typer.secho(f"{location}: ", nl=False, bold=True, err=True)
+    typer.secho("error: ", nl=False, fg=typer.colors.RED, bold=True, err=True)
+    typer.echo(message, err=True)
+    for detail in details or []:
+        typer.echo(f"  {detail}", err=True)

weavly/resources/wvl-grammar.lark

@@ -0,0 +1,241 @@
+// =====================
+// Entry / Nodes
+// =====================
+
+start: (env_block | node)+
+
+// =====================
+// Env Block
+// =====================
+
+env_block: _NEWLINE* _ENV _NEWLINE declaration+ _ENDENV _NEWLINE*
+
+?declaration: number_declaration
+    | string_declaration
+    | flag_declaration
+
+number_declaration: ID _COLON _NUMBER_TYPE ["(" [signed_number] "," [signed_number] ")"] ["=" signed_number] _NEWLINE
+string_declaration: ID _COLON _STRING_TYPE ["=" STRING] _NEWLINE
+flag_declaration: ID _COLON _FLAG_TYPE ["=" bool_literal] _NEWLINE
+?bool_literal: TRUE
+    | FALSE
+
+node: node_start body node_end
+node_start: _NEWLINE* _NODESTART ID _NEWLINE
+node_end: _NODEEND _NEWLINE*
+
+body: statement*
+
+?statement: line_statement
+    | block_statement
+    | blank_line
+
+?line_statement: narration_line
+    | character_line
+    | set
+    | increase
+    | decrease
+    | setflag
+    | clearflag
+    | command
+    | goto
+    | finish
+    | continue
+
+?block_statement: if_block
+    | option_block
+    | random_block
+    | match_block
+
+?inline_statement: _COLON line_statement
+
+inline_goto: _ARROW ID _NEWLINE
+
+?action: (inline_statement | inline_goto | _NEWLINE body)
+
+?inline_action: (inline_statement | inline_goto)
+
+// =====================
+// Lines / Statements
+// =====================
+
+narration_line: TEXT _NEWLINE
+character_line: variable _COLON TEXT _NEWLINE
+    | _CHARACTER_MARKER CHARACTER_NAME _COLON TEXT _NEWLINE -> named_character_line
+blank_line: _NEWLINE
+
+set: _SET variable "=" expression _NEWLINE
+increase: _INC variable [signed_number] _NEWLINE
+decrease: _DEC variable [signed_number] _NEWLINE
+setflag: _SETFLAG variable _NEWLINE
+clearflag: _CLEARFLAG variable _NEWLINE
+
+goto: _GOTO ID _NEWLINE
+
+finish: _FINISH _NEWLINE
+
+command: _COMMAND ID [_COLON TEXT] _NEWLINE
+
+continue: _CONTINUE STRING (inline_action | _NEWLINE) -> continue_
+
+// =====================
+// If Block
+// =====================
+
+if_block: if_ [elif_list] [else_] _ENDIF _NEWLINE
+if_: _IF condition action
+elif_: _ELIF condition action
+else_: _ELSE action
+elif_list: elif_+
+
+// =====================
+// Option Block
+// =====================
+
+option_block: _OPTIONS _NEWLINE option_item+ _END_OPTIONS _NEWLINE
+?option_item: option | hint_option
+option: _OPTION [_LBRACKET condition _RBRACKET] STRING action
+hint_option: _HINT_OPTION [_LBRACKET condition _RBRACKET] STRING _NEWLINE
+
+// =====================
+// Random Block
+// =====================
+
+random_block: _RANDOM _NEWLINE case+ _END_RANDOM _NEWLINE
+case: _CASE [_LBRACKET condition _RBRACKET] [term] action
+
+// =====================
+// Match Block
+// =====================
+
+match_block: _MATCH [MATCH_MODIFIER] _NEWLINE when+ _END_MATCH _NEWLINE
+when: _WHEN condition action
+
+// =====================
+// Expressions
+// =====================
+
+condition: expression
+
+?expression: or_expr
+
+?or_expr: and_expr 
+    | or_expr _OR and_expr -> or_
+
+?and_expr: not_expr 
+    | and_expr _AND not_expr -> and_
+
+?not_expr: _NOT not_expr -> not_
+    | comparison
+    
+?comparison: term
+    | term COMP_OP term -> compare
+
+?term: sum
+
+?sum: product
+    | sum "+" product -> add
+    | sum "-" product -> sub
+
+?product: unary
+    | product "*" unary -> mul
+    | product "/" unary -> div
+
+?unary: atom
+    | "-" unary -> neg
+
+?atom: literal
+    | variable
+    | "(" expression ")"
+
+variable: _VARIABLEMARKER ID
+
+?signed_number: NUMBER
+    | "-" NUMBER -> negative_number
+    | "+" NUMBER
+
+?literal: NUMBER
+    | STRING
+    | TRUE
+    | FALSE
+
+// =====================
+// Tokens
+// =====================
+
+TEXT: /(?![ \t]*[@#$>])[ \t]*\S[^\n]*/
+CHARACTER_NAME: /[A-Za-z0-9][A-Za-z0-9 ]*/
+COMP_OP: "==" | "!=" | ">" | "<" | ">=" | "<="
+TRUE: "true"
+FALSE: "false"
+
+_NODESTART: "@node"
+_NODEEND: "@endnode"
+
+_ENV: "@env"
+_ENDENV: "@endenv"
+_NUMBER_TYPE: "number"
+_STRING_TYPE: "string"
+_FLAG_TYPE: "flag"
+
+_SET: "@set"
+_INC: "@increase"
+_DEC: "@decrease"
+_SETFLAG: "@setflag"
+_CLEARFLAG: "@clearflag"
+_GOTO: "@goto"
+_FINISH: "@finish"
+_COMMAND: /@(?!(node|endnode|env|endenv|set|increase|decrease|setflag|clearflag|goto|finish|if|elif|else|endif|options|option|hint|endoptions|continue|random|case|endrandom|match|when|endmatch)\b)/
+_CONTINUE: "@continue"
+
+_IF: "@if"
+_ELIF: "@elif"
+_ELSE: "@else"
+_ENDIF: "@endif"
+
+_OPTIONS: "@options"
+_END_OPTIONS: "@endoptions"
+_OPTION: "@option"
+_HINT_OPTION: "@hint"
+
+_RANDOM: "@random"
+_CASE: "@case"
+_END_RANDOM: "@endrandom"
+
+_MATCH: "@match"
+MATCH_MODIFIER: "first" | "last" | "all"
+_WHEN: "@when"
+_END_MATCH: "@endmatch"
+
+_NOT: "not"
+_AND: "and"
+_OR: "or"
+_VARIABLEMARKER: "$"
+_CHARACTER_MARKER: ">"
+
+_COLON: ":"
+_LBRACKET: "["
+_RBRACKET: "]"
+_ARROW: "->"
+
+// =====================
+// Imports
+// =====================
+
+%import common.CNAME -> ID
+%import common.NUMBER
+%import common.ESCAPED_STRING -> STRING
+%import common.WS_INLINE
+
+// =====================
+// Ignored
+// =====================
+
+// A statement terminator is one or more physical newlines, and it absorbs any
+// trailing comments and blank lines. This lets `# ...` sit at the end of a line
+// (inline comment) or on its own line inside a block without leaving a stray
+// _NEWLINE that block rules like @options/@random/@match can't consume.
+COMMENT: /#[^\n]*/
+_NEWLINE: ( /\r?\n[\t ]*/ | COMMENT )+
+%ignore COMMENT
+%ignore WS_INLINE

weavly-0.1.0.dist-info/METADATA

@@ -0,0 +1,77 @@
+Metadata-Version: 2.4
+Name: weavly
+Version: 0.1.0
+Summary: Compiler for the Weavly dialog scripting language
+Author: Weavly contributors
+License-Expression: MIT
+Project-URL: Repository, https://github.com/weavly-lang/weavly-compiler
+Project-URL: Documentation, https://weavly-lang.github.io/weavly-docs/
+Project-URL: Issues, https://github.com/weavly-lang/weavly-compiler/issues
+Keywords: weavly,dialog,compiler,godot,interactive-fiction
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Games/Entertainment
+Classifier: Topic :: Software Development :: Compilers
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: lark>=1.3.1
+Requires-Dist: typer>=0.21.0
+Dynamic: license-file
+
+# Weavly Compiler
+
+Compiler for the Weavly dialog scripting language. Parses `.wvl` files and compiles them to JSON for the Weavly Godot runtime.
+
+Language documentation: https://weavly-lang.github.io/weavly-docs/
+
+## Install
+
+Install [uv](https://docs.astral.sh/uv/getting-started/installation/), then:
+
+```bash
+uv tool install weavly
+```
+
+uv installs a suitable Python if needed and puts `weavly` on your PATH (run `uv tool update-shell` if it isn't). Upgrade with `uv tool upgrade weavly`.
+
+With Python 3.11+ already installed, `pipx install weavly` works too.
+
+## Usage
+
+```bash
+weavly init my-project   # creates my-project/src/nodes.wvl
+cd my-project
+weavly build             # compiles src/**/*.wvl into build/
+weavly build --pretty    # same, with indented JSON
+weavly --version         # installed compiler version
+```
+
+`weavly init` without a name sets up `src/` in the current directory.
+
+The build writes:
+
+- `build/<path>.wvl.json` for each source file, containing its nodes
+- `build/env.json` with every `@env` declaration in the project
+
+Syntax errors, duplicate variable declarations, number declarations whose min, max or default don't fit together, duplicate node ids and `@goto` targets with no matching node fail the build with exit code 1. A failed build leaves the previous `build/` untouched.
+
+## Development
+
+```bash
+git clone https://github.com/weavly-lang/weavly-compiler.git
+cd weavly-compiler
+uv sync --group dev
+```
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for the workflow and release steps.
+
+## License
+
+[MIT](LICENSE)

weavly-0.1.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+weavly/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+weavly/cli.py,sha256=ULJx11l3pjQ5rPKRrvKtgZmNCVM9AMhJWil2usqp1xA,2031
+weavly/reporting.py,sha256=yKcxVTjaWEODB418QkuMOdbGfC4It-b1_2Obo9nLm4U,759
+weavly/parsing/__init__.py,sha256=LtCR23zwiCxtey4Wup-s4lKnpx_h2IPxdHURXu5_XUs,172
+weavly/parsing/parser.py,sha256=nqLLOpbQwQ7BGltVTKmMZIxrZcz1Lh-rfpA2zwHFJJc,8402
+weavly/parsing/syntax_errors.py,sha256=PisMPRw_0Z7Luw8Ar46jTczwRsZbLCfpAB6sHM_dlf8,4542
+weavly/parsing/wvl_transformer.py,sha256=fICcNiBNUs2bqlEe3QycUKvCC0XciU-T-uDW6TvnNUI,9160
+weavly/resources/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+weavly/resources/wvl-grammar.lark,sha256=UPEuD6lovJ0S1WgdiXOhF4NyjPjpDsrg1GZ0ZASJjrA,5278
+weavly-0.1.0.dist-info/licenses/LICENSE,sha256=kudIsspZciiruGid7hQWUAHRy6I8xqnA_a6PlbLMaI4,1076
+weavly-0.1.0.dist-info/METADATA,sha256=x9v5143FBUFFIBGdjD52tv9Bs4Vg3LCcIQwXT8Lmwzc,2619
+weavly-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+weavly-0.1.0.dist-info/entry_points.txt,sha256=iBG6cl4CxX2yrE6juoOoDphXIoa1QqN8J4f8rlWDjmg,42
+weavly-0.1.0.dist-info/top_level.txt,sha256=FvfZyzx984EKi00-oQLLf03sX3v0RFcWjWMemtQPkBA,7
+weavly-0.1.0.dist-info/RECORD,,

weavly-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

weavly-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+weavly = weavly.cli:app

weavly-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Weavly contributors
+
+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.

weavly-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+weavly