machineconfig 2.0__py3-none-any.whl → 2.2__py3-none-any.whl

machineconfig/scripts/python/devops_update_repos.py

@@ -1,21 +1,220 @@
-"""Update repositories with fancy output
-"""
+"""Update repositories with fancy output"""
 
-from machineconfig.utils.path_reduced import P as PathExtended
-from machineconfig.utils.utils import DEFAULTS_PATH
+import git
+import subprocess
+import hashlib
+from pathlib import Path
+from machineconfig.utils.path_reduced import PathExtended as PathExtended
+from machineconfig.utils.source_of_truth import DEFAULTS_PATH
 from machineconfig.utils.utils2 import read_ini
-from platform import system
 
 
-sep = "\n"
+def get_file_hash(file_path: Path) -> str | None:
+    """Get SHA256 hash of a file, return None if file doesn't exist."""
+    if not file_path.exists():
+        return None
+    return hashlib.sha256(file_path.read_bytes()).hexdigest()
 
 
-def main(verbose: bool=True) -> str:
+def set_permissions_recursive(path: Path, executable: bool = True) -> None:
+    """Set permissions recursively for a directory."""
+    if not path.exists():
+        return
+
+    if path.is_file():
+        if executable:
+            path.chmod(0o755)
+        else:
+            path.chmod(0o644)
+    elif path.is_dir():
+        path.chmod(0o755)
+        for item in path.rglob("*"):
+            set_permissions_recursive(item, executable)
+
+
+def run_uv_sync(repo_path: Path) -> bool:
+    """Run uv sync in the given repository path. Returns True if successful."""
+    try:
+        print(f"🔄 Running uv sync in {repo_path}")
+        result = subprocess.run(["uv", "sync"], cwd=repo_path, capture_output=True, text=True, check=True)
+        print("✅ uv sync completed successfully")
+        if result.stdout:
+            print(f"📝 Output: {result.stdout}")
+        return True
+    except subprocess.CalledProcessError as e:
+        print(f"❌ uv sync failed: {e}")
+        if e.stderr:
+            print(f"📝 Error: {e.stderr}")
+        return False
+    except FileNotFoundError:
+        print("⚠️  uv command not found. Please install uv first.")
+        return False
+
+
+def update_repository(repo: git.Repo, auto_sync: bool = True, allow_password_prompt: bool = False) -> bool:
+    """Update a single repository and return True if pyproject.toml or uv.lock changed."""
+    repo_path = Path(repo.working_dir)
+    print(f"🔄 {'Updating ' + str(repo_path):.^80}")
+
+    # Check if this repo has pyproject.toml or uv.lock
+    pyproject_path = repo_path / "pyproject.toml"
+    uv_lock_path = repo_path / "uv.lock"
+
+    # Get hashes before pull
+    pyproject_hash_before = get_file_hash(pyproject_path)
+    uv_lock_hash_before = get_file_hash(uv_lock_path)
+
+    # Get current commit hash before pull
+    commit_before = repo.head.commit.hexsha
+
+    try:
+        # Use subprocess for git pull to get better output control
+        dependencies_changed = False
+
+        # Get list of remotes
+        remotes = list(repo.remotes)
+        if not remotes:
+            print("⚠️  No remotes configured for this repository")
+            return False
+
+        for remote in remotes:
+            try:
+                print(f"📥 Fetching from {remote.name}...")
+
+                # Set up environment for git commands
+                env = None
+                if not allow_password_prompt:
+                    # Disable interactive prompts
+                    import os
+
+                    env = os.environ.copy()
+                    env["GIT_TERMINAL_PROMPT"] = "0"
+                    env["GIT_ASKPASS"] = "echo"  # Returns empty string for any credential request
+
+                # First fetch to see what's available
+                fetch_result = subprocess.run(
+                    ["git", "fetch", remote.name, "--verbose"],
+                    cwd=repo_path,
+                    capture_output=True,
+                    text=True,
+                    env=env,
+                    timeout=30,  # Add timeout to prevent hanging
+                )
+
+                # Check if fetch failed due to authentication
+                if fetch_result.returncode != 0 and not allow_password_prompt:
+                    auth_error_indicators = [
+                        "Authentication failed",
+                        "Password for",
+                        "Username for",
+                        "could not read Username",
+                        "could not read Password",
+                        "fatal: Authentication failed",
+                        "fatal: could not read Username",
+                        "fatal: could not read Password",
+                    ]
+
+                    error_output = (fetch_result.stderr or "") + (fetch_result.stdout or "")
+                    if any(indicator in error_output for indicator in auth_error_indicators):
+                        print(f"⚠️  Skipping {remote.name} - authentication required but password prompts are disabled")
+                        continue
+
+                if fetch_result.stdout:
+                    print(f"📡 Fetch output: {fetch_result.stdout.strip()}")
+                if fetch_result.stderr:
+                    print(f"📡 Fetch info: {fetch_result.stderr.strip()}")
+
+                # Now pull with verbose output
+                print(f"📥 Pulling from {remote.name}/{repo.active_branch.name}...")
+                pull_result = subprocess.run(["git", "pull", remote.name, repo.active_branch.name, "--verbose"], cwd=repo_path, capture_output=True, text=True, env=env, timeout=30)
+
+                # Check if pull failed due to authentication
+                if pull_result.returncode != 0 and not allow_password_prompt:
+                    auth_error_indicators = [
+                        "Authentication failed",
+                        "Password for",
+                        "Username for",
+                        "could not read Username",
+                        "could not read Password",
+                        "fatal: Authentication failed",
+                        "fatal: could not read Username",
+                        "fatal: could not read Password",
+                    ]
+
+                    error_output = (pull_result.stderr or "") + (pull_result.stdout or "")
+                    if any(indicator in error_output for indicator in auth_error_indicators):
+                        print(f"⚠️  Skipping pull from {remote.name} - authentication required but password prompts are disabled")
+                        continue
+
+                if pull_result.stdout:
+                    print(f"📦 Pull output: {pull_result.stdout.strip()}")
+                if pull_result.stderr:
+                    print(f"📦 Pull info: {pull_result.stderr.strip()}")
+
+                # Check if pull was successful
+                if pull_result.returncode == 0:
+                    # Check if commits changed
+                    commit_after = repo.head.commit.hexsha
+                    if commit_before != commit_after:
+                        print(f"✅ Repository updated: {commit_before[:8]} → {commit_after[:8]}")
+                    else:
+                        print("✅ Already up to date")
+                else:
+                    print(f"❌ Pull failed with return code {pull_result.returncode}")
+
+            except Exception as e:
+                print(f"⚠️  Failed to pull from {remote.name}: {e}")
+                continue
+
+        # Check if pyproject.toml or uv.lock changed after pull
+        pyproject_hash_after = get_file_hash(pyproject_path)
+        uv_lock_hash_after = get_file_hash(uv_lock_path)
+
+        if pyproject_hash_before != pyproject_hash_after:
+            print("📋 pyproject.toml has changed")
+            dependencies_changed = True
+
+        if uv_lock_hash_before != uv_lock_hash_after:
+            print("🔒 uv.lock has changed")
+            dependencies_changed = True
+
+        # Special handling for machineconfig repository
+        if "machineconfig" in str(repo_path):
+            print("🛠  Special handling for machineconfig repository...")
+            scripts_path = Path.home() / "scripts"
+            if scripts_path.exists():
+                set_permissions_recursive(scripts_path)
+                print(f"✅ Set permissions for {scripts_path}")
+
+            linux_jobs_path = repo_path / "src" / "machineconfig" / "jobs" / "linux"
+            if linux_jobs_path.exists():
+                set_permissions_recursive(linux_jobs_path)
+                print(f"✅ Set permissions for {linux_jobs_path}")
+
+            lf_exe_path = repo_path / "src" / "machineconfig" / "settings" / "lf" / "linux" / "exe"
+            if lf_exe_path.exists():
+                set_permissions_recursive(lf_exe_path)
+                print(f"✅ Set permissions for {lf_exe_path}")
+
+        # Run uv sync if dependencies changed and auto_sync is enabled
+        if dependencies_changed and auto_sync:
+            run_uv_sync(repo_path)
+
+        return dependencies_changed
+
+    except Exception as e:
+        print(f"❌ Error updating repository {repo_path}: {e}")
+        return False
+
+
+def main(verbose: bool = True, allow_password_prompt: bool = False) -> str:
+    """Main function to update all configured repositories."""
     _ = verbose
-    repos: list[str] = ["~/code/crocodile", "~/code/machineconfig", ]
+    repos: list[str] = ["~/code/machineconfig", "~/code/crocodile"]
     try:
-        tmp = read_ini(DEFAULTS_PATH)['general']['repos'].split(",")
-        if tmp[-1] == "": tmp = tmp[:-1]
+        tmp = read_ini(DEFAULTS_PATH)["general"]["repos"].split(",")
+        if tmp[-1] == "":
+            tmp = tmp[:-1]
         repos += tmp
     except (FileNotFoundError, KeyError, IndexError):
         print(f"""
@@ -34,57 +233,31 @@ def main(verbose: bool=True) -> str:
 │ to_email = myemail@email.com
 └────────────────────────────────────────────────────────────────""")
 
-    repos_objs = []
+    # Process repositories
+    repos_with_changes = []
     for a_package_path in repos:
         try:
-            import git
-            repo = git.Repo(str(PathExtended(a_package_path).expanduser()), search_parent_directories=True)
-            repos_objs.append(repo)
+            expanded_path = PathExtended(a_package_path).expanduser()
+            repo = git.Repo(str(expanded_path), search_parent_directories=True)
+
+            # Update repository and check if dependencies changed
+            dependencies_changed = update_repository(repo, allow_password_prompt=allow_password_prompt)
+
+            if dependencies_changed:
+                repos_with_changes.append(Path(repo.working_dir))
+
         except Exception as ex:
-            print(f"""
-❌ Repository Error:
-   Path: {a_package_path}
-   Exception: {ex}
-{'-' * 50}""")
-
-    if system() == "Linux":
-        additions = []
-        for a_repo in repos_objs:
-            if "machineconfig" in str(a_repo.working_dir):  # special treatment because of executables.
-                an_addition = f"""
-echo ""
-echo "🔄 {("Updating " + str(a_repo.working_dir)).center(80, "═")}"
-echo "🛠  Special handling for machineconfig repository..."
-cd "{a_repo.working_dir}"
-# git reset --hard
-git pull origin &
-chmod +x ~/scripts -R
-chmod +x ~/code/machineconfig/src/machineconfig/jobs/linux -R
-chmod +x ~/code/machineconfig/src/machineconfig/settings/lf/linux/exe -R
-"""
-                additions.append(an_addition)
-            else:
-                additions.append(f"""
-echo "🔄 {("Updating " + str(a_repo.working_dir)).center(80, "═")}"
-cd "{a_repo.working_dir}"
-{sep.join([f'git pull {remote.name} {a_repo.active_branch.name} &' for remote in a_repo.remotes])}
-"""
-)
-        program = "\n".join(additions)
-
-    elif system() == "Windows":
-        program = "\n".join([f"""
-echo "🔄 {("Updating " + str(a_repo.working_dir)).center(80, "═")}"
-cd "{a_repo.working_dir}"
-{sep.join([f'git pull {remote.name} {a_repo.active_branch.name}' for remote in a_repo.remotes])}
-""" for a_repo in repos_objs])
-    else: raise NotImplementedError(f"""
-┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-┃ ⚠️  Unsupported System: {system()}
-┃ ℹ️  This functionality is only available on Windows and Linux
-┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━""")
-    return program
+            print(f"""❌ Repository Error: Path: {a_package_path}
+Exception: {ex}
+{"-" * 50}""")
+
+    # Run uv sync for repositories where pyproject.toml or uv.lock changed
+    for repo_path in repos_with_changes:
+        run_uv_sync(repo_path)
+
+    # print("\n🎉 All repositories updated successfully!")
+    return """echo "🎉 All repositories updated successfully!" """
 
 
-if __name__ == '__main__':
-    pass
+if __name__ == "__main__":
+    main()

machineconfig/scripts/python/dotfile.py

@@ -1,15 +1,13 @@
-"""Like yadm and dotter.
-"""
+"""Like yadm and dotter."""
 
-
-from machineconfig.utils.path_reduced import P as PathExtended
-from machineconfig.profile.create import symlink_func
-from machineconfig.utils.utils import LIBRARY_ROOT, REPO_ROOT
+from machineconfig.utils.path_reduced import PathExtended as PathExtended
+from machineconfig.utils.links import symlink_func
+from machineconfig.utils.source_of_truth import LIBRARY_ROOT, REPO_ROOT
 import argparse
 
 
 def main():
-    parser = argparse.ArgumentParser(description='FTP client')
+    parser = argparse.ArgumentParser(description="FTP client")
 
     parser.add_argument("file", help="file/folder path.", default="")
     # FLAGS
@@ -20,11 +18,15 @@ def main():
     args = parser.parse_args()
     orig_path = PathExtended(args.file).expanduser().absolute()
     if args.dest == "":
-        if "Local" in str(orig_path): junction = orig_path.split(at="Local", sep=-1)[1]
-        elif "Roaming" in str(orig_path): junction = orig_path.split(at="Roaming", sep=-1)[1]
-        elif ".config" in str(orig_path): junction = orig_path.split(at=".config", sep=-1)[1]
-        else: junction = orig_path.rel2home()
-        new_path = REPO_ROOT.joinpath(junction)
+        if "Local" in str(orig_path):
+            junction = orig_path.split(at="Local", sep=-1)[1]
+        elif "Roaming" in str(orig_path):
+            junction = orig_path.split(at="Roaming", sep=-1)[1]
+        elif ".config" in str(orig_path):
+            junction = orig_path.split(at=".config", sep=-1)[1]
+        else:
+            junction = orig_path.rel2home()
+        new_path = PathExtended(REPO_ROOT).joinpath(junction)
     else:
         dest_path = PathExtended(args.dest).expanduser().absolute()
         dest_path.mkdir(parents=True, exist_ok=True)
@@ -39,12 +41,12 @@ def main():
 ┃ 🔄 To enshrine this mapping, add the following to mapper.toml:
 ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━""")
     print(f"""
-📝 Edit configuration file: nano {LIBRARY_ROOT}/symlinks/mapper.toml
+📝 Edit configuration file: nano {PathExtended(LIBRARY_ROOT)}/symlinks/mapper.toml
 
 [{new_path.parent.name}]
-{orig_path.name.split('.')[0]} = {{ this = '{orig_path.collapseuser().as_posix()}', to_this = '{new_path.collapseuser().as_posix()}' }}
+{orig_path.name.split(".")[0]} = {{ this = '{orig_path.collapseuser().as_posix()}', to_this = '{new_path.collapseuser().as_posix()}' }}
 """)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()

machineconfig/scripts/python/fire_agents.py

@@ -1,4 +1,3 @@
-
 """Utility to launch multiple AI agent prompts in a Zellij session.
 
 Improved design notes:
@@ -17,14 +16,20 @@ from typing import Literal, TypeAlias, get_args, Iterable
 
 from machineconfig.cluster.sessions_managers.zellij_local_manager import ZellijLocalManager
 from machineconfig.utils.utils2 import randstr
+import random
+# import time
 
-AGENTS: TypeAlias = Literal["cursor-agent", "gemini", "crush"]
+AGENTS: TypeAlias = Literal[
+    "cursor-agent", "gemini", "crush", "q", "onlyPrepPromptFiles"
+    # warp terminal
+]
 TabConfig = dict[str, tuple[str, str]]  # tab name -> (cwd, command)
 DEFAULT_AGENT_CAP = 6
 
 
 def get_gemini_api_keys() -> list[str]:
     from machineconfig.utils.utils2 import read_ini
+
     config = read_ini(Path.home().joinpath("dotfiles/creds/llm/gemini/api_keys.ini"))
     res: list[str] = []
     for a_section_name in list(config.sections()):
@@ -41,12 +46,17 @@ def get_gemini_api_keys() -> list[str]:
 def _search_python_files(repo_root: Path, keyword: str) -> list[Path]:
     """Return all Python files under repo_root whose text contains keyword.
 
-    Errors reading individual files are ignored (decoded with 'ignore').
+    Notes:
+      - Skips any paths that reside under a directory named ".venv" at any depth.
+      - Errors reading individual files are ignored (decoded with 'ignore').
     """
     py_files = list(repo_root.rglob("*.py"))
     keyword_lower = keyword.lower()
     matches: list[Path] = []
     for f in py_files:
+        # Skip anything under a .venv directory anywhere in the path
+        if any(part == ".venv" for part in f.parts):
+            continue
         try:
             if keyword_lower in f.read_text(encoding="utf-8", errors="ignore").lower():
                 matches.append(f)
@@ -59,6 +69,8 @@ def _search_python_files(repo_root: Path, keyword: str) -> list[Path]:
 def _write_list_file(target: Path, files: Iterable[Path]) -> None:
     target.parent.mkdir(parents=True, exist_ok=True)
     target.write_text("\n".join(str(f) for f in files), encoding="utf-8")
+
+
 def _chunk_prompts(prompts: list[str], max_agents: int) -> list[str]:
     prompts = [p for p in prompts if p.strip() != ""]  # drop blank entries
     if len(prompts) <= max_agents:
@@ -69,6 +81,8 @@ def _chunk_prompts(prompts: list[str], max_agents: int) -> list[str]:
     for i in range(0, len(prompts), chunk_size):
         grouped.append("\nTargeted Locations:\n".join(prompts[i : i + chunk_size]))
     return grouped
+
+
 def _confirm(message: str, default_no: bool = True) -> bool:
     suffix = "[y/N]" if default_no else "[Y/n]"
     answer = input(f"{message} {suffix} ").strip().lower()
@@ -89,11 +103,7 @@ def launch_agents(repo_root: Path, prompts: list[str], agent: AGENTS, *, max_age
         raise ValueError("No prompts provided")
 
     if len(prompts) > max_agents:
-        proceed = _confirm(
-            message=(
-                f"You are about to launch {len(prompts)} agents which exceeds the cap ({max_agents}). Proceed?"
-            )
-        )
+        proceed = _confirm(message=(f"You are about to launch {len(prompts)} agents which exceeds the cap ({max_agents}). Proceed?"))
         if not proceed:
             print("Aborting per user choice.")
             return {}
@@ -105,6 +115,7 @@ def launch_agents(repo_root: Path, prompts: list[str], agent: AGENTS, *, max_age
     for idx, a_prompt in enumerate(prompts):
         prompt_path = tmp_dir / f"agent{idx}_prompt.txt"
         prompt_path.write_text(a_prompt, encoding="utf-8")
+        cmd_path = tmp_dir / f"agent{idx}_cmd.sh"
         match agent:
             case "gemini":
                 # model = "gemini-2.5-pro"
@@ -122,27 +133,45 @@ def launch_agents(repo_root: Path, prompts: list[str], agent: AGENTS, *, max_age
                 cmd = f"""
 export GEMINI_API_KEY={shlex.quote(api_key)}
 echo "Using Gemini API key $GEMINI_API_KEY"
-echo "Launching gemini agent with prompt from {shlex.quote(str(prompt_path))}"
 cat {prompt_path}
 GEMINI_API_KEY={shlex.quote(api_key)} bash -lc 'cat {safe_path} | gemini {model_arg} --yolo --prompt'
 """
             case "cursor-agent":
                 # As originally implemented
                 cmd = f"""
-echo "Launching cursor-agent with prompt from {shlex.quote(str(prompt_path))}"
-cat {prompt_path}
+
 cursor-agent --print --output-format text < {prompt_path}
+
 """
             case "crush":
                 cmd = f"""
-echo "Launching crush with prompt from {shlex.quote(str(prompt_path))}"
-cat {prompt_path}
-cat {prompt_path} | crush run
+# cat {prompt_path} | crush run
+crush run {prompt_path}
+"""
+            case "q":
+                cmd = f"""
+q chat --no-interactive --trust-all-tools {prompt_path}
+"""
+            case "onlyPrepPromptFiles":
+                cmd = f"""
+echo "Prepared prompt file at {prompt_path}"
 """
             case _:
                 raise ValueError(f"Unsupported agent type: {agent}")
-        cmd_path = tmp_dir / f"agent{idx}_cmd.sh"
-        cmd_path.write_text(cmd, encoding="utf-8")
+        random_sleep_time = random.uniform(0, 5)
+        cmd_prefix = f"""
+echo "Sleeping for {random_sleep_time:.2f} seconds to stagger agent startups..."
+sleep {random_sleep_time:.2f}
+echo "Launching `{agent}` with prompt from {prompt_path}"
+echo "Launching `{agent}` with command from {cmd_path}"
+echo "--------START OF AGENT OUTPUT--------"
+sleep 0.1
+"""
+        cmd_postfix = """
+sleep 0.1
+echo "---------END OF AGENT OUTPUT---------"
+"""
+        cmd_path.write_text(cmd_prefix + cmd + cmd_postfix, encoding="utf-8")
         fire_cmd = f"bash {shlex.quote(str(cmd_path))}"
         tab_config[f"Agent{idx}"] = (str(repo_root), fire_cmd)
 
@@ -189,18 +218,15 @@ def main():  # noqa: C901 - (complexity acceptable for CLI glue)
     combined_prompts = [prefix + "\n" + p for p in combined_prompts]
 
     from machineconfig.utils.options import choose_one_option
+
     agent_selected = choose_one_option(header="Select agent type", options=get_args(AGENTS))
 
-    tab_config = launch_agents(
-        repo_root=repo_root,
-        prompts=combined_prompts,
-        agent=agent_selected,
-        max_agents=DEFAULT_AGENT_CAP,
-    )
+    tab_config = launch_agents(repo_root=repo_root, prompts=combined_prompts, agent=agent_selected, max_agents=DEFAULT_AGENT_CAP)
     if not tab_config:
         return
 
     from machineconfig.utils.utils2 import randstr
+
     random_name = randstr(length=3)
     manager = ZellijLocalManager(session2zellij_tabs={"Agents": tab_config}, session_name_prefix=random_name)
     manager.start_all_sessions()