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

machineconfig/scripts/python/helpers_repos/action.py

@@ -0,0 +1,209 @@
+from machineconfig.scripts.python.helpers_repos.action_helper import GitAction, GitOperationResult, GitOperationSummary, print_git_operations_summary
+from machineconfig.utils.path_extended import PathExtended
+from machineconfig.utils.accessories import randstr
+from machineconfig.scripts.python.helpers_repos.update import update_repository
+
+from typing import Optional, Dict, Any, List, cast
+import concurrent.futures
+import os
+
+from rich import print as pprint
+
+
+def git_action(path: PathExtended, action: GitAction, mess: Optional[str], r: bool, auto_uv_sync: bool) -> GitOperationResult:
+    """Perform git actions using Python instead of shell scripts. Returns detailed operation result."""
+    from git.exc import InvalidGitRepositoryError
+    from git.repo import Repo
+
+    try:
+        repo = Repo(str(path), search_parent_directories=False)
+    except InvalidGitRepositoryError:
+        pprint(f"⚠️ Skipping {path} because it is not a git repository.")
+        if r:
+            results = [git_action(path=sub_path, action=action, mess=mess, r=r, auto_uv_sync=auto_uv_sync) for sub_path in path.search()]
+            # For recursive calls, we need to aggregate results somehow
+            # For now, return success if all recursive operations succeeded
+            all_successful = all(result.success for result in results)
+            return GitOperationResult(
+                repo_path=path,
+                action=action.value,
+                success=all_successful,
+                message=f"Recursive operation: {len([r for r in results if r.success])}/{len(results)} succeeded",
+                is_git_repo=False,
+            )
+        else:
+            return GitOperationResult(repo_path=path, action=action.value, success=False, message="Not a git repository", is_git_repo=False)
+
+    print(f">>>>>>>>> 🔧{action} - {path}")
+    remote_count = len(repo.remotes)
+
+    try:
+        if action == GitAction.commit:
+            if mess is None:
+                mess = "auto_commit_" + randstr()
+
+            # Check if there are changes to commit
+            if repo.is_dirty() or repo.untracked_files:
+                repo.git.add(A=True)  # Stage all changes
+                repo.index.commit(mess)
+                print(f"✅ Committed changes with message: {mess}")
+                return GitOperationResult(
+                    repo_path=path,
+                    action=action.value,
+                    success=True,
+                    message=f"Committed changes with message: {mess}",
+                    had_changes=True,
+                    remote_count=remote_count,
+                )
+            else:
+                print("ℹ️  No changes to commit")
+                return GitOperationResult(
+                    repo_path=path, action=action.value, success=True, message="No changes to commit", had_changes=False, remote_count=remote_count
+                )
+
+        elif action == GitAction.push:
+            if not repo.remotes:
+                print("⚠️ No remotes configured for push")
+                return GitOperationResult(repo_path=path, action=action.value, success=False, message="No remotes configured", remote_count=0)
+
+            success = True
+            failed_remotes = []
+            for remote in repo.remotes:
+                try:
+                    print(f"🚀 Pushing to {remote.url}")
+                    remote.push(repo.active_branch.name)
+                    print(f"✅ Pushed to {remote.name}")
+                except Exception as e:
+                    print(f"❌ Failed to push to {remote.name}: {e}")
+                    failed_remotes.append(f"{remote.name}: {str(e)}")
+                    success = False
+
+            message = "Push successful" if success else f"Push failed for: {', '.join(failed_remotes)}"
+            return GitOperationResult(repo_path=path, action=action.value, success=success, message=message, remote_count=remote_count)
+
+        elif action == GitAction.pull:
+            # Use the enhanced update function with uv sync support
+            try:
+                update_repository(repo, auto_uv_sync=auto_uv_sync, allow_password_prompt=False)
+                print("✅ Pull completed")
+                return GitOperationResult(
+                    repo_path=path, action=action.value, success=True, message="Pull completed successfully", remote_count=remote_count
+                )
+            except Exception as e:
+                print(f"❌ Pull failed: {e}")
+                return GitOperationResult(
+                    repo_path=path, action=action.value, success=False, message=f"Pull failed: {str(e)}", remote_count=remote_count
+                )
+
+    except Exception as e:
+        print(f"❌ Error performing {action} on {path}: {e}")
+        return GitOperationResult(repo_path=path, action=action.value, success=False, message=f"Error: {str(e)}", remote_count=remote_count)
+
+    # This should never be reached, but just in case
+    return GitOperationResult(repo_path=path, action=action.value, success=False, message="Unknown error", remote_count=remote_count)
+
+
+def perform_git_operations(repos_root: PathExtended, pull: bool, commit: bool, push: bool, recursive: bool, auto_uv_sync: bool) -> None:
+    """Perform git operations on all repositories and provide detailed summary."""
+    print(f"\n🔄 Performing Git actions on repositories @ `{repos_root}`...")
+    summary = GitOperationSummary()
+    # Keep track of which operations we are performing
+    operations_performed: List[str] = []
+    if pull:
+        operations_performed.append("pull")
+    if commit:
+        operations_performed.append("commit")
+    if push:
+        operations_performed.append("push")
+
+    # Collect all candidate paths first
+    paths = list(repos_root.search("*"))
+
+    def _process_path(a_path: PathExtended) -> Dict[str, Any]:
+        """Worker that processes a single path and returns metadata and results."""
+        from git.exc import InvalidGitRepositoryError
+        from git.repo import Repo
+
+        result_payload: Dict[str, Any] = {"path": a_path, "is_git": False, "results": [], "repo_remotes_count": 0}
+        print(f"{('Handling ' + str(a_path)).center(80, '-')}")
+
+        try:
+            repo = Repo(str(a_path), search_parent_directories=False)
+        except InvalidGitRepositoryError:
+            result_payload["non_git"] = True
+            pprint(f"⚠️ Skipping {a_path} because it is not a git repository.")
+            return result_payload
+
+        # It's a git repo
+        result_payload["is_git"] = True
+        result_payload["repo_remotes_count"] = len(repo.remotes)
+
+        # Perform configured operations sequentially for this repo (the repo-level work is done concurrently between repos)
+        try:
+            if pull:
+                r = git_action(path=a_path, action=GitAction.pull, mess=None, r=recursive, auto_uv_sync=auto_uv_sync)
+                result_payload["results"].append(r)
+            if commit:
+                r = git_action(path=a_path, action=GitAction.commit, mess=None, r=recursive, auto_uv_sync=auto_uv_sync)
+                result_payload["results"].append(r)
+            if push:
+                r = git_action(path=a_path, action=GitAction.push, mess=None, r=recursive, auto_uv_sync=auto_uv_sync)
+                result_payload["results"].append(r)
+        except Exception as e:
+            # Capture any unexpected exception for this path
+            pprint(f"❌ Error processing {a_path}: {e}")
+
+        return result_payload
+
+    # Choose a reasonable number of workers
+    max_workers = min(32, (os.cpu_count() or 1) * 5, len(paths) or 1)
+
+    # Run the workers in parallel and aggregate results
+    with concurrent.futures.ThreadPoolExecutor(max_workers=max_workers) as exc:
+        future_to_path = {exc.submit(_process_path, p): p for p in paths}
+        for fut in concurrent.futures.as_completed(future_to_path):
+            payload = fut.result()
+            a_path = cast(PathExtended, payload.get("path"))
+            summary.total_paths_processed += 1
+
+            if not payload.get("is_git"):
+                summary.non_git_paths += 1
+                continue
+
+            # git repo found
+            summary.git_repos_found += 1
+            if payload.get("repo_remotes_count", 0) == 0:
+                summary.repos_without_remotes.append(a_path)
+
+            for r in payload.get("results", []):
+                action_name = r.action if hasattr(r, "action") else ""
+                # Pull
+                if action_name == "pull":
+                    summary.pulls_attempted += 1
+                    if r.success:
+                        summary.pulls_successful += 1
+                    else:
+                        summary.pulls_failed += 1
+                        summary.failed_operations.append(r)
+                # Commit
+                elif action_name == "commit":
+                    summary.commits_attempted += 1
+                    if r.success:
+                        if getattr(r, "had_changes", False):
+                            summary.commits_successful += 1
+                        else:
+                            summary.commits_no_changes += 1
+                    else:
+                        summary.commits_failed += 1
+                        summary.failed_operations.append(r)
+                # Push
+                elif action_name == "push":
+                    summary.pushes_attempted += 1
+                    if r.success:
+                        summary.pushes_successful += 1
+                    else:
+                        summary.pushes_failed += 1
+                        summary.failed_operations.append(r)
+
+    # Print the detailed summary
+    print_git_operations_summary(summary, operations_performed)

machineconfig/scripts/python/helpers_repos/action_helper.py

@@ -0,0 +1,150 @@
+from enum import Enum
+from machineconfig.utils.path_extended import PathExtended
+
+
+from dataclasses import dataclass
+
+from rich.columns import Columns
+from rich.panel import Panel
+from rich.table import Table
+
+
+@dataclass
+class GitOperationResult:
+    """Result of a git operation on a single repository."""
+    repo_path: PathExtended
+    action: str
+    success: bool
+    message: str
+    is_git_repo: bool = True
+    had_changes: bool = False
+    remote_count: int = 0
+
+
+class GitAction(Enum):
+    commit = "commit"
+    push = "push"
+    pull = "pull"
+
+
+@dataclass
+class GitOperationSummary:
+    """Summary of all git operations performed."""
+
+    # Basic statistics
+    total_paths_processed: int = 0
+    git_repos_found: int = 0
+    non_git_paths: int = 0
+
+    # Per-operation statistics
+    commits_attempted: int = 0
+    commits_successful: int = 0
+    commits_no_changes: int = 0
+    commits_failed: int = 0
+
+    pulls_attempted: int = 0
+    pulls_successful: int = 0
+    pulls_failed: int = 0
+
+    pushes_attempted: int = 0
+    pushes_successful: int = 0
+    pushes_failed: int = 0
+
+    def __post_init__(self):
+        self.failed_operations: list[GitOperationResult] = []
+        self.repos_without_remotes: list[PathExtended] = []
+
+
+def print_git_operations_summary(summary: GitOperationSummary, operations_performed: list[str]) -> None:
+    """Print a detailed summary of git operations with rich formatting and tables."""
+    from rich.console import Console
+
+    console = Console()
+
+    # Main summary panel
+    summary_stats = [
+        f"Total paths processed: {summary.total_paths_processed}",
+        f"Git repositories found: {summary.git_repos_found}",
+        f"Non-git paths skipped: {summary.non_git_paths}",
+    ]
+
+    console.print(Panel.fit("\n".join(summary_stats), title="[bold blue]📊 Git Operations Summary[/bold blue]", border_style="blue"))
+
+    # Statistics panels in columns
+    stat_panels = []
+
+    if "commit" in operations_performed:
+        commit_stats = [
+            f"Attempted: {summary.commits_attempted}",
+            f"Successful: {summary.commits_successful}",
+            f"No changes: {summary.commits_no_changes}",
+            f"Failed: {summary.commits_failed}",
+        ]
+        stat_panels.append(Panel.fit("\n".join(commit_stats), title="[bold green]💾 Commit Operations[/bold green]", border_style="green"))
+
+    if "pull" in operations_performed:
+        pull_stats = [f"Attempted: {summary.pulls_attempted}", f"Successful: {summary.pulls_successful}", f"Failed: {summary.pulls_failed}"]
+        stat_panels.append(Panel.fit("\n".join(pull_stats), title="[bold cyan]⬇️ Pull Operations[/bold cyan]", border_style="cyan"))
+
+    if "push" in operations_performed:
+        push_stats = [f"Attempted: {summary.pushes_attempted}", f"Successful: {summary.pushes_successful}", f"Failed: {summary.pushes_failed}"]
+        stat_panels.append(Panel.fit("\n".join(push_stats), title="[bold magenta]🚀 Push Operations[/bold magenta]", border_style="magenta"))
+
+    if stat_panels:
+        console.print(Columns(stat_panels, equal=True, expand=True))
+
+    # Repositories without remotes warning
+    if summary.repos_without_remotes:
+        repos_table = Table(title="[bold yellow]⚠️ Repositories Without Remotes[/bold yellow]")
+        repos_table.add_column("Repository Name", style="cyan", no_wrap=True)
+        repos_table.add_column("Full Path", style="dim")
+
+        for repo_path in summary.repos_without_remotes:
+            repos_table.add_row(repo_path.name, str(repo_path))
+
+        console.print(repos_table)
+        console.print("[yellow]These repositories cannot be pushed to remote servers.[/yellow]")
+    elif "push" in operations_performed:
+        console.print("[green]✅ All repositories have remote configurations.[/green]")
+
+    # Failed operations table
+    if summary.failed_operations:
+        failed_table = Table(title=f"[bold red]❌ Failed Operations ({len(summary.failed_operations)} total)[/bold red]")
+        failed_table.add_column("Action", style="bold red", no_wrap=True)
+        failed_table.add_column("Repository", style="cyan", no_wrap=True)
+        failed_table.add_column("Problem", style="red")
+
+        # Group failed operations by type for better organization
+        failed_by_action = {}
+        for failed_op in summary.failed_operations:
+            if failed_op.action not in failed_by_action:
+                failed_by_action[failed_op.action] = []
+            failed_by_action[failed_op.action].append(failed_op)
+
+        for action, failures in failed_by_action.items():
+            for failure in failures:
+                repo_name = failure.repo_path.name if failure.is_git_repo else f"{failure.repo_path.name} (not git repo)"
+                problem = failure.message if failure.is_git_repo else "Not a git repository"
+                failed_table.add_row(action.upper(), repo_name, problem)
+
+        console.print(failed_table)
+    else:
+        console.print("[green]✅ All git operations completed successfully![/green]")
+
+    # Overall success assessment
+    total_failed = len(summary.failed_operations)
+    total_operations = summary.commits_attempted + summary.pulls_attempted + summary.pushes_attempted
+
+    if total_failed == 0 and total_operations > 0:
+        console.print(f"\n[bold green]🎉 SUCCESS: All {total_operations} operations completed successfully![/bold green]")
+    elif total_operations == 0:
+        console.print("\n[blue]📝 No git operations were performed.[/blue]")
+    else:
+        success_rate = ((total_operations - total_failed) / total_operations * 100) if total_operations > 0 else 0
+        if total_failed > 0:
+            console.print(
+                f"\n[bold yellow]⚖️ SUMMARY: {total_operations - total_failed}/{total_operations} operations succeeded ({success_rate:.1f}% success rate)[/bold yellow]"
+            )
+            console.print("[yellow]Review the failed operations table above for details on what needs attention.[/yellow]")
+        else:
+            console.print(f"\n[bold green]⚖️ SUMMARY: {total_operations}/{total_operations} operations succeeded (100% success rate)[/bold green]")

machineconfig/scripts/python/{repos_helper_clone.py → helpers_repos/clone.py}

@@ -1,4 +1,3 @@
-from __future__ import annotations
 
 from pathlib import Path
 from typing import Literal, Optional, cast
@@ -95,8 +94,8 @@ def clone_single_repo(repo_spec: RepoRecordDict, preferred_remote: Optional[str]
 
 
 def clone_repos(spec_path: Path, preferred_remote: Optional[str], checkout_branch_flag: bool, checkout_commit_flag: bool) -> list[tuple[CloneStatus, str]]:
-    data = cast(RepoRecordFile, read_json(path=spec_path))
-    repos = data["repos"]
+    spec_file = cast(RepoRecordFile, read_json(path=spec_path))
+    repos = spec_file["repos"]
     results: list[tuple[CloneStatus, str]] = []
     with Progress(SpinnerColumn(), TextColumn("[progress.description]{task.description}"), BarColumn(), MofNCompleteColumn(), TimeElapsedColumn()) as progress:
         task_id = progress.add_task("Processing repositories...", total=len(repos))

machineconfig/scripts/python/helpers_repos/cloud_repo_sync.py

@@ -0,0 +1,218 @@
+
+from typing import Optional, Literal, Annotated
+
+import typer
+
+
+def main(
+    cloud: Annotated[Optional[str], typer.Option(..., "--cloud", "-c", help="Cloud storage profile name. If not provided, uses default from config.")] = None,
+    repo: Annotated[Optional[str], typer.Option(..., "--repo", "-r", help="Path to the local repository. Defaults to current working directory.")] = None,
+    message: Annotated[Optional[str], typer.Option(..., "--message", "-m", help="Commit message for local changes.")] = None,
+    on_conflict: Annotated[Literal["ask", "a",
+                                   "push-local-merge", "p",
+                                   "overwrite-local", "o",
+                                   "stop-on-conflict", "s",
+                                   "remove-rclone-conflict", "r"
+                                   ], typer.Option(..., "--on-conflict", "-o", help="Action to take on merge conflict. Default is 'ask'.")] = "ask",
+    pwd: Annotated[Optional[str], typer.Option(..., "--password", help="Password for encryption/decryption of the remote repository.")] = None,
+):
+    on_conflict_mapper: dict[str, Literal["ask", "push-local-merge", "overwrite-local", "stop-on-conflict", "remove-rclone-conflict"]] = {
+        "a": "ask",
+        "ask": "ask",
+        "p": "push-local-merge",
+        "push-local-merge": "push-local-merge",
+        "o": "overwrite-local",
+        "overwrite-local": "overwrite-local",
+        "s": "stop-on-conflict",
+        "stop-on-conflict": "stop-on-conflict",
+        "r": "remove-rclone-conflict",
+        "remove-rclone-conflict": "remove-rclone-conflict",
+    }
+    on_conflict = on_conflict_mapper[on_conflict]
+    import git
+    from rich.console import Console
+    from rich.panel import Panel
+
+    from machineconfig.utils.path_extended import PathExtended
+    from machineconfig.utils.terminal import Response
+    from machineconfig.utils.source_of_truth import CONFIG_ROOT, DEFAULTS_PATH
+    from machineconfig.utils.code import get_uv_command_executing_python_script
+    from pathlib import Path
+    import platform
+    import subprocess
+    console = Console()
+
+    if cloud is None:
+        try:
+            from machineconfig.utils.io import read_ini
+
+            cloud_resolved = read_ini(DEFAULTS_PATH)["general"]["rclone_config_name"]
+            console.print(Panel(f"⚠️  Using default cloud: `{cloud_resolved}` from {DEFAULTS_PATH}", title="Default Cloud", border_style="yellow"))
+        except FileNotFoundError:
+            console.print(Panel(f"❌ ERROR: No cloud profile found\nLocation: {DEFAULTS_PATH}\nPlease set one up or provide one via the --cloud flag.", title="Error", border_style="red"))
+            return ""
+    else:
+        cloud_resolved = cloud
+    repo_local_root = PathExtended.cwd() if repo is None else PathExtended(repo).expanduser().absolute()
+    try:
+        repo_local_obj = git.Repo(repo_local_root, search_parent_directories=True)
+    except git.InvalidGitRepositoryError:
+        typer.echo(f"[red]Error:[/] The specified path '{repo_local_root}' is not a valid git repository.")
+        typer.Exit(code=1)
+        return ""
+    repo_local_root = PathExtended(repo_local_obj.working_dir)  # cwd might have been in a sub directory of repo_root, so its better to redefine it.
+    local_relative_home = PathExtended(repo_local_root.expanduser().absolute().relative_to(Path.home()))
+    PathExtended(CONFIG_ROOT).joinpath("remote").mkdir(parents=True, exist_ok=True)
+    repo_remote_root = PathExtended(CONFIG_ROOT).joinpath("remote", local_relative_home)
+    repo_remote_root.delete(sure=True)
+    try:
+        console.print(Panel("📥 DOWNLOADING REMOTE REPOSITORY", title_align="left", border_style="blue"))
+        remote_path = repo_local_root.get_remote_path(rel2home=True, os_specific=False, root="myhome") + ".zip.enc"
+        res = repo_remote_root.from_cloud(remotepath=remote_path, cloud=cloud_resolved, unzip=True, decrypt=True, rel2home=True, os_specific=False, pwd=pwd)
+        if res is None:
+            raise AssertionError("Remote repo does not exist.")
+    except AssertionError:
+        console.print(Panel("🆕 Remote repository doesn't exist\n📤 Creating new remote and exiting...", title_align="left", border_style="green"))
+        repo_local_root.to_cloud(cloud=cloud_resolved, zip=True, encrypt=True, rel2home=True, pwd=pwd, os_specific=False)
+        return ""
+
+    repo_remote_obj = git.Repo(repo_remote_root)
+    if repo_remote_obj.is_dirty():
+        console.print(Panel(f"⚠️  WARNING: REMOTE REPOSITORY IS DIRTY\nLocation: {repo_remote_root}\nPlease commit or stash changes before proceeding.", title="Warning", border_style="yellow"))
+
+    script = f"""
+echo ""
+echo 'echo -e "\\033[1;34m═════ COMMITTING LOCAL CHANGES ═════\\033[0m"'
+cd {repo_local_root}
+git status
+git add .
+git commit -am "{message}"
+echo ""
+echo ""
+echo 'echo -e "\\033[1;34m═════ PULLING LATEST FROM REMOTE ═════\\033[0m"'
+cd {repo_local_root}
+echo '-> Trying to removing originEnc remote from local repo if it exists.'
+# git remote remove originEnc
+git remote remove originEnc 2>/dev/null || true
+echo '-> Adding originEnc remote to local repo'
+git remote add originEnc {repo_remote_root}
+echo '-> Fetching originEnc remote.'
+git pull originEnc master
+
+"""
+
+    if Path.home().joinpath("code/machineconfig").exists():
+        uv_project_dir = f"""{str(Path.home().joinpath("code/machineconfig"))}"""
+        uv_with = None
+    else:
+        uv_with = ["machineconfig>=7.98"]
+        uv_project_dir = None
+
+    import tempfile
+    shell_path = Path(tempfile.mkstemp(suffix=".ps1" if platform.system() == "Windows" else ".sh")[1])
+    shell_path.write_text(script, encoding="utf-8")
+
+    command = f". {shell_path}"
+    if platform.system() == "Windows":
+        completed = subprocess.run(["powershell", "-Command", command], capture_output=True, check=False, text=True)
+    else:
+        completed = subprocess.run(command, shell=True, capture_output=True, check=False, text=True)
+    res = Response.from_completed_process(completed).capture().print()
+
+    if res.is_successful(strict_err=True, strict_returcode=True):
+        console.print(Panel("✅ Pull succeeded!\n🧹 Removing originEnc remote and local copy\n📤 Pushing merged repository to cloud storage", title="Success", border_style="green"))
+        repo_remote_root.delete(sure=True)
+        from git.remote import Remote
+
+        Remote.remove(repo_local_obj, "originEnc")
+        repo_local_root.to_cloud(cloud=cloud_resolved, zip=True, encrypt=True, rel2home=True, pwd=pwd, os_specific=False)
+        return "success"
+    else:
+        console.print(Panel(f"⚠️  MERGE FAILED\n💾 Keeping local copy of remote at:\n📂 {repo_remote_root}", title="Merge Failed", border_style="red"))
+
+        # ================================================================================
+        option1 = "Delete remote copy and push local:"
+        from machineconfig.utils.meta import lambda_to_python_script
+        def func2(remote_repo: str, local_repo: str, cloud: str):
+            from machineconfig.scripts.python.helpers_repos.sync import delete_remote_repo_copy_and_push_local
+            delete_remote_repo_copy_and_push_local(remote_repo=remote_repo, local_repo=local_repo, cloud=cloud)
+        program_1_py = lambda_to_python_script(lambda: func2(remote_repo=str(repo_remote_root), local_repo=str(repo_local_root), cloud=str(cloud_resolved)),
+                                                        in_global=True, import_module=False)
+        program1, _pyfile1 = get_uv_command_executing_python_script(python_script=program_1_py, uv_with=uv_with, uv_project_dir=uv_project_dir)
+        # ================================================================================
+        option2 = "Delete local repo and replace it with remote copy:"
+        program_2 = f"""
+rm -rfd {repo_local_root}
+mv {repo_remote_root} {repo_local_root}
+"""
+        if platform.system() in ["Linux", "Darwin"]:
+            program_2 += """
+sudo chmod 600 $HOME/.ssh/*
+sudo chmod 700 $HOME/.ssh
+sudo chmod +x $HOME/dotfiles/scripts/linux -R
+"""
+        import tempfile
+        shell_file_2 = Path(tempfile.mkstemp(suffix=".ps1" if platform.system() == "Windows" else ".sh")[1])
+        shell_file_2.write_text(program_2, encoding="utf-8")
+
+        # ================================================================================
+        option3 = "Inspect repos:"
+        def func(repo_local_root: str, repo_remote_root: str):
+            from machineconfig.scripts.python.helpers_repos.sync import inspect_repos
+            inspect_repos(repo_local_root=repo_local_root, repo_remote_root=repo_remote_root)
+        # program_3_py = function_to_script(func=func, call_with_kwargs={"repo_local_root": str(repo_local_root), "repo_remote_root": str(repo_remote_root)})
+        # shell_file_3 = get_shell_file_executing_python_script(python_script=program_3_py, ve_path=None, executable=executable)
+        program_3_py = lambda_to_python_script(lambda: func(repo_local_root=str(repo_local_root), repo_remote_root=str(repo_remote_root)),
+                                                        in_global=True, import_module=False)
+        program3, _pyfile3 = get_uv_command_executing_python_script(python_script=program_3_py, uv_with=uv_with, uv_project_dir=uv_project_dir)
+        # ================================================================================
+
+        option4 = "Remove problematic rclone file from repo and replace with remote:"
+        program_4 = f"""
+rm $HOME/dotfiles/creds/rclone/rclone.conf
+cp $HOME/.config/machineconfig/remote/dotfiles/creds/rclone/rclone.conf $HOME/dotfiles/creds/rclone
+cd $HOME/dotfiles
+git commit -am "finished merging"
+{program1}
+"""
+        shell_file_4 = Path(tempfile.mkstemp(suffix=".ps1" if platform.system() == "Windows" else ".sh")[1])
+        shell_file_4.write_text(program_4, encoding="utf-8")
+        # ================================================================================
+
+        console.print(Panel("🔄 RESOLVE MERGE CONFLICT\nChoose an option to resolve the conflict:", title_align="left", border_style="blue"))
+
+        print(f"• {option1:75} 👉 {program1}")
+        print(f"• {option2:75} 👉 {shell_file_2}")
+        print(f"• {option3:75} 👉 {program3}")
+        print(f"• {option4:75} 👉 {shell_file_4}")
+        print("\n\n")
+
+        program_content = None
+        match on_conflict:
+            case "ask":
+                import questionary
+                choice = questionary.select("Choose one option:", choices=[option1, option2, option3, option4]).ask()
+                if choice == option1:
+                    program_content = program1
+                elif choice == option2:
+                    program_content = program_2
+                elif choice == option3:
+                    program_content = program3
+                elif choice == option4:
+                    program_content = program_4
+                else:
+                    raise NotImplementedError(f"Choice {choice} not implemented.")
+            case "push-local-merge":
+                program_content = program1
+            case "overwrite-local":
+                program_content = program_2
+            case "stop-on-conflict":
+                program_content = program3
+            case "remove-rclone-conflict":
+                program_content = program_4
+            case _:
+                raise ValueError(f"Unknown action: {on_conflict}")
+        from machineconfig.utils.code import run_shell_script
+        run_shell_script(script=program_content)
+    return program_content
+

machineconfig/scripts/python/{repos_helper.py → helpers_repos/entrypoint.py}

@@ -3,19 +3,11 @@
 
 from typing import Optional
 from pathlib import Path
-from machineconfig.utils.source_of_truth import CONFIG_PATH, DEFAULTS_PATH
+from machineconfig.utils.source_of_truth import CONFIG_ROOT, DEFAULTS_PATH
 
 import typer
 
 
-
-def print_banner() -> None:
-    typer.echo("\n" + "=" * 50)
-    typer.echo("📂 Welcome to the Repository Manager")
-    typer.echo("=" * 50 + "\n")
-
-
-
 def resolve_directory(directory: Optional[str]) -> Path:
     if directory is None:
         directory = Path.cwd().as_posix()
@@ -28,12 +20,11 @@ def git_operations(
     commit: bool,
     push: bool,
     recursive: bool,
-    no_sync: bool,
+    auto_uv_sync: bool,
 ) -> None:
-    print_banner()
+    
     repos_root = resolve_directory(directory)
-    auto_sync = not no_sync
-    from machineconfig.scripts.python.repos_helper_action import perform_git_operations
+    from machineconfig.scripts.python.helpers_repos.action import perform_git_operations
     from machineconfig.utils.path_extended import PathExtended
     perform_git_operations(
         repos_root=PathExtended(repos_root),
@@ -41,13 +32,14 @@ def git_operations(
         commit=commit,
         push=push,
         recursive=recursive,
-        auto_sync=auto_sync,
+        auto_uv_sync=auto_uv_sync,
     )
 def resolve_spec_path(directory: Optional[str], cloud: Optional[str]) -> Path:
     repos_root = resolve_directory(directory)
     from machineconfig.utils.path_extended import PathExtended
     if not repos_root.exists() or repos_root.name != "repos.json":
-        candidate = Path(CONFIG_PATH).joinpath("repos").joinpath(PathExtended(repos_root).rel2home()).joinpath("repos.json")
+        relative_repos_root = PathExtended(repos_root).expanduser().absolute().relative_to(Path.home())
+        candidate = Path(CONFIG_ROOT).joinpath("repos").joinpath(relative_repos_root).joinpath("repos.json")
         repos_root = candidate
         if not repos_root.exists():
             cloud_name: Optional[str]
@@ -73,10 +65,10 @@ def clone_from_specs(
     checkout_branch_flag: bool,
     checkout_commit_flag: bool,
 ) -> None:
-    print_banner()
+    
     typer.echo("\n📥 Cloning or checking out repositories...")
     spec_path = resolve_spec_path(directory, cloud)
-    from machineconfig.scripts.python.repos_helper_clone import clone_repos
+    from machineconfig.scripts.python.helpers_repos.clone import clone_repos
     clone_repos(
         spec_path=spec_path,
         preferred_remote=None,