machineconfig 5.17__py3-none-any.whl → 5.19__py3-none-any.whl

machineconfig/cluster/sessions_managers/wt_local.py

@@ -2,6 +2,9 @@
 """
 Windows Terminal local layout generator and session manager.
 Equivalent to zellij_local.py but for Windows Terminal.
+
+https://github.com/ruby9455/app_management/tree/main/app_management
+
 """
 
 import shlex
@@ -13,11 +16,13 @@ import platform
 from typing import Dict, List, Optional, Any
 from pathlib import Path
 import logging
+from rich.console import Console
 
 from machineconfig.utils.schemas.layouts.layout_types import LayoutConfig
 
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
+console = Console()
 TMP_LAYOUT_DIR = Path.home().joinpath("tmp_results", "session_manager", "wt", "layout_manager")
 
 # Check if we're on Windows
@@ -341,7 +346,7 @@ try {{
                 for proc in cmd_status["processes"][:2]:  # Show first 2 processes
                     pid = proc.get("pid", "Unknown")
                     name = proc.get("name", "Unknown")
-                    print(f"      └─ PID {pid}: {name}")
+                    console.print(f"      [dim]└─[/dim] PID {pid}: {name}")
         print()
 
         print("=" * 80)

machineconfig/cluster/sessions_managers/wt_local_manager.py

@@ -6,6 +6,7 @@ import logging
 import subprocess
 from pathlib import Path
 from typing import TypedDict, Optional, Dict, List, Any
+from rich.console import Console
 from machineconfig.utils.scheduler import Scheduler
 from machineconfig.cluster.sessions_managers.wt_local import WTLayoutGenerator
 from machineconfig.utils.schemas.layouts.layout_types import LayoutConfig
@@ -21,6 +22,7 @@ class WTSessionReport(TypedDict):
 
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
+console = Console()
 
 TMP_SERIALIZATION_DIR = Path.home().joinpath("tmp_results", "session_manager", "wt", "local_manager")
 
@@ -220,11 +222,11 @@ class WTLocalManager:
                 cmd_text = cmd_status.get("command", "Unknown")[:50]
                 if len(cmd_status.get("command", "")) > 50:
                     cmd_text += "..."
-                print(f"     {status_icon} {tab_name}: {cmd_text}")
+                console.print(f"     {status_icon} {tab_name}: {cmd_text}")
 
                 if cmd_status.get("processes"):
                     for proc in cmd_status["processes"][:2]:  # Show first 2 processes
-                        print(f"        └─ PID {proc['pid']}: {proc['name']}")
+                        console.print(f"        [dim]└─[/dim] PID {proc['pid']}: {proc['name']}")
             print()
 
         print("=" * 80)

machineconfig/cluster/sessions_managers/wt_remote_manager.py

@@ -4,6 +4,7 @@ import uuid
 import logging
 from pathlib import Path
 from typing import Optional, Any
+from rich.console import Console
 from machineconfig.utils.scheduler import Scheduler
 from machineconfig.cluster.sessions_managers.wt_local import run_command_in_wt_tab
 from machineconfig.cluster.sessions_managers.wt_remote import WTRemoteLayoutGenerator
@@ -13,6 +14,7 @@ TMP_SERIALIZATION_DIR = Path.home().joinpath("tmp_results", "session_manager", "
 
 # Module-level logger to be used throughout this module
 logger = logging.getLogger(__name__)
+console = Console()
 
 
 class WTSessionManager:
@@ -315,11 +317,11 @@ class WTSessionManager:
                 cmd_text = cmd_status.get("command", "Unknown")[:50]
                 if len(cmd_status.get("command", "")) > 50:
                     cmd_text += "..."
-                print(f"     {status_icon} {tab_name}: {cmd_text}")
+                console.print(f"     {status_icon} {tab_name}: {cmd_text}")
 
                 if cmd_status.get("processes"):
                     for proc in cmd_status["processes"][:2]:  # Show first 2 processes
-                        print(f"        └─ PID {proc.get('pid', 'Unknown')}: {proc.get('name', 'Unknown')}")
+                        console.print(f"        [dim]└─[/dim] PID {proc.get('pid', 'Unknown')}: {proc.get('name', 'Unknown')}")
             print()
 
         print("=" * 80)

machineconfig/cluster/sessions_managers/wt_utils/status_reporter.py

@@ -5,11 +5,13 @@ Status reporting utilities for Windows Terminal layouts and sessions.
 
 import logging
 from typing import Dict, Any, List
+from rich.console import Console
 from machineconfig.cluster.sessions_managers.wt_utils.process_monitor import WTProcessMonitor
 from machineconfig.cluster.sessions_managers.wt_utils.session_manager import WTSessionManager
 from machineconfig.utils.schemas.layouts.layout_types import TabConfig
 
 logger = logging.getLogger(__name__)
+console = Console()
 
 
 class WTStatusReporter:
@@ -82,11 +84,11 @@ class WTStatusReporter:
                 for proc in processes:
                     pid = proc.get("pid", "Unknown")
                     name = proc.get("name", "Unknown")
-                    print(f"       └─ PID {pid}: {name}")
+                    console.print(f"       [dim]└─[/dim] PID {pid}: {name}")
 
                 if len(cmd_status["processes"]) > 3:
                     remaining = len(cmd_status["processes"]) - 3
-                    print(f"       └─ ... and {remaining} more processes")
+                    console.print(f"       [dim]└─[/dim] ... and {remaining} more processes")
 
             if cmd_status.get("error"):
                 print(f"     Error: {cmd_status['error']}")

machineconfig/cluster/sessions_managers/zellij_local_manager.py

@@ -245,7 +245,7 @@ class ZellijLocalManager:
 
                 if cmd_status.get("processes"):
                     for proc in cmd_status["processes"][:2]:  # Show first 2 processes
-                        print(f"        └─ PID {proc['pid']}: {proc['name']} ({proc['status']})")
+                        console.print(f"        [dim]└─[/dim] PID {proc['pid']}: {proc['name']} ({proc['status']})")
             print()
 
         print("=" * 80)

machineconfig/cluster/sessions_managers/zellij_utils/status_reporter.py

@@ -5,11 +5,13 @@ Status reporting utilities for Zellij remote layouts.
 
 import logging
 from typing import Dict, Any
+from rich.console import Console
 from machineconfig.cluster.sessions_managers.zellij_utils.process_monitor import ProcessMonitor
 from machineconfig.cluster.sessions_managers.zellij_utils.session_manager import SessionManager
 from machineconfig.utils.schemas.layouts.layout_types import LayoutConfig
 
 logger = logging.getLogger(__name__)
+console = Console()
 
 
 class StatusReporter:
@@ -70,7 +72,7 @@ class StatusReporter:
                 print(f"✅ {tab_name}: Running on {remote_name}")
                 if cmd_status.get("processes"):
                     for proc in cmd_status["processes"][:2]:  # Show first 2 processes
-                        print(f"   └─ PID {proc['pid']}: {proc['name']} ({proc['status']})")
+                        console.print(f"   [dim]└─[/dim] PID {proc['pid']}: {proc['name']} ({proc['status']})")
             else:
                 print(f"❌ {tab_name}: Not running on {remote_name}")
             print(f"   Command: {cmd_status.get('command', 'Unknown')}")

machineconfig/profile/create.py

@@ -11,18 +11,15 @@ from rich.text import Text
 from rich.table import Table
 
 from machineconfig.utils.path_extended import PathExtended
-from machineconfig.utils.links import symlink_func, symlink_copy
-from machineconfig.utils.options import choose_from_options
-from machineconfig.utils.source_of_truth import LIBRARY_ROOT, REPO_ROOT
-from machineconfig.profile.shell import create_default_shell_profile
+from machineconfig.utils.links import symlink_map, copy_map
+from machineconfig.utils.source_of_truth import LIBRARY_ROOT
 
 import platform
-import os
-import ctypes
 import subprocess
 import tomllib
 from typing import Optional, Any, TypedDict, Literal
 
+
 system = platform.system()  # Linux or Windows
 ERROR_LIST: list[Any] = []  # append to this after every exception captured.
 SYSTEM = system.lower()
@@ -38,10 +35,43 @@ def get_other_systems(current_system: str) -> list[str]:
 OTHER_SYSTEMS = get_other_systems(SYSTEM)
 
 
-class SymlinkMapper(TypedDict):
+class Base(TypedDict):
     this: str
     to_this: str
     contents: Optional[bool]
+    copy: Optional[bool]
+
+class ConfigMapper(TypedDict):
+    file_name: str
+    config_file_default_path: str
+    self_managed_config_file_path: str
+    contents: Optional[bool]
+    copy: Optional[bool]
+class MapperFileData(TypedDict):
+    public: dict[str, list[ConfigMapper]]
+    private: dict[str, list[ConfigMapper]]
+def read_mapper() -> MapperFileData:
+    mapper_data: dict[str, dict[str, Base]] = tomllib.loads(LIBRARY_ROOT.joinpath("profile/mapper.toml").read_text(encoding="utf-8"))
+    public: dict[str, list[ConfigMapper]] = {}
+    private: dict[str, list[ConfigMapper]] = {}
+    for program_key, program_map in mapper_data.items():
+        for file_name, file_base in program_map.items():
+            file_map: ConfigMapper = {
+                "file_name": file_name,
+                "config_file_default_path": file_base["this"],
+                "self_managed_config_file_path": file_base["to_this"],
+                "contents": file_base.get("contents"),
+                "copy": file_base.get("copy"),
+            }
+            if "LIBRARY_ROOT" in file_map["self_managed_config_file_path"]:
+                if program_key not in public:
+                    public[program_key] = []
+                public[program_key].append(file_map)
+            else:
+                if program_key not in private:
+                    private[program_key] = []
+                private[program_key].append(file_map)
+    return {"public": public, "private": private}
 
 
 class OperationRecord(TypedDict):
@@ -69,156 +99,113 @@ class OperationRecord(TypedDict):
     status: str
 
 
-def apply_mapper(choice: Optional[str], prioritize_to_this: bool):
-    symlink_mapper: dict[str, dict[str, SymlinkMapper]] = tomllib.loads(LIBRARY_ROOT.joinpath("profile/mapper.toml").read_text(encoding="utf-8"))
-    exclude: list[str] = []  # "wsl_linux", "wsl_windows"
+def apply_mapper(mapper_data: dict[str, list[ConfigMapper]],
+                 on_conflict: Literal["throwError", "overwriteSelfManaged", "backupSelfManaged", "overwriteDefaultPath", "backupDefaultPath"],
+                 method: Literal["symlink", "copy"]
+                 ):
     operation_records: list[OperationRecord] = []
 
-    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 any([another_system in program_key for another_system in OTHER_SYSTEMS]):
-            continue
-        else:
-            program_keys.append(program_key)
-
-    program_keys.sort()
-    if choice is None:
-        choice_selected = choose_from_options(msg="Which symlink to create?", options=program_keys + ["all", "none(EXIT)"], default="none(EXIT)", fzf=True, multi=True)
-        assert isinstance(choice_selected, list)
-        if len(choice_selected) == 1 and choice_selected[0] == "none(EXIT)":
-            return  # terminate function.
-        elif len(choice_selected) == 1 and choice_selected[0] == "all":
-            choice_selected = "all"  # i.e. program_keys = program_keys
-    else:
-        choice_selected = choice
-
-    if isinstance(choice_selected, str):
-        if str(choice_selected) == "all" and system == "Windows":
-            if os.name == "nt":
-                try:
-                    is_admin = ctypes.windll.shell32.IsUserAnAdmin()
-                except Exception:
-                    is_admin = False
-            else:
-                is_admin = False
-            if not is_admin:
-                warning_body = "\n".join([
-                    "[bold yellow]Administrator privileges required[/]",
-                    "Run the terminal as admin and try again to avoid repeated elevation prompts.",
-                ])
-                console.print(
-                    Panel.fit(
-                        warning_body,
-                        title="⚠️ Permission Needed",
-                        border_style="yellow",
-                        padding=(1, 2),
-                    )
-                )
-                raise RuntimeError("Run terminal as admin and try again, otherwise, there will be too many popups for admin requests and no chance to terminate the program.")
-        elif choice_selected == "all":
+    import os
+    if os.name == "nt":
+        import ctypes
+        try:
+            is_admin = ctypes.windll.shell32.IsUserAnAdmin()
+        except Exception:
+            is_admin = False
+        total_length = sum(len(item) for item in mapper_data.values())
+        if not is_admin and method == "symlink" and total_length > 5:
+            warning_body = "\n".join([
+                "[bold yellow]Administrator privileges required[/]",
+                "Run the terminal as admin and try again to avoid repeated elevation prompts.",
+            ])
             console.print(
-                Panel(
-                    Pretty(program_keys),
-                    title="🔍 Processing All Program Keys",
-                    border_style="cyan",
+                Panel.fit(
+                    warning_body,
+                    title="⚠️ Permission Needed",
+                    border_style="yellow",
                     padding=(1, 2),
                 )
             )
-            pass  # i.e. program_keys = program_keys
-        else:
-            program_keys = [choice_selected]
-    else:
-        program_keys = choice_selected
+            raise RuntimeError("Run terminal as admin and try again, otherwise, there will be too many popups for admin requests and no chance to terminate the program.")
 
-    for program_key in program_keys:
-        console.rule(f"🔄 Processing [bold]{program_key}[/] symlinks", style="cyan")
-        for file_key, file_map in symlink_mapper[program_key].items():
-            this = PathExtended(file_map["this"])
-            to_this = PathExtended(file_map["to_this"].replace("REPO_ROOT", REPO_ROOT.as_posix()).replace("LIBRARY_ROOT", LIBRARY_ROOT.as_posix()))
+    for program_name, program_files in mapper_data.items():
+        console.rule(f"🔄 Processing [bold]{program_name}[/] symlinks", style="cyan")
+        for a_mapper in program_files:
+            config_file_default_path = PathExtended(a_mapper["config_file_default_path"])
+            self_managed_config_file_path = PathExtended(a_mapper["self_managed_config_file_path"].replace("LIBRARY_ROOT", LIBRARY_ROOT.as_posix()))
+            
+            # Determine whether to use copy or symlink
+            use_copy = method == "copy" or "copy" in a_mapper
             
-            if "contents" in file_map:
+            if "contents" in a_mapper:
                 try:
-                    targets = list(to_this.expanduser().search("*"))
+                    targets = list(self_managed_config_file_path.expanduser().search("*"))
                     for a_target in targets:
-                        result = symlink_func(this=this.joinpath(a_target.name), to_this=a_target, prioritize_to_this=prioritize_to_this)
+                        if use_copy:
+                            result = copy_map(config_file_default_path=config_file_default_path.joinpath(a_target.name), self_managed_config_file_path=a_target, on_conflict=on_conflict)
+                            operation_type = "contents_copy"
+                        else:
+                            result = symlink_map(config_file_default_path=config_file_default_path.joinpath(a_target.name), self_managed_config_file_path=a_target, on_conflict=on_conflict)
+                            operation_type = "contents_symlink"
                         operation_records.append({
-                            "program": program_key,
-                            "file_key": file_key,
-                            "source": str(this.joinpath(a_target.name)),
+                            "program": program_name,
+                            "file_key": a_mapper["file_name"],
+                            "source": str(config_file_default_path.joinpath(a_target.name)),
                             "target": str(a_target),
-                            "operation": "contents_symlink",
+                            "operation": operation_type,
                             "action": result["action"],
                             "details": result["details"],
                             "status": "success"
                         })
                 except Exception as ex:
-                    console.print(f"❌ [red]Config error[/red]: {program_key} | {file_key} | missing keys 'this ==> to_this'. {ex}")
+                    console.print(f"❌ [red]Config error[/red]: {program_name} | {a_mapper['file_name']} | missing keys 'config_file_default_path ==> self_managed_config_file_path'. {ex}")
                     operation_records.append({
-                        "program": program_key,
-                        "file_key": file_key,
-                        "source": str(this),
-                        "target": str(to_this),
-                        "operation": "contents_symlink",
+                        "program": program_name,
+                        "file_key": a_mapper["file_name"],
+                        "source": str(config_file_default_path),
+                        "target": str(self_managed_config_file_path),
+                        "operation": "contents_symlink" if not use_copy else "contents_copy",
                         "action": "error",
                         "details": f"Failed to process contents: {str(ex)}",
                         "status": f"error: {str(ex)}"
-                    })
-                    
-            elif "copy" in file_map:
-                try:
-                    result = symlink_copy(this=this, to_this=to_this, prioritize_to_this=prioritize_to_this)
-                    operation_records.append({
-                        "program": program_key,
-                        "file_key": file_key,
-                        "source": str(this),
-                        "target": str(to_this),
-                        "operation": "copy",
-                        "action": result["action"],
-                        "details": result["details"],
-                        "status": "success"
-                    })
-                except Exception as ex:
-                    console.print(f"❌ [red]Config error[/red]: {program_key} | {file_key} | {ex}")
-                    operation_records.append({
-                        "program": program_key,
-                        "file_key": file_key,
-                        "source": str(this),
-                        "target": str(to_this),
-                        "operation": "copy",
-                        "action": "error",
-                        "details": f"Failed to copy: {str(ex)}",
-                        "status": f"error: {str(ex)}"
-                    })
+                    })                    
             else:
                 try:
-                    result = symlink_func(this=this, to_this=to_this, prioritize_to_this=prioritize_to_this)
+                    if use_copy:
+                        result = copy_map(config_file_default_path=config_file_default_path, self_managed_config_file_path=self_managed_config_file_path, on_conflict=on_conflict)
+                        operation_type = "copy"
+                    else:
+                        result = symlink_map(config_file_default_path=config_file_default_path, self_managed_config_file_path=self_managed_config_file_path, on_conflict=on_conflict)
+                        operation_type = "symlink"
                     operation_records.append({
-                        "program": program_key,
-                        "file_key": file_key,
-                        "source": str(this),
-                        "target": str(to_this),
-                        "operation": "symlink",
+                        "program": program_name,
+                        "file_key": a_mapper["file_name"],
+                        "source": str(config_file_default_path),
+                        "target": str(self_managed_config_file_path),
+                        "operation": operation_type,
                         "action": result["action"],
                         "details": result["details"],
                         "status": "success"
                     })
                 except Exception as ex:
-                    console.print(f"❌ [red]Config error[/red]: {program_key} | {file_key} | missing keys 'this ==> to_this'. {ex}")
+                    console.print(f"❌ [red]Config error[/red]: {program_name} | {a_mapper['file_name']} | missing keys 'config_file_default_path ==> self_managed_config_file_path'. {ex}")
                     operation_records.append({
-                        "program": program_key,
-                        "file_key": file_key,
-                        "source": str(this),
-                        "target": str(to_this),
-                        "operation": "symlink",
+                        "program": program_name,
+                        "file_key": a_mapper["file_name"],
+                        "source": str(config_file_default_path),
+                        "target": str(self_managed_config_file_path),
+                        "operation": "symlink" if not use_copy else "copy",
                         "action": "error",
-                        "details": f"Failed to create symlink: {str(ex)}",
+                        "details": f"Failed to create {'symlink' if not use_copy else 'copy'}: {str(ex)}",
                         "status": f"error: {str(ex)}"
                     })
 
-            if program_key == "ssh" and system == "Linux":  # permissions of ~/dotfiles/.ssh should be adjusted
+            if program_name == "ssh" and system == "Linux":  # permissions of ~/dotfiles/.ssh should be adjusted
                 try:
                     console.print("\n[bold]🔒 Setting secure permissions for SSH files...[/bold]")
+                    # run_shell_script("sudo chmod 600 $HOME/.ssh/*")
+                    # run_shell_script("sudo chmod 700 $HOME/.ssh")
+
                     subprocess.run("chmod 700 ~/.ssh/", check=True)
                     subprocess.run("chmod 700 ~/dotfiles/creds/.ssh/", check=True)  # may require sudo
                     subprocess.run("chmod 600 ~/dotfiles/creds/.ssh/*", check=True)
@@ -280,24 +267,5 @@ def apply_mapper(choice: Optional[str], prioritize_to_this: bool):
         )
 
 
-def main_symlinks():
-    console.print("")
-    console.rule("[bold blue]🔗 CREATING SYMLINKS 🔗")
-    apply_mapper(choice="all", prioritize_to_this=True)
-
-
-def main_profile():
-    console.print("")
-    console.rule("[bold green]🐚 CREATING SHELL PROFILE 🐚")
-    create_default_shell_profile()
-    console.print(
-        Panel.fit(
-            Text("✨ Configuration setup complete! ✨", justify="center"),
-            title="Profile Setup",
-            border_style="green",
-        )
-    )
-
-
 if __name__ == "__main__":
     pass

machineconfig/profile/create_frontend.py

@@ -0,0 +1,58 @@
+
+import typer
+from typing import Optional, Literal
+from pathlib import Path
+
+
+def main_public_from_parser(method: Literal["symlink", "copy"] = typer.Option(..., help="Method to use for setting up the config file."),
+                            on_conflict: Literal["throwError", "overwriteDefaultPath", "backupDefaultPath"] = typer.Option(..., help="Action to take on conflict"),
+                            which: Optional[str] = typer.Option(None, help="Specific items to process"),
+                            interactive: bool = typer.Option(False, help="Run in interactive mode")):
+    """Terminology:
+    SOURCE = Self-Managed-Config-File-Path
+    TARGET = Config-File-Default-Path
+    For public config files, the source always exists, because we know it comes from machineconfig repo."""
+    from machineconfig.profile.create import ConfigMapper, read_mapper
+    if method == "symlink":
+        machineconfig_repo_path = Path.home().joinpath("code/machineconfig")
+        if not machineconfig_repo_path.exists() or not machineconfig_repo_path.is_dir():
+            raise FileNotFoundError(f"machineconfig repo not found at {machineconfig_repo_path}. Cannot create symlinks to non-existing source files.")
+
+    mapper_full = read_mapper()["public"]
+    if which is None:
+        assert interactive is True
+        from machineconfig.utils.options import choose_from_options
+        items_chosen = choose_from_options(msg="Which symlink to create?", options=list(mapper_full.keys()), fzf=True, multi=True)
+    else:
+        assert interactive is False
+        if which == "all":
+            items_chosen = list(mapper_full.keys())
+        else:
+            items_chosen = which.split(",")
+    items_objections: dict[str, list[ConfigMapper]] = {item: mapper_full[item] for item in items_chosen if item in mapper_full}
+
+    from machineconfig.profile.create import apply_mapper
+    apply_mapper(mapper_data=items_objections, on_conflict=on_conflict, method=method)
+
+
+def main_private_from_parser(method: Literal["symlink", "copy"] = typer.Option(..., help="Method to use for linking files"),
+                             on_conflict: Literal["throwError", "overwriteSelfManaged", "backupSelfManaged", "overwriteDefaultPath", "backupDefaultPath"] = typer.Option("throwError", help="Action to take on conflict"),
+                             which: Optional[str] = typer.Option(None, help="Specific items to process"),
+                             interactive: bool = typer.Option(False, help="Run in interactive mode")):
+    from machineconfig.profile.create import ConfigMapper, read_mapper
+
+    mapper_full = read_mapper()["private"]
+    if which is None:
+        assert interactive is True
+        from machineconfig.utils.options import choose_from_options
+        items_chosen = choose_from_options(msg="Which symlink to create?", options=list(mapper_full.keys()), fzf=True, multi=True)
+    else:
+        assert interactive is False
+        if which == "all":
+            items_chosen = list(mapper_full.keys())
+        else:
+            items_chosen = which.split(",")
+    items_objections: dict[str, list[ConfigMapper]] = {item: mapper_full[item] for item in items_chosen if item in mapper_full}
+
+    from machineconfig.profile.create import apply_mapper
+    apply_mapper(mapper_data=items_objections, on_conflict=on_conflict, method=method)

machineconfig/profile/shell.py

@@ -1,7 +1,8 @@
 """shell"""
 
+from typing import Literal
 from machineconfig.utils.path_extended import PathExtended
-from machineconfig.utils.source_of_truth import LIBRARY_ROOT
+from machineconfig.utils.source_of_truth import LIBRARY_ROOT, CONFIG_PATH
 
 import platform
 import os
@@ -35,25 +36,60 @@ def get_shell_profile_path() -> PathExtended:
     return profile_path
 
 
-def create_default_shell_profile() -> None:
+def create_default_shell_profile(method: Literal["copy", "reference"]) -> None:
+    if method == "reference":
+        machineconfig_repo_path = PathExtended.home().joinpath("code/machineconfig")
+        if not machineconfig_repo_path.exists() or not machineconfig_repo_path.is_dir():
+            raise FileNotFoundError(f"machineconfig repo not found at {machineconfig_repo_path}. Cannot create symlinks to non-existing source files.")
+
     shell_profile_path = get_shell_profile_path()
     shell_profile = shell_profile_path.read_text(encoding="utf-8")
+
     if system == "Windows":
-        source = f""". {str(PathExtended(LIBRARY_ROOT).joinpath("settings/shells/pwsh/init.ps1").collapseuser()).replace("~", "$HOME")}"""
+        init_script = PathExtended(LIBRARY_ROOT).joinpath("settings/shells/pwsh/init.ps1")
+
+        init_script_copy_path = PathExtended(CONFIG_PATH).joinpath("profile/init.ps1").collapseuser()
+        init_script_copy_path.parent.mkdir(parents=True, exist_ok=True)
+        init_script.copy(path=init_script_copy_path, overwrite=True)
+
+        source_using_copy = f""". {str(init_script_copy_path).replace("~", "$HOME")}"""
+        source_using_reference = f""". {str(init_script.collapseuser()).replace("~", "$HOME")}"""
     else:
-        source = f"""source {str(PathExtended(LIBRARY_ROOT).joinpath("settings/shells/bash/init.sh").collapseuser()).replace("~", "$HOME")}"""
-    if source in shell_profile:
-        console.print(Panel("🔄 PROFILE | Skipping init script sourcing - already present in profile", title="[bold blue]Profile[/bold blue]", border_style="blue"))
+        init_script = PathExtended(LIBRARY_ROOT).joinpath("settings/shells/bash/init.sh")
+        init_script_copy_path = PathExtended(CONFIG_PATH).joinpath("profile/init.sh").collapseuser()
+        init_script_copy_path.parent.mkdir(parents=True, exist_ok=True)
+        init_script.copy(path=init_script_copy_path, overwrite=True)
+
+        source_using_reference = f"""source {str(init_script.collapseuser()).replace("~", "$HOME")}"""
+        source_using_copy = f"""source {str(init_script_copy_path).replace("~", "$HOME")}"""
+
+    match method:
+        case "copy":
+            line_of_interest = source_using_copy
+            line_other = source_using_reference
+        case "reference":
+            line_of_interest = source_using_reference
+            line_other = source_using_copy
+
+    was_shell_updated = False
+    if line_other in shell_profile:  # always remove this irrelevant line
+        shell_profile = shell_profile.replace(line_other, "")
+        was_shell_updated = True
+
+    if line_of_interest in shell_profile:
+        console.print(Panel("🔄 PROFILE | Skipping init script sourcing - already present in profile", title="[bold blue]Profile[/bold blue]", border_style="blue"))        
     else:
         console.print(Panel("📝 PROFILE | Adding init script sourcing to profile", title="[bold blue]Profile[/bold blue]", border_style="blue"))
-        shell_profile += "\n" + source + "\n"
+        shell_profile += "\n" + line_of_interest + "\n"
         if system == "Linux":
             result = subprocess.run(["cat", "/proc/version"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, check=False)
             if result.returncode == 0 and result.stdout:
                 version_info = result.stdout.lower()
                 if "microsoft" in version_info or "wsl" in version_info:
-                    shell_profile += "\ncd ~"
-                    console.print("📌 WSL detected - adding 'cd ~' to profile to avoid Windows filesystem")
+                    shell_profile += "\ncd $HOME"
+                    console.print("📌 WSL detected - adding 'cd $HOME' to profile to avoid Windows filesystem")
+        was_shell_updated = True
+    if was_shell_updated:
         shell_profile_path.parent.mkdir(parents=True, exist_ok=True)
         shell_profile_path.write_text(shell_profile, encoding="utf-8")
         console.print(Panel("✅ Profile updated successfully", title="[bold blue]Profile[/bold blue]", border_style="blue"))

machineconfig/scripts/python/ai/solutions/_shared.py

@@ -2,4 +2,12 @@ from pathlib import Path
 from machineconfig.utils.source_of_truth import LIBRARY_ROOT
 
 def get_generic_instructions_path() -> Path:
-    return LIBRARY_ROOT.joinpath("scripts/python/ai/solutions/copilot/instructions/python/dev.instructions.md")
+    path = LIBRARY_ROOT.joinpath("scripts/python/ai/solutions/copilot/instructions/python/dev.instructions.md")
+    text = path.read_text(encoding="utf-8")
+    import platform
+    if platform.system().lower() == "windows":
+        text = text.replace("bash", "powershell").replace(".sh", ".ps1")
+    import tempfile
+    temp_path = Path(tempfile.gettempdir()).joinpath("generic_instructions.md")
+    temp_path.write_text(data=text, encoding="utf-8")
+    return temp_path

machineconfig/scripts/python/ai/solutions/copilot/instructions/python/dev.instructions.md

@@ -34,7 +34,7 @@ applyTo: "**/*.py"
 * when finished, run a linting static analysis check against files you touched, Any fix any mistakes.
 * Please run `uv run -m pyright $file_touched` and address all issues. if `pyright is not there, first run `uv add pyright --dev`.
 * For all type checkers and linters, like mypy, pyright, pyrefly and pylint, there are config files at different levels of the repo all the way up to home directory level. You don't need to worry about them, just be mindful that they exist. The tools themselves will respect the configs therein.
-* If you want to run all linters and pycheckers agains the entire project to make sure everything is clean, I prepared a nice shell script, you can run it from the repo root as `./.scripts/lint_and_typecheck.sh`. It will produce markdown files that are you are meant to look at @ ./.linters/*.md
+* If you want to run all linters and pycheckers agains the entire project to make sure everything is clean, I prepared a nice shell script, you can run it from the repo root as `./.scripts/lint_and_type_check.sh`. It will produce markdown files that are you are meant to look at @ ./.linters/*.md
 
 # General Programming Ethos:
 * Make sure all the code is rigorous, no lazy stuff.