inscript-lang 1.9.8__tar.gz → 1.9.9__tar.gz

{inscript_lang-1.9.8 → inscript_lang-1.9.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: inscript-lang
-Version: 1.9.8
+Version: 1.9.9
 Summary: InScript — a game-focused scripting language with 59 game modules and a bytecode VM
 Author: Shreyasi Sarkar
 License: MIT

{inscript_lang-1.9.8 → inscript_lang-1.9.9}/inscript.py

@@ -24,7 +24,7 @@ from errors   import (InScriptError, LexerError, ParseError,
                        SemanticError, InScriptRuntimeError,
                        MultiError, InScriptWarning)
 
-VERSION = "1.9.8"
+VERSION = "1.9.9"
 LANG    = "InScript"
 PACKAGES_DIR = os.path.join(os.path.expanduser("~"), ".inscript", "packages")
 REGISTRY_URL = "https://raw.githubusercontent.com/authorss81/inscript-packages/main/registry.json"
@@ -34,24 +34,117 @@ REGISTRY_URL = "https://raw.githubusercontent.com/authorss81/inscript-packages/m
 # RUN A FILE
 # ─────────────────────────────────────────────────────────────────────────────
 
-def install_package(pkg_name: str) -> int:
-    """Download and install an InScript package to ~/.inscript/packages/"""
+def _parse_pkg_spec(spec: str):
+    """
+    v1.9.9: Parse 'PKG@version' or just 'PKG'.
+    Returns (name, version_or_None).
+    """
+    if "@" in spec:
+        idx  = spec.index("@")
+        return spec[:idx].strip(), spec[idx+1:].strip()
+    return spec.strip(), None
+
+
+def _read_lock(lock_path: str) -> dict:
+    """
+    v1.9.9: Read inscript.lock and return {pkg_name: version} mapping.
+    Returns empty dict if file doesn't exist or can't be parsed.
+    """
+    if not os.path.isfile(lock_path):
+        return {}
+    import re as _re
+    result = {}
+    current_pkg = None
+    for line in open(lock_path, encoding="utf-8"):
+        m = _re.match(r'^\[package\.(.+)\]', line.strip())
+        if m:
+            current_pkg = m.group(1)
+        elif current_pkg:
+            m2 = _re.match(r'^version\s*=\s*"([^"]+)"', line.strip())
+            if m2:
+                result[current_pkg] = m2.group(1)
+    return result
+
+
+def _write_lock_entry(lock_path: str, pkg_name: str, version: str) -> None:
+    """
+    v1.9.9: Add or update a single package entry in inscript.lock.
+    Creates the file if it doesn't exist.
+    """
+    import hashlib, re as _re, datetime
+    # Read existing content
+    if os.path.isfile(lock_path):
+        content = open(lock_path, encoding="utf-8").read()
+    else:
+        content = (
+            "# InScript lockfile — do not edit manually\n"
+            f"# Generated by InScript {VERSION}\n\n"
+            "[metadata]\n"
+            f'inscript  = "{VERSION}"\n'
+            "generated = \"" + datetime.datetime.utcnow().strftime("%Y-%m-%dT%H:%M:%SZ") + "\"\n\n"
+        )
+
+    sha256 = hashlib.sha256(f"{pkg_name}@{version}".encode()).hexdigest()
+    entry  = "[package." + pkg_name + "]\nversion = \"" + version + "\"\nsha256  = \"" + sha256 + "\"\n\n"
+
+    # Remove old entry if present
+    content = _re.sub(
+        rf'\[package\.{_re.escape(pkg_name)}\][^\[]*', '', content
+    )
+    content = content.rstrip() + "\n\n" + entry
+    with open(lock_path, "w", encoding="utf-8") as f:
+        f.write(content)
+
+
+def _remove_lock_entry(lock_path: str, pkg_name: str) -> None:
+    """v1.9.9: Remove a package entry from inscript.lock."""
+    import re as _re
+    if not os.path.isfile(lock_path):
+        return
+    content = open(lock_path, encoding="utf-8").read()
+    content = _re.sub(
+        rf'\[package\.{_re.escape(pkg_name)}\][^\[]*', '', content
+    )
+    with open(lock_path, "w", encoding="utf-8") as f:
+        f.write(content)
+
+
+def install_package(pkg_spec: str, lock_path: str = None) -> int:
+    """
+    v1.9.9: Download and install an InScript package to ~/.inscript/packages/
+
+    Supports 'PKG' and 'PKG@version' specs.
+    Writes the installed version to inscript.lock if lock_path is given.
+    Falls back to lock file version info on network failure.
+    """
     import urllib.request, json as _json, zipfile, io
 
+    pkg_name, requested_version = _parse_pkg_spec(pkg_spec)
     os.makedirs(PACKAGES_DIR, exist_ok=True)
     pkg_dir = os.path.join(PACKAGES_DIR, pkg_name)
 
-    if os.path.exists(pkg_dir):
+    # Check if already installed at requested version
+    if os.path.exists(pkg_dir) and not requested_version:
         print(f"[InScript] Package '{pkg_name}' is already installed at {pkg_dir}")
         return 0
 
-    print(f"[InScript] Fetching registry...")
+    # Try fetching registry
+    registry = None
     try:
+        print(f"[InScript] Fetching registry...")
         with urllib.request.urlopen(REGISTRY_URL, timeout=10) as resp:
             registry = _json.loads(resp.read().decode())
     except Exception as e:
+        # v1.9.9: Offline fallback — if lock file has this package, report it
+        if lock_path:
+            locked = _read_lock(lock_path)
+            if pkg_name in locked:
+                print(f"[InScript] Registry unreachable ({e})")
+                print(f"[InScript] Offline: '{pkg_name}' is pinned at v{locked[pkg_name]} in lock file.")
+                print(f"[InScript] Tip: manually place .ins files in {PACKAGES_DIR}/{pkg_name}/ to install offline.")
+                return 0
         print(f"[InScript] Could not reach package registry: {e}", file=sys.stderr)
-        print(f"[InScript] Tip: you can also install manually by placing .ins files in {PACKAGES_DIR}/",
+        print(f"[InScript] Tip: place .ins files in {PACKAGES_DIR}/ or run 'inscript lock' first.",
               file=sys.stderr)
         return 1
 
@@ -62,22 +155,139 @@ def install_package(pkg_name: str) -> int:
         return 1
 
     pkg_info = registry[pkg_name]
-    zip_url  = pkg_info.get("url")
-    version  = pkg_info.get("version", "?")
+    latest_version = pkg_info.get("version", "?")
+    install_version = requested_version or latest_version
+    zip_url = pkg_info.get("url")
 
-    print(f"[InScript] Installing {pkg_name}@{version}...")
+    print(f"[InScript] Installing {pkg_name}@{install_version}...")
     try:
         with urllib.request.urlopen(zip_url, timeout=30) as resp:
             data = resp.read()
         with zipfile.ZipFile(io.BytesIO(data)) as zf:
             zf.extractall(PACKAGES_DIR)
-        print(f"[InScript] ✅ {pkg_name}@{version} installed to {pkg_dir}")
+        print(f"[InScript] ✅ {pkg_name}@{install_version} installed to {pkg_dir}")
+        # v1.9.9: Write to lock file
+        if lock_path:
+            _write_lock_entry(lock_path, pkg_name, install_version)
+            print(f"[InScript] Pinned {pkg_name}@{install_version} in lock file.")
         return 0
     except Exception as e:
         print(f"[InScript] Install failed: {e}", file=sys.stderr)
         return 1
 
 
+def install_all_from_toml(project_dir: str = ".") -> int:
+    """
+    v1.9.9: `inscript install` (no args) — read inscript.toml [dependencies]
+    and install every listed package, respecting inscript.lock if present.
+    """
+    manifest_path = os.path.join(project_dir, MANIFEST_FILENAME)
+    lock_path     = os.path.join(project_dir, LOCK_FILENAME)
+
+    if not os.path.isfile(manifest_path):
+        print(f"[InScript install] No '{MANIFEST_FILENAME}' found in '{project_dir}'.", file=sys.stderr)
+        print(f"[InScript install] Run 'inscript init' to create one.", file=sys.stderr)
+        return 1
+
+    try:
+        with open(manifest_path, encoding="utf-8") as f:
+            content = f.read()
+        data = _parse_toml_simple(content)
+    except Exception as e:
+        print(f"[InScript install] Cannot parse '{manifest_path}': {e}", file=sys.stderr)
+        return 1
+
+    deps = data.get("dependencies", {})
+    if not deps:
+        print(f"[InScript install] No dependencies listed in '{manifest_path}'.")
+        return 0
+
+    # v1.9.9: If lock file exists, use its pinned versions
+    locked = _read_lock(lock_path) if os.path.isfile(lock_path) else {}
+
+    print(f"[InScript install] Installing {len(deps)} dependenc{'y' if len(deps)==1 else 'ies'}...")
+    failed = 0
+    for pkg_name, constraint in sorted(deps.items()):
+        # Prefer locked version over constraint range
+        pinned = locked.get(pkg_name)
+        spec   = f"{pkg_name}@{pinned}" if pinned else pkg_name
+        ret = install_package(spec, lock_path=lock_path)
+        if ret != 0:
+            failed += 1
+
+    if failed:
+        print(f"[InScript install] {failed} package(s) failed to install.", file=sys.stderr)
+        return 1
+    print(f"[InScript install] ✅ All dependencies installed.")
+    return 0
+
+
+def outdated_packages(project_dir: str = ".") -> int:
+    """
+    v1.9.9: `inscript outdated` — compare inscript.lock versions against
+    the latest available in the registry. Reports which packages have updates.
+    """
+    import urllib.request, json as _json
+    lock_path = os.path.join(project_dir, LOCK_FILENAME)
+    locked    = _read_lock(lock_path)
+
+    if not locked:
+        print("[InScript outdated] No inscript.lock found or no packages locked.")
+        print("[InScript outdated] Run 'inscript lock' to generate one.")
+        return 0
+
+    try:
+        with urllib.request.urlopen(REGISTRY_URL, timeout=10) as resp:
+            registry = _json.loads(resp.read().decode())
+    except Exception as e:
+        print(f"[InScript outdated] Cannot reach registry: {e}", file=sys.stderr)
+        print("[InScript outdated] Showing locked versions (cannot check for updates):")
+        for pkg, ver in sorted(locked.items()):
+            print(f"  • {pkg}@{ver} (locked)")
+        return 1
+
+    any_outdated = False
+    for pkg_name, current_ver in sorted(locked.items()):
+        if pkg_name not in registry:
+            print(f"  ? {pkg_name}@{current_ver} — not found in registry")
+            continue
+        latest = registry[pkg_name].get("version", "?")
+        if latest != current_ver:
+            print(f"  ↑ {pkg_name}  {current_ver} → {latest}")
+            any_outdated = True
+        else:
+            print(f"  ✓ {pkg_name}@{current_ver} (up to date)")
+
+    if not any_outdated:
+        print("[InScript outdated] All packages are up to date.")
+    return 0
+
+
+def update_package(pkg_spec: str, project_dir: str = ".") -> int:
+    """
+    v1.9.9: `inscript update PKG` or `inscript update PKG@version` —
+    remove the existing installation and reinstall at the specified (or latest) version.
+    Updates inscript.lock with the new pinned version.
+    """
+    import shutil
+    pkg_name, new_version = _parse_pkg_spec(pkg_spec)
+    lock_path = os.path.join(project_dir, LOCK_FILENAME)
+    pkg_dir   = os.path.join(PACKAGES_DIR, pkg_name)
+
+    # Remove existing installation
+    if os.path.exists(pkg_dir):
+        shutil.rmtree(pkg_dir)
+        print(f"[InScript update] Removed existing {pkg_name} installation.")
+
+    spec = f"{pkg_name}@{new_version}" if new_version else pkg_name
+    ret  = install_package(spec, lock_path=lock_path)
+    if ret == 0:
+        print(f"[InScript update] ✅ {pkg_name} updated.")
+    return ret
+
+
+
+
 def list_packages() -> int:
     """List installed packages."""
     if not os.path.exists(PACKAGES_DIR):
@@ -1707,8 +1917,12 @@ Examples:
     parser.add_argument("--watch",   action="store_true",
                         help="Watch file for changes and rerun: inscript --watch game.ins")
     parser.add_argument("--version", action="store_true", help="Print version and exit")
-    parser.add_argument("--install", metavar="PKG",
-                        help="Install a package: inscript install math-utils")
+    parser.add_argument("--install", metavar="PKG", nargs="?", const="",
+                        help="v1.9.9: Install a package (PKG or PKG@version); no arg = install all from inscript.toml")
+    parser.add_argument("--update", metavar="PKG",
+                        help="v1.9.9: Update a package to latest (or PKG@version)")
+    parser.add_argument("--outdated", action="store_true",
+                        help="v1.9.9: Show packages with newer versions available")
     parser.add_argument("--remove", metavar="PKG",
                         help="Remove a package: inscript --remove math-utils")
     parser.add_argument("--packages", action="store_true",
@@ -1787,8 +2001,19 @@ Examples:
     if args.packages:
         return list_packages()
 
-    if args.install:
-        return install_package(args.install)
+    if getattr(args, 'install', None) is not None:
+        # v1.9.9: `inscript install` (no args) → install from toml
+        #         `inscript install PKG[@version]` → install specific pkg
+        lock_path = os.path.join(".", LOCK_FILENAME)
+        if args.install == "":
+            return install_all_from_toml(".")
+        return install_package(args.install, lock_path=lock_path)
+
+    if getattr(args, 'update', None):
+        return update_package(args.update, project_dir=".")
+
+    if getattr(args, 'outdated', False):
+        return outdated_packages(project_dir=".")
 
     if args.remove:
         return remove_package(args.remove)

{inscript_lang-1.9.8 → inscript_lang-1.9.9}/inscript_lang.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: inscript-lang
-Version: 1.9.8
+Version: 1.9.9
 Summary: InScript — a game-focused scripting language with 59 game modules and a bytecode VM
 Author: Shreyasi Sarkar
 License: MIT

{inscript_lang-1.9.8 → inscript_lang-1.9.9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "inscript-lang"
-version = "1.9.8"
+version = "1.9.9"
 description = "InScript — a game-focused scripting language with 59 game modules and a bytecode VM"
 readme = "README.md"
 license = { text = "MIT" }

{inscript_lang-1.9.8 → inscript_lang-1.9.9}/repl.py

@@ -40,7 +40,7 @@ sys.path.insert(0, str(Path(__file__).parent))
 
 HISTORY_FILE = Path.home() / ".inscript" / "history"
 HISTORY_FILE.parent.mkdir(parents=True, exist_ok=True)
-VERSION = "1.9.8"
+VERSION = "1.9.9"
 
 # ── ANSI colours ──────────────────────────────────────────────────────────────
 def _c(code, text):