jaclang 0.8.6__py3-none-any.whl → 0.8.8__py3-none-any.whl

jaclang/cli/cli.md

@@ -1,12 +1,12 @@
 # **Jac Language Command Line Interface (CLI)**
 
-Jac Language CLI is with a variety of commands to facilitate users. Additionally, Jac language offers users the ability to define custom CLI commands through plugins. This document aims to provide an overview of each command along with clear usage instructions.
+git Jac Language CLI provides a variety of commands to facilitate users. Additionally, Jac language offers users the ability to define custom CLI commands through plugins. This document aims to provide an overview of each command along with clear usage instructions.
 
 > [!TIP]
-> Type "help" on Jac CLI and see!
+> Use `jac --help` to see available commands and usage.
 
 ### Click one of the default commands below and see the usage.
-- [tool](#tool) , [run](#run) , [clean](#clean) , [format](#format) , [check](#check) , [build](#build)  , [enter](#enter) , [test](#test)
+- [tool](#tool) , [run](#run) , [clean](#clean) , [format](#format) , [check](#check) , [build](#build) , [enter](#enter) , [test](#test)
 
 
 

jaclang/cli/cli.py

@@ -1,23 +1,24 @@
 """Command line interface tool for the Jac language."""
 
 import ast as ast3
-import importlib
 import marshal
 import os
 import pickle
 import sys
 import types
+from importlib.metadata import version as pkg_version
 from pathlib import Path
 from typing import Optional
 
 import jaclang.compiler.unitree as uni
-from jaclang.cli.cmdreg import CommandShell, cmd_registry
+from jaclang.cli.cmdreg import cmd_registry
 from jaclang.compiler.passes.main import PyastBuildPass
 from jaclang.compiler.program import JacProgram
 from jaclang.runtimelib.builtin import printgraph
 from jaclang.runtimelib.constructs import WalkerArchetype
 from jaclang.runtimelib.machine import ExecutionContext, JacMachine as Jac
 from jaclang.runtimelib.utils import read_file_with_encoding
+from jaclang.settings import settings
 from jaclang.utils.helpers import debugger as db
 from jaclang.utils.lang_tools import AstTool
 
@@ -132,7 +133,7 @@ def run(
         jac run myprogram.jac --session mysession
         jac run myprogram.jac --no-main
     """
-    # if no session specified, check if it was defined when starting the command shell
+    # if no session specified, check if it was defined via global CLI args
     # otherwise default to jaclang.session
     base, mod, mach = proc_file_sess(filename, session)
     lng = filename.split(".")[-1]
@@ -160,11 +161,6 @@ def run(
                 )
         except Exception as e:
             print(f"Error running {filename}: {e}", file=sys.stderr)
-    else:
-        print(
-            "Not a valid file!\nOnly supports `.jac`, `.jir`, and `.py`",
-            file=sys.stderr,
-        )
 
     mach.close()
 
@@ -322,25 +318,7 @@ def lsp() -> None:
     Examples:
         jac lsp
     """
-    from jaclang.langserve.server import run_lang_server
-
-    run_lang_server()
-
-
-@cmd_registry.register
-def lsp_dev() -> None:
-    """Run Jac Language Server Protocol in Developer Mode.
-
-    Starts the experimental Jac Language Server with enhanced features
-    for development and testing. Used by editor extensions in developer mode.
-
-    Args:
-        This command takes no parameters.
-
-    Examples:
-        jac lsp_dev
-    """
-    from jaclang.langserve.dev_server import run_lang_server
+    from jaclang.langserve.server import run_lang_server  # type: ignore
 
     run_lang_server()
 
@@ -662,25 +640,47 @@ def start_cli() -> None:
     - None
     """
     parser = cmd_registry.parser
+    # Default to `run` when a file is provided without a subcommand
+    raw_argv = sys.argv[1:]
+    if (
+        raw_argv
+        and not raw_argv[0].startswith("-")
+        and raw_argv[0].lower().endswith((".jac", ".jir", ".py"))
+    ):
+        sys.argv = [sys.argv[0], "run"] + raw_argv
     args = parser.parse_args()
     cmd_registry.args = args
 
+    # Apply global settings overrides from CLI flags before running commands
+    settings.load_command_line_arguments(args)
+
     if args.version:
-        version = importlib.metadata.version("jaclang")
+        version = pkg_version("jaclang")
         print(f"Jac version {version}")
         print("Jac path:", __file__)
         return
 
+    if args.command is None:
+        parser.print_help()
+        return
+
     command = cmd_registry.get(args.command)
-    if command:
-        args_dict = vars(args)
-        args_dict.pop("command")
-        args_dict.pop("version", None)
-        ret = command.call(**args_dict)
-        if ret:
-            print(ret)
-    else:
-        CommandShell(cmd_registry).cmdloop()
+    if not command:
+        print(f"Unknown command: {args.command}", file=sys.stderr)
+        parser.print_help()
+        return
+
+    args_dict = vars(args)
+    args_dict.pop("command")
+    args_dict.pop("version", None)
+
+    # Only pass parameters that the target command accepts
+    allowed_params = set(command.sig.parameters.keys())
+    filtered_args = {k: v for k, v in args_dict.items() if k in allowed_params}
+
+    ret = command.call(**filtered_args)
+    if ret:
+        print(ret)
 
 
 if __name__ == "__main__":

jaclang/cli/cmdreg.py

@@ -3,12 +3,13 @@
 from __future__ import annotations
 
 import argparse
-import cmd
 import inspect
-import pprint
 import re
+from dataclasses import fields as dataclass_fields
 from typing import Callable, Dict, Optional
 
+from jaclang.settings import Settings as JacSettings
+
 
 class Command:
     """Represents a command in the command line interface."""
@@ -108,6 +109,47 @@ class CommandRegistry:
         )
         self.args = argparse.Namespace()
 
+        # Global settings overrides
+        settings_group = self.parser.add_argument_group(
+            "settings",
+            "Override Jac settings (from config/env). Provide only flags you want to change.",
+        )
+        for fld in dataclass_fields(JacSettings):
+            name = fld.name
+            opt = f"--{name.replace('_', '-')}"
+            if fld.type is bool:
+                # Tri-state: default None so unspecified won't override
+                settings_group.add_argument(
+                    opt,
+                    dest=name,
+                    action="store_true",
+                    default=None,
+                    help=f"bool - Override setting '{name}' to true",
+                )
+                settings_group.add_argument(
+                    f"--no-{name.replace('_', '-')}",
+                    dest=name,
+                    action="store_false",
+                    default=None,
+                    help=f"bool - Override setting '{name}' to false",
+                )
+            elif fld.type is int:
+                settings_group.add_argument(
+                    opt,
+                    dest=name,
+                    type=int,
+                    default=None,
+                    help=f"int - Override setting '{name}'",
+                )
+            else:
+                settings_group.add_argument(
+                    opt,
+                    dest=name,
+                    type=str,
+                    default=None,
+                    help=f"str - Override setting '{name}'",
+                )
+
     def register(self, func: Callable) -> Callable:
         """Register a command in the registry."""
         name = func.__name__
@@ -241,141 +283,4 @@ class CommandRegistry:
 cmd_registry = CommandRegistry()
 
 
-class CommandShell(cmd.Cmd):
-    """Command shell for the command line interface."""
-
-    intro = "Welcome to the Jac CLI!"
-    prompt = "jac> "
-    cmd_reg: CommandRegistry
-
-    def __init__(self, cmd_reg: CommandRegistry) -> None:
-        """Initialize a CommandShell instance."""
-        self.cmd_reg = cmd_reg
-        super().__init__()
-
-    def do_exit(self, arg: list) -> bool:
-        """Exit the command shell."""
-        return True
-
-    def default(self, line: str) -> None:
-        """Process the command line input."""
-        args = vars(self.cmd_reg.parser.parse_args(line.split()))
-        command = self.cmd_reg.get(args["command"])
-        if command:
-            args.pop("command")
-            ret = command.call(**args)
-            if ret:
-                ret_str = pprint.pformat(ret, indent=2)
-                self.stdout.write(f"{ret_str}\n")
-
-    def do_help(self, arg: str) -> None:
-        """Jac CLI help implementation."""
-
-        def get_info(name: str, doc: str, args: dict[str, inspect.Parameter]) -> None:
-            """Format and display detailed command information."""
-            # Format the command header
-            self.stdout.write(f"\n{'=' * 80}\n")
-            self.stdout.write(f"COMMAND: {name}\n")
-            self.stdout.write(f"{'=' * 80}\n\n")
-
-            # Format the command description
-            doc_lines = doc.strip().split("\n")
-            for line in doc_lines:
-                self.stdout.write(f"{line}\n")
-
-            # Format the command arguments
-            if args:
-                self.stdout.write("\nARGUMENTS:\n")
-                for param_name, param in args.items():
-                    # Get parameter type
-                    type_name = (
-                        param.annotation.__name__
-                        if hasattr(param.annotation, "__name__")
-                        else str(param.annotation)
-                    )
-
-                    # Format default value if present
-                    default_str = ""
-                    if param.default is not param.empty:
-                        default_str = f" (default: {param.default})"
-
-                    # Format required/optional status
-                    req_str = (
-                        " [required]"
-                        if param.default is param.empty and param_name != "args"
-                        else " [optional]"
-                    )
-
-                    self.stdout.write(
-                        f"  {param_name}: {type_name}{default_str}{req_str}\n"
-                    )
-            else:
-                self.stdout.write("\nNo arguments\n")
-
-            # Format usage examples
-            command_parser = self.cmd_reg.sub_parsers.choices[name]
-            self.stdout.write(f"\nUSAGE:\n  {command_parser.format_usage()[7:]}\n")
-
-            # Extract and format examples from docstring if present
-            if "Examples:" in doc:
-                examples_section = doc.split("Examples:")[1].strip()
-                example_lines = examples_section.split("\n")
-                self.stdout.write("\nEXAMPLES:\n")
-                for example in example_lines:
-                    if example.strip():
-                        self.stdout.write(f"  {example.strip()}\n")
-
-            self.stdout.write("\n")
-
-        if arg == "all":
-            # Display all commands with their details
-            command_details = self.cmd_reg.get_all_commands()
-            for name, (doc, args) in sorted(command_details.items()):
-                get_info(name, doc, args)
-
-        elif arg:
-            # Display help for a specific command
-            command = self.cmd_reg.get(arg)
-            if command:
-                doc = command.func.__doc__ or "No help available."
-                args = command.sig.parameters
-                get_info(arg, doc, args)
-            else:
-                self.stdout.write(f"\nUnknown command: '{arg}'\n")
-                self.stdout.write("Type 'help' to see available commands.\n")
-        else:
-            # Display general help information
-            self.stdout.write("\n")
-            self.stdout.write("JAC PROGRAMMING LANGUAGE COMMAND LINE INTERFACE\n")
-            self.stdout.write("=" * 50 + "\n\n")
-
-            self.stdout.write("AVAILABLE COMMANDS:\n")
-
-            # Get all command names and sort them alphabetically
-            command_names = sorted(self.cmd_reg.registry.keys())
-
-            # Get brief descriptions for each command
-            command_descriptions: dict[str, str] = {}
-            for name in command_names:
-                command = self.cmd_reg.get(name)
-                if command and command.func.__doc__:
-                    # Extract the first line of the docstring as a brief description
-                    brief = command.func.__doc__.split("\n")[0].strip()
-                    command_descriptions[name] = brief
-                else:
-                    command_descriptions[name] = "No description available"
-
-            # Display commands with their brief descriptions
-            for name in command_names:
-                self.stdout.write(
-                    f"  {name.ljust(15)} - {command_descriptions[name]}\n"
-                )
-
-            self.stdout.write("\nFor detailed information on a specific command:\n")
-            self.stdout.write("  help <command>\n")
-
-            self.stdout.write("\nTo see detailed information for all commands:\n")
-            self.stdout.write("  help all\n")
-
-            self.stdout.write("\nTo exit the Jac CLI:\n")
-            self.stdout.write("  exit\n\n")
+# Shell mode removed; interactive cmd-based shell is no longer supported.

jaclang/compiler/constant.py

@@ -178,7 +178,6 @@ class Tokens(str, Enum):
     KW_WAIT = "KW_WAIT"
     KW_TEST = "KW_TEST"
     KW_ASSERT = "KW_ASSERT"
-    KW_CHECK = "KW_CHECK"
     COLON = "COLON"
     PIPE_FWD = "PIPE_FWD"
     PIPE_BKWD = "PIPE_BKWD"

jaclang/compiler/jac.lark

@@ -70,6 +70,8 @@ func_decl: (LPAREN func_decl_params? RPAREN) (RETURN_HINT expression)?
 
 func_decl_params: (param_var COMMA)* param_var COMMA?
 param_var: (STAR_POW | STAR_MUL)? named_ref type_tag (EQ expression)?
+         | DIV
+         | STAR_MUL
 
 // [Heading]: Implementations.
 impl_def: decorators? KW_IMPL dotted_name impl_spec? impl_tail
@@ -113,7 +115,6 @@ statement: import_stmt
        | (yield_expr | KW_YIELD) SEMI
        | raise_stmt SEMI
        | assert_stmt SEMI
-       | check_stmt SEMI
        | assignment SEMI
        | delete_stmt SEMI
        | report_stmt SEMI
@@ -209,9 +210,6 @@ raise_stmt: KW_RAISE (expression (KW_FROM expression)?)?
 // [Heading]: Assert statements.
 assert_stmt: KW_ASSERT expression (COMMA expression)?
 
-// [Heading]: Check statements.
-check_stmt: KW_CHECK expression
-
 // [Heading]: Delete statements.
 delete_stmt: KW_DELETE expression
 
@@ -402,7 +400,7 @@ kw_expr_list: (kw_expr_list COMMA)? kw_expr
 kw_expr: named_ref EQ expression | STAR_POW expression
 
 // [Heading]: Object-Spatial References.
-edge_ref_chain: LSQUARE (KW_NODE| KW_EDGE)? expression? (edge_op_ref (filter_compr | expression)?)+ RSQUARE
+edge_ref_chain: LSQUARE KW_ASYNC? (KW_NODE| KW_EDGE)? expression? (edge_op_ref (filter_compr | expression)?)+ RSQUARE
 edge_op_ref: edge_any | edge_from | edge_to
 edge_to: ARROW_R | ARROW_R_P1 typed_filter_compare_list ARROW_R_P2
 edge_from: ARROW_L | ARROW_L_P1 typed_filter_compare_list ARROW_L_P2
@@ -523,7 +521,6 @@ KW_TEST: "test"
 KW_IMPL: "impl"
 KW_SEM: "sem"
 KW_ASSERT: "assert"
-KW_CHECK: "check"
 KW_IF: "if"
 KW_ELIF: "elif"
 KW_ELSE: "else"