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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: inscript-lang
-Version: 1.9.7
+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.7 → inscript_lang-1.9.9}/analyzer.py

@@ -1151,13 +1151,21 @@ class Analyzer(Visitor):
     def visit_ArrayLiteralExpr(self, node: ArrayLiteralExpr) -> InScriptType:
         if not node.elements:
             return array_type(T_ANY)
+        # v1.9.8: infer element type; fall back to Array<any> on mixed types
         first_type = self.visit(node.elements[0])
+        # Normalise literal string types to T_STRING for array inference
+        if is_literal_type(first_type):
+            first_type = T_STRING
+        mixed = False
         for elem in node.elements[1:]:
             et = self.visit(elem)
-            if not types_compatible(first_type, et):
-                self._warn(f"Mixed types in array literal: '{first_type}' and '{et}'",
-                           node.line)
-        return array_type(first_type)
+            if is_literal_type(et):
+                et = T_STRING
+            if not types_compatible(first_type, et) and not types_compatible(et, first_type):
+                mixed = True
+        if mixed:
+            return array_type(T_ANY)   # [1, "a", true] → Array<any>
+        return array_type(first_type)  # [1, 2, 3] → Array<int>
 
     def visit_DictLiteralExpr(self, node: DictLiteralExpr) -> InScriptType:
         if not node.pairs:

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

@@ -24,7 +24,7 @@ from errors   import (InScriptError, LexerError, ParseError,
                        SemanticError, InScriptRuntimeError,
                        MultiError, InScriptWarning)
 
-VERSION = "1.9.7"
+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):
@@ -315,6 +525,81 @@ def _compat_files(path: str) -> int:
     return 1
 
 
+def _infer_types_file(path: str) -> int:
+    """
+    v1.9.8: `inscript --infer-types FILE`
+    Parse and type-check FILE, then print the inferred type for every
+    let/const declaration. Useful for understanding what the analyzer infers.
+    Returns 0 on success, 1 if file not found or parse error.
+    """
+    import os
+    if not os.path.isfile(path):
+        print(f"[InScript infer-types] File not found: '{path}'", file=sys.stderr)
+        return 1
+    try:
+        with open(path, encoding="utf-8") as f:
+            src = f.read()
+    except OSError as e:
+        print(f"[InScript infer-types] Cannot read '{path}': {e}", file=sys.stderr)
+        return 1
+
+    from lexer import Lexer
+    from parser import Parser
+    from analyzer import Analyzer
+    from ast_nodes import VarDecl
+
+    try:
+        tokens = Lexer(src).tokenize()
+        tree   = Parser(tokens).parse()
+    except Exception as e:
+        print(f"[InScript infer-types] Parse error: {e}", file=sys.stderr)
+        return 1
+
+    analyzer = Analyzer()
+    try:
+        analyzer.analyze(tree)
+    except Exception:
+        pass   # best-effort — show what we have even if there are errors
+
+    # Walk all VarDecl / ConstDecl nodes and report inferred types
+    results = []
+    def _walk(node):
+        if node is None:
+            return
+        if isinstance(node, (VarDecl,)):
+            sym = analyzer._scope.lookup(node.name) if hasattr(analyzer, '_scope') else None
+            typ = sym.type_ if sym else None
+            type_str = str(typ) if typ else "any"
+            results.append((node.line, "let" if not node.is_const else "const",
+                             node.name, type_str))
+        # Recurse into body of blocks, fns etc.
+        for attr in ("body", "then_branch", "else_branch", "value",
+                     "initializer", "statements"):
+            child = getattr(node, attr, None)
+            if child is None:
+                continue
+            if hasattr(child, "__iter__") and not isinstance(child, str):
+                for c in child:
+                    if hasattr(c, "__class__") and hasattr(c, "line"):
+                        _walk(c)
+            elif hasattr(child, "line"):
+                _walk(child)
+
+    if hasattr(tree, "body"):
+        for stmt in tree.body:
+            _walk(stmt)
+
+    if not results:
+        print(f"[InScript infer-types] No let/const declarations found in '{path}'")
+        return 0
+
+    print(f"[InScript infer-types] Inferred types in '{path}':\n")
+    for line, kw, name, typ in results:
+        print(f"  Line {line:3d}:  {kw} {name:<20s}  →  {typ}")
+    print()
+    return 0
+
+
 def _migrate_files(path: str) -> int:
     """v1.7.4: Auto-migrate deprecated InScript syntax in-place."""
     import re, os
@@ -1573,6 +1858,8 @@ Examples:
     parser.add_argument("--check",  action="store_true", help="Type-check only, don't run")
     parser.add_argument("--check-all", metavar="DIR",
                         help="v1.6.0: Check all .ins files in DIR recursively, exit 1 if any errors")
+    parser.add_argument("--infer-types", metavar="FILE",
+                        help="v1.9.8: Print inferred type for every let/const declaration in FILE")
     parser.add_argument("--migrate", metavar="DIR_OR_FILE",
                         help="v1.7.4: Auto-migrate deprecated syntax (null→nil, div→//)")
     parser.add_argument("--compat", metavar="DIR_OR_FILE",
@@ -1630,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",
@@ -1710,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)
@@ -1754,6 +2056,8 @@ Examples:
         return _fmt_all_files(args.fmt_all)
     if getattr(args, 'migrate', None):
         return _migrate_files(args.migrate)
+    if getattr(args, 'infer_types', None):
+        return _infer_types_file(args.infer_types)
     if getattr(args, 'compat', None):
         return _compat_files(args.compat)
     if getattr(args, 'init', None) is not None:

{inscript_lang-1.9.7 → 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.7
+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.7 → inscript_lang-1.9.9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "inscript-lang"
-version = "1.9.7"
+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.7 → 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.7"
+VERSION = "1.9.9"
 
 # ── ANSI colours ──────────────────────────────────────────────────────────────
 def _c(code, text):