cpyte-cpm 1.1.1__tar.gz

cpyte_cpm-1.1.1/PKG-INFO

@@ -0,0 +1,145 @@
+Metadata-Version: 2.4
+Name: cpyte-cpm
+Version: 1.1.1
+Summary: A package manager for cpy
+Author: Albert
+License: MIT
+Project-URL: Homepage, https://gitea.5gnew.io.vn/Cpyte-Project/Cpyte
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.34.2
+Requires-Dist: cpyte
+Requires-Dist: packaging
+Provides-Extra: dev
+Requires-Dist: pytest>=9.1.1; extra == "dev"
+
+# CPM — Cpyte Package Manager
+
+A compiler-pipeline dependency resolver and installer for the [Cpyte](https://gitea.5gnew.io.vn/Cpyte-Project/Cpyte) programming language.
+
+```
+import @std.json
+          ↓
+Resolve → Lower → Optimize → Execute
+```
+
+## Install
+
+```bash
+pip install cpm
+```
+
+## Quick Start
+
+```bash
+cpm init                        # create cpytoml
+cpm add @std/json@^2.0          # add a dependency
+cpm install                     # install all from manifest
+```
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `cpm init` | Initialize a new project (`cpytoml`) |
+| `cpm add <pkg>` | Add packages to manifest + install |
+| `cpm remove <pkg>` | Remove packages + uninstall |
+| `cpm install` | Install all dependencies from manifest |
+| `cpm install <pkg>` | Install specific packages |
+| `cpm update` | Re-resolve and update all packages |
+| `cpm update <pkg>` | Re-resolve specific packages |
+| `cpm build` | Build the project |
+| `cpm run <script>` | Run a named script |
+
+## Global Flags
+
+```
+-v, --verbose        Verbose output
+-q, --quiet          Suppress output
+-y, --yes            Auto-confirm prompts
+--offline            Offline mode (skip network)
+--no-cache           Disable cache
+--config <path>      Custom config / repo URL
+--target <platform>  Target platform (e.g. linux/x86_64)
+--llvm-version <V>   LLVM version for prebuilt packages
+```
+
+## Manifest (`cpytoml`)
+
+```toml
+[cpm]
+name = "my-app"
+version = "1.0"
+prebuilt = false
+llvm_version = "18.1.0"
+
+[cpm.target]
+os = "linux"
+arch = "x86_64"
+features = ["gui", "ssl"]
+
+[cpm.dependencies]
+"@std/json" = "^2.0"
+"@std/http" = "1.0"
+"package_a" = "latest"
+```
+
+## Claims System
+
+Packages declare platform support; CPM filters based on your target.
+
+**Package metadata (registry):**
+```json
+{
+  "name": "win32-api",
+  "claims": { "os": ["windows"], "arch": ["x86_64"] }
+}
+```
+
+**Resolution:**
+| Target | `win32-api` (windows) | `posix-api` (linux) | `@std/json` (any) |
+|--------|----------------------|--------------------|--------------------|
+| `linux/x86_64` | skip | install | install |
+| `windows/x86_64` | install | skip | install |
+
+Auto-detects from current platform when no target is specified.
+
+## Prebuilt Mode
+
+When the registry serves precompiled LLVM IR:
+
+```toml
+[cpm]
+prebuilt = true
+llvm_version = "18.1.0"
+```
+
+CPM fetches `.ll` artifacts from `metadata/prebuilt/...` and skips source packages
+with incompatible LLVM versions (major version must match).
+
+## Lockfile (`cpm.lock`)
+
+Auto-generated. Pins exact versions for reproducible builds.
+
+```toml
+[[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"
+```
+
+## Directory Layout
+
+```
+~/.cpm/
+├── cache/<name>/<version>/     # downloaded archives
+└── modules/<name>/<version>/   # extracted packages
+```
+
+## License
+
+MIT

cpyte_cpm-1.1.1/README.md

@@ -0,0 +1,130 @@
+# CPM — Cpyte Package Manager
+
+A compiler-pipeline dependency resolver and installer for the [Cpyte](https://gitea.5gnew.io.vn/Cpyte-Project/Cpyte) programming language.
+
+```
+import @std.json
+          ↓
+Resolve → Lower → Optimize → Execute
+```
+
+## Install
+
+```bash
+pip install cpm
+```
+
+## Quick Start
+
+```bash
+cpm init                        # create cpytoml
+cpm add @std/json@^2.0          # add a dependency
+cpm install                     # install all from manifest
+```
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `cpm init` | Initialize a new project (`cpytoml`) |
+| `cpm add <pkg>` | Add packages to manifest + install |
+| `cpm remove <pkg>` | Remove packages + uninstall |
+| `cpm install` | Install all dependencies from manifest |
+| `cpm install <pkg>` | Install specific packages |
+| `cpm update` | Re-resolve and update all packages |
+| `cpm update <pkg>` | Re-resolve specific packages |
+| `cpm build` | Build the project |
+| `cpm run <script>` | Run a named script |
+
+## Global Flags
+
+```
+-v, --verbose        Verbose output
+-q, --quiet          Suppress output
+-y, --yes            Auto-confirm prompts
+--offline            Offline mode (skip network)
+--no-cache           Disable cache
+--config <path>      Custom config / repo URL
+--target <platform>  Target platform (e.g. linux/x86_64)
+--llvm-version <V>   LLVM version for prebuilt packages
+```
+
+## Manifest (`cpytoml`)
+
+```toml
+[cpm]
+name = "my-app"
+version = "1.0"
+prebuilt = false
+llvm_version = "18.1.0"
+
+[cpm.target]
+os = "linux"
+arch = "x86_64"
+features = ["gui", "ssl"]
+
+[cpm.dependencies]
+"@std/json" = "^2.0"
+"@std/http" = "1.0"
+"package_a" = "latest"
+```
+
+## Claims System
+
+Packages declare platform support; CPM filters based on your target.
+
+**Package metadata (registry):**
+```json
+{
+  "name": "win32-api",
+  "claims": { "os": ["windows"], "arch": ["x86_64"] }
+}
+```
+
+**Resolution:**
+| Target | `win32-api` (windows) | `posix-api` (linux) | `@std/json` (any) |
+|--------|----------------------|--------------------|--------------------|
+| `linux/x86_64` | skip | install | install |
+| `windows/x86_64` | install | skip | install |
+
+Auto-detects from current platform when no target is specified.
+
+## Prebuilt Mode
+
+When the registry serves precompiled LLVM IR:
+
+```toml
+[cpm]
+prebuilt = true
+llvm_version = "18.1.0"
+```
+
+CPM fetches `.ll` artifacts from `metadata/prebuilt/...` and skips source packages
+with incompatible LLVM versions (major version must match).
+
+## Lockfile (`cpm.lock`)
+
+Auto-generated. Pins exact versions for reproducible builds.
+
+```toml
+[[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"
+```
+
+## Directory Layout
+
+```
+~/.cpm/
+├── cache/<name>/<version>/     # downloaded archives
+└── modules/<name>/<version>/   # extracted packages
+```
+
+## License
+
+MIT

cpyte_cpm-1.1.1/cpyte/__init__.py

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

cpyte_cpm-1.1.1/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_cpm-1.1.1/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_cpm-1.1.1/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.")