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

machineconfig/scripts/python/devops_backup_retrieve.py

@@ -2,7 +2,7 @@
 """
 
 # import subprocess
-from machineconfig.utils.path_reduced import P as PathExtended
+from machineconfig.utils.path_reduced import PathExtended as PathExtended
 from machineconfig.utils.utils2 import read_ini, read_toml
 from machineconfig.utils.utils import LIBRARY_ROOT, DEFAULTS_PATH, print_code, choose_cloud_interactively, choose_multiple_options
 from machineconfig.scripts.python.helpers.helpers2 import ES
@@ -17,7 +17,7 @@ OPTIONS = Literal["BACKUP", "RETRIEVE"]
 
 def main_backup_retrieve(direction: OPTIONS, which: Optional[str] = None):
     console = Console()
-    
+
     try:
         cloud: str = read_ini(DEFAULTS_PATH)['general']['rclone_config_name']
         console.print(Panel(f"⚠️  DEFAULT CLOUD CONFIGURATION\n🌥️  Using default cloud: {cloud}", title="[bold blue]Cloud Configuration[/bold blue]", border_style="blue"))
@@ -26,13 +26,13 @@ def main_backup_retrieve(direction: OPTIONS, which: Optional[str] = None):
         cloud = choose_cloud_interactively()
 
     bu_file: dict[str, Any] = read_toml(LIBRARY_ROOT.joinpath("profile/backup.toml"))
-    
+
     console.print(Panel(f"🧰 LOADING BACKUP CONFIGURATION\n📄 File: {LIBRARY_ROOT.joinpath('profile/backup.toml')}", title="[bold blue]Backup Configuration[/bold blue]", border_style="blue"))
-    
-    if system() == "Linux": 
+
+    if system() == "Linux":
         bu_file = {key: val for key, val in bu_file.items() if "windows" not in key}
         console.print(Panel(f"🐧 LINUX ENVIRONMENT DETECTED\n🔍 Filtering out Windows-specific entries\n✅ Found {len(bu_file)} applicable backup configuration entries", title="[bold blue]Linux Environment[/bold blue]", border_style="blue"))
-    elif system() == "Windows": 
+    elif system() == "Windows":
         bu_file = {key: val for key, val in bu_file.items() if "linux" not in key}
         console.print(Panel(f"🪟 WINDOWS ENVIRONMENT DETECTED\n🔍 Filtering out Linux-specific entries\n✅ Found {len(bu_file)} applicable backup configuration entries", title="[bold blue]Windows Environment[/bold blue]", border_style="blue"))
 
@@ -59,14 +59,14 @@ def main_backup_retrieve(direction: OPTIONS, which: Optional[str] = None):
         flags += 'o' if system().lower() in item_name else ''
         console.print(Panel(f"📦 PROCESSING: {item_name}\n📂 Path: {PathExtended(item['path']).as_posix()}\n🏳️  Flags: {flags or 'None'}", title=f"[bold blue]Processing Item: {item_name}[/bold blue]", border_style="blue"))
         if flags: flags = "-" + flags
-        if direction == "BACKUP": 
+        if direction == "BACKUP":
             program += f"""\ncloud_copy "{PathExtended(item['path']).as_posix()}" $cloud {flags}\n"""
-        elif direction == "RETRIEVE": 
+        elif direction == "RETRIEVE":
             program += f"""\ncloud_copy $cloud "{PathExtended(item['path']).as_posix()}" {flags}\n"""
         else:
             console.print(Panel("❌ ERROR: INVALID DIRECTION\n⚠️  Direction must be either \"BACKUP\" or \"RETRIEVE\"", title="[bold red]Error: Invalid Direction[/bold red]", border_style="red"))
-            raise RuntimeError(f"Unknown direction: {direction}")            
-        if item_name == "dotfiles" and system() == "Linux": 
+            raise RuntimeError(f"Unknown direction: {direction}")
+        if item_name == "dotfiles" and system() == "Linux":
             program += """\nchmod 700 ~/.ssh/*\n"""
             console.print(Panel("🔒 SPECIAL HANDLING: SSH PERMISSIONS\n🛠️  Setting secure permissions for SSH files\n📝 Command: chmod 700 ~/.ssh/*", title="[bold blue]Special Handling: SSH Permissions[/bold blue]", border_style="blue"))
     print_code(program, lexer="shell", desc=f"{direction} script")
@@ -76,14 +76,14 @@ def main_backup_retrieve(direction: OPTIONS, which: Optional[str] = None):
 
 def main(direction: OPTIONS, which: Optional[str] = None):
     console = Console()
-    
+
     console.print(Panel(f"🔄 {direction} OPERATION STARTED\n⏱️  {'-' * 58}", title="[bold blue]Operation Initiated[/bold blue]", border_style="blue"))
-    
+
     code = main_backup_retrieve(direction=direction, which=which)
     from machineconfig.utils.utils import write_shell_script_to_default_program_path
-    
+
     console.print(Panel("💾 GENERATING SHELL SCRIPT\n📄 Filename: backup_retrieve.sh", title="[bold blue]Shell Script Generation[/bold blue]", border_style="blue"))
-    
+
     write_shell_script_to_default_program_path(program=code, desc="backup_retrieve.sh", preserve_cwd=True, display=True, execute=False)
 
 

machineconfig/scripts/python/devops_devapps_install.py

@@ -70,10 +70,10 @@ def get_programs_by_category(program_name: WHICH_CAT):
             program = ""
 
         case "SystemInstallers":
-            if system() == "Windows": options_system = parse_apps_installer_windows(LIBRARY_ROOT.joinpath("setup_windows/apps.ps1").read_text())
+            if system() == "Windows": options_system = parse_apps_installer_windows(LIBRARY_ROOT.joinpath("setup_windows/apps.ps1").read_text(encoding="utf-8"))
             elif system() == "Linux":
-                options_system_1 = parse_apps_installer_linux(LIBRARY_ROOT.joinpath("setup_linux/apps_dev.sh").read_text())
-                options_system_2 = parse_apps_installer_linux(LIBRARY_ROOT.joinpath("setup_linux/apps.sh").read_text())
+                options_system_1 = parse_apps_installer_linux(LIBRARY_ROOT.joinpath("setup_linux/apps_dev.sh").read_text(encoding="utf-8"))
+                options_system_2 = parse_apps_installer_linux(LIBRARY_ROOT.joinpath("setup_linux/apps.sh").read_text(encoding="utf-8"))
                 options_system = {**options_system_1, **options_system_2}
             else: raise NotImplementedError(f"❌ System {system()} not supported")
             program_names = choose_multiple_options(msg="", options=sorted(list(options_system.keys())), header="🚀 CHOOSE DEV APP")

machineconfig/scripts/python/devops_update_repos.py

@@ -1,21 +1,135 @@
 """Update repositories with fancy output
 """
-
-from machineconfig.utils.path_reduced import P as PathExtended
+import git
+import subprocess
+import hashlib
+from pathlib import Path
+from machineconfig.utils.path_reduced import PathExtended as PathExtended
 from machineconfig.utils.utils 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 _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 main(verbose: bool=True) -> str:
+
+def _run_uv_sync(repo_path: Path) -> None:
+    """Run uv sync in the given repository path."""
+    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}")
+    except subprocess.CalledProcessError as e:
+        print(f"❌ uv sync failed: {e}")
+        if e.stderr:
+            print(f"📝 Error: {e.stderr}")
+    except FileNotFoundError:
+        print("⚠️  uv command not found. Please install uv first.")
+
+
+def _update_repository(repo: git.Repo) -> 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)
+    
+    try:
+        # Perform git pull for each remote
+        dependencies_changed = False
+        for remote in repo.remotes:
+            try:
+                print(f"📥 Pulling from {remote.name} {repo.active_branch.name}")
+                pull_info = remote.pull(repo.active_branch.name)
+                for info in pull_info:
+                    if info.flags & info.FAST_FORWARD:
+                        print("✅ Fast-forward pull completed")
+                    elif info.flags & info.NEW_HEAD:
+                        print("✅ Repository updated")
+                    else:
+                        print(f"✅ Pull completed: {info.flags}")
+            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}")
+        
+        return dependencies_changed
+        
+    except Exception as e:
+        print(f"❌ Error updating repository {repo_path}: {e}")
+        return False
+
+
+def main(verbose: bool = True) -> str:
+    """Main function to update all configured repositories."""
     _ = verbose
-    repos: list[str] = ["~/code/crocodile", "~/code/machineconfig", ]
+    repos: list[str] = ["~/code/machineconfig", "~/code/machineconfig", ]
     try:
         tmp = read_ini(DEFAULTS_PATH)['general']['repos'].split(",")
-        if tmp[-1] == "": tmp = tmp[:-1]
+        if tmp[-1] == "": 
+            tmp = tmp[:-1]
         repos += tmp
     except (FileNotFoundError, KeyError, IndexError):
         print(f"""
@@ -26,7 +140,7 @@ def main(verbose: bool=True) -> str:
         print("""
 ┌────────────────────────────────────────────────────────────────
 │ ✨ Example Configuration:
-│ 
+│
 │ [general]
 │ repos = ~/code/repo1,~/code/repo2
 │ rclone_config_name = onedrivePersonal
@@ -34,57 +148,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)
+            
+            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}
+            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)
+    # Run uv sync for repositories where pyproject.toml or uv.lock changed
+    for repo_path in repos_with_changes:
+        _run_uv_sync(repo_path)
 
-    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("\n🎉 All repositories updated successfully!")
+    return """echo "🎉 All repositories updated successfully!" """
 
 
 if __name__ == '__main__':
-    pass
+    main()

machineconfig/scripts/python/dotfile.py

@@ -2,7 +2,7 @@
 """
 
 
-from machineconfig.utils.path_reduced import P as PathExtended
+from machineconfig.utils.path_reduced import PathExtended as PathExtended
 from machineconfig.profile.create import symlink_func
 from machineconfig.utils.utils import LIBRARY_ROOT, REPO_ROOT
 import argparse
@@ -25,7 +25,7 @@ def main():
         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)
-    else: 
+    else:
         dest_path = PathExtended(args.dest).expanduser().absolute()
         dest_path.mkdir(parents=True, exist_ok=True)
         new_path = dest_path.joinpath(orig_path.name)
@@ -35,7 +35,7 @@ def main():
     print("""
 ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 ┃ ✅ Symbolic Link Created Successfully
-┃ 
+┃
 ┃ 🔄 To enshrine this mapping, add the following to mapper.toml:
 ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━""")
     print(f"""

machineconfig/scripts/python/fire_agents.py

@@ -1,63 +1,224 @@
 
+"""Utility to launch multiple AI agent prompts in a Zellij session.
+
+Improved design notes:
+  * Clear separation of: input collection, prompt preparation, agent launch.
+  * Configurable max agent cap (default 15) with interactive confirmation if exceeded.
+  * Added type aliases + docstrings for maintainability.
+  * Preserves original core behavior & command generation for each agent type.
+"""
+
+from __future__ import annotations
 
 from pathlib import Path
-# from machineconfig.cluster.sessions_managers.zellij_local import run_zellij_layout
+import shlex
+from math import ceil
+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", "q",
+                            # 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()):
+        a_section = config[a_section_name]
+        if "api_key" in a_section:
+            api_key = a_section["api_key"].strip()
+            if api_key:
+                res.append(api_key)
+    # res = [v for k, v in config.items("api_keys") if k.startswith("key") and v.strip() != ""]
+    print(f"Found {len(res)} Gemini API keys configured.")
+    return res
+
+
+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').
+    """
+    py_files = list(repo_root.rglob("*.py"))
+    keyword_lower = keyword.lower()
+    matches: list[Path] = []
+    for f in py_files:
+        try:
+            if keyword_lower in f.read_text(encoding="utf-8", errors="ignore").lower():
+                matches.append(f)
+        except OSError:
+            # Skip unreadable file
+            continue
+    return matches
+
+
+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:
+        return prompts
+    print(f"Chunking {len(prompts)} prompts into groups for up to {max_agents} agents because it exceeds the cap.")
+    chunk_size = ceil(len(prompts) / max_agents)
+    grouped: 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()
+    if answer in {"y", "yes"}:
+        return True
+    if not default_no and answer == "":
+        return True
+    return False
+
+
+def launch_agents(repo_root: Path, prompts: list[str], agent: AGENTS, *, max_agents: int = DEFAULT_AGENT_CAP) -> TabConfig:
+    """Create tab configuration for a set of agent prompts.
 
+    If number of prompts exceeds max_agents, ask user for confirmation.
+    (Original behavior raised an error; now interactive override.)
+    """
+    if not prompts:
+        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?"
+            )
+        )
+        if not proceed:
+            print("Aborting per user choice.")
+            return {}
+
+    tab_config: TabConfig = {}
+    tmp_dir = repo_root / ".ai" / f"tmp_prompts/{randstr()}"
+    tmp_dir.mkdir(parents=True, exist_ok=True)
 
-def launch_agents(repo_root: Path, prompts: list[str]):
-    tab_config: dict[str, tuple[str, str]] = {}
     for idx, a_prompt in enumerate(prompts):
-        tmp_file_path = repo_root.joinpath(f".ai/tmp_prompts/agent{idx}.txt")
-        tmp_file_path.parent.mkdir(parents=True, exist_ok=True)
-        Path(tmp_file_path).write_text(a_prompt)
-        tab_config[f"Agent{idx}"] = (str(repo_root), f"cursor-agent --print --output-format text < .ai/tmp_prompts/agent{idx}.txt")
-    if len(tab_config) > 15:
-        raise RuntimeError(f"Too many agents (#{len(tab_config)}), please cut them down to 15 or less")
+        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"
+                # model = "gemini-2.5-flash-lite"
+                model = None  # auto-select
+                if model is None:
+                    model_arg = ""
+                else:
+                    model_arg = f"--model {shlex.quote(model)}"
+                # Need a real shell for the pipeline; otherwise '| gemini ...' is passed as args to 'cat'
+                safe_path = shlex.quote(str(prompt_path))
+                api_keys = get_gemini_api_keys()
+                api_key = api_keys[idx % len(api_keys)] if api_keys else ""
+                # Export the environment variable so it's available to subshells
+                cmd = f"""
+export GEMINI_API_KEY={shlex.quote(api_key)}
+echo "Using Gemini API key $GEMINI_API_KEY"
+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"""
+
+cursor-agent --print --output-format text < {prompt_path}
+
+"""
+            case "crush":
+                cmd = f"""
+# cat {prompt_path} | crush run
+crush run {prompt_path}
+"""
+            case "q":
+                cmd = f"""
+q chat --no-interactive --trust-all-tools {prompt_path}
+"""
+            case _:
+                raise ValueError(f"Unsupported agent type: {agent}")
+        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)
+
     print(f"Launching a template with #{len(tab_config)} agents")
     return tab_config
 
 
-def main():
+def main():  # noqa: C901 - (complexity acceptable for CLI glue)
     repo_root = Path.cwd()
     print(f"Operating @ {repo_root}")
-    file_path = input("Enter path to target file [press Enter to generate it from searching]: ")
-    if file_path == "":
-        keyword = input("Enter keyword to search recursively for all .py files containing it. ")
-        py_files = list(repo_root.rglob("*.py"))
-        matching_files = [
-            f for f in py_files
-            if keyword in f.read_text(encoding='utf-8', errors='ignore')
-        ]
+
+    file_path_input = input("Enter path to target file [press Enter to generate it from searching]: ").strip()
+    if file_path_input == "":
+        keyword = input("Enter keyword to search recursively for all .py files containing it: ").strip()
+        if not keyword:
+            print("No keyword supplied. Exiting.")
+            return
+        matching_files = _search_python_files(repo_root, keyword)
         if not matching_files:
             print(f"💥 No .py files found containing keyword: {keyword}")
             return
-        print(f"Found {len(matching_files)} .py files containing keyword: {keyword}")
-        file_path = repo_root.joinpath(".ai", "target_file.txt")
-        file_path.parent.mkdir(parents=True, exist_ok=True)
-        file_path.write_text("\n".join(str(f) for f in matching_files), encoding='utf-8')
+        for idx, mf in enumerate(matching_files):
+            print(f"{idx:>3}: {mf}")
+        print(f"\nFound {len(matching_files)} .py files containing keyword: {keyword}")
+        target_list_file = repo_root / ".ai" / "target_file.txt"
+        _write_list_file(target_list_file, matching_files)
         separator = "\n"
+        source_text = target_list_file.read_text(encoding="utf-8", errors="ignore")
     else:
-        separator = input("Enter separator [\\n]: ") or "\n"
+        target_file_path = Path(file_path_input).expanduser().resolve()
+        if not target_file_path.exists() or not target_file_path.is_file():
+            print(f"Invalid file path: {target_file_path}")
+            return
+        separator = input("Enter separator [\\n]: ").strip() or "\n"
+        if not target_file_path.exists():
+            print(f"File does not exist: {target_file_path}")
+            return
+        source_text = target_file_path.read_text(encoding="utf-8", errors="ignore")
 
-    err_file = Path(file_path).expanduser().absolute().read_text(encoding='utf-8', errors='ignore')
+    raw_prompts = source_text.split(separator)
+    print(f"Loaded {len(raw_prompts)} raw prompts from source.")
     prefix = input("Enter prefix prompt: ")
-    prompts = [item for item in err_file.split(separator)]
-    # Dynamically choose chunk size so we end up with <= 15 combined prompts.
-    # If we already have 15 or fewer, keep them as-is.
-    if len(prompts) <= 15:
-        combined_prompts = prompts
-    else:
-        # Compute minimal chunk size so that number_of_chunks <= 15.
-        # number_of_chunks = ceil(len(prompts)/chunk_size) <= 15
-        # => chunk_size >= len(prompts)/15 -> choose ceil(len/15)
-        from math import ceil
-        chunk_size = ceil(len(prompts) / 15)
-        combined_prompts: list[str] = []
-        for i in range(0, len(prompts), chunk_size):
-            combined_prompts.append("\nTargeted Locations:\n".join(prompts[i:i+chunk_size]))
-    combined_prompts = [prefix + "\n" + item for item in combined_prompts]
-    tab_config = launch_agents(repo_root=repo_root, prompts=combined_prompts)
+    combined_prompts = _chunk_prompts(raw_prompts, DEFAULT_AGENT_CAP)
+    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,
+    )
+    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)
@@ -65,5 +226,5 @@ def main():
     manager.run_monitoring_routine()
 
 
-if __name__ == "__main__":
+if __name__ == "__main__":  # pragma: no cover
     main()