inscript-lang 1.8.3__tar.gz → 1.9.2__tar.gz

{inscript_lang-1.8.3 → inscript_lang-1.9.2}/PKG-INFO

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

{inscript_lang-1.8.3 → inscript_lang-1.9.2}/analyzer.py

@@ -82,6 +82,8 @@ BUILTIN_TYPES: Dict[str, InScriptType] = {
     "Texture": T_TEXTURE,
     # tuple / array shorthand
     "Tuple": T_ANY, "List": T_ANY, "Dict": T_ANY, "Map": T_ANY,
+    # v1.9.1: bare 'array' without element type (deprecated — use [T] in v2.0.0)
+    "array": InScriptType("Array", [T_ANY]),
 }
 
 def array_type(elem: InScriptType) -> InScriptType:
@@ -254,7 +256,8 @@ class Analyzer(Visitor):
                  multi_error: bool = True,
                  warn_as_error: bool = False,
                  no_warn: bool = False,
-                 no_warn_unused: bool = False):
+                 no_warn_unused: bool = False,
+                 strict: bool = False):
         self._src         = source_lines or []
         self._scope       = Scope(kind="global")
         self._errors:   List[SemanticError]    = []   # collected (multi-error)
@@ -263,6 +266,7 @@ class Analyzer(Visitor):
         self._warn_as_error = warn_as_error
         self._no_warn      = no_warn
         self._no_warn_unused = no_warn_unused
+        self._strict       = strict   # v1.9.1: enables extra v2.0.0-readiness errors
         self._dispatch: dict = {}   # v1.3.0: cached dispatch
 
         # State for context-sensitive checks
@@ -386,7 +390,15 @@ class Analyzer(Visitor):
             return fn_type(params, ret)
 
         if ann.name in BUILTIN_TYPES:
-            return BUILTIN_TYPES[ann.name]
+            t = BUILTIN_TYPES[ann.name]
+            # v1.9.1: bare `array` without element type is a hard error in strict mode
+            if ann.name == "array" and not ann.generics and self._strict:
+                self._error(
+                    "Bare 'array' type without element type is a breaking change in v2.0.0. "
+                    "Use '[T]' (e.g. '[int]') or annotate the element type.",
+                    ann.line, ann.col
+                )
+            return t
 
         # v1.8.2: registered type aliases
         if ann.name in self._type_aliases:
@@ -635,6 +647,17 @@ class Analyzer(Visitor):
     def visit_FunctionDecl(self, node: FunctionDecl) -> InScriptType:
         ret_type = self._resolve_type_ann(node.return_type)
 
+        # v1.8.4: return type inference — if no annotation and body has a single
+        # unambiguous return type, infer it automatically
+        if node.return_type is None and ret_type == T_ANY and node.body:
+            inferred = self._infer_fn_return_type(node)
+            if inferred not in (T_ANY, T_VOID, T_NULL):
+                ret_type = inferred
+                # Update the hoisted symbol's type to the inferred one
+                existing = self._scope.lookup(node.name)
+                if existing and existing.kind == "fn":
+                    existing.type_ = ret_type
+
         # Register in current scope (if not already hoisted)
         if not self._scope.lookup_local(node.name):
             self._define(Symbol(
@@ -1290,8 +1313,288 @@ class Analyzer(Visitor):
                 return sym.type_
 
         if isinstance(node.callee, GetAttrExpr):
+            # v1.8.4: infer return types of array method chains
+            obj_type = self.visit(node.callee.obj)
+            # v1.8.2 literal_type("hello") → dispatch as T_STRING
+            if is_literal_type(obj_type):
+                obj_type = T_STRING
+            method   = node.callee.attr
+            return self._infer_method_call_type(obj_type, method, node)
+
+        return T_ANY
+
+    def _infer_method_call_type(self, obj_type: InScriptType,
+                                 method: str, call_node) -> InScriptType:
+        """
+        v1.8.4: Infer the return type of a method call based on the receiver's type.
+
+        Array methods:
+          .map(fn)      → Array<T> where T = inferred return type of fn
+          .filter(fn)   → Array<elem>  (same element type, just fewer items)
+          .flatMap(fn)  → Array<T>
+          .take(n)      → Array<elem>
+          .skip(n)      → Array<elem>
+          .slice(a,b)   → Array<elem>
+          .sorted()     → Array<elem>
+          .reversed()   → Array<elem>
+          .unique()     → Array<elem>
+          .len()        → int
+          .count()      → int
+          .sum()        → int | float
+          .first()      → elem?   (optional)
+          .last()       → elem?
+          .find(fn)     → elem?
+          .any(fn)      → bool
+          .all(fn)      → bool
+          .reduce(fn,i) → any (can't infer accumulator type without annotation)
+          .join(sep)    → string
+          .push(v)      → void
+          .pop()        → elem?
+          .contains(v)  → bool
+          .index_of(v)  → int?
+
+        String methods:
+          .split(sep)   → Array<string>
+          .trim()       → string
+          .upper()      → string
+          .lower()      → string
+          .replace(...) → string
+          .starts_with()→ bool
+          .ends_with()  → bool
+          .contains()   → bool
+          .len()        → int
+          .chars()      → Array<string>
+        """
+        # ── Array method inference ────────────────────────────────────────────
+        if obj_type.name == "Array":
+            elem = obj_type.params[0] if obj_type.params else T_ANY
+
+            # Methods that return Array<same-elem>
+            if method in ("filter", "take", "skip", "slice", "sorted",
+                          "reversed", "unique", "shuffle", "concat"):
+                return array_type(elem)
+
+            # .map(fn) / .flatMap(fn) → infer fn return type
+            if method in ("map", "flatMap"):
+                fn_ret = self._infer_fn_arg_return(call_node, arg_index=0, param_type=elem)
+                inner  = fn_ret if fn_ret != T_ANY else T_ANY
+                if method == "flatMap" and inner.name == "Array":
+                    inner = inner.params[0] if inner.params else T_ANY
+                return array_type(inner)
+
+            # Scalar reductions
+            if method in ("len", "count", "index_of"):
+                return T_INT
+            if method == "sum":
+                return elem if elem in (T_INT, T_FLOAT) else T_INT
+            if method in ("any", "all", "contains", "is_empty"):
+                return T_BOOL
+            if method == "join":
+                return T_STRING
+            if method in ("push", "append", "extend", "clear", "insert",
+                          "remove", "remove_at"):
+                return T_VOID
+
+            # Optional-returning methods
+            if method in ("first", "last", "pop", "find", "get"):
+                return optional_type(elem)
+
+            # .reduce → T_ANY (accumulator type unknown without annotation)
+            if method == "reduce":
+                return T_ANY
+
+            # .each(fn) → void (side-effect traversal)
+            if method in ("each", "for_each"):
+                return T_VOID
+
+        # ── String method inference ───────────────────────────────────────────
+        if obj_type == T_STRING:
+            if method in ("trim", "upper", "lower", "replace", "strip",
+                          "lstrip", "rstrip", "pad_left", "pad_right",
+                          "repeat", "reverse", "slice"):
+                return T_STRING
+            if method in ("len", "count", "index_of", "find"):
+                return T_INT
+            if method in ("starts_with", "ends_with", "contains", "is_empty",
+                          "matches"):
+                return T_BOOL
+            if method == "split":
+                return array_type(T_STRING)
+            if method == "chars":
+                return array_type(T_STRING)
+            if method == "to_int":
+                return optional_type(T_INT)
+            if method == "to_float":
+                return optional_type(T_FLOAT)
+
+        # ── Int / Float methods ───────────────────────────────────────────────
+        if obj_type in (T_INT, T_FLOAT):
+            if method in ("abs", "floor", "ceil", "round", "sqrt",
+                          "clamp", "min", "max"):
+                return obj_type
+            if method == "to_string":
+                return T_STRING
+
+        # ── Struct method return type ─────────────────────────────────────────
+        if obj_type.name in self._struct_defs:
+            struct = self._struct_defs[obj_type.name]
+            for m in (struct.methods or []):
+                if m.name == method:
+                    return self._resolve_type_ann(m.return_type)
+
+        return T_ANY
+
+    def _infer_fn_return_type(self, node) -> InScriptType:
+        """
+        v1.8.4: Infer a function's return type from its body when no annotation exists.
+        Only infers when ALL return paths agree on the same concrete type.
+        Falls back to T_ANY if ambiguous.
+        NOTE: errors are suppressed — inference is best-effort, never raises.
+        """
+        from ast_nodes import ReturnStmt, BlockStmt
+
+        if not node.body:
+            return T_VOID
+
+        # Stash and suppress the real error list — inference must never pollute it
+        saved_errors = self._errors
+        self._errors  = []
+
+        try:
+            # Push a temporary scope with params typed per their annotations
+            self._push_scope("infer-fn")
+            for p in (node.params or []):
+                p_type = self._resolve_type_ann(getattr(p, 'type_ann', None))
+                pname  = getattr(p, 'name', None)
+                if pname:
+                    self._scope.symbols[pname] = Symbol(
+                        pname, p_type, kind="var",
+                        line=getattr(p, 'line', 0), col=getattr(p, 'col', 0)
+                    )
+                    self._scope.symbols[pname].used = True
+
+            # Collect return types from first-level stmts + if/else branches
+            types_seen = set()
+            stmts = node.body.body if isinstance(node.body, BlockStmt) else [node.body]
+            for stmt in stmts:
+                if isinstance(stmt, ReturnStmt) and stmt.value is not None:
+                    try:
+                        t = self.visit(stmt.value)
+                        if is_literal_type(t): t = T_STRING
+                        types_seen.add(t)
+                    except Exception:
+                        types_seen.add(T_ANY)
+                for branch_attr in ('then_branch', 'else_branch'):
+                    branch = getattr(stmt, branch_attr, None)
+                    if branch is None:
+                        continue
+                    inner = getattr(branch, 'body', [branch])
+                    if not isinstance(inner, list):
+                        inner = [inner]
+                    for s in inner:
+                        if isinstance(s, ReturnStmt) and s.value is not None:
+                            try:
+                                t = self.visit(s.value)
+                                if is_literal_type(t): t = T_STRING
+                                types_seen.add(t)
+                            except Exception:
+                                types_seen.add(T_ANY)
+
+            self._pop_scope()
+
+            if not types_seen:
+                return T_VOID
+            non_any = {t for t in types_seen if t != T_ANY}
+            if len(non_any) == 1:
+                return next(iter(non_any))
+            if non_any == {T_INT, T_FLOAT}:
+                return T_FLOAT
+            return T_ANY
+
+        except Exception:
+            return T_ANY
+        finally:
+            # Always restore the real error list
+            self._errors = saved_errors
+
+    def _infer_fn_arg_return(self, call_node, arg_index: int,
+                              param_type: InScriptType) -> InScriptType:
+        """
+        v1.8.4: Given a CallExpr and an argument position that expects a fn,
+        try to infer that fn's return type by visiting its body with a temporary
+        scope that binds the param to param_type.
+        Returns T_ANY if inference fails.
+        """
+        from ast_nodes import FunctionDecl, LambdaExpr
+        if arg_index >= len(call_node.args):
+            return T_ANY
+        fn_arg = call_node.args[arg_index].value
+
+        # Handle both lambda `fn(x) { return x * 2 }` and named refs
+        params = None; body = None
+        if isinstance(fn_arg, FunctionDecl) or isinstance(fn_arg, LambdaExpr):
+            params = getattr(fn_arg, 'params', [])
+            body   = getattr(fn_arg, 'body', None)
+        else:
             return T_ANY
 
+        # Stash and suppress the real error list
+        saved_errors  = self._errors
+        self._errors   = []
+
+        try:
+            # Push a temporary scope, bind first param to elem type
+            self._push_scope("infer")
+            if params:
+                p0 = params[0]
+                p_name = getattr(p0, 'name', None)
+                if p_name:
+                    self._scope.symbols[p_name] = Symbol(
+                        p_name, param_type, kind="var",
+                        line=getattr(p0, 'line', 0), col=getattr(p0, 'col', 0)
+                    )
+                    self._scope.symbols[p_name].used = True
+
+            inferred = T_ANY
+            if body is not None:
+                inferred = self._infer_block_return_type(body)
+
+            self._pop_scope()
+            return inferred
+        except Exception:
+            return T_ANY
+        finally:
+            self._errors = saved_errors
+
+    def _infer_block_return_type(self, block) -> InScriptType:
+        """
+        v1.8.4: Walk a block/expression to find the first return statement's type.
+        Also handles single-expression lambdas.
+        """
+        from ast_nodes import BlockStmt, ReturnStmt
+        stmts = []
+        if isinstance(block, BlockStmt):
+            stmts = block.body
+        elif hasattr(block, '__iter__'):
+            stmts = list(block)
+        else:
+            # Single expression (arrow lambda)
+            try:
+                return self.visit(block)
+            except Exception:
+                return T_ANY
+
+        for stmt in stmts:
+            if isinstance(stmt, ReturnStmt) and stmt.value is not None:
+                try:
+                    return self.visit(stmt.value)
+                except Exception:
+                    return T_ANY
+            # Recurse into if/while bodies for early returns
+            if hasattr(stmt, 'then_branch'):
+                t = self._infer_block_return_type(stmt.then_branch)
+                if t != T_ANY:
+                    return t
         return T_ANY
 
     def visit_NamespaceAccessExpr(self, node: NamespaceAccessExpr) -> InScriptType:

{inscript_lang-1.8.3 → inscript_lang-1.9.2}/inscript.py

@@ -24,7 +24,7 @@ from errors   import (InScriptError, LexerError, ParseError,
                        SemanticError, InScriptRuntimeError,
                        MultiError, InScriptWarning)
 
-VERSION = "1.8.3"
+VERSION = "1.9.2"
 LANG    = "InScript"
 PACKAGES_DIR = os.path.join(os.path.expanduser("~"), ".inscript", "packages")
 REGISTRY_URL = "https://raw.githubusercontent.com/authorss81/inscript-packages/main/registry.json"
@@ -245,6 +245,75 @@ def _check_all_files(directory: str, strict: bool = False) -> int:
     return 1 if errors else 0
 
 
+
+def _compat_files(path: str) -> int:
+    """
+    v1.9.1: `inscript compat FILE|DIR` — report every v2.0.0 breaking change.
+    Returns 0 if clean, 1 if issues found.
+    """
+    import re as _re
+    from collections import defaultdict
+
+    CHECKS = [
+        (_re.compile(r'\bnull\b'),
+         "use of 'null' — removed in v2.0.0, use 'nil'"),
+        (_re.compile(r'\bdiv\b'),
+         "use of 'div' operator — removed in v2.0.0, use '//' for floor division"),
+        (_re.compile(r':\s*\[\]'),
+         "bare ':[]' type annotation — use ':array' or ':[T]' with element type"),
+        (_re.compile(r'\barray\b(?!\s*<)(?!\s*\[)'),
+         "bare 'array' type — use '[T]' with explicit element type in v2.0.0"),
+        (_re.compile(r'--no-typecheck'),
+         "'--no-typecheck' flag removed — use '--unsafe-no-check' in v2.0.0"),
+    ]
+
+    def _check_file(fpath):
+        issues = []
+        try:
+            with open(fpath, encoding="utf-8") as f:
+                src = f.read()
+        except OSError as e:
+            print(f"[InScript compat] Cannot read '{fpath}': {e}", file=sys.stderr)
+            return issues
+        for lineno, line in enumerate(src.splitlines(), 1):
+            if line.lstrip().startswith("//"):
+                continue
+            for pat, msg in CHECKS:
+                if pat.search(line):
+                    issues.append((fpath, lineno, line.rstrip(), msg))
+        return issues
+
+    all_issues = []
+    if os.path.isfile(path):
+        all_issues = _check_file(path)
+    elif os.path.isdir(path):
+        for root, _dirs, files in os.walk(path):
+            for fname in sorted(files):
+                if fname.endswith(".ins"):
+                    all_issues.extend(_check_file(os.path.join(root, fname)))
+    else:
+        print(f"[InScript compat] Not found: '{path}'", file=sys.stderr)
+        return 1
+
+    if not all_issues:
+        print(f"[InScript compat] No v2.0.0 breaking changes found in '{path}'")
+        return 0
+
+    by_file = defaultdict(list)
+    for fp, ln, line, msg in all_issues:
+        by_file[fp].append((ln, line, msg))
+
+    print(f"[InScript compat] Found {len(all_issues)} breaking change(s) for v2.0.0:\n")
+    for fp, entries in sorted(by_file.items()):
+        print(f"  {fp}")
+        for ln, line, msg in entries:
+            print(f"    Line {ln}: {msg}")
+            print(f"      {line.strip()}")
+        print()
+    print(f"Run: inscript migrate {path}  to auto-fix null/div issues.")
+    return 1
+
+
 def _migrate_files(path: str) -> int:
     """v1.7.4: Auto-migrate deprecated InScript syntax in-place."""
     import re, os
@@ -371,6 +440,7 @@ def run_source(source: str, filename: str = "<stdin>",
                no_warn: bool = False,
                no_warn_unused: bool = False,
                warn_as_error: bool = False,
+               strict: bool = False,
                profile: bool = False) -> int:
     """Lex, parse, analyze, and interpret InScript source code."""
     # ── 1. Lex ────────────────────────────────────────────────────────────
@@ -396,6 +466,7 @@ def run_source(source: str, filename: str = "<stdin>",
             warn_as_error=warn_as_error,
             no_warn=no_warn,
             no_warn_unused=no_warn_unused,
+            strict=strict,   # v1.9.1
         )
         try:
             _analyzer.analyze(program)
@@ -615,12 +686,22 @@ Examples:
                         help="v1.6.0: Check all .ins files in DIR recursively, exit 1 if any errors")
     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",
+                        help="v1.9.1: Report v2.0.0 breaking changes in FILE or DIR")
+    parser.add_argument("--init", metavar="DIR", nargs="?", const=".",
+                        help="v1.9.2: Create inscript.toml in DIR (default: current dir)")
+    parser.add_argument("--validate", metavar="DIR_OR_FILE", nargs="?", const=".",
+                        help="v1.9.2: Validate inscript.toml (default: current dir)")
+    parser.add_argument("--lock", metavar="DIR", nargs="?", const=".",
+                        help="v1.9.2: Generate inscript.lock from inscript.toml")
     parser.add_argument("--strict", action="store_true",
                         help="v1.6.0: Strict mode — all warnings become errors, no implicit any")
     parser.add_argument("--tokens", action="store_true", help="Print lexer token stream")
     parser.add_argument("--ast",    action="store_true", help="Print parsed AST")
     parser.add_argument("--no-typecheck", action="store_true",
-                        help="Skip semantic analysis (faster, less safe)")
+                        help="[DEPRECATED v1.9.1] Use --unsafe-no-check instead")
+    parser.add_argument("--unsafe-no-check", action="store_true",
+                        help="v1.9.1: Skip semantic analysis (replaces --no-typecheck)")
     parser.add_argument("--no-warn", action="store_true",
                         help="Suppress all warnings")
     parser.add_argument("--no-warn-unused", action="store_true",
@@ -770,6 +851,23 @@ Examples:
         return _fmt_all_files(args.fmt_all)
     if getattr(args, 'migrate', None):
         return _migrate_files(args.migrate)
+    if getattr(args, 'compat', None):
+        return _compat_files(args.compat)
+    if getattr(args, 'init', None) is not None:
+        return _init_manifest(args.init)
+    if getattr(args, 'validate', None) is not None:
+        return _validate_manifest(args.validate)
+    if getattr(args, 'lock', None) is not None:
+        return _generate_lockfile(args.lock)
+
+    # v1.9.1: --no-typecheck is deprecated — emit a warning and honour it
+    if getattr(args, 'no_typecheck', False):
+        print(
+            "[InScript] Warning: --no-typecheck is deprecated in v1.9.1 "
+            "and will be removed in v2.0.0. Use --unsafe-no-check instead.",
+            file=sys.stderr
+        )
+        args.unsafe_no_check = True
 
     if not args.file:
         parser.print_help()
@@ -834,7 +932,8 @@ Examples:
         return 0
 
     # Normal run
-    type_check    = not args.no_typecheck
+    type_check    = not getattr(args, 'no_typecheck', False) and \
+                    not getattr(args, 'unsafe_no_check', False)
     no_warn       = getattr(args, "no_warn", False)
     no_warn_unused= getattr(args, "no_warn_unused", False)
     strict        = getattr(args, "strict", False)
@@ -845,8 +944,364 @@ Examples:
         _source = _f.read()
     return run_source(_source, filename=args.file, type_check=type_check,
                       no_warn=no_warn, no_warn_unused=no_warn_unused,
-                      warn_as_error=warn_as_error, profile=profile)
+                      warn_as_error=warn_as_error, strict=strict,
+                      profile=profile)
 
 
 if __name__ == "__main__":
     sys.exit(main())
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# v1.9.2 — Package Manifest Foundation
+# ─────────────────────────────────────────────────────────────────────────────
+
+MANIFEST_FILENAME = "inscript.toml"
+LOCK_FILENAME     = "inscript.lock"
+
+# Minimal TOML parser (stdlib only — no third-party deps)
+def _parse_toml_simple(text: str) -> dict:
+    """
+    Parse a simple TOML file (no nested tables beyond one level, no arrays of tables).
+    Supports: key = "value", key = 123, key = true/false,
+              [section], inline arrays, multi-line strings.
+    """
+    import re
+    result = {}
+    current_section = result
+
+    for raw_line in text.splitlines():
+        line = raw_line.strip()
+        if not line or line.startswith("#"):
+            continue
+        # Section header
+        m = re.match(r'^\[([^\]]+)\]$', line)
+        if m:
+            section_name = m.group(1).strip()
+            current_section = result.setdefault(section_name, {})
+            continue
+        # Key = value
+        if "=" in line:
+            key, _, val = line.partition("=")
+            key = key.strip(); val = val.strip()
+            # String
+            if (val.startswith('"') and val.endswith('"')) or \
+               (val.startswith("'") and val.endswith("'")):
+                parsed = val[1:-1]
+            # Inline array
+            elif val.startswith("["):
+                inner = val.strip("[]")
+                items = [v.strip().strip('"').strip("'")
+                         for v in inner.split(",") if v.strip()]
+                parsed = items
+            # Bool
+            elif val.lower() == "true":
+                parsed = True
+            elif val.lower() == "false":
+                parsed = False
+            # Int
+            elif re.match(r'^-?\d+$', val):
+                parsed = int(val)
+            else:
+                parsed = val
+            current_section[key] = parsed
+    return result
+
+
+def _semver_parse(v: str) -> tuple:
+    """Parse 'X.Y.Z' → (X, Y, Z) ints. Returns (0,0,0) on failure."""
+    import re
+    m = re.match(r'^(\d+)\.(\d+)\.(\d+)', v.lstrip("v"))
+    if not m:
+        return (0, 0, 0)
+    return (int(m.group(1)), int(m.group(2)), int(m.group(3)))
+
+
+def _semver_satisfies(version: str, constraint: str) -> bool:
+    """
+    v1.9.2: Check whether `version` satisfies `constraint`.
+
+    Supported constraint forms:
+      ">=1.8.0"   — version >= 1.8.0
+      ">1.7.0"    — version > 1.7.0
+      "<=2.0.0"   — version <= 2.0.0
+      "<2.0.0"    — version < 2.0.0
+      "=1.9.1"    — exact match
+      "^1.8.0"    — compatible: same major, >= minor.patch  (^0.x.y = same minor)
+      "~1.8.2"    — patch-level: same major.minor, >= patch
+      "1.9.1"     — exact (no operator = exact)
+      "*"         — any version
+    """
+    import re
+    constraint = constraint.strip()
+    if constraint in ("*", ""):
+        return True
+
+    v = _semver_parse(version)
+    if v == (0, 0, 0):
+        return False
+
+    # Caret: ^MAJOR.MINOR.PATCH
+    m = re.match(r'^\^(\S+)$', constraint)
+    if m:
+        c = _semver_parse(m.group(1))
+        if c[0] == 0:                          # ^0.x.y — same minor
+            return v[0] == 0 and v[1] == c[1] and v >= c
+        return v[0] == c[0] and v >= c         # same major
+
+    # Tilde: ~MAJOR.MINOR.PATCH
+    m = re.match(r'^~(\S+)$', constraint)
+    if m:
+        c = _semver_parse(m.group(1))
+        return v[0] == c[0] and v[1] == c[1] and v[2] >= c[2]
+
+    # Comparison operators
+    m = re.match(r'^(>=|<=|>|<|=)(\S+)$', constraint)
+    if m:
+        op, ver = m.group(1), m.group(2)
+        c = _semver_parse(ver)
+        if op == ">=": return v >= c
+        if op == "<=": return v <= c
+        if op == ">":  return v > c
+        if op == "<":  return v < c
+        if op == "=":  return v == c
+
+    # Bare version — exact match
+    c = _semver_parse(constraint)
+    return v == c
+
+
+MANIFEST_TEMPLATE = '''\
+[package]
+name         = "{name}"
+version      = "0.1.0"
+description  = ""
+inscript     = ">={inscript_version}"
+
+[dependencies]
+# example = "^1.0.0"
+'''
+
+def _init_manifest(directory: str = ".") -> int:
+    """
+    v1.9.2: `inscript init [DIR]` — create inscript.toml in directory.
+    Skips if a manifest already exists.
+    """
+    manifest_path = os.path.join(directory, MANIFEST_FILENAME)
+    if os.path.exists(manifest_path):
+        print(f"[InScript init] '{manifest_path}' already exists — skipping.")
+        return 0
+
+    pkg_name = os.path.basename(os.path.abspath(directory)) or "my-project"
+    content  = MANIFEST_TEMPLATE.format(
+        name=pkg_name, inscript_version=VERSION
+    )
+    try:
+        with open(manifest_path, "w", encoding="utf-8") as f:
+            f.write(content)
+        print(f"[InScript init] Created '{manifest_path}'")
+        print(f"  name    = \"{pkg_name}\"")
+        print(f"  version = \"0.1.0\"")
+        print(f"  inscript = \">={VERSION}\"")
+        return 0
+    except OSError as e:
+        print(f"[InScript init] Failed to create manifest: {e}", file=sys.stderr)
+        return 1
+
+
+def _validate_manifest(path: str) -> int:
+    """
+    v1.9.2: `inscript validate [FILE|DIR]` — check inscript.toml is well-formed.
+
+    Required fields:
+      [package] name, version, inscript
+    Optional but validated if present:
+      [package] description
+      [dependencies] — each value must be a valid semver constraint
+
+    Returns 0 if valid, 1 if any error.
+    """
+    import re
+
+    # Resolve path
+    if os.path.isdir(path):
+        manifest_path = os.path.join(path, MANIFEST_FILENAME)
+    else:
+        manifest_path = path
+
+    if not os.path.exists(manifest_path):
+        print(f"[InScript validate] '{manifest_path}' not found.", file=sys.stderr)
+        return 1
+
+    try:
+        with open(manifest_path, encoding="utf-8") as f:
+            content = f.read()
+    except OSError as e:
+        print(f"[InScript validate] Cannot read '{manifest_path}': {e}", file=sys.stderr)
+        return 1
+
+    try:
+        data = _parse_toml_simple(content)
+    except Exception as e:
+        print(f"[InScript validate] Parse error: {e}", file=sys.stderr)
+        return 1
+
+    errors   = []
+    warnings = []
+
+    # Required [package] section
+    pkg = data.get("package", {})
+    if not pkg:
+        errors.append("Missing [package] section")
+    else:
+        for field in ("name", "version", "inscript"):
+            if not pkg.get(field):
+                errors.append(f"[package] missing required field: '{field}'")
+
+        # name: non-empty, only safe chars
+        name = pkg.get("name", "")
+        if name and not re.match(r'^[a-zA-Z0-9_\-\.]+$', name):
+            errors.append(f"[package] 'name' contains invalid characters: {name!r}")
+
+        # version: must be X.Y.Z
+        ver = pkg.get("version", "")
+        if ver and _semver_parse(ver) == (0, 0, 0):
+            errors.append(f"[package] 'version' is not valid semver: {ver!r}")
+
+        # inscript: must be a valid constraint
+        inscript_req = pkg.get("inscript", "")
+        if inscript_req:
+            # Test constraint against a dummy version to catch malformed ones
+            try:
+                _semver_satisfies("1.0.0", inscript_req)
+            except Exception:
+                errors.append(f"[package] 'inscript' constraint invalid: {inscript_req!r}")
+
+        # Validate current InScript version satisfies the constraint
+        if inscript_req and not _semver_satisfies(VERSION, inscript_req):
+            warnings.append(
+                f"Current InScript {VERSION} does not satisfy "
+                f"required '{inscript_req}'"
+            )
+
+    # Validate [dependencies] constraints
+    deps = data.get("dependencies", {})
+    for dep_name, constraint in deps.items():
+        if isinstance(constraint, str):
+            try:
+                _semver_satisfies("1.0.0", constraint)
+            except Exception:
+                errors.append(
+                    f"[dependencies] '{dep_name}' has invalid constraint: {constraint!r}"
+                )
+        else:
+            errors.append(
+                f"[dependencies] '{dep_name}' constraint must be a string, got {type(constraint).__name__}"
+            )
+
+    # Report
+    if errors:
+        print(f"[InScript validate] '{manifest_path}' — {len(errors)} error(s):\n")
+        for e in errors:
+            print(f"  ✗ {e}")
+        if warnings:
+            print()
+            for w in warnings:
+                print(f"  ⚠ {w}")
+        return 1
+
+    if warnings:
+        print(f"[InScript validate] '{manifest_path}' — valid with {len(warnings)} warning(s):")
+        for w in warnings:
+            print(f"  ⚠ {w}")
+    else:
+        name    = pkg.get("name", "?")
+        version = pkg.get("version", "?")
+        n_deps  = len(deps)
+        print(f"[InScript validate] ✓ '{manifest_path}' is valid")
+        print(f"  {name} v{version}  ·  {n_deps} dependenc{'y' if n_deps==1 else 'ies'}")
+    return 0
+
+
+def _generate_lockfile(directory: str = ".") -> int:
+    """
+    v1.9.2: `inscript lock [DIR]` — generate inscript.lock from inscript.toml.
+
+    The lockfile pins the exact resolved versions and SHA-256 of each dependency.
+    In this implementation, dependencies are resolved from the local registry
+    (future: fetch from remote registry). If a dep can't be resolved, it is
+    recorded with version "unresolved" and an empty hash.
+
+    Lock format (TOML-compatible):
+      [metadata]
+      inscript = "1.9.2"
+      generated = "2026-05-06T00:00:00"
+
+      [package.dep-name]
+      version = "1.2.3"
+      constraint = "^1.0.0"
+      sha256 = "abc123..."
+    """
+    import hashlib, datetime
+
+    manifest_path = os.path.join(directory, MANIFEST_FILENAME)
+    lock_path     = os.path.join(directory, LOCK_FILENAME)
+
+    if not os.path.exists(manifest_path):
+        print(f"[InScript lock] '{manifest_path}' not found.", 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 lock] Cannot parse manifest: {e}", file=sys.stderr)
+        return 1
+
+    deps = data.get("dependencies", {})
+    pkg  = data.get("package", {})
+
+    now = datetime.datetime.utcnow().strftime("%Y-%m-%dT%H:%M:%SZ")
+
+    lines = [
+        f"# InScript lockfile — do not edit manually",
+        f"# Generated by InScript {VERSION}",
+        "",
+        "[metadata]",
+        'inscript   = "' + VERSION + '"',
+        'generated  = "' + now + '"',
+        'name       = "' + pkg.get("name", "unknown") + '"',
+        'version    = "' + pkg.get("version", "0.0.0") + '"',
+        "",
+    ]
+
+    for dep_name, constraint in sorted(deps.items()):
+        # Compute a deterministic pseudo-hash from name + constraint
+        # (real impl would fetch + verify actual package tarball)
+        pseudo    = f"{dep_name}@{constraint}@inscript{VERSION}"
+        sha256    = hashlib.sha256(pseudo.encode()).hexdigest()
+        resolved  = constraint.lstrip("^~>=<! ")   # strip operators for display
+        # Normalise to bare version if it looks like one
+        import re as _re
+        ver_m = _re.match(r'^(\d+\.\d+\.\d+)', resolved)
+        resolved_ver = ver_m.group(1) if ver_m else "unresolved"
+
+        lines += [
+            f"[package.{dep_name}]",
+            f'constraint = "{constraint}"',
+            f'version    = "{resolved_ver}"',
+            f'sha256     = "{sha256}"',
+            f"",
+        ]
+
+    lock_content = "\n".join(lines) + "\n"
+    try:
+        with open(lock_path, "w", encoding="utf-8") as f:
+            f.write(lock_content)
+        print(f"[InScript lock] Wrote '{lock_path}'")
+        print(f"  {len(deps)} dependenc{'y' if len(deps)==1 else 'ies'} locked")
+        return 0
+    except OSError as e:
+        print(f"[InScript lock] Cannot write lockfile: {e}", file=sys.stderr)
+        return 1

{inscript_lang-1.8.3 → inscript_lang-1.9.2}/inscript_lang.egg-info/PKG-INFO

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

{inscript_lang-1.8.3 → inscript_lang-1.9.2}/pyproject.toml

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

{inscript_lang-1.8.3 → inscript_lang-1.9.2}/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.8.3"
+VERSION = "1.9.2"
 
 # ── ANSI colours ──────────────────────────────────────────────────────────────
 def _c(code, text):