mapack 0.0.0__tar.gz

mapack-0.0.0/PKG-INFO

@@ -0,0 +1,31 @@
+Metadata-Version: 2.4
+Name: mapack
+Version: 0.0.0
+Summary: Config-driven Minecraft map packer CLI
+Keywords: minecraft,cli,packaging,jsonc
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Operating System :: OS Independent
+Classifier: Environment :: Console
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: click<9,>=8.1
+
+# Mapack (Minecraft Map Packer)
+
+Config-driven CLI tool to build and export Minecraft map artifacts from a JSON/JSONC config file.
+
+## Usage
+
+```bash
+mapack <config.jsonc>
+```
+
+## Documentation
+
+To Be Written.

mapack-0.0.0/README.md

@@ -0,0 +1,13 @@
+# Mapack (Minecraft Map Packer)
+
+Config-driven CLI tool to build and export Minecraft map artifacts from a JSON/JSONC config file.
+
+## Usage
+
+```bash
+mapack <config.jsonc>
+```
+
+## Documentation
+
+To Be Written.

mapack-0.0.0/app/__init__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+__all__ = ["main"]

mapack-0.0.0/app/cli.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+
+import click
+
+from config.parser import load_json_or_jsonc
+from core.interpreter import ConfigInterpreter
+
+logging.basicConfig(level=logging.INFO, format="[%(levelname)s] %(message)s")
+logger = logging.getLogger("mapack")
+
+
+@click.command(context_settings={"help_option_names": ["-h", "--help"]})
+@click.argument("config_file", type=click.Path(exists=True, dir_okay=False, path_type=Path))
+@click.option(
+    "--target",
+    "targets",
+    multiple=True,
+    help="Target(s) to execute. If omitted, all targets are executed.",
+)
+@click.option("--dry-run", is_flag=True, default=False, help="Build plan without writing output files.")
+def main(config_file: Path, targets: tuple[str, ...], dry_run: bool) -> None:
+    """Pack maps from a JSON/JSONC config file."""
+    config_path = config_file.resolve()
+    config = load_json_or_jsonc(config_path)
+
+    interpreter = ConfigInterpreter(config=config, config_path=config_path)
+    outputs_by_target = interpreter.run(list(targets) if targets else None, dry_run=dry_run)
+
+    click.echo("Build finished.")
+    for target_name, outputs in outputs_by_target.items():
+        click.echo(f"- target={target_name}")
+        if outputs:
+            for output in outputs:
+                click.echo(f"  - {output}")
+        else:
+            click.echo("  - (no exported artifacts)")
+
+
+if __name__ == "__main__":
+    main()

mapack-0.0.0/config/__init__.py

@@ -0,0 +1,13 @@
+from .expressions import ExpressionContext, evaluate_expression
+from .parser import load_json_or_jsonc
+from .templating import get_dotted, render_template, resolve_templates, set_dotted
+
+__all__ = [
+    "ExpressionContext",
+    "evaluate_expression",
+    "load_json_or_jsonc",
+    "get_dotted",
+    "render_template",
+    "resolve_templates",
+    "set_dotted",
+]

mapack-0.0.0/config/expressions.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+import ast
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Callable
+
+
+@dataclass(slots=True)
+class ExpressionContext:
+    cwd: Path
+
+
+_ALLOWED_BOOL_NAMES = {
+    "true": True,
+    "false": False,
+    "null": None,
+    "none": None,
+}
+
+
+class SafeExpressionEvaluator(ast.NodeVisitor):
+    def __init__(self, *, functions: dict[str, Callable[..., Any]]) -> None:
+        self.functions = functions
+
+    def visit_Expression(self, node: ast.Expression) -> Any:  # noqa: N802
+        return self.visit(node.body)
+
+    def visit_Constant(self, node: ast.Constant) -> Any:  # noqa: N802
+        return node.value
+
+    def visit_Name(self, node: ast.Name) -> Any:  # noqa: N802
+        key = node.id.casefold()
+        if key in _ALLOWED_BOOL_NAMES:
+            return _ALLOWED_BOOL_NAMES[key]
+        raise ValueError(f"Unknown name in expression: {node.id}")
+
+    def visit_Call(self, node: ast.Call) -> Any:  # noqa: N802
+        if not isinstance(node.func, ast.Name):
+            raise ValueError("Only direct function calls are supported")
+        if node.func.id not in self.functions:
+            raise ValueError(f"Function not allowed: {node.func.id}")
+
+        fn = self.functions[node.func.id]
+        args = [self.visit(arg) for arg in node.args]
+        kwargs = {kw.arg: self.visit(kw.value) for kw in node.keywords if kw.arg is not None}
+        return fn(*args, **kwargs)
+
+    def generic_visit(self, node: ast.AST) -> Any:
+        raise ValueError(f"Unsupported expression node: {type(node).__name__}")
+
+
+def evaluate_expression(text: str, *, context: ExpressionContext) -> Any:
+    def count_files(path: str, recursive: bool = True, include_dirs: bool = False) -> int:
+        root = (context.cwd / path).resolve()
+        if not root.exists():
+            return 0
+
+        total = 0
+        if recursive:
+            for child in root.rglob("*"):
+                if child.is_file() or (include_dirs and child.is_dir()):
+                    total += 1
+        else:
+            for child in root.iterdir():
+                if child.is_file() or (include_dirs and child.is_dir()):
+                    total += 1
+        return total
+
+    tree = ast.parse(text, mode="eval")
+    evaluator = SafeExpressionEvaluator(functions={"count_files": count_files})
+    return evaluator.visit(tree)

mapack-0.0.0/config/parser.py

@@ -0,0 +1,120 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+
+def _strip_jsonc(text: str) -> str:
+    """Remove // and /* */ comments while preserving string literals."""
+    out: list[str] = []
+    i = 0
+    in_string = False
+    string_quote = ""
+    escaped = False
+    in_line_comment = False
+    in_block_comment = False
+
+    while i < len(text):
+        ch = text[i]
+        nxt = text[i + 1] if i + 1 < len(text) else ""
+
+        if in_line_comment:
+            if ch == "\n":
+                in_line_comment = False
+                out.append(ch)
+            i += 1
+            continue
+
+        if in_block_comment:
+            if ch == "*" and nxt == "/":
+                in_block_comment = False
+                i += 2
+            else:
+                i += 1
+            continue
+
+        if in_string:
+            out.append(ch)
+            if escaped:
+                escaped = False
+            elif ch == "\\":
+                escaped = True
+            elif ch == string_quote:
+                in_string = False
+            i += 1
+            continue
+
+        if ch in ('"', "'"):
+            in_string = True
+            string_quote = ch
+            out.append(ch)
+            i += 1
+            continue
+
+        if ch == "/" and nxt == "/":
+            in_line_comment = True
+            i += 2
+            continue
+
+        if ch == "/" and nxt == "*":
+            in_block_comment = True
+            i += 2
+            continue
+
+        out.append(ch)
+        i += 1
+
+    return "".join(out)
+
+
+def _strip_trailing_commas(text: str) -> str:
+    """Remove trailing commas before ] or } while preserving strings."""
+    out: list[str] = []
+    i = 0
+    in_string = False
+    string_quote = ""
+    escaped = False
+
+    while i < len(text):
+        ch = text[i]
+
+        if in_string:
+            out.append(ch)
+            if escaped:
+                escaped = False
+            elif ch == "\\":
+                escaped = True
+            elif ch == string_quote:
+                in_string = False
+            i += 1
+            continue
+
+        if ch in ('"', "'"):
+            in_string = True
+            string_quote = ch
+            out.append(ch)
+            i += 1
+            continue
+
+        if ch == ",":
+            j = i + 1
+            while j < len(text) and text[j] in " \t\r\n":
+                j += 1
+            if j < len(text) and text[j] in "]}":
+                i += 1
+                continue
+
+        out.append(ch)
+        i += 1
+
+    return "".join(out)
+
+
+def load_json_or_jsonc(config_path: Path) -> dict:
+    raw = config_path.read_text(encoding="utf-8")
+    cleaned = _strip_jsonc(raw)
+    cleaned = _strip_trailing_commas(cleaned)
+    data = json.loads(cleaned)
+    if not isinstance(data, dict):
+        raise ValueError("Top-level config must be an object")
+    return data

mapack-0.0.0/config/templating.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+import copy
+import re
+from typing import Any
+
+_TOKEN = re.compile(r"\{([a-zA-Z0-9_.-]+)\}")
+
+
+def get_dotted(mapping: dict[str, Any], dotted: str) -> Any:
+    current: Any = mapping
+    for part in dotted.split("."):
+        if not isinstance(current, dict) or part not in current:
+            raise KeyError(dotted)
+        current = current[part]
+    return current
+
+
+def set_dotted(mapping: dict[str, Any], dotted: str, value: Any) -> None:
+    parts = dotted.split(".")
+    current: dict[str, Any] = mapping
+    for part in parts[:-1]:
+        child = current.get(part)
+        if not isinstance(child, dict):
+            child = {}
+            current[part] = child
+        current = child
+    current[parts[-1]] = value
+
+
+def render_template(value: str, scope: dict[str, Any]) -> str:
+    def replace(match: re.Match[str]) -> str:
+        key = match.group(1)
+        resolved = get_dotted(scope, key)
+        return str(resolved)
+
+    return _TOKEN.sub(replace, value)
+
+
+def resolve_templates(obj: Any, scope: dict[str, Any]) -> Any:
+    if isinstance(obj, str):
+        return render_template(obj, scope)
+    if isinstance(obj, list):
+        return [resolve_templates(item, scope) for item in obj]
+    if isinstance(obj, dict):
+        return {k: resolve_templates(v, scope) for k, v in obj.items()}
+    return copy.deepcopy(obj)

mapack-0.0.0/core/__init__.py

@@ -0,0 +1,4 @@
+from .interpreter import ConfigInterpreter
+from .runtime import ArtifactResult, InterpreterState
+
+__all__ = ["ConfigInterpreter", "ArtifactResult", "InterpreterState"]

mapack-0.0.0/core/interpreter.py

@@ -0,0 +1,347 @@
+from __future__ import annotations
+
+import copy
+import logging
+import shutil
+from dataclasses import dataclass
+from pathlib import Path
+from tempfile import TemporaryDirectory
+from typing import Any
+
+from config.expressions import ExpressionContext, evaluate_expression
+from config.templating import render_template, resolve_templates, set_dotted
+from transforms import load_builtin_transforms
+from transforms.registry import run_transform
+from .runtime import ArtifactResult, InterpreterState
+
+logger = logging.getLogger("mapack")
+
+
+@dataclass(slots=True)
+class TransformContext:
+    interpreter: "ConfigInterpreter"
+    state: InterpreterState
+    artifact_name: str
+    workdir: Path
+
+    def resolve_value(self, value: Any) -> Any:
+        return self.interpreter._resolve_value(value, self.state)
+
+    def resolve_expr_or_value(self, value: Any) -> Any:
+        return self.interpreter._resolve_expr_or_value(value, self.state, self.workdir)
+
+    def resolve_source(self, source_spec: Any, *, allow_artifact_output: bool) -> Path:
+        return self.interpreter._resolve_source(source_spec, self.state, allow_artifact_output=allow_artifact_output)
+
+    def run_nested_transform(self, spec: dict[str, Any]) -> None:
+        self.interpreter._run_transform(spec, self.state, self.artifact_name, self.workdir)
+
+
+class ConfigInterpreter:
+    def __init__(self, config: dict[str, Any], config_path: Path) -> None:
+        self.config = config
+        self.config_path = config_path.resolve()
+        load_builtin_transforms()
+
+    def run(self, targets: list[str] | None = None, *, dry_run: bool = False) -> dict[str, list[Path]]:
+        available_targets = self._get_targets()
+        selected = targets or list(available_targets.keys())
+
+        outputs_by_target: dict[str, list[Path]] = {}
+        for target_name in selected:
+            if target_name not in available_targets:
+                raise KeyError(f"Unknown target: {target_name}")
+
+            merged_target = self._materialize_target(target_name)
+            state = self._build_state_for_target(target_name, merged_target)
+            outputs_by_target[target_name] = self._execute_target(state, merged_target, dry_run=dry_run)
+
+        return outputs_by_target
+
+    def _execute_target(self, state: InterpreterState, target_config: dict[str, Any], *, dry_run: bool) -> list[Path]:
+        artifacts = target_config.get("artifacts")
+        if not isinstance(artifacts, dict):
+            raise ValueError("target.artifacts must be an object")
+
+        requested: list[str] = []
+        for name, spec in artifacts.items():
+            if not isinstance(spec, dict):
+                continue
+            export = spec.get("export") or {}
+            if isinstance(export, dict) and export.get("enabled", False):
+                requested.append(name)
+
+        produced: list[Path] = []
+        with TemporaryDirectory(prefix=f"mapack-{state.target_name}-") as tmpdir:
+            tmp_root = Path(tmpdir)
+            for artifact_name in requested:
+                result = self._build_artifact(
+                    artifact_name,
+                    state=state,
+                    target_artifacts=artifacts,
+                    temp_root=tmp_root,
+                    dry_run=dry_run,
+                )
+                if result.output_path:
+                    produced.append(result.output_path)
+
+        return produced
+
+    def _build_artifact(
+        self,
+        artifact_name: str,
+        *,
+        state: InterpreterState,
+        target_artifacts: dict[str, Any],
+        temp_root: Path,
+        dry_run: bool,
+    ) -> ArtifactResult:
+        existing = state.artifact_results.get(artifact_name)
+        if existing is not None:
+            return existing
+
+        if artifact_name not in target_artifacts:
+            raise KeyError(f"Unknown artifact: {artifact_name}")
+
+        artifact_spec = target_artifacts[artifact_name]
+        if not isinstance(artifact_spec, dict):
+            raise ValueError(f"Artifact '{artifact_name}' definition must be an object")
+
+        depends_on = artifact_spec.get("depends_on", [])
+        if depends_on is None:
+            depends_on = []
+        if not isinstance(depends_on, list):
+            raise ValueError(f"Artifact '{artifact_name}' depends_on must be a list")
+
+        for dep in depends_on:
+            dep_name = str(dep)
+            self._build_artifact(dep_name, state=state, target_artifacts=target_artifacts, temp_root=temp_root, dry_run=dry_run)
+
+        workdir = temp_root / artifact_name
+        workdir.mkdir(parents=True, exist_ok=True)
+        result = ArtifactResult(name=artifact_name, workdir=workdir)
+        state.artifact_results[artifact_name] = result
+
+        if not dry_run:
+            src_spec = artifact_spec.get("src")
+            if src_spec is not None:
+                src_path = self._resolve_source(src_spec, state, allow_artifact_output=False)
+                self._copy_source_to_artifact_root(src_path, workdir)
+
+            for transform in artifact_spec.get("transforms", []):
+                self._run_transform(transform, state, artifact_name, workdir)
+        else:
+            logger.info("artifact=%s dry-run: skipped source copy and transforms", artifact_name)
+
+        export = artifact_spec.get("export")
+        if isinstance(export, dict) and export.get("enabled", False):
+            resolved_export = self._resolve_value(export, state)
+            if not isinstance(resolved_export, dict):
+                raise ValueError(f"Artifact '{artifact_name}' export must resolve to object")
+
+            dest_raw = resolved_export.get("dest")
+            if not isinstance(dest_raw, str):
+                raise ValueError(f"Artifact '{artifact_name}' export.dest must be a string")
+            dest_path = self._resolve_path(dest_raw)
+
+            zipped = bool(resolved_export.get("zipped", True))
+            if not dry_run:
+                if zipped:
+                    self._zip_directory(workdir, dest_path)
+                else:
+                    if dest_path.exists():
+                        shutil.rmtree(dest_path, ignore_errors=True)
+                    shutil.copytree(workdir, dest_path, dirs_exist_ok=True)
+            result.output_path = dest_path
+            logger.info("artifact=%s exported -> %s", artifact_name, dest_path)
+        else:
+            logger.info("artifact=%s built (no export)", artifact_name)
+
+        return result
+
+    def _run_transform(self, spec: dict[str, Any], state: InterpreterState, artifact_name: str, workdir: Path) -> None:
+        if not isinstance(spec, dict):
+            raise ValueError(f"Transform in '{artifact_name}' must be an object")
+        transform_type = spec.get("type")
+        if not isinstance(transform_type, str):
+            raise ValueError(f"Transform in '{artifact_name}' missing string field 'type'")
+
+        resolved_spec = self._resolve_value(spec, state)
+        if not isinstance(resolved_spec, dict):
+            raise ValueError("Resolved transform spec must be an object")
+
+        logger.info("artifact=%s transform=%s id=%s", artifact_name, transform_type, resolved_spec.get("id"))
+        ctx = TransformContext(interpreter=self, state=state, artifact_name=artifact_name, workdir=workdir)
+        run_transform(transform_type, ctx, resolved_spec)
+
+    def _copy_source_to_artifact_root(self, src_path: Path, workdir: Path) -> None:
+        if not src_path.exists():
+            raise FileNotFoundError(f"Artifact source does not exist: {src_path}")
+
+        if src_path.is_file():
+            shutil.copy2(src_path, workdir / src_path.name)
+            return
+
+        for child in src_path.iterdir():
+            dest = workdir / child.name
+            if child.is_dir():
+                shutil.copytree(child, dest, dirs_exist_ok=True)
+            else:
+                shutil.copy2(child, dest)
+
+    def _resolve_source(self, source_spec: Any, state: InterpreterState, *, allow_artifact_output: bool) -> Path:
+        resolved = self._resolve_value(source_spec, state)
+
+        if isinstance(resolved, str):
+            return self._resolve_path(resolved)
+
+        if isinstance(resolved, dict):
+            artifact_ref = resolved.get("artifact")
+            if artifact_ref is not None:
+                ref_name = str(artifact_ref)
+                if ref_name not in state.artifact_results:
+                    raise KeyError(f"Referenced artifact has not been built yet: {ref_name}")
+                ref = state.artifact_results[ref_name]
+                wants_output = bool(resolved.get("output", False))
+                if wants_output:
+                    if not allow_artifact_output:
+                        raise ValueError("This source location does not allow artifact output references")
+                    if ref.output_path is None:
+                        raise ValueError(f"Artifact '{ref_name}' has no output to reference")
+                    return ref.output_path
+                return ref.workdir
+
+            if "path" in resolved and isinstance(resolved["path"], str):
+                return self._resolve_path(resolved["path"])
+
+        raise ValueError(f"Unsupported source spec: {source_spec}")
+
+    def _resolve_path(self, value: str) -> Path:
+        path = Path(value)
+        if path.is_absolute():
+            return path
+        return (self.config_path.parent / path).resolve()
+
+    def _resolve_expr_or_value(self, value: Any, state: InterpreterState, cwd: Path) -> Any:
+        resolved = self._resolve_value(value, state)
+        if not isinstance(resolved, str):
+            return resolved
+
+        try:
+            return evaluate_expression(resolved, context=ExpressionContext(cwd=cwd))
+        except Exception:
+            return resolved
+
+    def _resolve_value(self, value: Any, state: InterpreterState) -> Any:
+        return resolve_templates(value, state.scope)
+
+    def _build_state_for_target(self, target_name: str, target_config: dict[str, Any]) -> InterpreterState:
+        variables = target_config.get("variables")
+        if not isinstance(variables, dict):
+            raise ValueError(f"target '{target_name}' missing object field: variables")
+
+        scope: dict[str, Any] = copy.deepcopy(variables)
+
+        precomputed = target_config.get("precomputed_vars", {})
+        if not isinstance(precomputed, dict):
+            raise ValueError(f"target '{target_name}' precomputed_vars must be an object")
+
+        for dotted_key, raw_value in precomputed.items():
+            if not isinstance(dotted_key, str):
+                raise ValueError("precomputed_vars keys must be strings")
+            if not isinstance(raw_value, str):
+                set_dotted(scope, dotted_key, raw_value)
+                continue
+            rendered = render_template(raw_value, scope)
+            set_dotted(scope, dotted_key, rendered)
+
+        return InterpreterState(config_path=self.config_path, target_name=target_name, scope=scope)
+
+    def _materialize_target(self, target_name: str) -> dict[str, Any]:
+        globals_obj = self.config.get("globals", {})
+        targets = self._get_targets()
+        target_obj = targets[target_name]
+
+        use_global = target_obj.get("use_global", {})
+        merged: dict[str, Any]
+        if isinstance(use_global, dict) and use_global.get("use_all", False):
+            merged = copy.deepcopy(globals_obj)
+        else:
+            merged = {}
+
+        target_without_use_global = {k: v for k, v in target_obj.items() if k != "use_global"}
+        merged = self._deep_merge(merged, target_without_use_global)
+
+        artifacts = merged.get("artifacts")
+        if isinstance(artifacts, dict):
+            for artifact_name, artifact_spec in list(artifacts.items()):
+                if not isinstance(artifact_spec, dict):
+                    continue
+                artifacts[artifact_name] = self._apply_mod_transforms(artifact_spec)
+
+        return merged
+
+    def _apply_mod_transforms(self, artifact_spec: dict[str, Any]) -> dict[str, Any]:
+        out = copy.deepcopy(artifact_spec)
+        mod_ops = out.pop("mod_transforms", None)
+        if not mod_ops:
+            return out
+
+        transforms = out.get("transforms", [])
+        if not isinstance(transforms, list):
+            raise ValueError("artifact.transforms must be a list")
+
+        for op in mod_ops:
+            if not isinstance(op, dict):
+                raise ValueError("mod_transforms entries must be objects")
+            action = op.get("op")
+            ref = op.get("ref")
+            transform = op.get("transform")
+            if not isinstance(ref, str):
+                raise ValueError("mod_transforms.ref must be a string")
+
+            idx = next((i for i, t in enumerate(transforms) if isinstance(t, dict) and t.get("id") == ref), None)
+            if idx is None:
+                raise ValueError(f"mod_transforms ref not found: {ref}")
+
+            if action == "replace":
+                if not isinstance(transform, dict):
+                    raise ValueError("mod_transforms.replace requires object transform")
+                transforms[idx] = transform
+            elif action == "insert":
+                if not isinstance(transform, dict):
+                    raise ValueError("mod_transforms.insert requires object transform")
+                transforms.insert(idx + 1, transform)
+            elif action in {"remove", "delete"}:
+                transforms.pop(idx)
+            else:
+                raise ValueError(f"Unsupported mod_transforms op: {action}")
+
+        out["transforms"] = transforms
+        return out
+
+    def _deep_merge(self, base: Any, override: Any) -> Any:
+        if isinstance(base, dict) and isinstance(override, dict):
+            merged = copy.deepcopy(base)
+            for key, value in override.items():
+                if key in merged:
+                    merged[key] = self._deep_merge(merged[key], value)
+                else:
+                    merged[key] = copy.deepcopy(value)
+            return merged
+        return copy.deepcopy(override)
+
+    def _get_targets(self) -> dict[str, Any]:
+        targets = self.config.get("targets")
+        if not isinstance(targets, dict):
+            raise ValueError("config.targets must be an object")
+        return targets
+
+    def _zip_directory(self, source_dir: Path, zip_path: Path) -> None:
+        zip_path.parent.mkdir(parents=True, exist_ok=True)
+        if zip_path.suffix.lower() == ".zip":
+            base_name = zip_path.with_suffix("")
+        else:
+            base_name = zip_path
+            zip_path = zip_path.with_suffix(".zip")
+        shutil.make_archive(str(base_name), "zip", root_dir=source_dir)

mapack-0.0.0/core/runtime.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+
+@dataclass(slots=True)
+class ArtifactResult:
+    name: str
+    workdir: Path
+    output_path: Path | None = None
+
+
+@dataclass(slots=True)
+class InterpreterState:
+    config_path: Path
+    target_name: str
+    scope: dict[str, Any]
+    artifact_results: dict[str, ArtifactResult] = field(default_factory=dict)
+
+    @property
+    def config_dir(self) -> Path:
+        return self.config_path.parent

mapack-0.0.0/mapack.egg-info/PKG-INFO

@@ -0,0 +1,31 @@
+Metadata-Version: 2.4
+Name: mapack
+Version: 0.0.0
+Summary: Config-driven Minecraft map packer CLI
+Keywords: minecraft,cli,packaging,jsonc
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Operating System :: OS Independent
+Classifier: Environment :: Console
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: click<9,>=8.1
+
+# Mapack (Minecraft Map Packer)
+
+Config-driven CLI tool to build and export Minecraft map artifacts from a JSON/JSONC config file.
+
+## Usage
+
+```bash
+mapack <config.jsonc>
+```
+
+## Documentation
+
+To Be Written.

mapack-0.0.0/mapack.egg-info/SOURCES.txt

@@ -0,0 +1,25 @@
+README.md
+pyproject.toml
+app/__init__.py
+app/cli.py
+config/__init__.py
+config/expressions.py
+config/parser.py
+config/templating.py
+core/__init__.py
+core/interpreter.py
+core/runtime.py
+mapack.egg-info/PKG-INFO
+mapack.egg-info/SOURCES.txt
+mapack.egg-info/dependency_links.txt
+mapack.egg-info/entry_points.txt
+mapack.egg-info/requires.txt
+mapack.egg-info/top_level.txt
+transforms/__init__.py
+transforms/base.py
+transforms/conditional.py
+transforms/copy.py
+transforms/git_ops.py
+transforms/log.py
+transforms/mc_feature.py
+transforms/registry.py

mapack-0.0.0/mapack.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

mapack-0.0.0/mapack.egg-info/entry_points.txt

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

mapack-0.0.0/mapack.egg-info/requires.txt

@@ -0,0 +1 @@
+click<9,>=8.1

mapack-0.0.0/mapack.egg-info/top_level.txt

@@ -0,0 +1,4 @@
+app
+config
+core
+transforms

mapack-0.0.0/pyproject.toml

@@ -0,0 +1,31 @@
+[build-system]
+requires = ["setuptools>=69", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "mapack"
+description = "Config-driven Minecraft map packer CLI"
+readme = "README.md"
+requires-python = ">=3.10"
+keywords = ["minecraft", "cli", "packaging", "jsonc"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Developers",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Operating System :: OS Independent",
+  "Environment :: Console",
+]
+dependencies = [
+  "click>=8.1,<9"
+]
+dynamic = ["version"]
+
+[project.scripts]
+mapack = "app.cli:main"
+
+[tool.setuptools.packages.find]
+include = ["app*", "config*", "core*", "transforms*"]

mapack-0.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

mapack-0.0.0/transforms/__init__.py

@@ -0,0 +1,13 @@
+from .registry import registry
+
+
+def load_builtin_transforms() -> None:
+    # import side-effects for registration
+    from . import conditional  # noqa: F401
+    from . import copy  # noqa: F401
+    from . import git_ops  # noqa: F401
+    from . import log  # noqa: F401
+    from . import mc_feature  # noqa: F401
+
+
+__all__ = ["registry", "load_builtin_transforms"]

mapack-0.0.0/transforms/base.py

@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from typing import Any, Protocol
+
+
+class TransformContextProtocol(Protocol):
+    def run_nested_transform(self, spec: dict[str, Any]) -> None: ...
+
+
+class TransformHandler(Protocol):
+    def __call__(self, ctx: TransformContextProtocol, spec: dict[str, Any]) -> None: ...

mapack-0.0.0/transforms/conditional.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+from .registry import register_transform
+
+
+def _compare(op: str, a, b) -> bool:
+    match op:
+        case "==":
+            return a == b
+        case "!=":
+            return a != b
+        case ">":
+            return a > b
+        case ">=":
+            return a >= b
+        case "<":
+            return a < b
+        case "<=":
+            return a <= b
+        case _:
+            raise ValueError(f"Unsupported conditional op: {op}")
+
+
+def _run_transform_or_list(ctx, block):
+    if block is None:
+        return
+    if isinstance(block, list):
+        for item in block:
+            ctx.run_nested_transform(item)
+        return
+    if isinstance(block, dict):
+        ctx.run_nested_transform(block)
+        return
+    raise ValueError("conditional transform expects dict or list for then/else")
+
+
+@register_transform("conditional")
+def transform_conditional(ctx, spec: dict) -> None:
+    op = str(spec.get("op", "=="))
+    a = ctx.resolve_expr_or_value(spec.get("a"))
+    b = ctx.resolve_expr_or_value(spec.get("b"))
+    if _compare(op, a, b):
+        _run_transform_or_list(ctx, spec.get("then"))
+    else:
+        _run_transform_or_list(ctx, spec.get("else"))

mapack-0.0.0/transforms/copy.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+import shutil
+from pathlib import Path
+
+from .registry import register_transform
+
+
+def _copy_file(src: Path, dst: Path) -> None:
+    dst.parent.mkdir(parents=True, exist_ok=True)
+    shutil.copy2(src, dst)
+
+
+def _copy_tree_contents(src: Path, dst: Path) -> None:
+    dst.mkdir(parents=True, exist_ok=True)
+    for child in src.iterdir():
+        target = dst / child.name
+        if child.is_dir():
+            shutil.copytree(child, target, dirs_exist_ok=True)
+        else:
+            _copy_file(child, target)
+
+
+@register_transform("copy")
+def transform_copy(ctx, spec: dict) -> None:
+    src = ctx.resolve_source(spec.get("src"), allow_artifact_output=True)
+    dest_rel = str(ctx.resolve_value(spec.get("dest", ".")))
+    dest = (ctx.workdir / dest_rel).resolve()
+
+    if not src.exists():
+        raise FileNotFoundError(f"copy transform source does not exist: {src}")
+
+    if src.is_file():
+        if dest.exists() and dest.is_dir():
+            _copy_file(src, dest / src.name)
+        else:
+            _copy_file(src, dest)
+        return
+
+    # directory source
+    if dest.exists() and dest.is_file():
+        raise ValueError(f"Cannot copy directory into file: {dest}")
+
+    _copy_tree_contents(src, dest)

mapack-0.0.0/transforms/git_ops.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+import subprocess
+
+from .registry import register_transform
+
+
+def _run_git(args: list[str], cwd) -> None:
+    subprocess.run(["git", *args], cwd=str(cwd), check=True)
+
+
+@register_transform("git:clone")
+def transform_git_clone(ctx, spec: dict) -> None:
+    repo_url = str(ctx.resolve_value(spec.get("repo_url")))
+    branch = spec.get("branch")
+    dest_rel = str(ctx.resolve_value(spec.get("dest", ".")))
+    dest = (ctx.workdir / dest_rel).resolve()
+    dest.parent.mkdir(parents=True, exist_ok=True)
+
+    args = ["clone"]
+    if branch:
+        args.extend(["--branch", str(ctx.resolve_value(branch))])
+    if dest_rel in {"", "."}:
+        args.extend([repo_url, "."])
+    else:
+        args.extend([repo_url, str(dest)])
+    _run_git(args, cwd=ctx.workdir)
+
+
+@register_transform("git:pull")
+def transform_git_pull(ctx, spec: dict) -> None:
+    repo_dir_rel = str(ctx.resolve_value(spec.get("repo_dir", ".")))
+    branch = spec.get("branch")
+    repo_dir = (ctx.workdir / repo_dir_rel).resolve()
+    catch = spec.get("catch")
+
+    args = ["pull"]
+    if branch:
+        args.extend(["origin", str(ctx.resolve_value(branch))])
+
+    try:
+        _run_git(args, cwd=repo_dir)
+    except Exception:
+        if catch is None:
+            raise
+        ctx.run_nested_transform(catch)

mapack-0.0.0/transforms/log.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+import logging
+
+from .registry import register_transform
+
+logger = logging.getLogger("mapack")
+
+
+@register_transform("log")
+def transform_log(ctx, spec: dict) -> None:
+    message = ctx.resolve_value(spec.get("message", ""))
+    logger.info("[transform:log] %s", message)

mapack-0.0.0/transforms/mc_feature.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+import shutil
+from pathlib import Path
+
+from .registry import register_transform
+
+
+_DIMENSION_PATHS = {
+    "minecraft:the_nether": [
+        ["DIM-1"],
+        ["dimensions", "minecraft", "the_nether"],
+    ],
+    "minecraft:the_end": [
+        ["DIM1"],
+        ["dimensions", "minecraft", "the_end"],
+    ],
+}
+
+
+def _remove_dimension_folders(workdir: Path, keep: set[str]) -> None:
+    for dim, folders in _DIMENSION_PATHS.items():
+        if dim in keep:
+            continue
+        for parts in folders:
+            path = workdir.joinpath(*parts)
+            if path.is_dir():
+                shutil.rmtree(path, ignore_errors=True)
+
+
+@register_transform("mc:feature")
+def transform_mc_feature(ctx, spec: dict) -> None:
+    feature = str(ctx.resolve_value(spec.get("feature", "")))
+    args = spec.get("args") or {}
+    if not isinstance(args, dict):
+        raise ValueError("mc:feature args must be an object")
+
+    if feature == "delete_dimensions":
+        keep_raw = args.get("keep", ["minecraft:overworld"])
+        if not isinstance(keep_raw, list):
+            raise ValueError("mc:feature delete_dimensions args.keep must be a list")
+        keep = {str(ctx.resolve_value(v)) for v in keep_raw}
+        _remove_dimension_folders(ctx.workdir, keep)
+        return
+
+    raise ValueError(f"Unsupported mc:feature value: {feature}")

mapack-0.0.0/transforms/registry.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+from typing import Any
+
+from .base import TransformHandler
+
+
+class TransformRegistry:
+    def __init__(self) -> None:
+        self._handlers: dict[str, TransformHandler] = {}
+
+    def register(self, name: str, handler: TransformHandler) -> None:
+        key = name.strip()
+        if not key:
+            raise ValueError("Transform name cannot be empty")
+        self._handlers[key] = handler
+
+    def get(self, name: str) -> TransformHandler:
+        if name not in self._handlers:
+            raise KeyError(f"Unknown transform type: {name}")
+        return self._handlers[name]
+
+    def names(self) -> list[str]:
+        return sorted(self._handlers.keys())
+
+
+registry = TransformRegistry()
+
+
+def register_transform(name: str):
+    def wrapper(func: TransformHandler) -> TransformHandler:
+        registry.register(name, func)
+        return func
+
+    return wrapper
+
+
+def run_transform(name: str, ctx: Any, spec: dict[str, Any]) -> None:
+    handler = registry.get(name)
+    handler(ctx, spec)