cpyte-cpm 1.1.1__py3-none-any.whl

cpyte/__init__.py

@@ -0,0 +1 @@
+"""CPM - A package manager for Cpyte."""

cpyte/cli/commands.py

@@ -0,0 +1,108 @@
+"""Structured types for parsed CLI commands."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import List, Optional, Union
+
+
+@dataclass(frozen=True)
+class GlobalOptions:
+    verbose: bool = False
+    quiet: bool = False
+    yes: bool = False
+    offline: bool = False
+    no_cache: bool = False
+    config: Optional[str] = None
+    server: List[str] = field(default_factory=list)
+    target: Optional[str] = None
+    llvm_version: Optional[str] = None
+
+
+@dataclass(frozen=True)
+class InitCommand:
+    pass
+
+
+@dataclass(frozen=True)
+class AddCommand:
+    packages: List[str] = field(default_factory=list)
+
+
+@dataclass(frozen=True)
+class RemoveCommand:
+    packages: List[str] = field(default_factory=list)
+
+
+@dataclass(frozen=True)
+class InstallCommand:
+    packages: List[str] = field(default_factory=list)
+
+
+@dataclass(frozen=True)
+class UpdateCommand:
+    packages: List[str] = field(default_factory=list)
+
+
+@dataclass(frozen=True)
+class BuildCommand:
+    pass
+
+
+@dataclass(frozen=True)
+class RunCommand:
+    script: str = ""
+    args: List[str] = field(default_factory=list)
+
+
+@dataclass(frozen=True)
+class VersionCommand:
+    pass
+
+
+@dataclass(frozen=True)
+class PublishCommand:
+    directory: str = ""
+    name: str = ""
+    version: str = ""
+    requires: List[str] = field(default_factory=list)
+    prebuilt: bool = False
+    llvm_version: str = ""
+    cpyte_version: str = ""
+    server: str = ""
+    token: str = ""
+
+
+@dataclass(frozen=True)
+class UnpublishCommand:
+    name: str = ""
+    version: str = ""
+    all: bool = False
+    block: bool = False
+    server: str = ""
+
+
+@dataclass(frozen=True)
+class SearchCommand:
+    query: str = ""
+
+
+Command = Union[
+    InitCommand,
+    AddCommand,
+    RemoveCommand,
+    InstallCommand,
+    UpdateCommand,
+    BuildCommand,
+    RunCommand,
+    VersionCommand,
+    PublishCommand,
+    UnpublishCommand,
+    SearchCommand,
+]
+
+
+@dataclass(frozen=True)
+class ParsedCLI:
+    global_options: GlobalOptions = field(default_factory=GlobalOptions)
+    command: Optional[Command] = None

cpyte/cli/errors.py

@@ -0,0 +1,49 @@
+"""CLI error types for clear, user-facing error messages."""
+
+from __future__ import annotations
+
+
+class CLIError(Exception):
+    """Base error for CLI parsing issues."""
+
+
+class UnknownCommandError(CLIError):
+    """Raised when an unrecognized subcommand is given."""
+
+    def __init__(self, command: str, suggestions: list[str] | None = None) -> None:
+        self.command = command
+        self.suggestions = suggestions or []
+        msg = f"unknown command '{command}'"
+        if self.suggestions:
+            msg += f". Did you mean: {', '.join(self.suggestions)}?"
+        super().__init__(msg)
+
+
+class MissingArgumentError(CLIError):
+    """Raised when a required argument is missing."""
+
+    def __init__(self, argument: str, command: str) -> None:
+        self.argument = argument
+        self.command = command
+        super().__init__(
+            f"command '{command}' requires {argument}"
+        )
+
+
+class InvalidPackageSpecError(CLIError):
+    """Raised when a package specification is invalid."""
+
+    def __init__(self, spec: str) -> None:
+        self.spec = spec
+        super().__init__(f"invalid package specification: '{spec}'")
+
+
+class InvalidOptionError(CLIError):
+    """Raised when an invalid option is provided."""
+
+    def __init__(self, option: str, message: str = "") -> None:
+        self.option = option
+        msg = f"invalid option '{option}'"
+        if message:
+            msg += f": {message}"
+        super().__init__(msg)

cpyte/cli/executor.py

@@ -0,0 +1,263 @@
+"""Execution engine for CPM instruction streams.
+
+Pipeline stage: Execute
+Consumes the flat instruction list produced by deduplicator() and
+performs actual filesystem operations.
+
+Directory layout:
+    ~/.cpm/cache/<name>/<version>/        — downloaded artifacts (shared cache)
+    <project>/.cpm/modules/<name>/<version>/ — installed packages (project-local)
+
+Modes:
+    prebuilt = false (default): install source (.cpy files)
+    prebuilt = true:            install precompiled LLVM IR (.ll)
+                                registry serves prebuilt artifacts
+"""
+
+import hashlib
+import os
+import shutil
+import tarfile
+import tempfile
+import zipfile
+from pathlib import Path
+
+import requests as rq
+
+from .gethins import fetch_repo
+
+
+CPM_HOME = Path.home() / ".cpm"
+CACHE_DIR = CPM_HOME / "cache"
+
+
+def _ensure_cache_dir():
+    """Create CPM cache directory if it doesn't exist."""
+    CACHE_DIR.mkdir(parents=True, exist_ok=True)
+
+
+def _cache_path(name: str, version: str) -> Path:
+    """Return the cache directory for a specific package version."""
+    return CACHE_DIR / name / version
+
+
+def _module_path(project_root: Path, name: str, version: str) -> Path:
+    """Return the project-local install directory for a specific package version."""
+    return project_root / ".cpm" / "modules" / name / version
+
+
+def calculate_checksum(file_path: str, algorithm: str = "sha256") -> str:
+    """Calculate checksum of a file."""
+    hash_func = hashlib.new(algorithm)
+    with open(file_path, "rb") as fp:
+        for chunk in iter(lambda: fp.read(4096), b""):
+            hash_func.update(chunk)
+    return f"{algorithm}:{hash_func.hexdigest()}"
+
+
+def _verify_checksum(file_path: str, expected: str) -> None:
+    """Verify a file's checksum. Expected format: 'algorithm:hex'."""
+    if ":" not in expected:
+        raise ValueError(f"Checksum must be 'algorithm:hex', got: {expected}")
+    algorithm, expected_hex = expected.split(":", 1)
+    actual = calculate_checksum(file_path, algorithm)
+    actual_hex = actual.split(":", 1)[1]
+    if actual_hex != expected_hex:
+        os.remove(file_path)
+        raise ValueError(
+            f"Checksum mismatch for {file_path}: "
+            f"expected {expected}, got {actual}"
+        )
+
+
+def _download(url: str, dest: Path) -> None:
+    """Download a file from url to dest."""
+    response = rq.get(url, stream=True, timeout=30)
+    response.raise_for_status()
+    with open(dest, "wb") as fp:
+        for chunk in response.iter_content(chunk_size=8192):
+            fp.write(chunk)
+
+
+def _extract(archive_path: Path, dest: Path) -> None:
+    """Extract a tar.gz or zip archive into dest."""
+    dest.mkdir(parents=True, exist_ok=True)
+    name = archive_path.name
+    if name.endswith(".tar.gz") or name.endswith(".tgz"):
+        with tarfile.open(archive_path, "r:gz") as tar:
+            tar.extractall(dest)
+    elif name.endswith(".tar.bz2"):
+        with tarfile.open(archive_path, "r:bz2") as tar:
+            tar.extractall(dest)
+    elif name.endswith(".tar"):
+        with tarfile.open(archive_path, "r") as tar:
+            tar.extractall(dest)
+    elif name.endswith(".zip"):
+        with zipfile.ZipFile(archive_path, "r") as zf:
+            zf.extractall(dest)
+    else:
+        # Raw file (e.g. .ll, .bc, .cpy) — copy directly
+        dest.mkdir(parents=True, exist_ok=True)
+        shutil.copy2(archive_path, dest / name)
+
+
+def _is_cached(name: str, version: str, checksum: str) -> bool:
+    """Check if a package is already in cache with matching checksum."""
+    cache = _cache_path(name, version)
+    if not cache.exists():
+        return False
+    for f in cache.iterdir():
+        if f.is_file():
+            try:
+                actual = calculate_checksum(str(f))
+                if actual == checksum:
+                    return True
+            except Exception:
+                continue
+    return False
+
+
+def _install_from_cache(project_root: Path, name: str, version: str) -> None:
+    """Copy a cached archive into the project modules directory and extract."""
+    cache = _cache_path(name, version)
+    target = _module_path(project_root, name, version)
+
+    if target.exists():
+        shutil.rmtree(target)
+
+    for f in cache.iterdir():
+        if f.is_file():
+            _extract(f, target)
+            return
+
+
+def execute_get(inst: dict, project_root: Path, prebuilt: bool = False) -> None:
+    """Execute a single GET instruction.
+
+    Parameters
+    ----------
+    inst:
+        Instruction dict with GET, url, version, checksum.
+    project_root:
+        Project root directory (where .cpm/modules/ lives).
+    prebuilt:
+        If True, fetch prebuilt .ll from registry.
+    """
+    name = inst["GET"]
+    url = inst.get("url")
+    version = inst.get("version", "latest")
+    checksum = inst.get("checksum")
+
+    if not url:
+        raise ValueError(f"No URL provided for package '{name}'")
+
+    target = _module_path(project_root, name, version)
+
+    # Already installed — skip
+    if target.exists():
+        print(f"  {name}@{version} already installed")
+        return
+
+    cache = _cache_path(name, version)
+
+    # Check cache
+    if checksum and _is_cached(name, version, checksum):
+        print(f"  {name}@{version} found in cache, installing...")
+        _install_from_cache(project_root, name, version)
+        print(f"  {name}@{version} installed")
+        return
+
+    # Download
+    print(f"  downloading {name}@{version}...")
+    cache.mkdir(parents=True, exist_ok=True)
+    filename = url.rsplit("/", 1)[-1] or f"{name}-{version}.tar.gz"
+    dest = cache / filename
+    _download(url, dest)
+
+    # Verify checksum
+    if checksum:
+        print(f"  verifying checksum...")
+        _verify_checksum(str(dest), checksum)
+
+    # Extract to cache first
+    print(f"  installing {name}@{version}...")
+    _extract(dest, cache)
+
+    # Install from cache to project
+    target.parent.mkdir(parents=True, exist_ok=True)
+    shutil.copytree(cache, target)
+
+    mode = "prebuilt" if prebuilt else "source"
+    print(f"  {name}@{version} installed [{mode}]")
+
+
+def execute_remove(inst: dict, project_root: Path) -> None:
+    """Execute a single REMOVE instruction."""
+    name = inst["REMOVE"]
+    target = project_root / ".cpm" / "modules" / name
+
+    if not target.exists():
+        print(f"  {name} not installed, skipping")
+        return
+
+    shutil.rmtree(target)
+    print(f"  {name} removed")
+
+
+def execute(
+    instructions: list[dict],
+    project_root: Path,
+    repo: str = None,
+    ver: str = "latest",
+    prebuilt: bool = False,
+) -> None:
+    """Execute a flat instruction stream.
+
+    Pipeline stage: Execute
+    This is the final stage — instructions are consumed and filesystem
+    operations are performed.
+
+    Parameters
+    ----------
+    instructions:
+        Flat list of dicts from deduplicator(), e.g.
+        [{"GET": "D", "url": "...", ...}, {"GET": "B", ...}]
+    project_root:
+        Project root directory (where .cpm/modules/ lives).
+    repo:
+        Repository URL. If provided, missing metadata (url, checksum)
+        will be fetched during execution.
+    ver:
+        Package version to resolve against.
+    prebuilt:
+        If True, registry serves prebuilt artifacts (.ll).
+    """
+    _ensure_cache_dir()
+
+    total = len(instructions)
+    mode = "prebuilt" if prebuilt else "source"
+    print(f"\nExecuting {total} instruction(s) [{mode}]...\n")
+
+    for i, inst in enumerate(instructions, 1):
+        # If metadata is missing from instruction, fetch it
+        if "GET" in inst and "url" not in inst:
+            name = inst["GET"]
+            if repo is None:
+                raise ValueError(
+                    f"Instruction for '{name}' has no URL and no repo provided"
+                )
+            metadata = fetch_repo(repo, f"metadata/{name}/{ver}")
+            inst["url"] = metadata["url"]
+            inst["checksum"] = metadata.get("checksum", "")
+            inst["version"] = metadata.get("version", ver)
+
+        if "GET" in inst:
+            print(f"[{i}/{total}] GET {inst['GET']}")
+            execute_get(inst, project_root, prebuilt=prebuilt)
+        elif "REMOVE" in inst:
+            print(f"[{i}/{total}] REMOVE {inst['REMOVE']}")
+            execute_remove(inst, project_root)
+        else:
+            print(f"[{i}/{total}] SKIP unknown instruction: {inst}")
+
+    print(f"\nDone. {total} instruction(s) executed.")

cpyte/cli/gethins.py

@@ -0,0 +1,36 @@
+import requests as rq
+
+
+def fetch_repo(url: str, back: str):
+    """Fetch metadata from a single repo."""
+    cleaned = url.strip("/")
+    based = "/".join([cleaned, back])
+    repo = rq.get(based)
+    repo.raise_for_status()
+    return repo.json()
+
+
+def fetch_repo_multi(repos: list[str], back: str):
+    """Fetch metadata trying repos in priority order.
+
+    Tries each repo in order. Returns the first successful result.
+    Raises the last error if all repos fail.
+    """
+    last_error = None
+    for url in repos:
+        try:
+            return fetch_repo(url, back)
+        except Exception as e:
+            last_error = e
+            continue
+    if last_error:
+        raise last_error
+    raise RuntimeError("no repositories configured")
+
+
+def fetch_group(repos: list[str], group: str) -> list[str]:
+    """Fetch package list for a group (e.g., @std -> ["@std/json", ...])."""
+    # Strip the @ for the metadata path
+    group_id = group.lstrip("@")
+    data = fetch_repo_multi(repos, f"metadata/@{group_id}/latest")
+    return data.get("packages", [])

cpyte/cli/lockfile.py

@@ -0,0 +1,183 @@
+"""Lockfile management for CPM.
+
+Handles reading and writing cpm.lock, which stores exact resolved
+versions for reproducible builds.
+
+Lockfile format:
+    [[package]]
+    name = "@std/json"
+    version = "2.0.3"
+    resolved = "https://repo.example.com/group/std/json/2.0.3.tar.gz"
+    checksum = "sha256:abc123..."
+    dependencies = ["@std/encoding@1.2.0"]
+    llvm_version = "18.1.0"
+    cpyte_version = "0.5.0"
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Optional
+
+
+LOCKFILE_NAME = "cpm.lock"
+
+
+@dataclass
+class LockEntry:
+    """A single locked package."""
+    name: str
+    version: str
+    resolved: str = ""
+    checksum: str = ""
+    dependencies: list[str] = field(default_factory=list)
+    llvm_version: str = ""
+    cpyte_version: str = ""
+
+
+@dataclass
+class Lockfile:
+    """Represents a cpm.lock file."""
+    entries: list[LockEntry] = field(default_factory=list)
+    path: Optional[Path] = None
+
+    def get(self, name: str) -> Optional[LockEntry]:
+        """Get a locked entry by package name."""
+        for entry in self.entries:
+            if entry.name == name:
+                return entry
+        return None
+
+    def add(self, entry: LockEntry) -> None:
+        """Add or update a locked entry."""
+        for i, existing in enumerate(self.entries):
+            if existing.name == entry.name:
+                self.entries[i] = entry
+                return
+        self.entries.append(entry)
+
+    def remove(self, name: str) -> bool:
+        """Remove a locked entry by name. Returns True if removed."""
+        for i, entry in enumerate(self.entries):
+            if entry.name == name:
+                self.entries.pop(i)
+                return True
+        return False
+
+    def toml_str(self) -> str:
+        """Serialize lockfile to TOML string."""
+        if not self.entries:
+            return "# cpm.lock — auto-generated, do not edit manually\n"
+
+        lines = ["# cpm.lock — auto-generated, do not edit manually", ""]
+        for entry in self.entries:
+            lines.append("[[package]]")
+            lines.append(f'name = "{entry.name}"')
+            lines.append(f'version = "{entry.version}"')
+            if entry.resolved:
+                lines.append(f'resolved = "{entry.resolved}"')
+            if entry.checksum:
+                lines.append(f'checksum = "{entry.checksum}"')
+            if entry.dependencies:
+                deps_str = ", ".join(f'"{d}"' for d in entry.dependencies)
+                lines.append(f"dependencies = [{deps_str}]")
+            if entry.llvm_version:
+                lines.append(f'llvm_version = "{entry.llvm_version}"')
+            if entry.cpyte_version:
+                lines.append(f'cpyte_version = "{entry.cpyte_version}"')
+            lines.append("")
+        return "\n".join(lines)
+
+
+def find_lockfile(start: Optional[Path] = None) -> Optional[Path]:
+    """Walk up from start directory to find cpm.lock."""
+    if start is None:
+        start = Path.cwd()
+
+    current = start.resolve()
+    while True:
+        candidate = current / LOCKFILE_NAME
+        if candidate.exists():
+            return candidate
+        parent = current.parent
+        if parent == current:
+            return None
+        current = parent
+
+
+def read_lockfile(path: Optional[Path] = None) -> Lockfile:
+    """Read a cpm.lock file.
+
+    If path is None, searches upward from cwd.
+    Returns an empty lockfile if not found.
+    """
+    if path is None:
+        path = find_lockfile()
+
+    lockfile = Lockfile(path=path)
+
+    if path is None or not path.exists():
+        return lockfile
+
+    content = path.read_text()
+    _parse_lockfile(content, lockfile)
+    return lockfile
+
+
+def write_lockfile(lockfile: Lockfile) -> Path:
+    """Write lockfile to its path. Creates cpm.lock in cwd if no path set."""
+    if lockfile.path is None:
+        lockfile.path = Path.cwd() / LOCKFILE_NAME
+
+    lockfile.path.write_text(lockfile.toml_str())
+    return lockfile.path
+
+
+def _parse_lockfile(content: str, lockfile: Lockfile) -> None:
+    """Minimal TOML parser for [[package]] sections."""
+    current_entry: Optional[LockEntry] = None
+
+    for line in content.splitlines():
+        stripped = line.strip()
+
+        # Skip empty lines and comments
+        if not stripped or stripped.startswith("#"):
+            continue
+
+        # Section header
+        if stripped == "[[package]]":
+            current_entry = LockEntry(name="", version="")
+            lockfile.entries.append(current_entry)
+            continue
+
+        if current_entry is None:
+            continue
+
+        # key = value
+        if "=" in stripped:
+            key, _, value = stripped.partition("=")
+            key = key.strip()
+            value = value.strip()
+
+            if key == "name":
+                current_entry.name = value.strip('"')
+            elif key == "version":
+                current_entry.version = value.strip('"')
+            elif key == "resolved":
+                current_entry.resolved = value.strip('"')
+            elif key == "checksum":
+                current_entry.checksum = value.strip('"')
+            elif key == "llvm_version":
+                current_entry.llvm_version = value.strip('"')
+            elif key == "cpyte_version":
+                current_entry.cpyte_version = value.strip('"')
+            elif key == "dependencies":
+                # Parse array: ["dep1", "dep2"]
+                inner = value.strip("[]")
+                if inner:
+                    current_entry.dependencies = [
+                        d.strip().strip('"')
+                        for d in inner.split(",")
+                        if d.strip()
+                    ]