zexus 1.6.8 → 1.7.2

package/src/zexus/zpm/registry.py

@@ -1,27 +1,136 @@
 """
 Package Registry - Manages package discovery and metadata
+
+Supports both a local cache and a remote HTTP registry.
+The registry URL defaults to ``https://registry.zexus.dev`` and can be
+overridden via the ``ZPM_REGISTRY`` environment variable.
+
+Auth tokens are read from ``~/.zpm/auth_token`` or the ``ZPM_AUTH_TOKEN``
+environment variable.
+
+REST API contract
+-----------------
+The following endpoints are expected on the registry server:
+
+    GET  /packages/<name>                 → package metadata (latest)
+    GET  /packages/<name>/<version>       → package metadata for version
+    GET  /packages/<name>/versions        → {"versions": ["0.1.0", …]}
+    GET  /search?q=<query>               → {"results": [{…}, …]}
+    POST /packages                        → publish (multipart: meta + tarball)
+    GET  /packages/<name>/<version>/download → tarball stream
 """
 import os
 import json
+import urllib.request
+import urllib.error
+import urllib.parse
 from pathlib import Path
 from typing import Dict, List, Optional
 
 
+class RegistryError(Exception):
+    """Raised when a registry operation fails."""
+
+
 class PackageRegistry:
     """Package registry for discovering and managing packages"""
     
     def __init__(self, registry_url: str = None):
-        self.registry_url = registry_url or os.environ.get(
-            "ZPM_REGISTRY",
-            "https://registry.zexus.dev"  # Default registry
-        )
+        self.registry_url = (
+            registry_url
+            or os.environ.get("ZPM_REGISTRY", "https://registry.zexus.dev")
+        ).rstrip("/")
         
         # Local cache directory
         self.cache_dir = Path.home() / ".zpm" / "cache"
         self.cache_dir.mkdir(parents=True, exist_ok=True)
         
+        # Auth token for publish operations
+        self._auth_token: Optional[str] = None
+        
         # Built-in packages
         self.builtin_packages = self._load_builtin_packages()
+
+    # ------------------------------------------------------------------
+    # Auth helpers
+    # ------------------------------------------------------------------
+
+    @property
+    def auth_token(self) -> Optional[str]:
+        """Lazily resolve the auth token from env or disk."""
+        if self._auth_token is not None:
+            return self._auth_token
+        # 1. Environment variable
+        token = os.environ.get("ZPM_AUTH_TOKEN")
+        if token:
+            self._auth_token = token
+            return token
+        # 2. Token file
+        token_path = Path.home() / ".zpm" / "auth_token"
+        if token_path.exists():
+            token = token_path.read_text().strip()
+            if token:
+                self._auth_token = token
+                return token
+        return None
+
+    def login(self, token: str) -> None:
+        """Store an auth token to ``~/.zpm/auth_token``."""
+        self._auth_token = token
+        token_path = Path.home() / ".zpm" / "auth_token"
+        token_path.parent.mkdir(parents=True, exist_ok=True)
+        token_path.write_text(token + "\n")
+        # Restrict permissions (owner-only read/write)
+        try:
+            token_path.chmod(0o600)
+        except OSError:
+            pass
+
+    # ------------------------------------------------------------------
+    # HTTP helpers
+    # ------------------------------------------------------------------
+
+    def _request(self, path: str, *, method: str = "GET",
+                 data: bytes = None, headers: dict = None,
+                 timeout: int = 30) -> Optional[bytes]:
+        """Perform an HTTP request against the registry.
+
+        Returns the response body on success, or ``None`` when the
+        resource is not found (HTTP 404).  Raises ``RegistryError`` for
+        other HTTP errors or connection failures.
+        """
+        url = f"{self.registry_url}{path}"
+        hdrs = {"User-Agent": "zpm/1.0"}
+        if self.auth_token:
+            hdrs["Authorization"] = f"Bearer {self.auth_token}"
+        if headers:
+            hdrs.update(headers)
+
+        req = urllib.request.Request(url, data=data, headers=hdrs, method=method)
+        try:
+            with urllib.request.urlopen(req, timeout=timeout) as resp:
+                return resp.read()
+        except urllib.error.HTTPError as exc:
+            if exc.code == 404:
+                return None
+            raise RegistryError(
+                f"Registry HTTP {exc.code} for {method} {path}: {exc.reason}"
+            ) from exc
+        except urllib.error.URLError as exc:
+            raise RegistryError(
+                f"Cannot reach registry at {self.registry_url}: {exc.reason}"
+            ) from exc
+
+    def _get_json(self, path: str) -> Optional[Dict]:
+        """GET ``path`` and parse the JSON body.  Returns None on 404."""
+        body = self._request(path)
+        if body is None:
+            return None
+        return json.loads(body)
+
+    # ------------------------------------------------------------------
+    # Built-in packages
+    # ------------------------------------------------------------------
     
     def _load_builtin_packages(self) -> Dict:
         """Load built-in package definitions"""
@@ -55,56 +164,176 @@ class PackageRegistry:
                 "files": []
             }
         }
+
+    # ------------------------------------------------------------------
+    # Public API
+    # ------------------------------------------------------------------
     
     def get_package(self, name: str, version: str = "latest") -> Optional[Dict]:
-        """Get package metadata from registry"""
-        # Check built-in packages first
+        """Get package metadata from registry.
+
+        Resolution order:
+        1. Built-in packages
+        2. Local cache (``~/.zpm/cache/<name>-<version>.json``)
+        3. Remote registry (``GET /packages/<name>[/<version>]``)
+        """
+        # 1. Check built-in packages
         if name in self.builtin_packages:
             return self.builtin_packages[name]
         
-        # Check cache
+        # 2. Check local cache
         cache_file = self.cache_dir / f"{name}-{version}.json"
         if cache_file.exists():
             with open(cache_file) as f:
                 return json.load(f)
         
-        # TODO: Fetch from remote registry
-        # For now, return None if not found
+        # 3. Fetch from remote registry
+        try:
+            path = f"/packages/{urllib.parse.quote(name)}"
+            if version and version != "latest":
+                path += f"/{urllib.parse.quote(version)}"
+            meta = self._get_json(path)
+            if meta:
+                # Cache the result locally
+                self._cache_metadata(name, meta.get("version", version), meta)
+                return meta
+        except RegistryError as e:
+            # Log but don't crash — fall through to None
+            print(f"⚠️  Registry lookup failed for {name}: {e}")
+
         return None
     
     def search(self, query: str) -> List[Dict]:
-        """Search for packages"""
+        """Search for packages.
+
+        Searches built-in packages locally *and* queries the remote
+        registry via ``GET /search?q=<query>``.
+        """
         results = []
         
         # Search built-in packages
+        q = query.lower()
         for name, pkg in self.builtin_packages.items():
-            if query.lower() in name.lower() or query.lower() in pkg.get("description", "").lower():
+            if q in name.lower() or q in pkg.get("description", "").lower():
                 results.append(pkg)
         
-        # TODO: Search remote registry
+        # Search remote registry
+        try:
+            encoded = urllib.parse.urlencode({"q": query})
+            data = self._get_json(f"/search?{encoded}")
+            if data and isinstance(data.get("results"), list):
+                for pkg in data["results"]:
+                    # Deduplicate against builtins
+                    if pkg.get("name") not in self.builtin_packages:
+                        results.append(pkg)
+        except RegistryError as e:
+            print(f"⚠️  Remote search failed: {e}")
         
         return results
     
     def publish_package(self, package_data: Dict, files: List[str]) -> bool:
-        """Publish a package to registry"""
-        # For now, just cache locally
-        name = package_data["name"]
-        version = package_data["version"]
-        
-        cache_file = self.cache_dir / f"{name}-{version}.json"
-        with open(cache_file, "w") as f:
-            json.dump(package_data, f, indent=2)
-        
-        print(f"✅ Package cached locally at {cache_file}")
-        print(f"⚠️  Remote registry publication not yet implemented")
-        
-        # TODO: Upload to remote registry
-        return True
+        """Publish a package to the registry.
+
+        Sends a multipart POST to ``/packages`` with the package metadata
+        (JSON) and the tarball (binary).  Requires an auth token.
+        """
+        name = package_data.get("name", "")
+        version = package_data.get("version", "")
+
+        # Always cache locally first
+        self._cache_metadata(name, version, package_data)
+
+        # Attempt remote publish
+        if not self.auth_token:
+            print(f"⚠️  No auth token — package cached locally only.")
+            print(f"   Run 'zpm login <token>' to enable remote publishing.")
+            return True
+
+        tarball_path = package_data.get("tarball")
+        try:
+            import mimetypes
+            boundary = "----ZPMPublishBoundary"
+            body_parts = []
+
+            # Part 1: metadata JSON
+            body_parts.append(f"--{boundary}".encode())
+            body_parts.append(b'Content-Disposition: form-data; name="metadata"')
+            body_parts.append(b"Content-Type: application/json")
+            body_parts.append(b"")
+            body_parts.append(json.dumps(package_data).encode())
+
+            # Part 2: tarball file (if present)
+            if tarball_path and os.path.isfile(tarball_path):
+                body_parts.append(f"--{boundary}".encode())
+                body_parts.append(
+                    f'Content-Disposition: form-data; name="tarball"; '
+                    f'filename="{os.path.basename(tarball_path)}"'.encode()
+                )
+                body_parts.append(b"Content-Type: application/gzip")
+                body_parts.append(b"")
+                with open(tarball_path, "rb") as f:
+                    body_parts.append(f.read())
+
+            body_parts.append(f"--{boundary}--".encode())
+            body = b"\r\n".join(body_parts)
+
+            self._request(
+                "/packages",
+                method="POST",
+                data=body,
+                headers={"Content-Type": f"multipart/form-data; boundary={boundary}"},
+            )
+            print(f"✅ Published {name}@{version} to {self.registry_url}")
+            return True
+        except RegistryError as e:
+            print(f"❌ Remote publish failed: {e}")
+            print(f"   Package was cached locally at ~/.zpm/cache/")
+            return False
     
     def get_versions(self, package: str) -> List[str]:
-        """Get all available versions of a package"""
+        """Get all available versions of a package."""
         if package in self.builtin_packages:
             return [self.builtin_packages[package]["version"]]
         
-        # TODO: Query remote registry
+        # Check remote registry
+        try:
+            encoded = urllib.parse.quote(package)
+            data = self._get_json(f"/packages/{encoded}/versions")
+            if data and isinstance(data.get("versions"), list):
+                return data["versions"]
+        except RegistryError as e:
+            print(f"⚠️  Version lookup failed for {package}: {e}")
+        
         return []
+
+    def download_tarball(self, name: str, version: str) -> Optional[Path]:
+        """Download a package tarball from the registry.
+
+        Returns the local path to the downloaded ``.tar.gz`` file,
+        or ``None`` on failure.
+        """
+        tarball_cache = self.cache_dir / f"{name}-{version}.tar.gz"
+        if tarball_cache.exists():
+            return tarball_cache
+
+        try:
+            encoded_name = urllib.parse.quote(name)
+            encoded_ver = urllib.parse.quote(version)
+            body = self._request(f"/packages/{encoded_name}/{encoded_ver}/download")
+            if body is None:
+                return None
+            tarball_cache.write_bytes(body)
+            return tarball_cache
+        except RegistryError as e:
+            print(f"⚠️  Tarball download failed for {name}@{version}: {e}")
+            return None
+
+    # ------------------------------------------------------------------
+    # Internal helpers
+    # ------------------------------------------------------------------
+
+    def _cache_metadata(self, name: str, version: str, meta: Dict) -> None:
+        """Write package metadata to the local cache."""
+        cache_file = self.cache_dir / f"{name}-{version}.json"
+        with open(cache_file, "w") as f:
+            json.dump(meta, f, indent=2)

package/src/zexus.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zexus
-Version: 1.6.8
+Version: 1.7.2
 Summary: A modern, security-first programming language with blockchain support
 Home-page: https://github.com/Zaidux/zexus-interpreter
 Author: Zaidux
@@ -41,6 +41,9 @@ Requires-Dist: mypy>=0.900; extra == "dev"
 Provides-Extra: blockchain
 Requires-Dist: web3>=5.0; extra == "blockchain"
 Requires-Dist: eth-account>=0.5; extra == "blockchain"
+Provides-Extra: jit
+Requires-Dist: llvmlite>=0.41.0; extra == "jit"
+Requires-Dist: Cython>=0.29; extra == "jit"
 Dynamic: author
 Dynamic: home-page
 Dynamic: license-file
@@ -50,14 +53,14 @@ Dynamic: requires-python
 
 <div align="center">
 
-![Zexus Logo](https://img.shields.io/badge/Zexus-v1.6.8-FF6B35?style=for-the-badge)
+![Zexus Logo](https://img.shields.io/badge/Zexus-v1.7.2-FF6B35?style=for-the-badge)
 [![License](https://img.shields.io/badge/License-MIT-blue.svg?style=for-the-badge)](LICENSE)
 [![Python](https://img.shields.io/badge/Python-3.8+-3776AB?style=for-the-badge&logo=python)](https://python.org)
 [![GitHub](https://img.shields.io/badge/GitHub-Zaidux/zexus--interpreter-181717?style=for-the-badge&logo=github)](https://github.com/Zaidux/zexus-interpreter)
 
 **A modern, security-first programming language with built-in blockchain support, VM-accelerated execution, advanced memory management, and policy-as-code**
 
-[What's New](#-whats-new-in-v150) • [Features](#-key-features) • [Installation](#-installation) • [Quick Start](#-quick-start) • [Keywords](#-complete-keyword-reference) • [Documentation](#-documentation) • [Examples](#-examples) • [Troubleshooting](#-getting-help--troubleshooting)
+[What's New](#-whats-new-in-v171) • [Features](#-key-features) • [Installation](#-installation) • [Quick Start](#-quick-start) • [Keywords](#-complete-keyword-reference) • [Documentation](#-documentation) • [Examples](#-examples) • [Troubleshooting](#-getting-help--troubleshooting)
 
 </div>
 
@@ -66,7 +69,7 @@ Dynamic: requires-python
 ## 📋 Table of Contents
 
 - [What is Zexus?](#-what-is-zexus)
-- [What's New](#-whats-new-in-v150)
+- [What's New](#-whats-new-in-v171)
 - [Key Features](#-key-features)
   - [VM-Accelerated Performance](#-vm-accelerated-performance-new)
   - [Security & Policy-as-Code](#-security--policy-as-code--verify-enhanced)
@@ -115,9 +118,16 @@ Zexus is a next-generation, general-purpose programming language designed for se
 
 ---
 
-## 🎉 What's New in v1.6.3
+## 🎉 What's New in v1.7.2
 
-### Latest Features (v1.6.3)
+### Latest Features (v1.7.2)
+
+✅ **FIND Keyword** - Declarative project search that resolves exact module paths with scope filtering and smart suggestions  
+✅ **LOAD Keyword & Manager** - Provider-aware configuration loader with built-in ENV, JSON, and YAML support plus caching  
+✅ **VM + Bytecode Support** - FIND/LOAD now compile to bytecode with helper bridges so scripts run identically in the VM and interpreter  
+✅ **Targeted Test Coverage** - Added regression tests that exercise both interpreter and VM paths for FIND/LOAD workflows  
+
+### Previous Features (v1.6.3)
 
 ✅ **Complete Database Ecosystem** - Production-ready database drivers  
 ✅ **4 Database Drivers** - SQLite, PostgreSQL, MySQL, MongoDB fully tested