machineconfig 2.1__py3-none-any.whl → 2.3__py3-none-any.whl

machineconfig/cluster/sessions_managers/zellij_remote_manager.py

@@ -2,10 +2,11 @@ from datetime import datetime
 import json
 import uuid
 from pathlib import Path
-from typing import Optional
+from typing import Optional, Dict
 from machineconfig.utils.utils5 import Scheduler
 from machineconfig.cluster.sessions_managers.zellij_local import run_command_in_zellij_tab
 from machineconfig.cluster.sessions_managers.zellij_remote import ZellijRemoteLayoutGenerator
+from machineconfig.cluster.sessions_managers.layout_types import LayoutConfig
 from machineconfig.logger import get_logger
 
 
@@ -14,13 +15,13 @@ logger = get_logger("cluster.sessions_managers.zellij_remote_manager")
 
 
 class ZellijSessionManager:
-    def __init__(self, machine2zellij_tabs: dict[str, dict[str, tuple[str, str]]], session_name_prefix: str = "JobMgr"):
+    def __init__(self, machine_layouts: Dict[str, LayoutConfig], session_name_prefix: str = "JobMgr"):
         self.session_name_prefix = session_name_prefix
-        self.machine2zellij_tabs = machine2zellij_tabs  # Store the original config
+        self.machine_layouts = machine_layouts  # Store the original config
         self.managers: list[ZellijRemoteLayoutGenerator] = []
-        for machine, tab_config in machine2zellij_tabs.items():
+        for machine, layout_config in machine_layouts.items():
             an_m = ZellijRemoteLayoutGenerator(remote_name=machine, session_name_prefix=self.session_name_prefix)
-            an_m.create_zellij_layout(tab_config=tab_config)
+            an_m.create_zellij_layout(layout_config=layout_config)
             self.managers.append(an_m)
 
     def ssh_to_all_machines(self) -> str:
@@ -93,13 +94,13 @@ class ZellijSessionManager:
         session_dir = TMP_SERIALIAZATION_DIR / session_id
         session_dir.mkdir(parents=True, exist_ok=True)
 
-        # Save the machine2zellij_tabs configuration
-        config_file = session_dir / "machine2zellij_tabs.json"
-        text = json.dumps(self.machine2zellij_tabs, indent=2, ensure_ascii=False)
+        # Save the machine_layouts configuration
+        config_file = session_dir / "machine_layouts.json"
+        text = json.dumps(self.machine_layouts, indent=2, ensure_ascii=False)
         config_file.write_text(text, encoding="utf-8")
 
         # Save session metadata
-        metadata = {"session_name_prefix": self.session_name_prefix, "created_at": str(datetime.now()), "num_managers": len(self.managers), "machines": list(self.machine2zellij_tabs.keys())}
+        metadata = {"session_name_prefix": self.session_name_prefix, "created_at": str(datetime.now()), "num_managers": len(self.managers), "machines": list(self.machine_layouts.keys())}
         metadata_file = session_dir / "metadata.json"
         text = json.dumps(metadata, indent=2, ensure_ascii=False)
         metadata_file.write_text(text, encoding="utf-8")
@@ -120,11 +121,11 @@ class ZellijSessionManager:
 
         if not session_dir.exists():
             raise FileNotFoundError(f"Session directory not found: {session_dir}")
-        config_file = session_dir / "machine2zellij_tabs.json"
+        config_file = session_dir / "machine_layouts.json"
         if not config_file.exists():
             raise FileNotFoundError(f"Configuration file not found: {config_file}")
         with open(config_file, "r", encoding="utf-8") as f:
-            machine2zellij_tabs = json.load(f)
+            machine_layouts = json.load(f)
 
         # Load metadata
         metadata_file = session_dir / "metadata.json"
@@ -134,7 +135,7 @@ class ZellijSessionManager:
                 metadata = json.load(f)
                 session_name_prefix = metadata.get("session_name_prefix", "JobMgr")
         # Create new instance (this will create new managers)
-        instance = cls(machine2zellij_tabs=machine2zellij_tabs, session_name_prefix=session_name_prefix)
+        instance = cls(machine_layouts=machine_layouts, session_name_prefix=session_name_prefix)
         # Load saved managers to restore their states
         managers_dir = session_dir / "managers"
         if managers_dir.exists():

machineconfig/cluster/sessions_managers/zellij_utils/example_usage.py

@@ -4,17 +4,21 @@ Example usage of the modularized Zellij remote layout generator.
 """
 
 from machineconfig.cluster.sessions_managers.zellij_remote import ZellijRemoteLayoutGenerator
+from machineconfig.cluster.sessions_managers.layout_types import LayoutConfig
 
 
 def example_usage():
     """Demonstrate the refactored modular usage."""
 
-    # Sample tab configuration
-    sample_tabs = {
-        "🤖Bot1": ("~/code/bytesense/bithence", "~/scripts/fire -mO go1.py bot1 --kw create_new_bot True"),
-        "🤖Bot2": ("~/code/bytesense/bithence", "~/scripts/fire -mO go2.py bot2 --kw create_new_bot True"),
-        "📊Monitor": ("~", "htop"),
-        "📝Logs": ("/var/log", "tail -f /var/log/app.log"),
+    # Sample layout configuration using new schema
+    sample_layout: LayoutConfig = {
+        "layoutName": "ExampleRemoteSession",
+        "layoutTabs": [
+            {"tabName": "🤖Bot1", "startDir": "~/code/bytesense/bithence", "command": "~/scripts/fire -mO go1.py bot1 --kw create_new_bot True"},
+            {"tabName": "🤖Bot2", "startDir": "~/code/bytesense/bithence", "command": "~/scripts/fire -mO go2.py bot2 --kw create_new_bot True"},
+            {"tabName": "📊Monitor", "startDir": "~", "command": "htop"},
+            {"tabName": "📝Logs", "startDir": "/var/log", "command": "tail -f /var/log/app.log"},
+        ],
     }
 
     # Replace 'myserver' with an actual SSH config alias
@@ -26,11 +30,11 @@ def example_usage():
         generator = ZellijRemoteLayoutGenerator(remote_name=remote_name, session_name_prefix=session_name)
 
         # Create layout file
-        layout_path = generator.create_zellij_layout(sample_tabs)
+        layout_path = generator.create_zellij_layout(sample_layout)
         print(f"✅ Remote layout created successfully: {layout_path}")
 
         # Preview the layout content
-        preview = generator.get_layout_preview(sample_tabs)
+        preview = generator.get_layout_preview(sample_layout)
         print(f"📄 Layout preview:\n{preview}")
 
         # Check status using the modular components
@@ -44,11 +48,11 @@ def example_usage():
         print(f"Remote executor: {generator.remote_executor.remote_name}")
 
         # Use layout generator directly
-        layout_content = generator.layout_generator.generate_layout_content(sample_tabs)
+        layout_content = generator.layout_generator.generate_layout_content(sample_layout)
         print(f"Layout content length: {len(layout_content)} characters")
 
         # Use process monitor directly
-        status = generator.process_monitor.check_all_commands_status(sample_tabs)
+        status = generator.process_monitor.check_all_commands_status(sample_layout)
         print(f"Command status check completed for {len(status)} commands")
 
         print("\n✅ All modular components working correctly!")

machineconfig/cluster/sessions_managers/zellij_utils/layout_generator.py

@@ -6,11 +6,12 @@ Zellij layout generation utilities for creating KDL layout files.
 import shlex
 import random
 import string
-from typing import Dict, List, Tuple
+from typing import List, Tuple
 from pathlib import Path
 import logging
 
 from rich.console import Console
+from machineconfig.cluster.sessions_managers.layout_types import LayoutConfig
 
 logger = logging.getLogger(__name__)
 console = Console()
@@ -77,36 +78,51 @@ class LayoutGenerator:
         return tab_section
 
     @staticmethod
-    def validate_tab_config(tab_config: Dict[str, Tuple[str, str]]) -> None:
-        """Validate tab configuration format and content."""
-        if not tab_config:
-            raise ValueError("Tab configuration cannot be empty")
-        for tab_name, (cwd, command) in tab_config.items():
+    def validate_tab_config(layout_config: LayoutConfig) -> None:
+        """Validate layout configuration format and content."""
+        if not layout_config:
+            raise ValueError("Layout configuration cannot be empty")
+
+        if not layout_config.get("layoutName", "").strip():
+            raise ValueError("Layout name cannot be empty")
+
+        layout_tabs = layout_config.get("layoutTabs", [])
+        if not layout_tabs:
+            raise ValueError("Layout must have at least one tab")
+
+        for tab in layout_tabs:
+            tab_name = tab.get("tabName", "")
+            command = tab.get("command", "")
+            start_dir = tab.get("startDir", "")
+
             if not tab_name.strip():
                 raise ValueError(f"Invalid tab name: {tab_name}")
             if not command.strip():
                 raise ValueError(f"Invalid command for tab '{tab_name}': {command}")
-            if not cwd.strip():
-                raise ValueError(f"Invalid cwd for tab '{tab_name}': {cwd}")
+            if not start_dir.strip():
+                raise ValueError(f"Invalid startDir for tab '{tab_name}': {start_dir}")
 
-    def generate_layout_content(self, tab_config: Dict[str, Tuple[str, str]]) -> str:
+    def generate_layout_content(self, layout_config: LayoutConfig) -> str:
         """Generate complete KDL layout content."""
-        self.validate_tab_config(tab_config)
+        self.validate_tab_config(layout_config)
 
         layout_content = self.LAYOUT_TEMPLATE
-        for tab_name, (cwd, command) in tab_config.items():
-            layout_content += "\n" + self.create_tab_section(tab_name, cwd, command)
+        for tab in layout_config["layoutTabs"]:
+            tab_name = tab["tabName"]
+            start_dir = tab["startDir"]
+            command = tab["command"]
+            layout_content += "\n" + self.create_tab_section(tab_name, start_dir, command)
         layout_content += "\n}\n"
 
         return layout_content
 
-    def create_layout_file(self, tab_config: Dict[str, Tuple[str, str]], output_dir: Path, session_name: str) -> str:
+    def create_layout_file(self, layout_config: LayoutConfig, output_dir: Path, session_name: str) -> str:
         """Create a layout file and return its absolute path."""
-        self.validate_tab_config(tab_config)
+        self.validate_tab_config(layout_config)
 
         # Generate unique suffix for this layout
         random_suffix = self.generate_random_suffix()
-        layout_content = self.generate_layout_content(tab_config)
+        layout_content = self.generate_layout_content(layout_config)
 
         try:
             # Create output directory if it doesn't exist

machineconfig/cluster/sessions_managers/zellij_utils/process_monitor.py

@@ -6,8 +6,9 @@ Process monitoring and status checking utilities for remote commands.
 import json
 import shlex
 import logging
-from typing import Dict, Tuple, Any
-from .remote_executor import RemoteExecutor
+from typing import Dict, Any
+from machineconfig.cluster.sessions_managers.zellij_utils.remote_executor import RemoteExecutor
+from machineconfig.cluster.sessions_managers.layout_types import LayoutConfig
 
 logger = logging.getLogger(__name__)
 
@@ -18,20 +19,37 @@ class ProcessMonitor:
     def __init__(self, remote_executor: RemoteExecutor):
         self.remote_executor = remote_executor
 
-    def check_command_status(self, tab_name: str, tab_config: Dict[str, Tuple[str, str]], use_verification: bool = True) -> Dict[str, Any]:
+    def check_command_status(self, tab_name: str, layout_config: LayoutConfig, use_verification: bool = True) -> Dict[str, Any]:
         """Check command status with optional process verification."""
-        if tab_name not in tab_config:
-            return {"status": "unknown", "error": f"Tab '{tab_name}' not found in tracked configuration", "running": False, "pid": None, "command": None, "remote": self.remote_executor.remote_name}
+        # Find the tab with the given name
+        tab_config = None
+        for tab in layout_config["layoutTabs"]:
+            if tab["tabName"] == tab_name:
+                tab_config = tab
+                break
+
+        if tab_config is None:
+            return {"status": "unknown", "error": f"Tab '{tab_name}' not found in layout config", "running": False, "pid": None, "command": None, "remote": self.remote_executor.remote_name}
 
         # Use the verified method by default for more accurate results
         if use_verification:
-            return self.get_verified_process_status(tab_name, tab_config)
+            return self.get_verified_process_status(tab_name, layout_config)
 
-        return self._basic_process_check(tab_name, tab_config)
+        return self._basic_process_check(tab_name, layout_config)
 
-    def _basic_process_check(self, tab_name: str, tab_config: Dict[str, Tuple[str, str]]) -> Dict[str, Any]:
+    def _basic_process_check(self, tab_name: str, layout_config: LayoutConfig) -> Dict[str, Any]:
         """Basic process checking without verification."""
-        _, command = tab_config[tab_name]
+        # Find the tab with the given name
+        tab_config = None
+        for tab in layout_config["layoutTabs"]:
+            if tab["tabName"] == tab_name:
+                tab_config = tab
+                break
+
+        if tab_config is None:
+            return {"status": "unknown", "error": f"Tab '{tab_name}' not found in layout config", "running": False, "command": None, "remote": self.remote_executor.remote_name}
+
+        command = tab_config["command"]
 
         try:
             check_script = self._create_process_check_script(command)
@@ -106,12 +124,19 @@ if __name__ == "__main__":
     print(json.dumps(processes))
 """
 
-    def force_fresh_process_check(self, tab_name: str, tab_config: Dict[str, Tuple[str, str]]) -> Dict[str, Any]:
+    def force_fresh_process_check(self, tab_name: str, layout_config: LayoutConfig) -> Dict[str, Any]:
         """Force a fresh process check with additional validation."""
-        if tab_name not in tab_config:
-            return {"status": "unknown", "error": f"Tab '{tab_name}' not found in tracked configuration", "running": False, "command": None, "remote": self.remote_executor.remote_name}
+        # Find the tab with the given name
+        tab_config = None
+        for tab in layout_config["layoutTabs"]:
+            if tab["tabName"] == tab_name:
+                tab_config = tab
+                break
+
+        if tab_config is None:
+            return {"status": "unknown", "error": f"Tab '{tab_name}' not found in layout config", "running": False, "command": None, "remote": self.remote_executor.remote_name}
 
-        _, command = tab_config[tab_name]
+        command = tab_config["command"]
 
         try:
             # Get timestamp for freshness validation
@@ -230,9 +255,9 @@ if __name__ == "__main__":
         except Exception:
             return False
 
-    def get_verified_process_status(self, tab_name: str, tab_config: Dict[str, Tuple[str, str]]) -> Dict[str, Any]:
+    def get_verified_process_status(self, tab_name: str, layout_config: LayoutConfig) -> Dict[str, Any]:
         """Get process status with additional verification that processes are actually alive."""
-        status = self.force_fresh_process_check(tab_name, tab_config)
+        status = self.force_fresh_process_check(tab_name, layout_config)
 
         if status.get("running") and status.get("processes"):
             verified_processes = []
@@ -252,13 +277,14 @@ if __name__ == "__main__":
 
         return status
 
-    def check_all_commands_status(self, tab_config: Dict[str, Tuple[str, str]]) -> Dict[str, Dict[str, Any]]:
-        """Check status of all commands in the tab configuration."""
-        if not tab_config:
-            logger.warning("No tab configuration provided.")
+    def check_all_commands_status(self, layout_config: LayoutConfig) -> Dict[str, Dict[str, Any]]:
+        """Check status of all commands in the layout configuration."""
+        if not layout_config or not layout_config.get("layoutTabs"):
+            logger.warning("No layout configuration provided.")
             return {}
 
         status_report = {}
-        for tab_name in tab_config:
-            status_report[tab_name] = self.check_command_status(tab_name, tab_config)
+        for tab in layout_config["layoutTabs"]:
+            tab_name = tab["tabName"]
+            status_report[tab_name] = self.check_command_status(tab_name, layout_config)
         return status_report

machineconfig/cluster/sessions_managers/zellij_utils/session_manager.py

@@ -9,7 +9,7 @@ from pathlib import Path
 
 from rich.console import Console
 
-from .remote_executor import RemoteExecutor
+from machineconfig.cluster.sessions_managers.zellij_utils.remote_executor import RemoteExecutor
 
 logger = logging.getLogger(__name__)
 console = Console()

machineconfig/cluster/sessions_managers/zellij_utils/status_reporter.py

@@ -4,9 +4,10 @@ Status reporting utilities for Zellij remote layouts.
 """
 
 import logging
-from typing import Dict, Any, Tuple
-from .process_monitor import ProcessMonitor
-from .session_manager import SessionManager
+from typing import Dict, Any
+from machineconfig.cluster.sessions_managers.zellij_utils.process_monitor import ProcessMonitor
+from machineconfig.cluster.sessions_managers.zellij_utils.session_manager import SessionManager
+from machineconfig.cluster.sessions_managers.layout_types import LayoutConfig
 
 logger = logging.getLogger(__name__)
 
@@ -18,10 +19,10 @@ class StatusReporter:
         self.process_monitor = process_monitor
         self.session_manager = session_manager
 
-    def get_comprehensive_status(self, tab_config: Dict[str, Tuple[str, str]]) -> Dict[str, Any]:
+    def get_comprehensive_status(self, layout_config: LayoutConfig) -> Dict[str, Any]:
         """Get comprehensive status including Zellij session and all commands."""
         zellij_status = self.session_manager.check_zellij_session_status()
-        commands_status = self.process_monitor.check_all_commands_status(tab_config)
+        commands_status = self.process_monitor.check_all_commands_status(layout_config)
 
         running_count = sum(1 for status in commands_status.values() if status.get("running", False))
         total_count = len(commands_status)
@@ -38,9 +39,9 @@ class StatusReporter:
             },
         }
 
-    def print_status_report(self, tab_config: Dict[str, Tuple[str, str]]) -> None:
+    def print_status_report(self, layout_config: LayoutConfig) -> None:
         """Print a formatted status report to console."""
-        status = self.get_comprehensive_status(tab_config)
+        status = self.get_comprehensive_status(layout_config)
         remote_name = self.session_manager.remote_executor.remote_name
         session_name = self.session_manager.session_name
 

machineconfig/cluster/templates/utils.py

@@ -1,41 +1,6 @@
-# """
-# This module contains utility functions for the cluster module.
-# """
-
-# import inspect
-# from machineconfig.utils.io_save import save_pickle
-
-# from machineconfig.cluster.remote_machine import WorkloadParams
 from typing import Optional
 from machineconfig.utils.path_reduced import PathExtended, PLike
 
-# def expensive_function(workload_params: WorkloadParams, sim_dict: Optional[dict[str, Any]] = None) -> P:
-#     import time
-#     from rich.progress import track
-#     print("Hello, I am one thread of an expensive function, and I just started running ...")
-#     print(f"Oh, I recieved this parameter: {sim_dict=} & {workload_params=} ")
-#     execution_time_in_seconds = 60 * 1
-#     steps = 100
-#     for _ in track(range(steps), description="Progress bar ..."):
-#         time.sleep(execution_time_in_seconds / steps)  # Simulate work being done
-#     print(f"I'm done, I crunched numbers from {workload_params.idx_start} to {workload_params.idx_end}.")
-#     _ = workload_params.idx_max
-
-#     save_dir = PathExtended.tmp().joinpath("tmp_dirs/expensive_function_single_thread").joinpath(workload_params.save_suffix, f"thread_{workload_params.idx_start}_{workload_params.idx_end}")
-#     save_dir.mkdir(parents=True, exist_ok=True)
-#     save_pickle(obj={'a': 1}, path=save_dir.joinpath("trial_func_result.pkl"))
-#     return save_dir
-
-
-# def assert_has_workload_params(func_or_method: Callable[..., Any]):
-#     if not inspect.isfunction(func_or_method) and not inspect.ismethod(func_or_method): raise TypeError(f"{func_or_method} is not a function or method.")
-#     try: params = inspect.signature(func_or_method).parameters
-#     except ValueError as e: raise ValueError(f"Failed to inspect signature of {func_or_method}: {e}") from e
-#     if 'workload_params' not in params: raise ValueError(f"{func_or_method.__name__}() does not have 'workload_params' parameter.")
-#     if params['workload_params'].kind != inspect.Parameter.POSITIONAL_OR_KEYWORD: raise ValueError(f"{func_or_method.__name__}() 'workload_params' parameter is not a positional or keyword parameter.")
-#     if params['workload_params'].default is not inspect.Parameter.empty: raise ValueError(f"{func_or_method.__name__}() 'workload_params' parameter should not have a default value.")
-#     return True
-
 
 def to_cloud(
     localpath: PLike,

machineconfig/jobs/python/check_installations.py

@@ -9,7 +9,7 @@ import platform
 # from rich.console import Console
 # from machineconfig.utils.utils2 import pprint
 # # from rich.progress import track
-from machineconfig.utils.utils import LIBRARY_ROOT
+from machineconfig.utils.source_of_truth import LIBRARY_ROOT
 # from machineconfig.utils.installer import get_installed_cli_apps
 
 # from tqdm import tqdm

machineconfig/jobs/python_custom_installers/dev/code.py

@@ -36,20 +36,7 @@ def main(version: Optional[str] = None):
 {"⚠️" * 20}
 """)
         raise NotImplementedError(error_msg)
-
     _ = version
-
-    print(f"""
-{"=" * 150}
-ℹ️  INFO | VS Code features:
-📝 Powerful code editor with IntelliSense
-🧩 Thousands of extensions available
-🔍 Integrated debugging
-🔄 Git integration
-⚙️  Highly customizable
-{"=" * 150}
-""")
-
     return install_script
 
 

machineconfig/jobs/python_generic_installers/config.json

@@ -219,7 +219,7 @@
     "doc": "🚀 Fly through your shell history. Great Scott!",
     "filename_template_linux_amd_64": "mcfly-v{}-x86_64-unknown-linux-musl.tar.gz",
     "filename_template_linux_arm_64": "mcfly-v{}-aarch64-unknown-linux-musl.tar.gz",
-    "filename_template_windows_amd_64": "mcfly-v{}-x86_64-pc-windows-msvc.zip",
+    "filename_template_windows_amd_64": "",
     "filename_template_macos_amd_64": "mcfly-v{}-x86_64-apple-darwin.tar.gz",
     "filename_template_macos_arm_64": "",
     "filename_template_windows_arm_64": "",

machineconfig/profile/create.py

@@ -5,7 +5,9 @@ This script Takes away all config files from the computer, place them in one dir
 """
 
 from machineconfig.utils.path_reduced import PathExtended as PathExtended
-from machineconfig.utils.utils import symlink_func, symlink_copy, LIBRARY_ROOT, REPO_ROOT, display_options
+from machineconfig.utils.links import symlink_func, symlink_copy
+from machineconfig.utils.options import display_options
+from machineconfig.utils.source_of_truth import LIBRARY_ROOT, REPO_ROOT
 from machineconfig.utils.utils2 import read_toml
 from machineconfig.profile.shell import create_default_shell_profile
 
@@ -19,11 +21,18 @@ from typing import Optional, Any, TypedDict
 
 system = platform.system()  # Linux or Windows
 ERROR_LIST: list[Any] = []  # append to this after every exception captured.
-CONFIG_ROOT = LIBRARY_ROOT.parent.parent.joinpath("settings")
-OTHER_SYSTEM = "windows" if system == "Linux" else "linux"
+
 SYSTEM = system.lower()
 
 
+def get_other_systems(current_system: str) -> list[str]:
+    all_systems = ["linux", "windows", "darwin"]
+    return [s for s in all_systems if s != current_system.lower()]
+
+
+OTHER_SYSTEMS = get_other_systems(SYSTEM)
+
+
 class SymlinkMapper(TypedDict):
     this: str
     to_this: str
@@ -38,7 +47,7 @@ def main_symlinks(choice: Optional[str] = None):
     program_keys_raw: list[str] = list(symlink_mapper.keys())
     program_keys: list[str] = []
     for program_key in program_keys_raw:
-        if program_key in exclude or OTHER_SYSTEM in program_key:
+        if program_key in exclude or any([another_system in program_key for another_system in OTHER_SYSTEMS]):
             continue
         else:
             program_keys.append(program_key)

machineconfig/profile/create_hardlinks.py

@@ -6,7 +6,9 @@ This script Takes away all config files from the computer, place them in one dir
 
 import platform
 from machineconfig.utils.path_reduced import PathExtended as PathExtended
-from machineconfig.utils.utils import symlink_copy as symlink_func, LIBRARY_ROOT, REPO_ROOT, display_options
+from machineconfig.utils.links import symlink_copy as symlink_func
+from machineconfig.utils.options import display_options
+from machineconfig.utils.source_of_truth import LIBRARY_ROOT, REPO_ROOT
 from machineconfig.utils.utils2 import read_toml
 from machineconfig.profile.shell import create_default_shell_profile
 

machineconfig/profile/shell.py

@@ -1,9 +1,10 @@
 """shell"""
 
 from machineconfig.utils.utils2 import randstr
-from machineconfig.utils.path_reduced import PathExtended as PathExtended, modify_text
+from machineconfig.utils.path_reduced import PathExtended as PathExtended
 from machineconfig.utils.terminal import Terminal
-from machineconfig.utils.utils import LIBRARY_ROOT, REPO_ROOT, display_options
+from machineconfig.utils.options import display_options
+from machineconfig.utils.source_of_truth import LIBRARY_ROOT, REPO_ROOT
 import platform
 import os
 from typing import Literal, Optional
@@ -27,9 +28,9 @@ def create_default_shell_profile() -> None:
     profile_path = get_shell_profile_path()
     profile = profile_path.read_text(encoding="utf-8")
     if system == "Windows":
-        source = f""". {str(LIBRARY_ROOT.joinpath("settings/shells/pwsh/init.ps1").collapseuser()).replace("~", "$HOME")}"""
+        source = f""". {str(PathExtended(LIBRARY_ROOT).joinpath("settings/shells/pwsh/init.ps1").collapseuser()).replace("~", "$HOME")}"""
     else:
-        source = f"""source {str(LIBRARY_ROOT.joinpath("settings/shells/bash/init.sh").collapseuser()).replace("~", "$HOME")}"""
+        source = f"""source {str(PathExtended(LIBRARY_ROOT).joinpath("settings/shells/bash/init.sh").collapseuser()).replace("~", "$HOME")}"""
 
     if source in profile:
         console.print(Panel("🔄 PROFILE | Skipping init script sourcing - already present in profile", title="[bold blue]Profile[/bold blue]", border_style="blue"))
@@ -116,9 +117,9 @@ def main_env_path(choice: Optional[str], profile_path: Optional[str]) -> None:
     profile_path_obj = PathExtended(profile_path) if isinstance(profile_path, str) else get_shell_profile_path()
     profile_path_obj.copy(name=profile_path_obj.name + ".orig_" + randstr())
     console.print(f"💾 Created backup of profile: {profile_path_obj.name}.orig_*")
-    # Inline deprecated P.modify_text: if file missing, seed with search text before modification
+    # Inline deprecated modify_text: if file missing, seed with search text before modification
     current = profile_path_obj.read_text(encoding="utf-8") if profile_path_obj.exists() else addition
-    updated = modify_text(current, addition, addition, replace_line=False, notfound_append=True)
+    updated = current if addition in current else current + "\n" + addition
     profile_path_obj.write_text(updated, encoding="utf-8")
     console.print(Panel("✅ PATH variables added to profile successfully", title="[bold blue]Environment[/bold blue]", border_style="blue"))
 
@@ -172,7 +173,7 @@ def main_add_sources_to_shell_profile(profile_path: Optional[str], choice: Optio
 
 
 def main_add_patches_to_shell_profile(profile_path: Optional[str], choice: Optional[str]) -> None:
-    patches: list[str] = [item.as_posix() for item in LIBRARY_ROOT.joinpath(f"profile/patches/{system.lower()}").search()]
+    patches: list[str] = [item.as_posix() for item in PathExtended(LIBRARY_ROOT).joinpath(f"profile/patches/{system.lower()}").search()]
 
     console.print(Panel("🩹 Adding patches to shell profile", title="[bold blue]Patches[/bold blue]", border_style="blue"))
 

machineconfig/scripts/__init__.py

@@ -1,5 +1,3 @@
-
-
 version = "0.5"
 release_notes = """
 created toml file for symlinks

machineconfig/scripts/linux/devops

@@ -1,14 +1,16 @@
 #!/usr/bin/env bash
 
-source ~/code/machineconfig/.venv/bin/activate
-
 op_script=$HOME/tmp_results/shells/python_return_command.sh
 if [ -f "$op_script" ]; then
   rm $op_script
 fi
 
-# uv run --no-dev --project ~/code/machineconfig python -m machineconfig.scripts.python.devops "$@"
-python -m machineconfig.scripts.python.devops "$@"
+# source ~/code/machineconfig/.venv/bin/activate
+# python -m machineconfig.scripts.python.devops "$@"
+# echo "🔄 Running devops script..."
+uv run --no-dev --project $HOME/code/machineconfig python -m machineconfig.scripts.python.devops "$@"
+# uv run --with machineconfig python -m machineconfig.scripts.python.devops "$@"
+
 
 if [ -f "$op_script" ]; then
   chmod +x $op_script