machineconfig 2.6__py3-none-any.whl → 2.8__py3-none-any.whl

machineconfig/scripts/python/repos.py

@@ -5,17 +5,17 @@ in the event that username@github.com is not mentioned in the remote url.
 
 """
 
-import subprocess
-from rich import print as pprint
 from machineconfig.utils.source_of_truth import CONFIG_PATH, DEFAULTS_PATH
 from machineconfig.utils.path_reduced import PathExtended as PathExtended
-from machineconfig.utils.io_save import save_json
-from machineconfig.utils.utils2 import randstr, read_json, read_ini
-from machineconfig.scripts.python.devops_update_repos import run_uv_sync, update_repository
+from machineconfig.utils.utils2 import randstr, read_ini
+from machineconfig.scripts.python.devops_update_repos import update_repository
+from machineconfig.scripts.python.repos_helper_record import main as record_repos
+
 import argparse
-from dataclasses import dataclass
 from enum import Enum
-from typing import Optional, Any
+from typing import Optional
+
+from rich import print as pprint
 
 
 class GitAction(Enum):
@@ -24,14 +24,6 @@ class GitAction(Enum):
     pull = "pull"
 
 
-@dataclass
-class RepoRecord:
-    name: str
-    parent_dir: str
-    remotes: dict[str, str]  # Fixed: should be dict mapping remote name to URL
-    version: dict[str, str]
-
-
 def git_action(path: PathExtended, action: GitAction, mess: Optional[str] = None, r: bool = False, auto_sync: bool = True) -> bool:
     """Perform git actions using Python instead of shell scripts. Returns True if successful."""
     from git.exc import InvalidGitRepositoryError
@@ -78,7 +70,7 @@ def git_action(path: PathExtended, action: GitAction, mess: Optional[str] = None
 
         elif action == GitAction.pull:
             # Use the enhanced update function with uv sync support
-            update_repository(repo, auto_sync=auto_sync)
+            update_repository(repo, auto_sync=auto_sync, allow_password_prompt=False)
             print("✅ Pull completed")
             return True
 
@@ -120,15 +112,10 @@ def main():
     auto_sync = not args.no_sync  # Enable auto sync by default, disable with --no-sync
 
     if args.record:
-        print("\n📝 Recording repositories...")
-        res = record_repos(repos_root=str(repos_root))
-        pprint("✅ Recorded repositories:\n", res)
-        save_path = CONFIG_PATH.joinpath("repos").joinpath(repos_root.rel2home()).joinpath("repos.json")
-        save_json(obj=res, path=save_path, indent=4)
-        pprint(f"📁 Result saved at {PathExtended(save_path)}")
+        save_path = record_repos(repos_root=repos_root)
         if args.cloud is not None:
             PathExtended(save_path).to_cloud(rel2home=True, cloud=args.cloud)
-        print(">>>>>>>>> Finished Recording")
+
 
     elif args.clone or args.checkout or args.checkout_to_branch:
         print("\n📥 Cloning or checking out repositories...")
@@ -144,11 +131,6 @@ def main():
                     assert cloud is not None, f"Path {repos_root} does not exist and cloud was not passed. You can't clone without one of them."
                 repos_root.from_cloud(cloud=cloud, rel2home=True)
         assert (repos_root.exists() and repos_root.name == "repos.json") or args.cloud is not None, f"Path {repos_root} does not exist and cloud was not passed. You can't clone without one of them."
-        success = install_repos_python(specs_path=str(repos_root), clone=args.clone, checkout_to_recorded_commit=args.checkout, checkout_to_branch=args.checkout_to_branch, auto_sync=auto_sync)
-        if success:
-            print("✅ Repository operations completed successfully")
-        else:
-            print("⚠️ Some repository operations encountered issues")
 
     elif args.all or args.commit or args.pull or args.push:
         print(f"\n🔄 Performing Git actions on repositories @ `{repos_root}`...")
@@ -172,205 +154,6 @@ def main():
         print("❌ No action specified. Try passing --push, --pull, --commit, or --all.")
 
 
-def record_repos(repos_root: str, r: bool = True) -> list[dict[str, Any]]:
-    path_obj = PathExtended(repos_root).expanduser().absolute()
-    if path_obj.is_file():
-        return []
-    search_res = path_obj.search("*", files=False)
-    res: list[dict[str, Any]] = []
-    for a_search_res in search_res:
-        if a_search_res.joinpath(".git").exists():
-            try:
-                res.append(record_a_repo(a_search_res))
-            except Exception as e:
-                print(f"⚠️ Failed to record {a_search_res}: {e}")
-        else:
-            if r:
-                res += record_repos(str(a_search_res), r=r)
-    return res
-
-
-def record_a_repo(path: PathExtended, search_parent_directories: bool = False, preferred_remote: Optional[str] = None):
-    from git.repo import Repo
-
-    repo = Repo(path, search_parent_directories=search_parent_directories)  # get list of remotes using git python
-    repo_root = PathExtended(repo.working_dir).absolute()
-    remotes = {remote.name: remote.url for remote in repo.remotes}
-    if preferred_remote is not None:
-        if preferred_remote in remotes:
-            remotes = {preferred_remote: remotes[preferred_remote]}
-        else:
-            print(f"⚠️ `{preferred_remote=}` not found in {remotes}.")
-            preferred_remote = None
-    try:
-        commit = repo.head.commit.hexsha
-    except ValueError:  # look at https://github.com/gitpython-developers/GitPython/issues/1016
-        print(f"⚠️ Failed to get latest commit of {repo}")
-        commit = None
-    try:
-        current_branch = repo.head.reference.name  # same as repo.active_branch.name
-    except TypeError:
-        print(f"⁉️ Failed to get current branch of {repo}. It is probably in a detached state.")
-        current_branch = None
-    res: dict[str, Any] = {"name": repo_root.name, "parent_dir": repo_root.parent.collapseuser().as_posix(), "current_branch": current_branch, "remotes": remotes, "version": {"branch": current_branch, "commit": commit}}
-    return res
-
-
-def install_repos_python(specs_path: str, clone: bool = True, checkout_to_recorded_commit: bool = False, checkout_to_branch: bool = False, editable_install: bool = False, preferred_remote: Optional[str] = None, auto_sync: bool = True) -> bool:
-    """Python-based repository installation with uv sync support. Returns True if all operations succeeded."""
-    from git.repo import Repo
-    from git.exc import GitCommandError
-
-    path_obj = PathExtended(specs_path).expanduser().absolute()
-    repos: list[dict[str, Any]] = read_json(path_obj)
-    overall_success = True
-
-    for repo in repos:
-        repo_success = True
-        parent_dir = PathExtended(repo["parent_dir"]).expanduser().absolute()
-        parent_dir.mkdir(parents=True, exist_ok=True)
-        repo_path = parent_dir / repo["name"]
-
-        print(f"\n{'Processing ' + repo['name']:.^80}")
-
-        # Handle cloning and remote setup
-        if clone:
-            # Select the remote to use for cloning
-            if len(repo["remotes"]) == 0:
-                print(f"⚠️ No remotes found for {repo['name']}. Skipping clone.")
-                repo_success = False
-                continue
-
-            remote_name, remote_url = next(iter(repo["remotes"].items()))  # Get first remote by default
-            if preferred_remote is not None and preferred_remote in repo["remotes"]:
-                remote_name = preferred_remote
-                remote_url = repo["remotes"][preferred_remote]
-            elif preferred_remote is not None:
-                print(f"⚠️ `{preferred_remote=}` not found in {repo['remotes']}.")
-
-            try:
-                # Clone with the selected remote
-                print(f"📥 Cloning {remote_url} to {repo_path}")
-                cloned_repo = Repo.clone_from(remote_url, repo_path, origin=remote_name, depth=2)
-                print(f"✅ Successfully cloned {repo['name']}")
-
-                # Add any additional remotes
-                for other_remote_name, other_remote_url in repo["remotes"].items():
-                    if other_remote_name != remote_name:
-                        try:
-                            cloned_repo.create_remote(other_remote_name, other_remote_url)
-                            print(f"✅ Added remote {other_remote_name}")
-                        except Exception as e:
-                            print(f"⚠️ Failed to add remote {other_remote_name}: {e}")
-
-            except GitCommandError as e:
-                print(f"❌ Failed to clone {repo['name']}: {e}")
-                repo_success = False
-                continue
-            except Exception as e:
-                print(f"❌ Unexpected error cloning {repo['name']}: {e}")
-                repo_success = False
-                continue
-
-        # Handle checkout operations (after cloning/if repo exists)
-        if repo_path.exists():
-            try:
-                existing_repo = Repo(repo_path)
-
-                if checkout_to_recorded_commit:
-                    commit = repo["version"]["commit"]
-                    if isinstance(commit, str):
-                        print(f"🔀 Checking out to commit {commit[:8]}...")
-                        existing_repo.git.checkout(commit)
-                        print("✅ Checked out to recorded commit")
-                    else:
-                        print(f"⚠️ Skipping {repo['name']} because it doesn't have a commit recorded. Found {commit}")
-
-                elif checkout_to_branch:
-                    if repo.get("current_branch"):
-                        print(f"🔀 Checking out to branch {repo['current_branch']}...")
-                        existing_repo.git.checkout(repo["current_branch"])
-                        print("✅ Checked out to recorded branch")
-                    else:
-                        print(f"⚠️ No current branch recorded for {repo['name']}")
-
-                # Handle editable install
-                if editable_install:
-                    pyproject_path = repo_path / "pyproject.toml"
-                    if pyproject_path.exists():
-                        print(f"📦 Installing {repo['name']} in editable mode...")
-                        result = subprocess.run(["uv", "pip", "install", "-e", "."], cwd=repo_path, capture_output=True, text=True)
-                        if result.returncode == 0:
-                            print("✅ Editable install completed")
-                        else:
-                            print(f"❌ Editable install failed: {result.stderr}")
-                            repo_success = False
-                    else:
-                        print(f"⚠️ No pyproject.toml found in {repo['name']}, skipping editable install")
-
-                # Run uv sync if auto_sync is enabled and pyproject.toml exists
-                if auto_sync and (repo_path / "pyproject.toml").exists():
-                    sync_success = run_uv_sync(repo_path)
-                    if not sync_success:
-                        repo_success = False
-
-            except Exception as e:
-                print(f"❌ Error processing existing repository {repo['name']}: {e}")
-                repo_success = False
-
-        overall_success = overall_success and repo_success
-
-    return overall_success
-
-
-def install_repos(specs_path: str, clone: bool = True, checkout_to_recorded_commit: bool = False, checkout_to_branch: bool = False, editable_install: bool = False, preferred_remote: Optional[str] = None):
-    program = ""
-    path_obj = PathExtended(specs_path).expanduser().absolute()
-    repos: list[dict[str, Any]] = read_json(path_obj)
-    for repo in repos:
-        parent_dir = PathExtended(repo["parent_dir"]).expanduser().absolute()
-        parent_dir.mkdir(parents=True, exist_ok=True)
-
-        # Handle cloning and remote setup
-        if clone:
-            # Select the remote to use for cloning
-            if len(repo["remotes"]) == 0:
-                print(f"⚠️ No remotes found for {repo['name']}. Skipping clone.")
-                continue
-            remote_name, remote_url = next(iter(repo["remotes"].items()))  # Get first remote by default
-            if preferred_remote is not None and preferred_remote in repo["remotes"]:
-                remote_name = preferred_remote
-                remote_url = repo["remotes"][preferred_remote]
-            elif preferred_remote is not None:
-                print(f"⚠️ `{preferred_remote=}` not found in {repo['remotes']}.")
-
-            # Clone with the selected remote
-            program += f"\ncd {parent_dir.collapseuser().as_posix()}; git clone {remote_url} --origin {remote_name} --depth 2"
-            program += f"\ncd {parent_dir.collapseuser().as_posix()}/{repo['name']}; git remote set-url {remote_name} {remote_url}"
-
-            # Add any additional remotes
-            for other_remote_name, other_remote_url in repo["remotes"].items():
-                if other_remote_name != remote_name:
-                    program += f"\ncd {parent_dir.collapseuser().as_posix()}/{repo['name']}; git remote add {other_remote_name} {other_remote_url}"
-
-        # Handle checkout operations (after all remotes are set up)
-        if checkout_to_recorded_commit:
-            commit = repo["version"]["commit"]
-            if isinstance(commit, str):
-                program += f"\ncd {parent_dir.collapseuser().as_posix()}/{repo['name']}; git checkout {commit}"
-            else:
-                print(f"Skipping {repo['parent_dir']} because it doesn't have a commit recorded. Found {commit}")
-        elif checkout_to_branch:
-            program += f"\ncd {parent_dir.collapseuser().as_posix()}/{repo['name']}; git checkout {repo['current_branch']}"
-
-        # Handle editable install
-        if editable_install:
-            program += f"\ncd {parent_dir.collapseuser().as_posix()}/{repo['name']}; uv pip install -e ."
-
-        program += "\n"
-    pprint(program)
-    return program
-
 
 if __name__ == "__main__":
     main()

machineconfig/scripts/python/repos_helper_record.py

@@ -0,0 +1,270 @@
+
+from machineconfig.utils.path_reduced import PathExtended as PathExtended
+from machineconfig.utils.schemas.repos.repos_types import GitVersionInfo, RepoRecordDict, RepoRemote
+
+from machineconfig.utils.schemas.repos.repos_types import RepoRecordFile
+from machineconfig.utils.source_of_truth import CONFIG_PATH
+from machineconfig.utils.io_save import save_json
+
+from typing import Optional
+
+from rich import print as pprint
+from rich.progress import Progress, TaskID, SpinnerColumn, TextColumn, BarColumn, TimeElapsedColumn, MofNCompleteColumn
+
+
+def build_tree_structure(repos: list[RepoRecordDict], repos_root: PathExtended) -> str:
+    """Build a tree structure representation of all repositories."""
+    if not repos:
+        return "No repositories found."
+    
+    # Group repos by their parent directories relative to repos_root
+    tree_dict: dict[str, list[RepoRecordDict]] = {}
+    repos_root_abs = repos_root.expanduser().absolute()
+    
+    for repo in repos:
+        parent_path = PathExtended(repo["parentDir"]).expanduser().absolute()
+        try:
+            relative_path = parent_path.relative_to(repos_root_abs)
+            relative_str = str(relative_path) if str(relative_path) != "." else ""
+        except ValueError:
+            # If the path is not relative to repos_root, use the full path
+            relative_str = str(parent_path)
+        
+        if relative_str not in tree_dict:
+            tree_dict[relative_str] = []
+        tree_dict[relative_str].append(repo)
+    
+    # Sort directories for consistent output
+    sorted_dirs = sorted(tree_dict.keys())
+    
+    tree_lines: list[str] = []
+    tree_lines.append(f"📂 {repos_root.name}/ ({repos_root_abs})")
+    
+    for i, dir_path in enumerate(sorted_dirs):
+        is_last_dir = i == len(sorted_dirs) - 1
+        dir_prefix = "└── " if is_last_dir else "├── "
+        
+        if dir_path:
+            tree_lines.append(f"│   {dir_prefix}📁 {dir_path}/")
+            repo_prefix_base = "│   │   " if not is_last_dir else "    "
+        else:
+            repo_prefix_base = "│   "
+        
+        repos_in_dir = tree_dict[dir_path]
+        # Sort repos by name
+        repos_in_dir.sort(key=lambda x: x["name"])
+        
+        for j, repo in enumerate(repos_in_dir):
+            is_last_repo = j == len(repos_in_dir) - 1
+            repo_prefix = f"{repo_prefix_base}└── " if is_last_repo else f"{repo_prefix_base}├── "
+            
+            # Create status indicators
+            status_indicators = []
+            if repo["isDirty"]:
+                status_indicators.append("🔶 DIRTY")
+            if not repo["remotes"]:
+                status_indicators.append("⚠️ NO_REMOTE")
+            if repo["currentBranch"] == "DETACHED":
+                status_indicators.append("🔀 DETACHED")
+            
+            status_str = f"[{' | '.join(status_indicators)}]" if status_indicators else "[✅ CLEAN]"
+            branch_info = f" ({repo['currentBranch']})" if repo['currentBranch'] != "DETACHED" else ""
+            
+            # Build the base string without status
+            base_str = f"{repo_prefix}📦 {repo['name']}{branch_info}"
+            
+            # Calculate padding to align status at 75 characters
+            target_width = 45
+            current_length = len(base_str)
+            padding = max(1, target_width - current_length)  # At least 1 space
+            
+            tree_lines.append(f"{base_str}{' ' * padding}{status_str}")
+    
+    return "\n".join(tree_lines)
+
+
+def record_a_repo(path: PathExtended, search_parent_directories: bool, preferred_remote: Optional[str]) -> RepoRecordDict:
+    from git.repo import Repo
+
+    repo = Repo(path, search_parent_directories=search_parent_directories)  # get list of remotes using git python
+    repo_root = PathExtended(repo.working_dir).absolute()
+    # remotes: = {remote.name: remote.url for remote in repo.remotes}
+    remotes: list[RepoRemote] = [{"name": remote.name, "url": remote.url} for remote in repo.remotes]
+    if preferred_remote is not None:
+        if preferred_remote in [remote["name"] for remote in remotes]:
+            remotes = [remote for remote in remotes if remote["name"] == preferred_remote]
+        else:
+            print(f"⚠️ `{preferred_remote=}` not found in {remotes}.")
+            preferred_remote = None
+    try:
+        commit = repo.head.commit.hexsha
+    except ValueError:  # look at https://github.com/gitpython-developers/GitPython/issues/1016
+        print(f"⚠️ Failed to get latest commit of {repo}")
+        commit = "UNKNOWN"
+    try:
+        current_branch = repo.head.reference.name  # same as repo.active_branch.name
+    except TypeError:
+        print(f"⁉️ Failed to get current branch of {repo}. It is probably in a detached state.")
+        # current_branch = None
+        current_branch = "DETACHED"
+
+    # Check if repo is dirty (has uncommitted changes)
+    is_dirty = repo.is_dirty(untracked_files=True)
+
+    version_info: GitVersionInfo = {
+        "branch": current_branch,
+        "commit": commit
+    }
+
+    res: RepoRecordDict = {
+        "name": repo_root.name,
+        "parentDir": repo_root.parent.collapseuser().as_posix(),
+        "currentBranch": current_branch,
+        "remotes": remotes,
+        "version": version_info,
+        "isDirty": is_dirty
+    }
+    return res
+
+
+def count_git_repositories(repos_root: str, r: bool) -> int:
+    """Count total git repositories for accurate progress tracking."""
+    path_obj = PathExtended(repos_root).expanduser().absolute()
+    if path_obj.is_file():
+        return 0
+    
+    search_res = path_obj.search("*", files=False, folders=True)
+    count = 0
+    
+    for a_search_res in search_res:
+        if a_search_res.joinpath(".git").exists():
+            count += 1
+        elif r:
+            count += count_git_repositories(str(a_search_res), r=r)
+    
+    return count
+
+
+def count_total_directories(repos_root: str, r: bool) -> int:
+    """Count total directories to scan for accurate progress tracking."""
+    path_obj = PathExtended(repos_root).expanduser().absolute()
+    if path_obj.is_file():
+        return 0
+    
+    search_res = path_obj.search("*", files=False, folders=True)
+    count = len(search_res)
+    
+    if r:
+        for a_search_res in search_res:
+            if not a_search_res.joinpath(".git").exists():
+                count += count_total_directories(str(a_search_res), r=r)
+    
+    return count
+
+
+def record_repos_recursively(repos_root: str, r: bool, progress: Progress | None, scan_task_id: TaskID | None, process_task_id: TaskID | None) -> list[RepoRecordDict]:
+    path_obj = PathExtended(repos_root).expanduser().absolute()
+    if path_obj.is_file():
+        return []
+    
+    search_res = path_obj.search("*", files=False, folders=True)
+    res: list[RepoRecordDict] = []
+    
+    for a_search_res in search_res:
+        if progress and scan_task_id:
+            progress.update(scan_task_id, description=f"Scanning: {a_search_res.name}")
+        
+        if a_search_res.joinpath(".git").exists():
+            try:
+                if progress and process_task_id:
+                    progress.update(process_task_id, description=f"Recording: {a_search_res.name}")
+                    
+                repo_record = record_a_repo(a_search_res, search_parent_directories=False, preferred_remote=None)
+                res.append(repo_record)
+                
+                if progress and process_task_id:
+                    progress.update(process_task_id, advance=1, description=f"Recorded: {repo_record['name']}")
+            except Exception as e:
+                print(f"⚠️ Failed to record {a_search_res}: {e}")
+        else:
+            if r:
+                res += record_repos_recursively(str(a_search_res), r=r, progress=progress, scan_task_id=scan_task_id, process_task_id=process_task_id)
+        
+        if progress and scan_task_id:
+            progress.update(scan_task_id, advance=1)
+    
+    return res
+
+
+def main(repos_root: PathExtended):
+    print("\n📝 Recording repositories...")
+    
+    # Count total directories and repositories for accurate progress tracking
+    print("🔍 Analyzing directory structure...")
+    total_dirs = count_total_directories(str(repos_root), r=True)
+    total_repos = count_git_repositories(str(repos_root), r=True)
+    print(f"📊 Found {total_dirs} directories to scan and {total_repos} git repositories to record")
+    
+    # Setup progress bars
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        BarColumn(),
+        MofNCompleteColumn(),
+        TimeElapsedColumn(),
+    ) as progress:
+        scan_task = progress.add_task("Scanning directories...", total=total_dirs)
+        process_task = progress.add_task("Recording repositories...", total=total_repos)
+        
+        repo_records = record_repos_recursively(
+            repos_root=str(repos_root), 
+            r=True,
+            progress=progress, 
+            scan_task_id=scan_task, 
+            process_task_id=process_task
+        )
+    
+    res: RepoRecordFile = {"version": "0.1", "repos": repo_records}
+    
+    # Summary with warnings
+    total_repos = len(repo_records)
+    repos_with_no_remotes = [repo for repo in repo_records if len(repo["remotes"]) == 0]
+    repos_with_remotes = [repo for repo in repo_records if len(repo["remotes"]) > 0]
+    dirty_repos = [repo for repo in repo_records if repo["isDirty"]]
+    clean_repos = [repo for repo in repo_records if not repo["isDirty"]]
+    
+    print("\n📊 Repository Summary:")
+    print(f"   Total repositories found: {total_repos}")
+    print(f"   Repositories with remotes: {len(repos_with_remotes)}")
+    print(f"   Repositories without remotes: {len(repos_with_no_remotes)}")
+    print(f"   Clean repositories: {len(clean_repos)}")
+    print(f"   Dirty repositories: {len(dirty_repos)}")
+    
+    if repos_with_no_remotes:
+        print(f"\n⚠️  WARNING: {len(repos_with_no_remotes)} repositories have no remotes configured:")
+        for repo in repos_with_no_remotes:
+            repo_path = PathExtended(repo["parentDir"]).joinpath(repo["name"])
+            print(f"   • {repo['name']} ({repo_path})")
+        print("   These repositories may be local-only or have configuration issues.")
+    else:
+        print("\n✅ All repositories have remote configurations.")
+
+    if dirty_repos:
+        print(f"\n⚠️  WARNING: {len(dirty_repos)} repositories have uncommitted changes:")
+        for repo in dirty_repos:
+            repo_path = PathExtended(repo["parentDir"]).joinpath(repo["name"])
+            print(f"   • {repo['name']} ({repo_path}) [branch: {repo['currentBranch']}]")
+        print("   These repositories have uncommitted changes that may need attention.")
+    else:
+        print("\n✅ All repositories are clean (no uncommitted changes).")
+    
+    # Display repository tree structure
+    print("\n🌳 Repository Tree Structure:")
+    tree_structure = build_tree_structure(repo_records, repos_root)
+    print(tree_structure)
+    
+    save_path = CONFIG_PATH.joinpath("repos").joinpath(repos_root.rel2home()).joinpath("repos.json")
+    save_json(obj=res, path=save_path, indent=4)
+    pprint(f"📁 Result saved at {PathExtended(save_path)}")
+    print(">>>>>>>>> Finished Recording")
+    return save_path

machineconfig/scripts/windows/choose_wezterm_theme.ps1

@@ -1 +1 @@
-uv run --python 3.13 --with machineconfig python -m fire machineconfig.scripts.python.choose_wezterm_theme main2 $args[0]
+uv run --python 3.13 --no-dev --project $HOME/code/machineconfig choose_wezterm_theme $args[0]

machineconfig/scripts/windows/cloud_copy.ps1

@@ -1 +1 @@
-uv run --python 3.13 --with machineconfig python -m machineconfig.scripts.python.cloud_copy $args
+uv run --python 3.13 --no-dev --project $HOME/code/machineconfig cloud_copy $args

machineconfig/scripts/windows/cloud_mount.ps1

@@ -1 +1 @@
-uv run --python 3.13 --with machineconfig python -m machineconfig.scripts.python.cloud_mount $args
+uv run --python 3.13 --no-dev --project $HOME/code/machineconfig cloud_mount $args

machineconfig/scripts/windows/cloud_repo_sync.ps1

@@ -1 +1 @@
-uv run --python 3.13 --with machineconfig python -m machineconfig.scripts.python.cloud_repo_sync $args
+uv run --python 3.13 --no-dev --project $HOME/code/machineconfig cloud_repo_sync $args

machineconfig/scripts/windows/cloud_sync.ps1

@@ -1 +1 @@
-uv run --python 3.13 --with machineconfig python -m machineconfig.scripts.python.cloud_sync $args
+uv run --python 3.13 --no-dev --project $HOME/code/machineconfig cloud_sync $args

machineconfig/scripts/windows/croshell.ps1

@@ -1 +1 @@
-uv run --python 3.13 --with machineconfig python -m machineconfig.scripts.python.croshell $args
+uv run --python 3.13 --no-dev --project $HOME/code/machineconfig croshell $args

machineconfig/scripts/windows/devops.ps1

@@ -1,29 +1 @@
-
-# ensure that python-output-script is deleted.
-$op_script = "~/tmp_results/shells/python_return_command.ps1"
-if (Test-Path $op_script ) {
-  Remove-Item $op_script
-}
-
-
-. "$HOME\code\machineconfig\.venv\Scripts\activate.ps1"
-
-# Locate the python script to run relative to the current directory (which might be a symlink)
-$script_root = (Get-Item $PSScriptRoot).Target  # resolves symlink if any
-if ( $script_root -eq $null) {  # this does happen if a virtual enviroment is activated before running this script (don't know why)
-$script_root = $PSScriptRoot
-}
-
-python $script_root/../python/devops.py $args
-
-if (Test-Path $op_script ) {
-  . $op_script
-}
-else
-{
-    Write-Host "🤷‍♂️ No output script to be executed @ $op_script"
-}
-
-
-deactivate -ErrorAction SilentlyContinue
-
+uv run --python 3.13 --no-dev --project $HOME/code/machineconfig devops $args

machineconfig/scripts/windows/dotfile.ps1

@@ -1 +1 @@
-uv run --python 3.13 --with machineconfig python -m machineconfig.scripts.python.dotfile $args
+uv run --python 3.13 --no-dev --project $HOME/code/machineconfig dotfile $args

machineconfig/scripts/windows/fire.ps1

@@ -1,45 +1 @@
-
-# param(
-#     [switch]$IgnoreKeyboardInterrupt
-# )
-
-# Generate a random string of 10 characters
-$random_str = -join ((65..90) + (97..122) + (48..57) | Get-Random -Count 10 | ForEach-Object {[char]$_})
-$op_script = "$HOME\tmp_results\shells\$random_str\python_return_command.ps1"
-# Export the op_script variable to environment so python can access it
-$env:op_script = $op_script
-
-# Create directory if it doesn't exist
-$script_dir = Split-Path -Path $op_script -Parent
-if (-not (Test-Path $script_dir)) {
-    New-Item -ItemType Directory -Path $script_dir -Force | Out-Null
-}
-
-# if (Test-Path $op_script ) {
-#   Remove-Item $op_script
-# }
-
-
-# try {
-#   # $null = & chafa --version
-#   # & chafa "$HOME\code\machineconfig\assets\aafire.webp" --speed 2 --duration 1
-#   # Chafa.exe "$HOME\code\machineconfig\assets\aafire.webp" --speed 2 --duration 1 --symbols ascii
-#   Write-Host "🔥"
-# } catch {
-#   Write-Host "Chafa not found, skipping."
-# }
-
-
-. "$HOME\code\machineconfig\.venv\Scripts\activate.ps1"
-python -m machineconfig.scripts.python.fire_jobs $args
-
-
-if (Test-Path $op_script ) {
-    . $op_script
-}
-else
-{
-    Write-Host "No output script to be executed at $op_script."
-}
-
-deactivate -ErrorAction SilentlyContinue
+uv run --python 3.13 --no-dev --project $HOME/code/machineconfig fire $args

machineconfig/scripts/windows/ftpx.ps1

@@ -1 +1 @@
-uv run --python 3.13 --with machineconfig python $PSScriptRoot/../python/ftpx.py $args
+uv run --python 3.13 --no-dev --project $HOME/code/machineconfig ftpx $args