jaclang 0.7.34__py3-none-any.whl → 0.8.1__py3-none-any.whl

jaclang/cli/cli.py

@@ -5,78 +5,89 @@ import importlib
 import marshal
 import os
 import pickle
-import shutil
 import sys
 import types
+from pathlib import Path
 from typing import Optional
 
-import jaclang.compiler.absyntree as ast
-from jaclang import jac_import
+import jaclang.compiler.unitree as uni
 from jaclang.cli.cmdreg import CommandShell, cmd_registry
-from jaclang.compiler.compile import jac_file_to_pass
-from jaclang.compiler.constant import Constants
-from jaclang.compiler.passes.main.pyast_load_pass import PyastBuildPass
-from jaclang.compiler.passes.main.schedules import py_code_gen_typed
-from jaclang.compiler.passes.tool.schedules import format_pass
-from jaclang.plugin.builtin import dotgen
-from jaclang.plugin.feature import JacCmd as Cmd
-from jaclang.plugin.feature import JacFeature as Jac
-from jaclang.runtimelib.constructs import WalkerArchitype
-from jaclang.runtimelib.context import ExecutionContext
-from jaclang.runtimelib.machine import JacMachine, JacProgram
+from jaclang.compiler.passes.main import CompilerMode as CMode, PyastBuildPass
+from jaclang.compiler.program import JacProgram
+from jaclang.runtimelib.builtin import printgraph
+from jaclang.runtimelib.constructs import WalkerArchetype
+from jaclang.runtimelib.machine import (
+    JacMachine,
+    JacMachineInterface as Jac,
+    call_jac_func_with_machine,
+)
 from jaclang.utils.helpers import debugger as db
 from jaclang.utils.lang_tools import AstTool
 
 
-Cmd.create_cmd()
+Jac.create_cmd()
 Jac.setup()
 
 
 @cmd_registry.register
-def format(path: str, outfile: str = "", debug: bool = False) -> None:
-    """Run the specified .jac file or format all .jac files in a given directory."""
+def format(path: str, outfile: str = "", to_screen: bool = False) -> None:
+    """Format .jac files with improved code style.
+
+    Applies consistent formatting to Jac code files to improve readability and
+    maintain a standardized code style across your project.
+
+    Args:
+        path: Path to a .jac file or directory containing .jac files
+        outfile: Optional output file path (when formatting a single file)
+        to_screen: Print formatted code to stdout instead of writing to file
+
+    Examples:
+        jac format myfile.jac
+        jac format myproject/
+        jac format myfile.jac --outfile formatted.jac
+        jac format myfile.jac --to_screen
+    """
 
-    def format_file(filename: str) -> None:
-        code_gen_format = jac_file_to_pass(filename, schedule=format_pass)
-        if code_gen_format.errors_had:
-            print(
-                f"Errors occurred while formatting the file {filename}.",
-                file=sys.stderr,
-            )
-        elif debug:
-            print(code_gen_format.ir.gen.jac)
+    def write_formatted_code(code: str, target_path: str) -> None:
+        """Write formatted code to the appropriate destination."""
+        if to_screen:
+            print(code)
         elif outfile:
             with open(outfile, "w") as f:
-                f.write(code_gen_format.ir.gen.jac)
+                f.write(code)
         else:
-            with open(filename, "w") as f:
-                f.write(code_gen_format.ir.gen.jac)
+            with open(target_path, "w") as f:
+                f.write(code)
+
+    path_obj = Path(path)
 
+    # Case 1: Single .jac file
     if path.endswith(".jac"):
-        if os.path.exists(path):
-            format_file(path)
-        else:
-            print("File does not exist.", file=sys.stderr)
-    elif os.path.isdir(path):
-        count = 0
-        for root, _, files in os.walk(path):
-            for file in files:
-                if file.endswith(".jac"):
-                    file_path = os.path.join(root, file)
-                    format_file(file_path)
-                    count += 1
-        print(f"Formatted {count} '.jac' files.", file=sys.stderr)
-    else:
-        print("Not a .jac file or directory.", file=sys.stderr)
+        if not path_obj.exists():
+            print(f"Error: File '{path}' does not exist.", file=sys.stderr)
+            return
+        formatted_code = JacProgram.jac_file_formatter(str(path_obj))
+        write_formatted_code(formatted_code, str(path_obj))
+        return
 
+    # Case 2: Directory with .jac files
+    if path_obj.is_dir():
+        jac_files = list(path_obj.glob("**/*.jac"))
+        for jac_file in jac_files:
+            formatted_code = JacProgram.jac_file_formatter(str(jac_file))
+            write_formatted_code(formatted_code, str(jac_file))
 
-@cmd_registry.register
-def run(
-    filename: str, session: str = "", main: bool = True, cache: bool = True
-) -> None:
-    """Run the specified .jac file."""
-    # if no session specified, check if it was defined when starting the command shell
-    # otherwise default to jaclang.session
+        print(f"Formatted {len(jac_files)} '.jac' files.", file=sys.stderr)
+        return
+
+    # Case 3: Invalid path
+    print(f"Error: '{path}' is not a .jac file or directory.", file=sys.stderr)
+
+
+def proc_file_sess(
+    filename: str, session: str, root: Optional[str] = None
+) -> tuple[str, str, JacMachine]:
+    """Create JacMachine and return the base path, module name, and machine state."""
     if session == "":
         session = (
             cmd_registry.args.session
@@ -85,19 +96,46 @@ def run(
             and cmd_registry.args.session
             else ""
         )
-
     base, mod = os.path.split(filename)
     base = base if base else "./"
     mod = mod[:-4]
+    mach = JacMachine(base, session=session, root=root)
+    return base, mod, mach
+
+
+@cmd_registry.register
+def run(
+    filename: str,
+    session: str = "",
+    main: bool = True,
+    cache: bool = True,
+) -> None:
+    """Run the specified .jac file.
+
+    Executes a Jac program file, loading it into the Jac runtime environment
+    and running its code. This is the primary way to execute Jac programs.
 
-    jctx = ExecutionContext.create(session=session)
+    Args:
+        filename: Path to the .jac or .jir file to run
+        session: Optional session identifier for persistent state
+        main: Treat the module as __main__ (default: True)
+        cache: Use cached compilation if available (default: True)
+
+    Examples:
+        jac run myprogram.jac
+        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
+    # otherwise default to jaclang.session
+    base, mod, mach = proc_file_sess(filename, session)
 
     if filename.endswith(".jac"):
         try:
-            jac_import(
+            Jac.jac_import(
+                mach=mach,
                 target=mod,
                 base_path=base,
-                cachable=cache,
                 override_name="__main__" if main else None,
             )
         except Exception as e:
@@ -105,94 +143,99 @@ def run(
     elif filename.endswith(".jir"):
         try:
             with open(filename, "rb") as f:
-                JacMachine(base).attach_program(
-                    JacProgram(mod_bundle=pickle.load(f), bytecode=None, sem_ir=None)
-                )
-                jac_import(
+                Jac.attach_program(mach, pickle.load(f))
+                Jac.jac_import(
+                    mach=mach,
                     target=mod,
                     base_path=base,
-                    cachable=cache,
                     override_name="__main__" if main else None,
                 )
         except Exception as e:
             print(e, file=sys.stderr)
 
     else:
-        jctx.close()
-        JacMachine.detach()
-        raise ValueError("Not a valid file!\nOnly supports `.jac` and `.jir`")
-
-    jctx.close()
-    JacMachine.detach()
+        print("Not a valid file!\nOnly supports `.jac` and `.jir`")
+    mach.close()
 
 
 @cmd_registry.register
-def get_object(
-    filename: str, id: str, session: str = "", main: bool = True, cache: bool = True
-) -> dict:
-    """Get the object with the specified id."""
-    if session == "":
-        session = (
-            cmd_registry.args.session
-            if hasattr(cmd_registry, "args")
-            and hasattr(cmd_registry.args, "session")
-            and cmd_registry.args.session
-            else ""
-        )
+def get_object(filename: str, id: str, session: str = "", main: bool = True) -> dict:
+    """Get the object with the specified id.
 
-    base, mod = os.path.split(filename)
-    base = base if base else "./"
-    mod = mod[:-4]
+    Retrieves a specific object from a Jac program by its unique identifier.
+    Returns the object's state as a dictionary.
 
-    jctx = ExecutionContext.create(session=session)
+    Args:
+        filename: Path to the .jac or .jir file containing the object
+        id: Unique identifier of the object to retrieve
+        session: Optional session identifier for persistent state
+        main: Treat the module as __main__ (default: True)
+
+    Examples:
+        jac get_object myprogram.jac obj123
+        jac get_object myprogram.jac obj123 --session mysession
+    """
+    base, mod, mach = proc_file_sess(filename, session)
 
     if filename.endswith(".jac"):
-        jac_import(
+        Jac.jac_import(
+            mach=mach,
             target=mod,
             base_path=base,
-            cachable=cache,
             override_name="__main__" if main else None,
         )
     elif filename.endswith(".jir"):
         with open(filename, "rb") as f:
-            JacMachine(base).attach_program(
-                JacProgram(mod_bundle=pickle.load(f), bytecode=None, sem_ir=None)
+            Jac.attach_program(
+                mach,
+                pickle.load(f),
             )
-            jac_import(
+            Jac.jac_import(
+                mach=mach,
                 target=mod,
                 base_path=base,
-                cachable=cache,
                 override_name="__main__" if main else None,
             )
     else:
-        jctx.close()
-        JacMachine.detach()
+        mach.close()
         raise ValueError("Not a valid file!\nOnly supports `.jac` and `.jir`")
 
     data = {}
-    obj = Jac.get_object(id)
+    obj = call_jac_func_with_machine(mach, Jac.get_object, id)
     if obj:
         data = obj.__jac__.__getstate__()
     else:
         print(f"Object with id {id} not found.", file=sys.stderr)
 
-    jctx.close()
-    JacMachine.detach()
+    mach.close()
     return data
 
 
 @cmd_registry.register
 def build(filename: str) -> None:
-    """Build the specified .jac file."""
+    """Build the specified .jac file.
+
+    Compiles a Jac source file into a Jac Intermediate Representation (.jir) file,
+    which can be executed more efficiently. Optionally performs type checking.
+
+    Args:
+        filename: Path to the .jac file to build
+        typecheck: Perform type checking during build (default: True)
+
+    Examples:
+        jac build myprogram.jac
+        jac build myprogram.jac --no-typecheck
+    """
     if filename.endswith(".jac"):
-        out = jac_file_to_pass(file_path=filename, schedule=py_code_gen_typed)
+        (out := JacProgram()).compile(
+            file_path=filename,
+            mode=CMode.COMPILE,
+        )
         errs = len(out.errors_had)
         warnings = len(out.warnings_had)
         print(f"Errors: {errs}, Warnings: {warnings}")
-        for i in out.ir.flatten():
-            i.gen.clean()
         with open(filename[:-4] + ".jir", "wb") as f:
-            pickle.dump(out.ir, f)
+            pickle.dump(out, f)
     else:
         print("Not a .jac file.", file=sys.stderr)
 
@@ -201,18 +244,27 @@ def build(filename: str) -> None:
 def check(filename: str, print_errs: bool = True) -> None:
     """Run type checker for a specified .jac file.
 
-    :param filename: The path to the .jac file.
+    Performs static type analysis on a Jac program to identify potential type errors
+    without executing the code. Useful for catching errors early in development.
+
+    Args:
+        filename: Path to the .jac file to check
+        print_errs: Print detailed error messages (default: True)
+
+    Examples:
+        jac check myprogram.jac
+        jac check myprogram.jac --no-print_errs
     """
     if filename.endswith(".jac"):
-        out = jac_file_to_pass(
+        (prog := JacProgram()).compile(
             file_path=filename,
-            schedule=py_code_gen_typed,
+            mode=CMode.TYPECHECK,
         )
 
-        errs = len(out.errors_had)
-        warnings = len(out.warnings_had)
+        errs = len(prog.errors_had)
+        warnings = len(prog.warnings_had)
         if print_errs:
-            for e in out.errors_had:
+            for e in prog.errors_had:
                 print("Error:", e, file=sys.stderr)
         print(f"Errors: {errs}, Warnings: {warnings}")
     else:
@@ -221,10 +273,24 @@ def check(filename: str, print_errs: bool = True) -> None:
 
 @cmd_registry.register
 def lsp() -> None:
-    """Run Jac Language Server Protocol."""
-    from jaclang.langserve.server import run_lang_server
+    """Run Jac Language Server Protocol.
+
+    Starts the Jac Language Server that provides IDE features like code completion,
+    error checking, and navigation for Jac files. Used by editor extensions.
+
+    Args:
+        This command takes no parameters.
+
+    Examples:
+        jac lsp
+    """
+    from jaclang import JacMachineInterface as _
 
-    run_lang_server()
+    run_lang_server_tuple = _.py_jac_import(
+        "...jaclang.langserve.server", __file__, items={"run_lang_server": None}
+    )
+    run_lang_server = run_lang_server_tuple[0]
+    run_lang_server()  # type: ignore
 
 
 @cmd_registry.register
@@ -234,56 +300,51 @@ def enter(
     args: list,
     session: str = "",
     main: bool = True,
-    cache: bool = True,
     root: str = "",
     node: str = "",
 ) -> None:
+    """Run the specified entrypoint function in the given .jac file.
+
+    Executes a specific function within a Jac program, allowing you to target
+    particular functionality without running the entire program. Useful for
+    testing specific components or running specific tasks.
+
+    Args:
+        filename: Path to the .jac or .jir file
+        entrypoint: Name of the function to execute
+        args: Arguments to pass to the entrypoint function
+        session: Optional session identifier for persistent state
+        main: Treat the module as __main__ (default: True)
+        root: Root executor identifier
+        node: Starting node identifier
+
+    Examples:
+        jac enter myprogram.jac main_function arg1 arg2
+        jac enter myprogram.jac process_data --node data_node data.json
     """
-    Run the specified entrypoint function in the given .jac file.
-
-    :param filename: The path to the .jac file.
-    :param entrypoint: The name of the entrypoint function.
-    :param args: Arguments to pass to the entrypoint function.
-    :param session: shelve.Shelf file path.
-    :param root: root executor.
-    :param node: starting node.
-    """
-    if session == "":
-        session = (
-            cmd_registry.args.session
-            if hasattr(cmd_registry, "args")
-            and hasattr(cmd_registry.args, "session")
-            and cmd_registry.args.session
-            else ""
-        )
-
-    base, mod = os.path.split(filename)
-    base = base if base else "./"
-    mod = mod[:-4]
-
-    jctx = ExecutionContext.create(session=session, root=root)
+    base, mod, mach = proc_file_sess(filename, session, root)
 
     if filename.endswith(".jac"):
-        ret_module = jac_import(
+        ret_module = Jac.jac_import(
+            mach=mach,
             target=mod,
             base_path=base,
-            cachable=cache,
             override_name="__main__" if main else None,
         )
     elif filename.endswith(".jir"):
         with open(filename, "rb") as f:
-            JacMachine(base).attach_program(
-                JacProgram(mod_bundle=pickle.load(f), bytecode=None, sem_ir=None)
+            Jac.attach_program(
+                mach,
+                pickle.load(f),
             )
-            ret_module = jac_import(
+            ret_module = Jac.jac_import(
+                mach=mach,
                 target=mod,
                 base_path=base,
-                cachable=cache,
                 override_name="__main__" if main else None,
             )
     else:
-        jctx.close()
-        JacMachine.detach()
+        mach.close()
         raise ValueError("Not a valid file!\nOnly supports `.jac` and `.jir`")
 
     if ret_module:
@@ -291,17 +352,15 @@ def enter(
         if not loaded_mod:
             print("Errors occurred while importing the module.", file=sys.stderr)
         else:
-            architype = getattr(loaded_mod, entrypoint)(*args)
-
-            jctx.set_entry_node(node)
+            archetype = getattr(loaded_mod, entrypoint)(*args)
 
-            if isinstance(architype, WalkerArchitype) and Jac.check_read_access(
-                jctx.entry_node
+            mach.set_entry_node(node)
+            if isinstance(archetype, WalkerArchetype) and call_jac_func_with_machine(
+                mach, Jac.check_read_access, mach.entry_node
             ):
-                Jac.spawn_call(jctx.entry_node.architype, architype)
+                Jac.spawn(mach.entry_node.archetype, archetype)
 
-    jctx.close()
-    JacMachine.detach()
+    mach.close()
 
 
 @cmd_registry.register
@@ -314,21 +373,34 @@ def test(
     directory: str = "",
     verbose: bool = False,
 ) -> None:
-    """Run the test suite in the specified .jac file.
-
-    :param filepath: Path/to/file.jac
-    :param test_name: Run a specific test.
-    :param filter: Filter the files using Unix shell style conventions.
-    :param xit(exit): Stop(exit) running tests as soon as finds an error.
-    :param maxfail: Stop running tests after n failures.
-    :param directory: Run tests from the specified directory.
-    :param verbose: Show more info.
-
-    jac test => jac test -d .
+    """Run the test suite in the specified .jac file or directory.
+
+    Executes test functions in Jac files to verify code correctness. Tests are
+    identified by functions with names starting with 'test_'. Provides various
+    options to control test execution and reporting.
+
+    Args:
+        filepath: Path to the .jac file or directory containing tests
+        test_name: Run a specific test (without the 'test_' prefix)
+        filter: Filter test files using Unix shell style patterns
+        xit: Stop running tests as soon as an error is found
+        maxfail: Stop running tests after specified number of failures
+        directory: Run tests from the specified directory
+        verbose: Show detailed test information and results
+
+    Examples:
+        jac test                     # Run all tests in current directory
+        jac test mytest.jac          # Run all tests in mytest.jac
+        jac test --test_name my_test # Run only test_my_test
+        jac test --directory tests/  # Run all tests in tests/ directory
+        jac test --filter "*_unit_*" # Run tests matching the pattern
+        jac test --xit               # Stop on first failure
+        jac test --verbose           # Show detailed output
     """
-    jctx = ExecutionContext.create()
+    mach = JacMachine()
 
     failcount = Jac.run_test(
+        mach=mach,
         filepath=filepath,
         func_name=("test_" + test_name) if test_name else None,
         filter=filter,
@@ -338,7 +410,7 @@ def test(
         verbose=verbose,
     )
 
-    jctx.close()
+    mach.close()
 
     if failcount:
         raise SystemExit(f"Tests failed: {failcount}")
@@ -348,8 +420,19 @@ def test(
 def tool(tool: str, args: Optional[list] = None) -> None:
     """Run the specified AST tool with optional arguments.
 
-    :param tool: The name of the AST tool to run.
-    :param args: Optional arguments for the AST tool.
+    Executes specialized tools for working with Jac's Abstract Syntax Tree (AST).
+    These tools help with code analysis, transformation, and debugging.
+
+    Args:
+        tool: Name of the AST tool to run
+        args: Optional arguments to pass to the tool
+
+    Available Tools:
+        list_tools: List all available AST tools
+
+    Examples:
+        jac tool list_tools
+        jac tool <tool_name> [args...]
     """
     if hasattr(AstTool, tool):
         try:
@@ -367,29 +450,28 @@ def tool(tool: str, args: Optional[list] = None) -> None:
 
 
 @cmd_registry.register
-def clean() -> None:
-    """Remove the __jac_gen__ , __pycache__ folders.
+def debug(filename: str, main: bool = True, cache: bool = False) -> None:
+    """Debug the specified .jac file using the Python debugger.
 
-    from the current directory recursively.
-    """
-    current_dir = os.getcwd()
-    for root, dirs, _files in os.walk(current_dir, topdown=True):
-        for folder_name in dirs[:]:
-            if folder_name in [Constants.JAC_GEN_DIR, Constants.JAC_MYPY_CACHE]:
-                folder_to_remove = os.path.join(root, folder_name)
-                shutil.rmtree(folder_to_remove)
-                print(f"Removed folder: {folder_to_remove}")
-    print("Done cleaning.")
+    Runs a Jac program in debug mode, allowing you to set breakpoints, step through
+    code execution, inspect variables, and troubleshoot issues interactively.
 
+    Args:
+        filename: Path to the .jac file to debug
+        main: Treat the module as __main__ (default: True)
+        cache: Use cached compilation if available (default: False)
 
-@cmd_registry.register
-def debug(filename: str, main: bool = True, cache: bool = False) -> None:
-    """Debug the specified .jac file using pdb."""
+    Examples:
+        jac debug myprogram.jac
+
+    Note:
+        Add breakpoints in your code using the 'breakpoint()' function.
+    """
     base, mod = os.path.split(filename)
     base = base if base else "./"
     mod = mod[:-4]
     if filename.endswith(".jac"):
-        bytecode = jac_file_to_pass(filename).ir.gen.py_bytecode
+        bytecode = JacProgram().compile(filename).gen.py_bytecode
         if bytecode:
             code = marshal.loads(bytecode)
             if db.has_breakpoint(bytecode):
@@ -419,41 +501,41 @@ def dot(
     node_limit: int = 512,
     saveto: str = "",
 ) -> None:
-    """Generate and Visualize a graph based on the specified .jac file contents and parameters.
-
-    :param filename: The name of the file to generate the graph from.
-    :param initial: The initial node for graph traversal (default is root node).
-    :param depth: The maximum depth for graph traversal (-1 for unlimited depth, default is -1).
-    :param traverse: Flag to indicate whether to traverse the graph (default is False).
-    :param connection: List of node connections(edge type) to include in the graph (default is an empty list).
-    :param bfs: Flag to indicate whether to use breadth-first search for traversal (default is False).
-    :param edge_limit: The maximum number of edges allowed in the graph.
-    :param node_limit: The maximum number of nodes allowed in the graph.
-    :param saveto: Path to save the generated graph.
+    """Generate a DOT graph visualization from a Jac program.
+
+    Creates a visual representation of the node graph in a Jac program using the
+    DOT graph description language. The generated file can be visualized with
+    tools like Graphviz.
+
+    Args:
+        filename: Path to the .jac file to visualize
+        session: Optional session identifier for persistent state
+        initial: Starting node for graph traversal (default: root node)
+        depth: Maximum traversal depth (-1 for unlimited)
+        traverse: Whether to traverse the graph structure (default: False)
+        connection: List of edge types to include in the visualization
+        bfs: Use breadth-first search for traversal (default: False)
+        edge_limit: Maximum number of edges to include (default: 512)
+        node_limit: Maximum number of nodes to include (default: 512)
+        saveto: Output file path for the DOT file (default: <module_name>.dot)
+
+    Examples:
+        jac dot myprogram.jac
+        jac dot myprogram.jac --initial root_node --depth 3
+        jac dot myprogram.jac --traverse --connection edge_type1 edge_type2
+        jac dot myprogram.jac --saveto graph.dot
     """
-    if session == "":
-        session = (
-            cmd_registry.args.session
-            if hasattr(cmd_registry, "args")
-            and hasattr(cmd_registry.args, "session")
-            and cmd_registry.args.session
-            else ""
-        )
-
-    base, mod = os.path.split(filename)
-    base = base if base else "./"
-    mod = mod[:-4]
-
-    jctx = ExecutionContext.create(session=session)
+    base, mod, jac_machine = proc_file_sess(filename, session)
 
     if filename.endswith(".jac"):
-        jac_machine = JacMachine(base)
-        jac_import(target=mod, base_path=base, override_name="__main__")
+        Jac.jac_import(
+            mach=jac_machine, target=mod, base_path=base, override_name="__main__"
+        )
         module = jac_machine.loaded_modules.get("__main__")
         globals().update(vars(module))
         try:
             node = globals().get(initial, eval(initial)) if initial else None
-            graph = dotgen(
+            graph = printgraph(
                 node=node,
                 depth=depth,
                 traverse=traverse,
@@ -467,33 +549,41 @@ def dot(
             import traceback
 
             traceback.print_exc()
-            jctx.close()
+            jac_machine.close()
             return
         file_name = saveto if saveto else f"{mod}.dot"
         with open(file_name, "w") as file:
             file.write(graph)
         print(f">>> Graph content saved to {os.path.join(os.getcwd(), file_name)}")
+        jac_machine.close()
     else:
         print("Not a .jac file.", file=sys.stderr)
 
-    jctx.close()
-
 
 @cmd_registry.register
 def py2jac(filename: str) -> None:
-    """Convert a Python file to Jac.
+    """Convert a Python file to Jac code.
+
+    Translates Python source code to equivalent Jac code, helping with migration
+    from Python to Jac. The conversion handles basic syntax and structures but
+    may require manual adjustments for complex code.
 
-    :param filename: The path to the .py file.
+    Args:
+        filename: Path to the .py file to convert
+
+    Examples:
+        jac py2jac myscript.py > converted.jac
     """
     if filename.endswith(".py"):
         with open(filename, "r") as f:
             file_source = f.read()
             code = PyastBuildPass(
-                input_ir=ast.PythonModuleAst(
+                ir_in=uni.PythonModuleAst(
                     ast3.parse(file_source),
-                    orig_src=ast.JacSource(file_source, filename),
+                    orig_src=uni.Source(file_source, filename),
                 ),
-            ).ir.unparse()
+                prog=JacProgram(),
+            ).ir_out.unparse()
         print(code)
     else:
         print("Not a .py file.")
@@ -501,13 +591,21 @@ def py2jac(filename: str) -> None:
 
 @cmd_registry.register
 def jac2py(filename: str) -> None:
-    """Convert a Jac file to Python.
+    """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.
+
+    Args:
+        filename: Path to the .jac file to convert
 
-    :param filename: The path to the .jac file.
+    Examples:
+        jac jac2py myprogram.jac > converted.py
     """
     if filename.endswith(".jac"):
         with open(filename, "r"):
-            code = jac_file_to_pass(file_path=filename).ir.gen.py
+            code = JacProgram().compile(file_path=filename).gen.py
         print(code)
     else:
         print("Not a .jac file.", file=sys.stderr)
@@ -527,6 +625,7 @@ def start_cli() -> None:
     if args.version:
         version = importlib.metadata.version("jaclang")
         print(f"Jac version {version}")
+        print("Jac path:", __file__)
         return
 
     command = cmd_registry.get(args.command)