machineconfig 8.51__py3-none-any.whl → 8.61__py3-none-any.whl

machineconfig/scripts/python/helpers/helpers_sessions/sessions_impl.py

@@ -1,63 +1,37 @@
 """Pure Python implementations for sessions commands - no typer dependencies."""
 
-from typing import Optional, Literal
+from typing import Literal
 from pathlib import Path
 
 
-def balance_load(
-    layout_path: str,
-    max_thresh: int,
-    thresh_type: Literal["number", "n", "weight", "w"],
-    breaking_method: Literal["moreLayouts", "ml", "combineTabs", "ct"],
-    output_path: Optional[str],
-) -> None:
-    """Adjust layout file to limit max tabs per layout, etc."""
-    thresh_type_resolved: dict[str, Literal["number", "weight"]] = {"number": "number", "n": "number", "weight": "weight", "w": "weight"}
-    breaking_method_resolved: dict[str, Literal["moreLayouts", "combineTabs"]] = {"moreLayouts": "moreLayouts", "ml": "moreLayouts", "combineTabs": "combineTabs", "ct": "combineTabs"}
-
-    layout_path_obj = Path(layout_path).expanduser().absolute()
-
-    from machineconfig.utils.schemas.layouts.layout_types import LayoutsFile
-    import json
-    layoutfile: LayoutsFile = json.loads(layout_path_obj.read_text())
-    layout_configs = layoutfile["layouts"]
-    from machineconfig.cluster.sessions_managers.utils.load_balancer import limit_tab_num
-    new_layouts = limit_tab_num(layout_configs=layout_configs, max_thresh=max_thresh, threshold_type=thresh_type_resolved[thresh_type], breaking_method=breaking_method_resolved[breaking_method])
-    layoutfile["layouts"] = new_layouts
-    target_file = Path(output_path) if output_path is not None else layout_path_obj.parent / f"{layout_path_obj.stem}_adjusted_{max_thresh}_{thresh_type}_{breaking_method}.json"
-    target_file.parent.mkdir(parents=True, exist_ok=True)
-    target_file.write_text(data=json.dumps(layoutfile, indent=4), encoding="utf-8")
-    print(f"Adjusted layout saved to {target_file}")
-
-
-def select_layout(layouts_json_file: str, selected_layouts_names: Optional[list[str]], select_interactively: bool, subsitute_home: bool) -> list["LayoutConfig"]:  # type: ignore[name-defined]
+def select_layout(layouts_json_file: str, selected_layouts_names: list[str], select_interactively: bool) -> list["LayoutConfig"]:
     """Select layout(s) from a layout file."""
     import json
-    from machineconfig.utils.schemas.layouts.layout_types import LayoutsFile, LayoutConfig
+    from machineconfig.utils.schemas.layouts.layout_types import LayoutsFile
     json_str = Path(layouts_json_file).read_text(encoding="utf-8")
-    if subsitute_home:
-        json_str = json_str.replace("~", str(Path.home())).replace("$HOME", str(Path.home()))
-        json_str = json_str.replace("""Command": "f """, """Command": "~/.config/machineconfig/scripts/wrap_mcfg fire """)
-        json_str = json_str.replace("""Command": "s """, """Command": "~/.config/machineconfig/scripts/wrap_mcfg sessions """)
-
     try:
-        # src/machineconfig/utils/io.py
         layout_file: LayoutsFile = json.loads(json_str)
     except Exception:
         print(f"Failed to parse the json file {layouts_json_file}, trying to clean the comments and giving it another shot ... ")
         from machineconfig.utils.io import remove_c_style_comments
         json_str = remove_c_style_comments(json_str)
-        # print(json_str)
         layout_file: LayoutsFile = json.loads(json_str)
-
     if len(layout_file["layouts"]) == 0:
         raise ValueError(f"No layouts found in {layouts_json_file}")
-    if selected_layouts_names is None:
+    if len(selected_layouts_names) == 0:
         if not select_interactively:
             return layout_file["layouts"]
-        options = [layout["layoutName"] for layout in layout_file["layouts"]]
-        from machineconfig.utils.options import choose_from_options
-        selected_layouts_names = choose_from_options(multi=True, options=options, prompt="Choose a layout configuration:", tv=True, msg="Choose one option")
+        # options = [layout["layoutName"] for layout in layout_file["layouts"]]
+        # from machineconfig.utils.options import choose_from_options
+        # selected_layouts_names = choose_from_options(multi=True, options=options, prompt="Choose a layout configuration:", tv=True, msg="Choose one option")
+        from machineconfig.utils.options_utils.tv_options import choose_from_dict_with_preview
+        selected_layouts_names = choose_from_dict_with_preview(
+            {layout["layoutName"]: json.dumps(layout, indent=4) for layout in layout_file["layouts"]},
+            extension="json",
+            multi=True,
+            preview_size_percent=40,
+        )
+
     print(f"Selected layout(s): {selected_layouts_names}")
     layouts_chosen: list[LayoutConfig] = []
     for name in selected_layouts_names:
@@ -70,7 +44,6 @@ def select_layout(layouts_json_file: str, selected_layouts_names: Optional[list[
         layouts_chosen.append(layout_chosen)
     return layouts_chosen
 
-
 def find_layout_file(layout_path: str) -> str:
     """Find layout file from a path."""
     from machineconfig.utils.path_helper import search_for_files_of_interest, match_file_name, sanitize_path
@@ -90,97 +63,52 @@ def find_layout_file(layout_path: str) -> str:
 
 
 def run_layouts(
-    layout_path: Optional[str],
-    max_tabs: int,
-    max_layouts: int,
     sleep_inbetween: float,
     monitor: bool,
-    parallel: bool,
+    sequential: bool,
     kill_upon_completion: bool,
-    choose: Optional[str],
-    choose_interactively: bool,
-    subsitute_home: bool,
+    backend: Literal["zellij", "windows-terminal"],
+    layouts_selected: list["LayoutConfig"],
 ) -> None:
     """Launch terminal sessions based on a layout configuration file."""
-    if layout_path is None:
-        raise ValueError("layout_path is required")
-
-    layout_path_resolved = find_layout_file(layout_path=layout_path)
-    layouts_selected = select_layout(layouts_json_file=layout_path_resolved, selected_layouts_names=choose.split(",") if choose else None, select_interactively=choose_interactively, subsitute_home=subsitute_home)
-
-    if parallel and len(layouts_selected) > max_layouts:
-        raise ValueError(f"Number of layouts {len(layouts_selected)} exceeds the maximum allowed {max_layouts}. Please adjust your layout file.")
-    for a_layout in layouts_selected:
-        if len(a_layout["layoutTabs"]) > max_tabs:
-            raise ValueError(f"Layout '{a_layout.get('layoutName', 'Unnamed')}' has {len(a_layout['layoutTabs'])} tabs which exceeds the max of {max_tabs}.")
-
     import time
-    import platform
-    if platform.system() == "Linux" or platform.system() == "Darwin":
-        from machineconfig.cluster.sessions_managers.zellij_local_manager import ZellijLocalManager
-        if not parallel:
-            iterable = [[item] for item in layouts_selected]
-        else:
-            iterable = [layouts_selected]
-        for i, a_layouts in enumerate(iterable):
-            manager = ZellijLocalManager(session_layouts=a_layouts)
-            manager.start_all_sessions(poll_interval=2, poll_seconds=2)
-            if monitor:
-                manager.run_monitoring_routine(wait_ms=2000)
-                if kill_upon_completion:
-                    manager.kill_all_sessions()
-            if i < len(layouts_selected) - 1:
-                time.sleep(sleep_inbetween)
-    elif platform.system() == "Windows":
-        from machineconfig.cluster.sessions_managers.wt_local_manager import WTLocalManager
-        if not parallel:
-            iterable = [[item] for item in layouts_selected]
-        else:
+    match backend:
+        case "zellij":
+            from machineconfig.cluster.sessions_managers.zellij_local_manager import ZellijLocalManager
+            if sequential:
+                iterable: list[list[LayoutConfig]] = [[item] for item in layouts_selected]
+            else:
+                iterable = [layouts_selected]
+            for i, a_layouts in enumerate(iterable):
+                manager = ZellijLocalManager(session_layouts=a_layouts)
+                manager.start_all_sessions(poll_interval=2, poll_seconds=2)
+                if monitor:
+                    manager.run_monitoring_routine(wait_ms=2000)
+                    if kill_upon_completion:
+                        manager.kill_all_sessions()
+                if i < len(layouts_selected) - 1:
+                    time.sleep(sleep_inbetween)
+        case "windows-terminal":
+            if sequential:
+                from machineconfig.cluster.sessions_managers.wt_local import run_wt_layout
+                for a_layout in layouts_selected:
+                    run_wt_layout(layout_config=a_layout)
+                return
             iterable = [layouts_selected]
-        for i, a_layouts in enumerate(iterable):
-            manager = WTLocalManager(session_layouts=a_layouts)
-            manager.start_all_sessions()
-            if monitor:
-                manager.run_monitoring_routine(wait_ms=2000)
-                if kill_upon_completion:
-                    manager.kill_all_sessions()
-            if i < len(layouts_selected) - 1:
-                time.sleep(sleep_inbetween)
-    else:
-        print(f"❌ Unsupported platform: {platform.system()}")
-
-
-def create_template(name: Optional[str], num_tabs: int) -> None:
-    """Create a layout template file."""
-    from machineconfig.utils.schemas.layouts.layout_types import LayoutsFile, TabConfig, LayoutConfig
-    tabs: list[TabConfig] = []
-    for i in range(1, num_tabs + 1):
-        tab: TabConfig = {
-            "tabName": f"Tab{i}",
-            "startDir": "~/" + str(Path.cwd().relative_to(Path.home())),
-            "command": "bash",
-        }
-        tabs.append(tab)
-    layouts: list[LayoutConfig] = [
-        {
-            "layoutName": f"{Path.cwd().name}Layout",
-            "layoutTabs": tabs,
-        }
-    ]
-    file: LayoutsFile = {
-        "$schema": "https://bit.ly/cfglayout",  # type: ignore
-        "version": "0.1",
-        "layouts": layouts,
-    }
-    import json
-    json_string = json.dumps(file, indent=4)
-    if name is None:
-        layout_path = Path.cwd() / "layout.json"
-    else:
-        layout_path = Path.cwd() / (name.replace(".json", "") + ".json")
-    layout_path.parent.mkdir(parents=True, exist_ok=True)
-    if layout_path.exists():
-        print(f"❌ File {layout_path} already exists. Aborting to avoid overwriting.")
-        return
-    layout_path.write_text(json_string, encoding="utf-8")
-    print(f"✅ Created layout template at {layout_path}")
+            from machineconfig.cluster.sessions_managers.wt_local_manager import WTLocalManager
+            for i, a_layouts in enumerate(iterable):
+                manager = WTLocalManager(session_layouts=a_layouts)
+                manager.start_all_sessions()
+                if monitor:
+                    manager.run_monitoring_routine(wait_ms=2000)
+                    if kill_upon_completion:
+                        manager.kill_all_sessions()
+                if i < len(layouts_selected) - 1:
+                    time.sleep(sleep_inbetween)
+        case _:
+            raise ValueError(f"Unsupported backend: {backend}")
+
+
+if __name__ == "__main__":
+    from machineconfig.utils.schemas.layouts.layout_types import LayoutConfig
+    _ = LayoutConfig

machineconfig/scripts/python/helpers/helpers_sessions/utils.py

@@ -0,0 +1,69 @@
+from pathlib import Path
+from typing import Literal, Optional
+
+
+def balance_load(
+    layout_path: str,
+    max_thresh: int,
+    thresh_type: Literal["number", "n", "weight", "w"],
+    breaking_method: Literal["moreLayouts", "ml", "combineTabs", "ct"],
+    output_path: Optional[str],
+) -> None:
+    """Adjust layout file to limit max tabs per layout, etc."""
+    thresh_type_resolved: dict[str, Literal["number", "weight"]] = {"number": "number", "n": "number", "weight": "weight", "w": "weight"}
+    breaking_method_resolved: dict[str, Literal["moreLayouts", "combineTabs"]] = {"moreLayouts": "moreLayouts", "ml": "moreLayouts", "combineTabs": "combineTabs", "ct": "combineTabs"}
+
+    layout_path_obj = Path(layout_path).expanduser().absolute()
+
+    from machineconfig.utils.schemas.layouts.layout_types import LayoutsFile
+    import json
+    layoutfile: LayoutsFile = json.loads(layout_path_obj.read_text())
+    layout_configs = layoutfile["layouts"]
+    from machineconfig.cluster.sessions_managers.utils.load_balancer import limit_tab_num
+    new_layouts = limit_tab_num(layout_configs=layout_configs, max_thresh=max_thresh, threshold_type=thresh_type_resolved[thresh_type], breaking_method=breaking_method_resolved[breaking_method])
+    layoutfile["layouts"] = new_layouts
+    target_file = Path(output_path) if output_path is not None else layout_path_obj.parent / f"{layout_path_obj.stem}_adjusted_{max_thresh}_{thresh_type}_{breaking_method}.json"
+    target_file.parent.mkdir(parents=True, exist_ok=True)
+    target_file.write_text(data=json.dumps(layoutfile, indent=4), encoding="utf-8")
+    print(f"Adjusted layout saved to {target_file}")
+
+
+def create_template(name: Optional[str], num_tabs: int) -> None:
+    """Create a layout template file."""
+    from machineconfig.utils.schemas.layouts.layout_types import LayoutsFile, TabConfig, LayoutConfig
+    tabs: list[TabConfig] = []
+    import platform
+    if platform.system().lower() == "windows":
+        default_command = "powershell"
+    else:
+        default_command = "bash"
+    for i in range(1, num_tabs + 1):
+        tab: TabConfig = {
+            "tabName": f"Tab{i}",
+            "startDir": "~/" + str(Path.cwd().relative_to(Path.home())),
+            "command": default_command,
+        }
+        tabs.append(tab)
+    layouts: list[LayoutConfig] = [
+        {
+            "layoutName": f"{Path.cwd().name}Layout",
+            "layoutTabs": tabs,
+        }
+    ]
+    file: LayoutsFile = {
+        "$schema": "https://bit.ly/cfglayout",  # type: ignore
+        "version": "0.1",
+        "layouts": layouts,
+    }
+    import json
+    json_string = json.dumps(file, indent=4)
+    if name is None:
+        layout_path = Path.cwd() / "layout.json"
+    else:
+        layout_path = Path.cwd() / (name.replace(".json", "") + ".json")
+    layout_path.parent.mkdir(parents=True, exist_ok=True)
+    if layout_path.exists():
+        print(f"❌ File {layout_path} already exists. Aborting to avoid overwriting.")
+        return
+    layout_path.write_text(json_string, encoding="utf-8")
+    print(f"✅ Created layout template at {layout_path}")

machineconfig/scripts/python/mcfg_entry.py

@@ -100,11 +100,6 @@ def utils(ctx: typer.Context) -> None:
     get_app()(ctx.args, standalone_mode=not ctx.args)
 
 
-def terminal(ctx: typer.Context) -> None:
-    """[t] Terminal management commands."""
-    from machineconfig.scripts.python.terminal import get_app
-    get_app()(ctx.args, standalone_mode=not ctx.args)
-
 
 def get_app() -> typer.Typer:
     app = typer.Typer(help="MachineConfig CLI - Manage your machine configurations and workflows", no_args_is_help=True, add_help_option=True, add_completion=False)
@@ -121,8 +116,6 @@ def get_app() -> typer.Typer:
     app.command(name="a", hidden=True, context_settings=ctx_settings)(agents)
     app.command(name="utils", help="[u] Utility commands", context_settings=ctx_settings)(utils)
     app.command(name="u", hidden=True, context_settings=ctx_settings)(utils)
-    app.command(name="terminal", help="[t] Terminal management commands", context_settings=ctx_settings)(terminal)
-    app.command(name="t", hidden=True, context_settings=ctx_settings)(terminal)
 
     app.command(name="fire", help="[f] Fire and manage jobs", no_args_is_help=False, context_settings={"allow_extra_args": True, "allow_interspersed_args": False})(fire)
     app.command(name="f", hidden=True, no_args_is_help=False, context_settings={"allow_extra_args": True, "allow_interspersed_args": False})(fire)

machineconfig/scripts/python/sessions.py

@@ -12,44 +12,122 @@ def balance_load(
     output_path: Annotated[Optional[str], typer.Option(..., "--output-path", "-o", help="Path to write the adjusted layout.json file")] = None,
 ) -> None:
     """Adjust layout file to limit max tabs per layout, etc."""
-    from machineconfig.scripts.python.helpers.helpers_sessions.sessions_impl import balance_load as impl
+    from machineconfig.scripts.python.helpers.helpers_sessions.utils import balance_load as impl
     impl(layout_path=layout_path, max_thresh=max_thresh, thresh_type=thresh_type, breaking_method=breaking_method, output_path=output_path)
 
 
 def run(
     ctx: typer.Context,
-    layout_path: Annotated[Optional[str], typer.Argument(..., help="Path to the layout.json file")] = None,
+    layouts_file: Annotated[Optional[str], typer.Option(..., "--layouts-file", "-f", help="Path to the layout.json file")] = None,
+    choose: Annotated[Optional[str], typer.Option(..., "--choose", "-c", help="Comma separated names of layouts to be selected from the layout file passed")] = None,
+    choose_interactively: Annotated[bool, typer.Option(..., "--choose-interactively", "-i", help="Select layouts interactively")] = False,
+
     sleep_inbetween: Annotated[float, typer.Option(..., "--sleep-inbetween", "-si", help="Sleep time in seconds between launching layouts")] = 1.0,
     monitor: Annotated[bool, typer.Option(..., "--monitor", "-m", help="Monitor the layout sessions for completion")] = False,
-    parallel: Annotated[bool, typer.Option(..., "--parallel", "-p", help="Launch multiple layouts in parallel")] = False,
+    sequential: Annotated[bool, typer.Option(..., "--sequential", "-s", help="Launch layouts sequentially")] = False,
     kill_upon_completion: Annotated[bool, typer.Option(..., "--kill-upon-completion", "-k", help="Kill session(s) upon completion (only relevant if monitor flag is set)")] = False,
-    choose: Annotated[Optional[str], typer.Option(..., "--choose", "-c", help="Comma separated names of layouts to be selected from the layout file passed")] = None,
-    choose_interactively: Annotated[bool, typer.Option(..., "--choose-interactively", "-i", help="Select layouts interactively")] = False,
     subsitute_home: Annotated[bool, typer.Option(..., "--substitute-home", "-sh", help="Substitute ~ and $HOME in layout file with actual home directory path")] = False,
     max_tabs: Annotated[int, typer.Option(..., "--max-tabs", "-mt", help="A Sanity checker that throws an error if any layout exceeds the maximum number of tabs to launch.")] = 25,
     max_layouts: Annotated[int, typer.Option(..., "--max-layouts", "-ml", help="A Sanity checker that throws an error if the total number of *parallel layouts exceeds this number.")] = 25,
+    backend: Annotated[Literal["zellij", "z", "windows-terminal", "wt", "auto", "a"], typer.Option(..., "--backend", "-b", help="Backend terminal multiplexer or emulator to use")] = "auto",
 ) -> None:
     """Launch terminal sessions based on a layout configuration file."""
-    if layout_path is None:
+    from machineconfig.scripts.python.helpers.helpers_sessions.sessions_impl import run_layouts, find_layout_file, select_layout
+
+    from pathlib import Path
+    if layouts_file is not None:
+        layouts_file_resolved = Path(find_layout_file(layout_path=layouts_file))
+    else:
+        layouts_file_resolved = Path.home().joinpath("dotfiles/machineconfig/layouts.json")
+    if not layouts_file_resolved.exists():
         typer.echo(ctx.get_help())
-        raise typer.Exit()
-    from machineconfig.scripts.python.helpers.helpers_sessions.sessions_impl import run_layouts
+        typer.echo(f"❌ Layouts file not found: {layouts_file_resolved}", err=True)
+        raise typer.Exit(code=1)
+
+    if choose is None: layouts_names_resolved: list[str] = []
+    else: layouts_names_resolved = [name.strip() for name in choose.split(",") if name.strip()]
+    layouts_selected = select_layout(layouts_json_file=str(layouts_file_resolved), selected_layouts_names=layouts_names_resolved,
+                    select_interactively=choose_interactively,)
+    if subsitute_home:
+        from machineconfig.utils.schemas.layouts.layout_types import substitute_home, LayoutConfig
+        layouts_modified: list["LayoutConfig"] = []
+        for a_layout in layouts_selected:
+            a_layout["layoutTabs"] = substitute_home(tabs=a_layout["layoutTabs"])
+            layouts_modified.append(a_layout)
+        layouts_selected = layouts_modified
+
+    import platform
+    backend_resolved: Literal["zellij", "windows-terminal"]
+    match backend:
+        case "windows-terminal" | "wt":
+            if platform.system().lower() != "windows":
+                typer.echo("Error: Windows Terminal layouts can only be started on Windows systems.", err=True)
+                raise typer.Exit(code=1)
+            backend_resolved = "windows-terminal"
+        case "zellij" | "z":
+            if platform.system().lower() == "windows":
+                typer.echo("Error: Zellij is not supported on Windows.", err=True)
+                raise typer.Exit(code=1)
+            backend_resolved = "zellij"
+        case "auto" | "a":
+            if platform.system().lower() == "windows":
+                backend_resolved = "windows-terminal"
+            else:
+                backend_resolved = "zellij"
+        case _:
+            typer.echo(f"Error: Unsupported backend '{backend}'.", err=True)
+            raise typer.Exit(code=1)
+
+    if not sequential and len(layouts_selected) > max_layouts:
+        raise ValueError(f"Number of layouts {len(layouts_selected)} exceeds the maximum allowed {max_layouts}. Please adjust your layout file.")
+    for a_layout in layouts_selected:
+        if len(a_layout["layoutTabs"]) > max_tabs:
+            raise ValueError(f"Layout '{a_layout.get('layoutName', 'Unnamed')}' has {len(a_layout['layoutTabs'])} tabs which exceeds the max of {max_tabs}.")
+
     try:
-        run_layouts(layout_path=layout_path, max_tabs=max_tabs, max_layouts=max_layouts, sleep_inbetween=sleep_inbetween, monitor=monitor, parallel=parallel, kill_upon_completion=kill_upon_completion, choose=choose, choose_interactively=choose_interactively, subsitute_home=subsitute_home)
+        run_layouts(
+        sleep_inbetween=sleep_inbetween, monitor=monitor, sequential=sequential, kill_upon_completion=kill_upon_completion,
+        layouts_selected=layouts_selected,
+        backend=backend_resolved)
     except ValueError as e:
         typer.echo(str(e))
         raise typer.Exit(1) from e
 
 
+def attach_to_session(
+        name: Annotated[str | None, typer.Argument(help="Name of the Zellij session to attach to. If not provided, a list will be shown to choose from.")] = None,
+        new_session: Annotated[bool, typer.Option("--new-session", "-n", help="Create a new Zellij session instead of attaching to an existing one.", show_default=True)] = False,
+        kill_all: Annotated[bool, typer.Option("--kill-all", "-k", help="Kill all existing Zellij sessions before creating a new one.", show_default=True)] = False) -> None:
+    """Choose a Zellij session to attach to."""
+    import platform
+    if platform.system().lower() == "windows":
+        typer.echo("Error: Zellij is not supported on Windows.", err=True, color=True)
+        raise typer.Exit()
+    from machineconfig.scripts.python.helpers.helpers_sessions.attach_impl import choose_zellij_session as impl
+    action, payload = impl(name=name, new_session=new_session, kill_all=kill_all)
+    if action == "error":
+        typer.echo(payload, err=True, color=True)
+        raise typer.Exit()
+    if action == "run_script" and payload:
+        from machineconfig.utils.code import exit_then_run_shell_script
+        exit_then_run_shell_script(script= payload, strict=True)
+
+
+
+def get_session_tabs() -> list[tuple[str, str]]:
+    """Get all Zellij session tabs."""
+    from machineconfig.scripts.python.helpers.helpers_sessions.attach_impl import get_session_tabs as impl
+    result = impl()
+    print(result)
+    return result
 def create_template(
     name: Annotated[Optional[str], typer.Argument(..., help="Name of the layout template to create")] = None,
     num_tabs: Annotated[int, typer.Option(..., "--num-tabs", "-t", help="Number of tabs to include in the template")] = 3,
 ) -> None:
     """Create a layout template file."""
-    from machineconfig.scripts.python.helpers.helpers_sessions.sessions_impl import create_template as impl
+    from machineconfig.scripts.python.helpers.helpers_sessions.utils import create_template as impl
     impl(name=name, num_tabs=num_tabs)
 
-
 def create_from_function(
     num_process: Annotated[int, typer.Option(..., "--num-process", "-n", help="Number of parallel processes to run")],
     path: Annotated[str, typer.Option(..., "--path", "-p", help="Path to a Python or Shell script file or a directory containing such files")] = ".",
@@ -63,12 +141,15 @@ def create_from_function(
 def get_app() -> typer.Typer:
     layouts_app = typer.Typer(help="Layouts management subcommands", no_args_is_help=True, add_help_option=True, add_completion=False)
 
-    layouts_app.command("create-from-function", no_args_is_help=True, short_help="[c] Create a layout from a function")(create_from_function)
-    layouts_app.command("c", no_args_is_help=True, hidden=True)(create_from_function)
-
     layouts_app.command("run", no_args_is_help=True, help=run.__doc__, short_help="[r] Run the selected layout(s)")(run)
     layouts_app.command("r", no_args_is_help=True, help=run.__doc__, hidden=True)(run)
 
+    layouts_app.command("attach", no_args_is_help=False, help=attach_to_session.__doc__, short_help="[a] Attach to a Zellij session")(attach_to_session)
+    layouts_app.command("a", no_args_is_help=False, help=attach_to_session.__doc__, hidden=True)(attach_to_session)
+
+    layouts_app.command("create-from-function", no_args_is_help=True, short_help="[c] Create a layout from a function")(create_from_function)
+    layouts_app.command("c", no_args_is_help=True, hidden=True)(create_from_function)
+
     layouts_app.command("balance-load", no_args_is_help=True, help=balance_load.__doc__, short_help="[b] Balance the load across sessions")(balance_load)
     layouts_app.command("b", no_args_is_help=True, help=balance_load.__doc__, hidden=True)(balance_load)
 

machineconfig/scripts/python/utils.py

@@ -6,9 +6,10 @@ from typing import Annotated, Optional, Literal
 
 def kill_process(interactive: Annotated[bool, typer.Option(..., "--interactive", "-i", help="Interactively choose the process to kill")] = True) -> None:
     """⚔️ Choose a process to kill."""
-    from machineconfig.utils.procs import main, ProcessManager
+    from machineconfig.utils.procs import ProcessManager
     if interactive:
-        main()
+        proc = ProcessManager()
+        proc.choose_and_kill()
         return
     _ = ProcessManager
 

machineconfig/settings/shells/bash/init.sh

@@ -56,7 +56,6 @@ alias fx='wrap_in_shell_script ftpx'
 alias f='wrap_in_shell_script fire'
 alias r='wrap_in_shell_script croshell'
 alias u='wrap_in_shell_script utils'
-alias t='wrap_in_shell_script terminal'
 alias ms='wrap_in_shell_script msearch'
 alias x='wrap_in_shell_script explore'
 
@@ -73,12 +72,6 @@ alias x='wrap_in_shell_script explore'
 #   gh copilot explain "Input command is: $x The output is this: $y"
 # }
 
-# 📦 Node Version Manager
-# export NVM_DIR="$HOME/.nvm"
-# [ -s "$NVM_DIR/nvm.sh" ] && \. "$NVM_DIR/nvm.sh"  # This loads nvm
-# [ -s "$NVM_DIR/bash_completion" ] && \. "$NVM_DIR/bash_completion"  # This loads nvm bash_completion
-
-
 # https://github.com/atuinsh/atuin
 # eval "$(atuin init bash)"
 

machineconfig/settings/shells/pwsh/init.ps1

@@ -40,12 +40,11 @@ if (Test-Path "$CONFIG_ROOT\scripts\wrap_mcfg.ps1") {
     function d { wrap_in_shell_script devops $args }
     function c { wrap_in_shell_script cloud $args }
     function a { wrap_in_shell_script agents $args }
-    function sx { wrap_in_shell_script sessions $args }
     function fx { wrap_in_shell_script ftpx $args }
+    function s { wrap_in_shell_script sessions $args }
     function f { wrap_in_shell_script fire $args }
     function rr { wrap_in_shell_script croshell $args }
     function u { wrap_in_shell_script utils $args }
-    function t { wrap_in_shell_script terminal $args }
     function ms { wrap_in_shell_script msearch $args }
 
 }
@@ -56,12 +55,11 @@ else {
     function d { devops $args }
     function c { cloud $args }
     function a { agents $args }
-    function sx { sessions $args }
+    function s { sessions $args }
     function fx { ftpx $args }
     function f { fire $args }
     function rr { croshell $args }
     function u { utils $args }
-    function t { terminal $args }
     function ms { msearch $args }
 }
 

machineconfig/settings/shells/wezterm/wezterm.lua

@@ -157,6 +157,7 @@ config.inactive_pane_hsb = {
   }
 
 -- config.ime_preedit_rendering = 'System'
+config.enable_tab_bar = false
 config.hide_tab_bar_if_only_one_tab = true
 config.use_fancy_tab_bar = false
 config.show_tabs_in_tab_bar = true

machineconfig/settings/shells/wt/settings.json

@@ -6,8 +6,7 @@
     "copyOnSelect": true,
     "defaultProfile": "{574e775e-4f2a-5b96-ac1e-a2962a402336}",
     "focusFollowMouse": true,
-    "keybindings": 
-    [
+    "keybindings": [
         {
             "id": "Terminal.FindText",
             "keys": "ctrl+shift+f"
@@ -38,28 +37,26 @@
         }
     ],
     "launchMode": "fullscreen",
-    "newTabMenu": 
-    [
+    "newTabMenu": [
         {
             "type": "remainingProfiles"
         }
     ],
-    "profiles": 
-    {
-        "defaults": 
-        {
+    "profiles": {
+        "defaults": {
             "colorScheme": "Campbell (modified)",
             "padding": "0",
-            "useAcrylic": false
+            "useAcrylic": false,
+            "font": {
+                "face": "CaskaydiaCove Nerd Font"
+            }
         },
-        "list": 
-        [
+        "list": [
             {
                 "commandline": "C:\\Program Files\\PowerShell\\7\\pwsh.exe",
                 "cursorColor": "#D4D8E1",
                 "cursorShape": "filledBox",
-                "font": 
-                {
+                "font": {
                     "face": "CaskaydiaCove Nerd Font"
                 },
                 "guid": "{574e775e-4f2a-5b96-ac1e-a2962a402336}",
@@ -71,8 +68,7 @@
             },
             {
                 "commandline": "%SystemRoot%\\System32\\WindowsPowerShell\\v1.0\\powershell.exe",
-                "font": 
-                {
+                "font": {
                     "face": "CaskaydiaCove Nerd Font"
                 },
                 "guid": "{61c54bbd-c2c6-5271-96e7-009a87ff44bf}",
@@ -93,8 +89,7 @@
             },
             {
                 "commandline": "nu.exe",
-                "font": 
-                {
+                "font": {
                     "face": "CaskaydiaCove Nerd Font"
                 },
                 "guid": "{4b9d9cef-cb7d-4a8c-8b08-0de52621c3ff}",
@@ -157,8 +152,7 @@
             }
         ]
     },
-    "schemes": 
-    [
+    "schemes": [
         {
             "background": "#000000",
             "black": "#000000",

machineconfig/settings/shells/zsh/init.sh

@@ -59,7 +59,6 @@ alias fx='wrap_in_shell_script ftpx'
 alias f='wrap_in_shell_script fire'
 alias r='wrap_in_shell_script croshell'
 alias u='wrap_in_shell_script utils'
-alias t='wrap_in_shell_script terminal'
 alias ms='wrap_in_shell_script msearch'
 alias x='. $CONFIG_ROOT/scripts/wrap_mcfg explore'