resolvescript 0.1.2__py3-none-any.whl

resolve_script/package.py

@@ -0,0 +1,103 @@
+"""Packaging an extension into a release artifact (M7).
+
+Produces a ``<name>-<version>.tgz`` in the exact shape ``add``/``install <spec>``
+consumes: single top-level layer with ``manifest.json``, entry ``<name>.py`` and
+the ``<name>/`` package directory (no wrapper folder). A ``SHA256SUMS.txt`` is
+written alongside the archive.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import tarfile
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from .install.installer import select_files
+from .manifest.model import Manifest
+from .manifest.validation import validate_manifest
+
+
+class PackageError(RuntimeError):
+    pass
+
+
+@dataclass
+class PackageResult:
+    archive: Path
+    sha256: str
+    files: list[str] = field(default_factory=list)
+    checksum_file: Path | None = None
+
+
+def _sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for chunk in iter(lambda: handle.read(65536), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def _entry_file(root: Path, manifest: Manifest) -> Path | None:
+    if manifest.entrypoint:
+        candidate = root / manifest.entrypoint
+        if candidate.is_file():
+            return candidate
+    direct = root / f"{manifest.name}.py"
+    return direct if direct.is_file() else None
+
+
+def package_project(root: Path | str, dist_dir: Path | None = None) -> PackageResult:
+    root = Path(root).resolve()
+    manifest_path = root / "manifest.json"
+    if not manifest_path.is_file():
+        manifest_path = root / "manifest.xml"
+        if not manifest_path.is_file():
+            raise PackageError(
+                f"no manifest.json or manifest.xml in {root} (run 'resolvescript create')"
+            )
+    if manifest_path.suffix == ".xml":
+        from .manifest.xml_reader import load_manifest
+
+        manifest = load_manifest(manifest_path)
+    else:
+        from .manifest.json_reader import load_manifest
+
+        manifest = load_manifest(manifest_path)
+    errors = validate_manifest(manifest)
+    if errors:
+        raise PackageError(errors[0])
+
+    dist_dir = (dist_dir or root / "dist").resolve()
+    dist_dir.mkdir(parents=True, exist_ok=True)
+
+    include = list(manifest.install.include) if manifest.install.include else ["*.py", "manifest.json"]
+    rel_files = select_files(root, include, manifest.install.exclude)
+
+    entry = _entry_file(root, manifest)
+    if entry is not None:
+        entry_rel = entry.relative_to(root).as_posix()
+        if not any(r.as_posix() == entry_rel for r in rel_files):
+            rel_files.append(entry.relative_to(root))
+
+    manifest_rel = manifest_path.relative_to(root).as_posix()
+    if not any(r.as_posix() == manifest_rel for r in rel_files):
+        rel_files.append(manifest_path.relative_to(root))
+
+    archive_name = f"{manifest.name}-{manifest.version}.tar.gz"
+    archive = dist_dir / archive_name
+    with tarfile.open(archive, "w:gz") as tf:
+        for rel in sorted(set(rel_files), key=lambda p: p.as_posix()):
+            arcname = rel.as_posix()
+            tf.add(root / rel, arcname=arcname)
+
+    sha = _sha256(archive)
+    checksum_file = dist_dir / "SHA256SUMS.txt"
+    checksum_file.write_text(f"{sha}  {archive_name}\n", encoding="utf-8")
+
+    return PackageResult(
+        archive=archive,
+        sha256=sha,
+        files=sorted({r.as_posix() for r in rel_files}),
+        checksum_file=checksum_file,
+    )

resolve_script/resolver.py

@@ -0,0 +1,204 @@
+"""Specifier resolution and materialization pipeline.
+
+Dispatch order (design §6): path -> file-archive -> archive -> manifest ->
+github (incl. ``name`` looked up in the known table).
+"""
+
+from __future__ import annotations
+
+import json
+import tempfile
+from dataclasses import dataclass
+from pathlib import Path
+
+from .fetch import fetch, sha256_file
+from .manifest.json_reader import load_manifest
+from .semver import SemVerError, Version
+from .sources import known, unpack_archive
+from .sources.git import download_github
+from .sources.release import ReleaseSpec, asset_download_url
+from .spec import Spec, SpecError, parse_specifier
+
+
+class ResolveError(RuntimeError):
+    pass
+
+
+@dataclass
+class Resolved:
+    name: str
+    version: str
+    kind: str
+    package_dir: Path
+    source: str
+    integrity: str
+    manifest: object
+
+    def describe(self) -> str:
+        if self.integrity:
+            return f"resolved {self.name} {self.version} ({self.kind}, {self.integrity[:12]})"
+        return f"resolved {self.name} {self.version} ({self.kind})"
+
+
+def _manifest(directory: Path):
+    manifest_path = directory / "manifest.json"
+    if not manifest_path.is_file():
+        raise ResolveError(f"{directory} is not an extension: missing manifest.json")
+    return load_manifest(manifest_path)
+
+
+def _require_package_root(package_dir: Path) -> Path:
+    if not (package_dir / "manifest.json").is_file():
+        raise ResolveError(f"{package_dir} has no manifest.json")
+    return package_dir
+
+
+def resolve_spec(
+    spec_text: str,
+    *,
+    cwd: Path | None = None,
+    work_dir: Path,
+) -> Resolved:
+    """Resolve a specifier to a concrete, unpacked package directory."""
+    cwd = cwd or Path.cwd()
+    spec = parse_specifier(spec_text, cwd=cwd)
+
+    if spec.kind == "name":
+        entry = known.lookup(spec.source)
+        if not entry:
+            raise ResolveError(
+                f"unknown extension {spec.source!r} - use a github:owner/repo, "
+                "a URL, or an archive/path"
+            )
+        spec = parse_specifier(entry["source"], cwd=cwd)
+
+    # -- path source -------------------------------------------------------
+    if spec.kind == "path":
+        package_dir = _require_package_root(spec.location)
+        manifest = _manifest(package_dir)
+        return Resolved(
+            name=manifest.name,
+            version=manifest.version,
+            kind="path",
+            package_dir=package_dir,
+            source=spec.source,
+            integrity="",
+            manifest=manifest,
+        )
+
+    # -- local archive -----------------------------------------------------
+    if spec.kind == "file-archive":
+        unzip_dir = work_dir / "unpacked"
+        package_dir = unpack_archive(spec.location, unzip_dir)
+        package_dir = _require_package_root(package_dir)
+        manifest = _manifest(package_dir)
+        return Resolved(
+            name=manifest.name,
+            version=manifest.version,
+            kind="archive",
+            package_dir=package_dir,
+            source=spec.source,
+            integrity=sha256_file(spec.location),
+            manifest=manifest,
+        )
+
+    # -- remote archive / manifest URL / github ---------------------------
+    if spec.kind == "github":
+        if not spec.owner or not spec.repo:
+            raise ResolveError(f"invalid github spec: {spec.source}")
+        package_dir, integrity = download_github(
+            spec.owner,
+            spec.repo,
+            ref=spec.ref,
+            range_text=spec.range_text,
+            cache_dir=work_dir / "cache",
+        )
+        package_dir = _require_package_root(package_dir)
+        manifest = _manifest(package_dir)
+        return Resolved(
+            name=manifest.name,
+            version=manifest.version,
+            kind="github",
+            package_dir=package_dir,
+            source=spec.source,
+            integrity=integrity,
+            manifest=manifest,
+        )
+
+    if spec.kind in ("archive", "manifest"):
+        url = _asset_url(spec)
+        archive = work_dir / "cache" / _slug(url)
+        if not archive.is_file():
+            fetch(url=url, dest=archive)
+        package_dir = unpack_archive(archive, work_dir / "unpacked")
+        package_dir = _require_package_root(package_dir)
+        manifest = _manifest(package_dir)
+        return Resolved(
+            name=manifest.name,
+            version=manifest.version,
+            kind="manifest" if spec.kind == "manifest" else "archive",
+            package_dir=package_dir,
+            source=spec.source,
+            integrity=sha256_file(archive),
+            manifest=manifest,
+        )
+
+    raise ResolveError(f"cannot resolve specifier {spec_text!r}")
+
+
+def _slug(url: str) -> str:
+    import hashlib
+
+    if "/" in url:
+        tail = url.rsplit("/", 1)[-1]
+        if tail:
+            return tail
+    return hashlib.sha256(url.encode()).hexdigest()[:16] + ".tgz"
+
+
+def _asset_url(spec: Spec) -> str:
+    if spec.kind == "archive":
+        return spec.url
+    # manifest URL: fetch the manifest, then follow release info
+    with tempfile.TemporaryDirectory() as tmp:
+        payload = Path(tmp) / "manifest.json"
+        try:
+            fetch(url=spec.url, dest=payload)
+        except Exception as exc:
+            raise ResolveError(f"failed to fetch manifest {spec.url}: {exc}") from exc
+        try:
+            data = json.loads(payload.read_text("utf-8"))
+        except json.JSONDecodeError as exc:
+            raise ResolveError(f"{spec.url} is not valid JSON: {exc}") from exc
+        if not isinstance(data, dict):
+            raise ResolveError(f"{spec.url} is not an object")
+    name = data.get("name") or "extension"
+    version = data.get("version") or "0.1.0"
+    release = data.get("release")
+    if not isinstance(release, dict):
+        raise ResolveError(f"manifest at {spec.url} has no 'release' entry")
+    try:
+        return asset_download_url(ReleaseSpec.from_data(release), str(name), str(version))
+    except Exception as exc:
+        raise ResolveError(str(exc)) from exc
+
+
+def lockfile_satisfies(entry: dict | None, spec_text: str, *, cwd: Path | None = None) -> bool:
+    """§6.8 lockfile-wins: is the recorded entry good for the requested spec?"""
+    if not entry:
+        return False
+    try:
+        spec = parse_specifier(spec_text, cwd=cwd or Path.cwd())
+    except SpecError:
+        return False
+    if entry.get("source") != spec.source:
+        return False
+    if not spec.range_text:
+        return True
+    try:
+        version = Version.parse(str(entry["version"]))
+    except (SemVerError, KeyError, ValueError):
+        return False
+    from .semver import matches
+
+    return matches(version, spec.range_text)

resolve_script/sandbox/__init__.py

@@ -0,0 +1,38 @@
+"""Mock Resolve API, environment injection, smoke checks and the REPL.
+
+Typical usage from a test or script::
+
+    from resolve_script.sandbox.env import install_fake_resolve
+    from resolve_script.sandbox.smoke import run_smoke
+
+    install_fake_resolve()
+    result = run_smoke(my_module)
+"""
+
+from .env import (
+    DEFAULT_PROJECT,
+    FUSION_SCRIPT_MODULE,
+    build_default_env,
+    fake_resolve_module,
+    install_fake_resolve,
+)
+from .loader import load_built_module, load_source_module, purge_module
+from .repl import default_namespace, start_repl
+from .smoke import SmokeCheck, SmokeResult, discover_exports, run_smoke
+
+__all__ = [
+    "DEFAULT_PROJECT",
+    "FUSION_SCRIPT_MODULE",
+    "SmokeCheck",
+    "SmokeResult",
+    "build_default_env",
+    "default_namespace",
+    "discover_exports",
+    "fake_resolve_module",
+    "install_fake_resolve",
+    "load_built_module",
+    "load_source_module",
+    "purge_module",
+    "run_smoke",
+    "start_repl",
+]