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

machineconfig/scripts/python/{helpers_repos → helpers/helpers_repos}/record.py

@@ -3,7 +3,6 @@ from pathlib import Path
 from machineconfig.utils.schemas.repos.repos_types import GitVersionInfo, RepoRecordDict, RepoRemote
 
 from machineconfig.utils.schemas.repos.repos_types import RepoRecordFile
-from machineconfig.utils.source_of_truth import CONFIG_ROOT
 from machineconfig.utils.io import save_json
 
 from typing import Optional
@@ -12,7 +11,7 @@ from rich import print as pprint
 from rich.progress import Progress, TaskID, SpinnerColumn, TextColumn, BarColumn, TimeElapsedColumn, MofNCompleteColumn
 
 
-def build_tree_structure(repos: list[RepoRecordDict], repos_root: PathExtended) -> str:
+def build_tree_structure(repos: list[RepoRecordDict], repos_root: Path) -> str:
     """Build a tree structure representation of all repositories."""
     if not repos:
         return "No repositories found."
@@ -186,10 +185,18 @@ def record_repos_recursively(repos_root: str, r: bool, progress: Progress | None
     return res
 
 
-def main_record(repos_root: Path):
-    print("\n📝 Recording repositories...")
-    repos_root = PathExtended(repos_root).expanduser().absolute()
+def _resolve_directory(directory: Optional[str]) -> Path:
+    import typer
+    if directory is None:
+        directory = Path.cwd().as_posix()
+        typer.echo(f"📁 Using directory: {directory}")
+    return Path(directory).expanduser().absolute().resolve()
+
 
+def main_record(repos_root_str: Optional[str]) -> Path:
+    print("\n📝 Recording repositories...")
+    repos_root = _resolve_directory(directory=repos_root_str)
+    
     # Count total directories and repositories for accurate progress tracking
     print("🔍 Analyzing directory structure...")
     total_dirs = count_total_directories(str(repos_root), r=True)
@@ -222,7 +229,7 @@ def main_record(repos_root: Path):
     if repos_with_no_remotes:
         print(f"\n⚠️  WARNING: {len(repos_with_no_remotes)} repositories have no remotes configured:")
         for repo in repos_with_no_remotes:
-            repo_path = PathExtended(repo["parentDir"]).joinpath(repo["name"])
+            repo_path = Path(repo["parentDir"]).joinpath(repo["name"])
             print(f"   • {repo['name']} ({repo_path})")
         print("   These repositories may be local-only or have configuration issues.")
     else:
@@ -231,7 +238,7 @@ def main_record(repos_root: Path):
     if dirty_repos:
         print(f"\n⚠️  WARNING: {len(dirty_repos)} repositories have uncommitted changes:")
         for repo in dirty_repos:
-            repo_path = PathExtended(repo["parentDir"]).joinpath(repo["name"])
+            repo_path = Path(repo["parentDir"]).joinpath(repo["name"])
             print(f"   • {repo['name']} ({repo_path}) [branch: {repo['currentBranch']}]")
         print("   These repositories have uncommitted changes that may need attention.")
     else:
@@ -239,12 +246,25 @@ def main_record(repos_root: Path):
 
     # Display repository tree structure
     print("\n🌳 Repository Tree Structure:")
-    tree_structure = build_tree_structure(repo_records, repos_root)
+    tree_structure = build_tree_structure(repos=repo_records, repos_root=repos_root)
     print(tree_structure)
 
-    relative_repos_root = PathExtended(repos_root).expanduser().absolute().relative_to(Path.home())
-    save_path = CONFIG_ROOT.joinpath("repos").joinpath(relative_repos_root).joinpath("repos.json")
-    save_json(obj=res, path=save_path, indent=4)
-    pprint(f"📁 Result saved at {PathExtended(save_path)}")
+    spec_path_default = Path(repos_root).expanduser().absolute().joinpath("repos.json")
+    from machineconfig.scripts.python.helpers.helpers_devops.cli_config_dotfile import get_backup_path, record_mapping
+    spec_path_self_managed = get_backup_path(
+        orig_path=spec_path_default,
+        sensitivity="private",
+        destination=None,
+        shared=False,
+    )
+    save_json(obj=res, path=spec_path_self_managed, indent=4)
+    pprint(f"📁 Result saved at {PathExtended(spec_path_self_managed)}")
+
+    # record_mapping(
+    #     orig_path=spec_path_default,
+
+    # )
+    _ = record_mapping
+
     print(">>>>>>>>> Finished Recording")
-    return save_path
+    return spec_path_self_managed

machineconfig/scripts/python/{helpers_repos → helpers/helpers_repos}/repo_analyzer_2.py

@@ -1,13 +1,23 @@
 from git import Repo
-from machineconfig.scripts.python.helpers_repos.repo_analyzer_1 import count_python_lines, get_default_branch
+from machineconfig.scripts.python.helpers.helpers_repos.repo_analyzer_1 import count_python_lines, get_default_branch
 from datetime import datetime
 import polars as pl
 from pathlib import Path
-from typing import Any, Dict, List, Union, Optional
+from typing import cast, TypedDict
 
 
-def print_python_files_by_size_impl(repo_path: str) -> "Union[pl.DataFrame, Exception]":
-    import polars as pl
+class FileDataRow(TypedDict):
+    filename: str
+    lines: int
+
+
+class CommitDataRow(TypedDict):
+    hash: str
+    dtmExit: datetime
+    lines: int
+
+
+def print_python_files_by_size_impl(repo_path: str) -> pl.DataFrame | Exception:
     import plotly.graph_objects as go
     import plotly.express as px
 
@@ -16,7 +26,7 @@ def print_python_files_by_size_impl(repo_path: str) -> "Union[pl.DataFrame, Exce
         if not os.path.exists(repo_path):
             return ValueError(f"Repository path does not exist: {repo_path}")
         # Initialize data storage
-        file_data: "List[Dict[str, Union[str, int]]]" = []
+        file_data: list[FileDataRow] = []
 
         # Walk through the repository
         for root, _, files in os.walk(repo_path):
@@ -66,7 +76,8 @@ def print_python_files_by_size_impl(repo_path: str) -> "Union[pl.DataFrame, Exce
         table.add_column("Lines", justify="right")
 
         for idx, row in enumerate(df.iter_rows(named=True), 1):
-            table.add_row(str(idx), row["filename"], f"{row['lines']:,}")
+            typed_row = cast(FileDataRow, row)
+            table.add_row(str(idx), typed_row["filename"], f"{typed_row['lines']:,}")
 
         console.print(table)
         print(f"\n📁 Total Python files: {file_count}")
@@ -118,7 +129,7 @@ def print_python_files_by_size_impl(repo_path: str) -> "Union[pl.DataFrame, Exce
         )
 
         # Define pie chart figure before conditionally using it
-        fig2: "Optional[go.Figure]" = None
+        fig2: go.Figure | None = None
 
         # Add pie chart showing distribution
         if len(df) > top_n:
@@ -175,14 +186,15 @@ def analyze_over_time(repo_path: str):
     repo: Repo = Repo(repo_path)
     branch_name: str = get_default_branch(repo)
     print(f"🔍 Using branch: {branch_name}")
-    commit_data: "List[Dict[str, Any]]" = []
+    commit_data: list[CommitDataRow] = []
     print("⏳ Analyzing commits...")
     try:
         commits = list(repo.iter_commits(branch_name))
         from datetime import timezone
         from rich.progress import track
         for commit in track(commits, description="Processing commits..."):
-            commit_data.append({"hash": commit.hexsha, "dtmExit": datetime.fromtimestamp(commit.committed_date, tz=timezone.utc), "lines": count_python_lines(commit)})
+            lines, _files = count_python_lines(commit)
+            commit_data.append({"hash": commit.hexsha, "dtmExit": datetime.fromtimestamp(commit.committed_date, tz=timezone.utc), "lines": lines})
     except Exception as e:
         print(f"❌ Error analyzing commits: {str(e)}")
         return
@@ -199,20 +211,50 @@ def analyze_over_time(repo_path: str):
     # Add markers for significant points (min, max, last)
     min_idx = df["lines"].arg_min()
     max_idx = df["lines"].arg_max()
-    min_point = df.slice(min_idx, 1).to_dicts()[0] if min_idx is not None else {}
-    max_point = df.slice(max_idx, 1).to_dicts()[0] if max_idx is not None else {}
-    last_point = df.slice(-1, 1).to_dicts()[0]
+    last_point = cast(CommitDataRow, df.slice(-1, 1).to_dicts()[0])
+    
+    marker_x: list[datetime] = []
+    marker_y: list[int] = []
+    marker_sizes: list[int] = []
+    marker_colors: list[str] = []
+    marker_symbols: list[str] = []
+    marker_texts: list[str] = []
+    
+    if min_idx is not None:
+        min_point = cast(CommitDataRow, df.slice(min_idx, 1).to_dicts()[0])
+        marker_x.append(min_point["dtmExit"])
+        marker_y.append(min_point["lines"])
+        marker_sizes.append(10)
+        marker_colors.append("#ff4f4f")
+        marker_symbols.append("circle")
+        marker_texts.append(f"🔽 Min: {min_point['lines']:,} lines")
+    
+    if max_idx is not None:
+        max_point = cast(CommitDataRow, df.slice(max_idx, 1).to_dicts()[0])
+        marker_x.append(max_point["dtmExit"])
+        marker_y.append(max_point["lines"])
+        marker_sizes.append(14)
+        marker_colors.append("#4fff4f")
+        marker_symbols.append("star")
+        marker_texts.append(f"🔼 Max: {max_point['lines']:,} lines")
+    
+    marker_x.append(last_point["dtmExit"])
+    marker_y.append(last_point["lines"])
+    marker_sizes.append(12)
+    marker_colors.append("#4f4fff")
+    marker_symbols.append("diamond")
+    marker_texts.append(f"📊 Current: {last_point['lines']:,} lines")
 
     # Add markers for significant points
     fig.add_trace(
         go.Scatter(
-            x=[min_point["dtmExit"], max_point["dtmExit"], last_point["dtmExit"]],
-            y=[min_point["lines"], max_point["lines"], last_point["lines"]],
+            x=marker_x,
+            y=marker_y,
             mode="markers",
-            marker={"size": [10, 14, 12], "color": ["#ff4f4f", "#4fff4f", "#4f4fff"], "line": {"width": 2, "color": "white"}, "symbol": ["circle", "star", "diamond"]},
+            marker={"size": marker_sizes, "color": marker_colors, "line": {"width": 2, "color": "white"}, "symbol": marker_symbols},
             name="Key Points",
             hovertemplate="<b>%{text}</b><br>Date: %{x}<br>Lines: %{y:,}<extra></extra>",
-            text=[f"🔽 Min: {min_point['lines']:,} lines", f"🔼 Max: {max_point['lines']:,} lines", f"📊 Current: {last_point['lines']:,} lines"],
+            text=marker_texts,
         )
     )
 
@@ -264,6 +306,8 @@ def analyze_over_time(repo_path: str):
     # Print statistics
     print("\n📊 Repository Statistics:")
     print(f"📚 Total commits analyzed: {len(df)}")
-    print(f"🔙 Initial line count: {df['lines'][-1]:,}")
-    print(f"🔜 Final line count: {df['lines'][0]:,}")
-    print(f"📈 Net change: {df['lines'][0] - df['lines'][-1]:,} lines")
+    initial_lines = int(df['lines'][-1])
+    final_lines = int(df['lines'][0])
+    print(f"🔙 Initial line count: {initial_lines:,}")
+    print(f"🔜 Final line count: {final_lines:,}")
+    print(f"📈 Net change: {final_lines - initial_lines:,} lines")

machineconfig/scripts/python/{helpers_repos → helpers/helpers_repos}/update.py

@@ -246,12 +246,6 @@ def update_repository(repo: git.Repo, auto_uv_sync: bool, allow_password_prompt:
                 result["permissions_updated"] = True
                 print(f"✅ Set permissions for {linux_jobs_path}")
 
-            lf_exe_path = repo_path / "src" / "machineconfig" / "settings" / "lf" / "linux" / "exe"
-            if lf_exe_path.exists():
-                set_permissions_recursive(lf_exe_path)
-                result["permissions_updated"] = True
-                print(f"✅ Set permissions for {lf_exe_path}")
-
         # Run uv sync if dependencies changed and auto_sync is enabled
         if result["dependencies_changed"] and auto_uv_sync:
             result["uv_sync_ran"] = True

machineconfig/scripts/python/helpers/helpers_search/script_help.py

@@ -0,0 +1,81 @@
+
+from typing import Literal
+
+
+def list_available_scripts(where: Literal["all", "a", "private", "p", "public", "b", "library", "l", "dynamic", "d", "custom", "c"]) -> None:
+    from pathlib import Path
+    from machineconfig.utils.source_of_truth import CONFIG_ROOT, LIBRARY_ROOT, DEFAULTS_PATH
+
+    private_root = Path.home().joinpath("dotfiles/scripts")
+    public_root = CONFIG_ROOT.joinpath("scripts")
+    library_root = LIBRARY_ROOT.joinpath("jobs", "scripts")
+
+    def get_custom_roots() -> list[Path]:
+        custom_roots: list[Path] = []
+        if DEFAULTS_PATH.is_file():
+            from configparser import ConfigParser
+            config = ConfigParser()
+            config.read(DEFAULTS_PATH)
+            if config.has_section("general") and config.has_option("general", "scripts"):
+                custom_dirs = config.get("general", "scripts").split(",")
+                for custom_dir in custom_dirs:
+                    custom_path = Path(custom_dir.strip()).expanduser().resolve()
+                    if custom_path.is_dir():
+                        custom_roots.append(custom_path)
+        return custom_roots
+
+    locations: dict[str, Path | str] = {}
+    match where:
+        case "all" | "a":
+            locations = {"private": private_root, "public": public_root, "library": library_root}
+            for idx, custom in enumerate(get_custom_roots()): locations[f"custom_{idx}"] = custom
+            locations["dynamic"] = "https://github.com/thisismygitrepo/machineconfig/tree/main/src/machineconfig/jobs/scripts_dynamic"
+        case "private" | "p":
+            locations = {"private": private_root}
+        case "public" | "b":
+            locations = {"public": public_root}
+        case "library" | "l":
+            locations = {"library": library_root}
+        case "dynamic" | "d":
+            locations = {"dynamic": "https://github.com/thisismygitrepo/machineconfig/tree/main/src/machineconfig/jobs/scripts_dynamic"}
+        case "custom" | "c":
+            for idx, custom in enumerate(get_custom_roots()): locations[f"custom_{idx}"] = custom
+
+    def _print_files_by_type(files: list[str]) -> None:
+        categories: dict[str, list[str]] = {".py": [], ".sh": [], ".ps1": [], ".cmd": [], ".bat": [], "other": []}
+        for f in files:
+            ext = Path(f).suffix.lower() if "." in str(f) else ""
+            if ext in categories: categories[ext].append(str(f))
+            else: categories["other"].append(str(f))
+        for ext, cat_files in categories.items():
+            if cat_files:
+                label = ext if ext else "other"
+                print(f"    [{label}]")
+                for cf in sorted(cat_files): print(f"      • {cf}")
+
+    for loc_name, loc_path in locations.items():
+        print(f"\n📁 {loc_name.upper()} ({loc_path}):")
+        print("-" * 60)
+        if isinstance(loc_path, Path):
+            if loc_path.is_dir():
+                files = [f for f in loc_path.rglob("*") if f.is_file() and f.suffix in (".py", ".sh", ".ps1", ".bat", ".cmd", "")]
+                if files:
+                    relative_files = [str(f.relative_to(loc_path)) for f in files]
+                    _print_files_by_type(relative_files)
+                else:
+                    print("  (empty)")
+            else:
+                print("  ⚠️  Directory does not exist")
+        else:
+            api_url = "https://api.github.com/repos/thisismygitrepo/machineconfig/contents/src/machineconfig/jobs/scripts_dynamic"
+            try:
+                import requests
+                response = requests.get(api_url, timeout=10)
+                if response.status_code == 200:
+                    items = response.json()
+                    files = [item["name"] for item in items if item["type"] == "file"]
+                    _print_files_by_type(files)
+                else:
+                    print(f"  ⚠️  Could not fetch from GitHub (status: {response.status_code})")
+            except Exception as e:
+                print(f"  ⚠️  Could not fetch from GitHub: {e}")

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

@@ -0,0 +1,186 @@
+"""Pure Python implementations for sessions commands - no typer dependencies."""
+
+from typing import Optional, 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]
+    """Select layout(s) from a layout file."""
+    import json
+    from machineconfig.utils.schemas.layouts.layout_types import LayoutsFile, LayoutConfig
+    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 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")
+    print(f"Selected layout(s): {selected_layouts_names}")
+    layouts_chosen: list[LayoutConfig] = []
+    for name in selected_layouts_names:
+        layout_chosen = next((layout for layout in layout_file["layouts"] if layout["layoutName"] == name), None)
+        if layout_chosen is None:
+            layout_chosen = next((layout for layout in layout_file["layouts"] if layout["layoutName"].lower() == name.lower()), None)
+        if layout_chosen is None:
+            available_layouts = [layout["layoutName"] for layout in layout_file["layouts"]]
+            raise ValueError(f"Layout '{name}' not found. Available layouts: {available_layouts}")
+        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
+    from machineconfig.utils.options import choose_from_options
+    path_obj = sanitize_path(layout_path)
+    if not path_obj.exists():
+        choice_file = match_file_name(sub_string=layout_path, search_root=Path.cwd(), suffixes={".json"})
+    elif path_obj.is_dir():
+        print(f"🔍 Searching recursively for Python, PowerShell and Shell scripts in directory `{path_obj}`")
+        files = search_for_files_of_interest(path_obj, suffixes={".py", ".sh", ".ps1"})
+        print(f"🔍 Got #{len(files)} results.")
+        choice_file = choose_from_options(multi=False, options=files, tv=True, msg="Choose one option")
+        choice_file = Path(choice_file).expanduser().absolute()
+    else:
+        choice_file = path_obj
+    return str(choice_file)
+
+
+def run_layouts(
+    layout_path: Optional[str],
+    max_tabs: int,
+    max_layouts: int,
+    sleep_inbetween: float,
+    monitor: bool,
+    parallel: bool,
+    kill_upon_completion: bool,
+    choose: Optional[str],
+    choose_interactively: bool,
+    subsitute_home: bool,
+) -> 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:
+            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}")

machineconfig/scripts/python/{helpers_sessions → helpers/helpers_sessions}/sessions_multiprocess.py

@@ -15,7 +15,6 @@ def create_from_function(
     from machineconfig.utils.accessories import get_repo_root
     from pathlib import Path
 
-
     path_obj = sanitize_path(path)
     if not path_obj.exists():
         suffixes = {".py"}
@@ -46,7 +45,7 @@ def create_from_function(
 
     # =========================  choosing function to run
     if function is None or function.strip() == "":
-        from machineconfig.scripts.python.helpers_fire_command.fire_jobs_route_helper import choose_function_or_lines
+        from machineconfig.scripts.python.helpers.helpers_fire_command.fire_jobs_route_helper import choose_function_or_lines
         choice_function, choice_file, _kwargs_dict = choose_function_or_lines(choice_file, kwargs_dict={})
     else:
         choice_function = function

machineconfig/scripts/python/helpers/helpers_terminal/terminal_impl.py

@@ -0,0 +1,96 @@
+import re
+import subprocess
+from pathlib import Path
+
+
+_ANSI_ESCAPE_RE = re.compile(
+    r"(?:\x1B|\u001B|\033)\[[0-?]*[ -/]*[@-~]|\[[0-9;?]+[ -/]*[@-~]|\[m"
+)
+
+
+def strip_ansi_codes(text: str) -> str:
+    return _ANSI_ESCAPE_RE.sub("", text)
+
+
+def choose_zellij_session(name: str | None, new_session: bool, kill_all: bool) -> tuple[str, str | None]:
+    """Choose a Zellij session. Returns tuple of (action, script_to_run) where action is 'run_script', 'exit', or 'error'."""
+    if name is not None:
+        return ("run_script", f"zellij attach {name}")
+    if new_session:
+        cmd = "zellij --layout st2"
+        if kill_all:
+            cmd = f"zellij kill-all-sessions --yes\n{cmd}"
+        return ("run_script", cmd)
+    cmd = "zellij list-sessions"
+    try:
+        sessions: list[str] = subprocess.check_output(cmd, shell=True).decode().strip().split("\n")
+    except subprocess.CalledProcessError:
+        sessions = []
+    sessions = [s for s in sessions if s.strip()]
+    # print(f"Found Zellij sessions: {sessions}")
+    sessions.sort(key=lambda s: "EXITED" in s)
+    if "current" in sessions:
+        return ("error", "Already in a Zellij session, avoiding nesting and exiting.")
+    if len(sessions) == 0:
+        return ("run_script", "zellij --layout st2")
+    if len(sessions) == 1:
+        sn = strip_ansi_codes(sessions[0])
+        session_name = sn.split(" [Created")[0]
+        return ("run_script", f"zellij attach {session_name}")
+    from machineconfig.utils.options import choose_from_options
+    NEW_SESSION_LABEL = "NEW SESSION"
+    KILL_ALL_AND_NEW_LABEL = "KILL ALL SESSIONS & START NEW"
+    options = sessions + [NEW_SESSION_LABEL, KILL_ALL_AND_NEW_LABEL]
+    try:
+        session_name = choose_from_options(msg="Choose a Zellij session to attach to:", multi=False, options=options, tv=True)
+    except Exception as e:
+        return ("error", f"Error choosing Zellij session: {e}")
+    if session_name == NEW_SESSION_LABEL:
+        cmd = "zellij --layout st2"
+        if kill_all:
+            cmd = f"zellij kill-all-sessions --yes\n{cmd}"
+        return ("run_script", cmd)
+    if session_name == KILL_ALL_AND_NEW_LABEL:
+        return ("run_script", "zellij kill-all-sessions --yes\nzellij --layout st2")
+    session_name_clean = strip_ansi_codes(session_name)
+    session_name_clean = session_name_clean.split(" [Created")[0]
+    return ("run_script", f"zellij attach {session_name_clean}")
+
+
+def get_session_tabs() -> list[tuple[str, str]]:
+    cmd = "zellij list-sessions"
+    try:
+        sessions: list[str] = subprocess.check_output(cmd, shell=True).decode().strip().split("\n")
+    except subprocess.CalledProcessError:
+        sessions = []
+    sessions = [strip_ansi_codes(s) for s in sessions]
+    active_sessions = [s for s in sessions if "EXITED" not in s]
+    result: list[tuple[str, str]] = []
+    for session_line in active_sessions:
+        session_name = session_line.split(" [Created")[0].strip()
+        tab_cmd = f"zellij  --session {session_name} action query-tab-names"
+        try:
+            tabs: list[str] = subprocess.check_output(tab_cmd, shell=True).decode().strip().split("\n")
+            for tab in tabs:
+                if tab.strip():
+                    result.append((session_name, tab.strip()))
+        except subprocess.CalledProcessError:
+            continue
+    return result
+
+
+def start_wt(layout_name: str) -> tuple[str, str | None]:
+    """Start a Windows Terminal layout by name. Returns tuple of (status, message) where status is 'success' or 'error'."""
+    import json
+    from machineconfig.utils.schemas.layouts.layout_types import LayoutsFile
+    from machineconfig.cluster.sessions_managers.wt_local import run_wt_layout
+    layouts_file = Path.home().joinpath("dotfiles/machineconfig/layouts.json")
+    if not layouts_file.exists():
+        return ("error", f"❌ Layouts file not found: {layouts_file}")
+    layouts_data: LayoutsFile = json.loads(layouts_file.read_text(encoding="utf-8"))
+    chosen_layout = next((a_layout for a_layout in layouts_data["layouts"] if a_layout["layoutName"] == layout_name), None)
+    if not chosen_layout:
+        available_layouts = [a_layout["layoutName"] for a_layout in layouts_data["layouts"]]
+        return ("error", f"❌ Layout '{layout_name}' not found in layouts file.\nAvailable layouts: {', '.join(available_layouts)}")
+    run_wt_layout(layout_config=chosen_layout)
+    return ("success", None)

machineconfig/scripts/python/{helpers_utils → helpers/helpers_utils}/download.py

@@ -22,7 +22,7 @@ def download(
     if output is not None and output_dir is not None:
         typer.echo("❌ Error: --output and --output-dir cannot be used together.", err=True)
         return None
-    typer.echo(f"📥 Downloading from: {url}")
+    typer.echo(f"    {url}")
 
     def _sanitize_candidate_filename(name: str) -> Optional[str]:
         candidate = Path(name).name.strip()

machineconfig/scripts/python/{helpers_devops/cli_utils.py → helpers/helpers_utils/pdf.py}

@@ -40,7 +40,7 @@ def merge_pdfs(
                                    in_global=True, import_module=False)
     from machineconfig.utils.code import run_shell_script, get_uv_command_executing_python_script
     uv_command, _py_file = get_uv_command_executing_python_script(python_script=code, uv_with=["pypdf"], uv_project_dir=None)
-    run_shell_script(uv_command)
+    run_shell_script(uv_command, display_script=True, clean_env=False)
 
 
 def compress_pdf(
@@ -92,5 +92,5 @@ def compress_pdf(
     )
     from machineconfig.utils.code import run_shell_script, get_uv_command_executing_python_script
     uv_command, _py_file = get_uv_command_executing_python_script(python_script=code, uv_with=["pymupdf"], uv_project_dir=None)
-    run_shell_script(uv_command)
+    run_shell_script(uv_command, display_script=True, clean_env=False)