jaclang 0.8.9__py3-none-any.whl → 0.8.10__py3-none-any.whl

jaclang/cli/cli.py

@@ -22,9 +22,6 @@ from jaclang.settings import settings
 from jaclang.utils.helpers import debugger as db
 from jaclang.utils.lang_tools import AstTool
 
-Jac.create_cmd()
-Jac.setup()
-
 
 @cmd_registry.register
 def format(path: str, outfile: str = "", to_screen: bool = False) -> None:
@@ -150,7 +147,9 @@ def run(
                 lng=lng,
             )
         except Exception as e:
-            print(f"Error running {filename}: {e}", file=sys.stderr)
+            from jaclang.utils.helpers import dump_traceback
+
+            print(dump_traceback(e), file=sys.stderr)
             mach.close()
             exit(1)
     elif filename.endswith(".jir"):
@@ -164,7 +163,9 @@ def run(
                     lng=lng,
                 )
         except Exception as e:
-            print(f"Error running {filename}: {e}", file=sys.stderr)
+            from jaclang.utils.helpers import dump_traceback
+
+            print(dump_traceback(e), file=sys.stderr)
             mach.close()
             exit(1)
 
@@ -640,9 +641,10 @@ def py2jac(filename: str) -> None:
 def jac2py(filename: str) -> None:
     """Convert a Jac file to Python code.
 
-    Translates Jac source code to equivalent Python code. This is useful for
-    understanding how Jac code is executed or for integrating Jac components
-    with Python projects.
+    Translates Jac source code to equivalent Python code. The generated Python
+    uses direct imports from jaclang.lib, making the output clean and suitable
+    for use as a standalone library or for integrating Jac components with
+    Python projects.
 
     Args:
         filename: Path to the .jac file to convert
@@ -662,38 +664,158 @@ def jac2py(filename: str) -> None:
 
 
 @cmd_registry.register
-def jac2lib(filename: str) -> None:
-    """Convert a Jac file to Python library code.
+def js(filename: str) -> None:
+    """Convert a Jac file to JavaScript code.
 
-    Translates Jac source code to equivalent Python code with library mode enabled.
-    In library mode, the generated Python uses direct imports from jaclang.lib
-    instead of aliased imports, making the output cleaner and more suitable for
-    use as a standalone library.
+    Translates Jac source code to equivalent JavaScript/ECMAScript code using
+    the ESTree AST specification. This allows Jac programs to run in JavaScript
+    environments like Node.js or web browsers.
 
     Args:
         filename: Path to the .jac file to convert
 
     Examples:
-        jac jac2lib myprogram.jac > mylib.py
+        jac js myprogram.jac > myprogram.js
+        jac js myprogram.jac
     """
     if filename.endswith(".jac"):
-        # Temporarily enable library mode
-        original_library_mode = settings.library_mode
-        settings.library_mode = True
         try:
-            code = JacProgram().compile(file_path=filename).gen.py
-            if code:
-                print(code)
-            else:
+            prog = JacProgram()
+            ir = prog.compile(file_path=filename)
+
+            if prog.errors_had:
+                for error in prog.errors_had:
+                    print(f"Error: {error}", file=sys.stderr)
                 exit(1)
-        finally:
-            # Restore original setting
-            settings.library_mode = original_library_mode
+            js_output = ir.gen.js or ""
+            if not js_output.strip():
+                print(
+                    "ECMAScript code generation produced no output.",
+                    file=sys.stderr,
+                )
+                exit(1)
+            print(js_output)
+        except Exception as e:
+            print(f"Error generating JavaScript: {e}", file=sys.stderr)
+            import traceback
+
+            traceback.print_exc()
+            exit(1)
     else:
         print("Not a .jac file.", file=sys.stderr)
         exit(1)
 
 
+# Register core commands first (before plugins load)
+# These can be overridden by plugins with higher priority
+
+
+@cmd_registry.register
+def serve(
+    filename: str,
+    session: str = "",
+    port: int = 8000,
+    main: bool = True,
+    faux: bool = False,
+) -> None:
+    """Start a REST API server for the specified .jac file.
+
+    Executes the target module and turns all functions into authenticated REST API
+    endpoints. Function signatures are introspected to create the API interface.
+    Walkers are converted to REST APIs where their fields become the interface,
+    with an additional target_node field for spawning location.
+
+    Each user gets their own persistent root node that persists across runs.
+    Users must create an account and authenticate to access the API.
+
+    Args:
+        filename: Path to the .jac file to serve
+        session: Session identifier for persistent state (default: auto-generated)
+        port: Port to run the server on (default: 8000)
+        main: Treat the module as __main__ (default: True)
+        faux: Perform introspection and print endpoint docs without starting server (default: False)
+
+    Examples:
+        jac serve myprogram.jac
+        jac serve myprogram.jac --port 8080
+        jac serve myprogram.jac --session myapp.session
+        jac serve myprogram.jac --faux
+    """
+    from jaclang.runtimelib.server import JacAPIServer
+
+    # Process file and session
+    base, mod, mach = proc_file_sess(filename, session)
+    lng = filename.split(".")[-1]
+    Jac.set_base_path(base)
+
+    # Import the module
+    if filename.endswith((".jac", ".py")):
+        try:
+            Jac.jac_import(
+                target=mod,
+                base_path=base,
+                lng=lng,
+            )
+        except Exception as e:
+            print(f"Error loading {filename}: {e}", file=sys.stderr)
+            mach.close()
+            exit(1)
+    elif filename.endswith(".jir"):
+        try:
+            with open(filename, "rb") as f:
+                Jac.attach_program(pickle.load(f))
+                Jac.jac_import(
+                    target=mod,
+                    base_path=base,
+                    lng=lng,
+                )
+        except Exception as e:
+            print(f"Error loading {filename}: {e}", file=sys.stderr)
+            mach.close()
+            exit(1)
+
+    # Create and start the API server
+    # Use session path for persistent storage across user sessions
+    session_path = session if session else os.path.join(base, f"{mod}.session")
+
+    server = JacAPIServer(
+        module_name=mod,
+        session_path=session_path,
+        port=port,
+        base_path=base,
+    )
+
+    # If faux mode, print endpoint documentation and exit
+    if faux:
+        try:
+            server.print_endpoint_docs()
+            mach.close()
+            return
+        except Exception as e:
+            print(f"Error generating endpoint documentation: {e}", file=sys.stderr)
+            mach.close()
+            exit(1)
+
+    # Don't close the context - keep the module loaded for the server
+    # mach.close()
+
+    try:
+        server.start()
+    except KeyboardInterrupt:
+        print("\nServer stopped.")
+        mach.close()  # Close on shutdown
+    except Exception as e:
+        print(f"Server error: {e}", file=sys.stderr)
+        mach.close()
+        exit(1)
+
+
+Jac.create_cmd()
+Jac.setup()
+
+cmd_registry.finalize()
+
+
 def start_cli() -> None:
     """
     Start the command line interface.

jaclang/cli/cmdreg.py

@@ -4,23 +4,47 @@ from __future__ import annotations
 
 import argparse
 import inspect
+import os
 import re
+import sys
 from dataclasses import fields as dataclass_fields
+from enum import IntEnum
 from typing import Callable, Dict, Optional
 
 from jaclang.settings import Settings as JacSettings
 
 
+class CommandPriority(IntEnum):
+    """Priority levels for command registration.
+
+    Higher values take precedence when multiple commands with the same name are registered.
+    This allows plugins to override core commands in a controlled manner.
+    """
+
+    CORE = 100  # Core jaclang commands (lowest priority, can be overridden)
+    PLUGIN = 200  # Plugin-provided commands (override core)
+    USER = 300  # User-defined commands (highest priority, override everything)
+
+
 class Command:
     """Represents a command in the command line interface."""
 
     func: Callable
     sig: inspect.Signature
-
-    def __init__(self, func: Callable) -> None:
+    priority: CommandPriority
+    source: str  # Source plugin/module name
+
+    def __init__(
+        self,
+        func: Callable,
+        priority: CommandPriority = CommandPriority.CORE,
+        source: str = "core",
+    ) -> None:
         """Initialize a Command instance."""
         self.func = func
         self.sig = inspect.signature(func)
+        self.priority = priority
+        self.source = source
 
     def call(self, *args: list, **kwargs: dict) -> str:
         """Call the associated function with the specified arguments and keyword arguments."""
@@ -82,13 +106,17 @@ class CommandRegistry:
     """Registry for managing commands in the command line interface."""
 
     registry: dict[str, Command]
+    pending_commands: dict[str, list[Command]]  # Commands waiting to be bound
     sub_parsers: argparse._SubParsersAction
     parser: argparse.ArgumentParser
     args: argparse.Namespace
+    _finalized: bool  # Whether command registration has been finalized
 
     def __init__(self) -> None:
         """Initialize a CommandRegistry instance."""
         self.registry = {}
+        self.pending_commands = {}
+        self._finalized = False
         self.parser = argparse.ArgumentParser(
             prog="jac",
             description="Jac Programming Language CLI - A tool for working with Jac programs",
@@ -150,11 +178,55 @@ class CommandRegistry:
                     help=f"str - Override setting '{name}'",
                 )
 
-    def register(self, func: Callable) -> Callable:
-        """Register a command in the registry."""
-        name = func.__name__
-        cmd = Command(func)
-        self.registry[name] = cmd
+    def register(
+        self,
+        func: Callable | None = None,
+        *,
+        priority: CommandPriority = CommandPriority.CORE,
+        source: str = "core",
+    ) -> Callable:
+        """Register a command in the registry.
+
+        This method supports both decorator syntax with and without arguments:
+            @cmd_registry.register
+            def my_cmd(): ...
+
+            @cmd_registry.register(priority=CommandPriority.PLUGIN, source="my-plugin")
+            def my_cmd(): ...
+
+        Args:
+            func: The command function to register
+            priority: Priority level for conflict resolution
+            source: Source plugin/module name for introspection
+
+        Returns:
+            The original function (for decorator usage)
+        """
+
+        def _register(f: Callable) -> Callable:
+            """Inner registration function."""
+            name = f.__name__
+            cmd = Command(f, priority=priority, source=source)
+
+            # Add to pending commands for priority resolution
+            if name not in self.pending_commands:
+                self.pending_commands[name] = []
+            self.pending_commands[name].append(cmd)
+
+            # If already finalized, bind immediately (late registration)
+            if self._finalized:
+                self._resolve_and_bind_command(name)
+
+            return f
+
+        # Support both @register and @register(...) syntax
+        if func is not None:
+            return _register(func)
+        return _register
+
+    def _bind_command_to_argparse(self, name: str, cmd: Command) -> None:
+        """Bind a command to argparse subparser."""
+        func = cmd.func
         # Extract the first paragraph from the docstring for brief description
         doc = func.__doc__ or ""
         brief_desc = doc.split("\n\n")[0].strip()
@@ -264,7 +336,51 @@ class CommandRegistry:
                             else param.annotation
                         ),
                     )
-        return func
+
+    def _resolve_and_bind_command(self, name: str) -> None:
+        """Resolve command conflicts by priority and bind to argparse."""
+        if name not in self.pending_commands:
+            return
+
+        commands = self.pending_commands[name]
+        if not commands:
+            return
+
+        # Sort by priority (highest first)
+        commands.sort(key=lambda c: c.priority, reverse=True)
+
+        # Winner is the highest priority command
+        winner = commands[0]
+
+        # Warn about conflicts if multiple commands with different priorities
+        # Only warn if JAC_CLI_VERBOSE environment variable is set
+        if len(commands) > 1 and os.getenv("JAC_CLI_VERBOSE"):
+            conflicts = [f"{c.source} (priority={c.priority})" for c in commands[1:]]
+            print(
+                f"Warning: Command '{name}' registered by multiple sources. "
+                f"Using {winner.source} (priority={winner.priority}). "
+                f"Overriding: {', '.join(conflicts)}",
+                file=sys.stderr,
+            )
+
+        # Register the winner
+        self.registry[name] = winner
+        self._bind_command_to_argparse(name, winner)
+
+    def finalize(self) -> None:
+        """Finalize command registration by resolving conflicts and binding to argparse.
+
+        This should be called after all plugins have had a chance to register commands.
+        """
+        if self._finalized:
+            return
+
+        # Resolve all pending commands
+        for name in list(self.pending_commands.keys()):
+            self._resolve_and_bind_command(name)
+
+        self._finalized = True
+        self.pending_commands.clear()
 
     def get(self, name: str) -> Optional[Command]:
         """Get the Command instance for a given command name."""
@@ -279,6 +395,26 @@ class CommandRegistry:
             all_commands[name] = (doc, args)
         return all_commands
 
+    def has_command(self, name: str) -> bool:
+        """Check if a command is already registered."""
+        return name in self.registry
+
+    def list_commands(self) -> dict[str, dict[str, CommandPriority | str]]:
+        """List all registered commands with metadata.
+
+        Returns:
+            Dictionary mapping command names to metadata including source and priority
+        """
+        return {
+            name: {
+                "source": cmd.source,
+                "priority": cmd.priority,
+                "priority_name": cmd.priority.name,
+                "doc": cmd.func.__doc__ or "No documentation",
+            }
+            for name, cmd in self.registry.items()
+        }
+
 
 cmd_registry = CommandRegistry()
 

jaclang/compiler/__init__.py

@@ -36,7 +36,12 @@ except ModuleNotFoundError:
     generate_static_parser(force=True)
     from jaclang.compiler.larkparse import jac_parser as jac_lark
 
-jac_lark.logger.setLevel(logging.DEBUG)
+if not hasattr(jac_lark, "Lark_StandAlone"):
+    generate_static_parser(force=True)
+    from jaclang.compiler.larkparse import jac_parser as jac_lark
+
+with contextlib.suppress(AttributeError):
+    jac_lark.logger.setLevel(logging.DEBUG)
 contextlib.suppress(ModuleNotFoundError)
 
 TOKEN_MAP = {

jaclang/compiler/codeinfo.py

@@ -3,12 +3,25 @@
 from __future__ import annotations
 
 import ast as ast3
-from typing import Optional, TYPE_CHECKING
+from dataclasses import dataclass, field
+from typing import Any, Optional, TYPE_CHECKING
 
 if TYPE_CHECKING:
+    from jaclang.compiler.passes.ecmascript.estree import Node as EsNode
     from jaclang.compiler.unitree import Source, Token
 
 
+@dataclass
+class ClientManifest:
+    """Client-side rendering manifest metadata."""
+
+    exports: list[str] = field(default_factory=list)
+    globals: list[str] = field(default_factory=list)
+    params: dict[str, list[str]] = field(default_factory=dict)
+    globals_values: dict[str, Any] = field(default_factory=dict)
+    has_client: bool = False
+
+
 class CodeGenTarget:
     """Code generation target."""
 
@@ -20,8 +33,10 @@ class CodeGenTarget:
         self.jac: str = ""
         self.doc_ir: doc.DocType = doc.Text("")
         self.js: str = ""
+        self.client_manifest: ClientManifest = ClientManifest()
         self.py_ast: list[ast3.AST] = []
         self.py_bytecode: Optional[bytes] = None
+        self.es_ast: Optional[EsNode] = None
 
 
 class CodeLocInfo:

jaclang/compiler/constant.py

@@ -247,6 +247,7 @@ class Tokens(str, Enum):
     KW_OVERRIDE = "KW_OVERRIDE"
     KW_MATCH = "KW_MATCH"
     KW_CASE = "KW_CASE"
+    KW_CLIENT = "KW_CLIENT"
     PLUS = "PLUS"
     MINUS = "MINUS"
     STAR_MUL = "STAR_MUL"
@@ -295,21 +296,40 @@ class Tokens(str, Enum):
     RETURN_HINT = "RETURN_HINT"
     NULL_OK = "NULL_OK"
     DECOR_OP = "DECOR_OP"
-    FSTR_START = "FSTR_START"
-    FSTR_END = "FSTR_END"
-    FSTR_SQ_START = "FSTR_SQ_START"
-    FSTR_SQ_END = "FSTR_SQ_END"
-    FSTR_TRIPLE_START = "FSTR_TRIPLE_START"
-    FSTR_TRIPLE_END = "FSTR_TRIPLE_END"
-    FSTR_SQ_TRIPLE_START = "FSTR_SQ_TRIPLE_START"
-    FSTR_SQ_TRIPLE_END = "FSTR_SQ_TRIPLE_END"
-    FSTR_PIECE = "FSTR_PIECE"
-    FSTR_SQ_PIECE = "FSTR_SQ_PIECE"
-    FSTR_TRIPLE_PIECE = "FSTR_TRIPLE_PIECE"
-    FSTR_SQ_TRIPLE_PIECE = "FSTR_SQ_TRIPLE_PIECE"
-    FSTR_BESC = "FSTR_BESC"
+    JSX_TEXT = "JSX_TEXT"
+    JSX_OPEN_START = "JSX_OPEN_START"
+    JSX_SELF_CLOSE = "JSX_SELF_CLOSE"
+    JSX_TAG_END = "JSX_TAG_END"
+    JSX_CLOSE_START = "JSX_CLOSE_START"
+    JSX_FRAG_OPEN = "JSX_FRAG_OPEN"
+    JSX_FRAG_CLOSE = "JSX_FRAG_CLOSE"
+    JSX_NAME = "JSX_NAME"
     COMMENT = "COMMENT"
     WS = "WS"
+    F_DQ_START = "F_DQ_START"
+    F_SQ_START = "F_SQ_START"
+    F_TDQ_START = "F_TDQ_START"
+    F_TSQ_START = "F_TSQ_START"
+    RF_DQ_START = "RF_DQ_START"
+    RF_SQ_START = "RF_SQ_START"
+    RF_TDQ_START = "RF_TDQ_START"
+    RF_TSQ_START = "RF_TSQ_START"
+    F_DQ_END = "F_DQ_END"
+    F_SQ_END = "F_SQ_END"
+    F_TDQ_END = "F_TDQ_END"
+    F_TSQ_END = "F_TSQ_END"
+    F_TEXT_DQ = "F_TEXT_DQ"
+    F_TEXT_SQ = "F_TEXT_SQ"
+    F_TEXT_TDQ = "F_TEXT_TDQ"
+    F_TEXT_TSQ = "F_TEXT_TSQ"
+    RF_TEXT_DQ = "RF_TEXT_DQ"
+    RF_TEXT_SQ = "RF_TEXT_SQ"
+    RF_TEXT_TDQ = "RF_TEXT_TDQ"
+    RF_TEXT_TSQ = "RF_TEXT_TSQ"
+    D_LBRACE = "D_LBRACE"
+    D_RBRACE = "D_RBRACE"
+    CONV = "CONV"
+    F_FORMAT_TEXT = "F_FORMAT_TEXT"
 
     def __str__(self) -> str:
         return self.value