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

machineconfig/scripts/python/fire_agents.py

@@ -7,63 +7,19 @@ Improved design notes:
   * Preserves original core behavior & command generation for each agent type.
 """
 
-from __future__ import annotations
-
 from pathlib import Path
-import shlex
-from math import ceil
-from typing import Literal, TypeAlias, get_args, Iterable
+from typing import cast, get_args, Iterable, TypeAlias, Literal
+import json
+import sys
 
+from machineconfig.scripts.python.fire_agents_help_launch import prep_agent_launch, get_agents_launch_layout, AGENTS
+from machineconfig.scripts.python.fire_agents_help_search import search_files_by_pattern, search_python_files
+from machineconfig.scripts.python.fire_agents_load_balancer import chunk_prompts, SPLITTING_STRATEGY, DEFAULT_AGENT_CAP
 from machineconfig.cluster.sessions_managers.zellij_local_manager import ZellijLocalManager
-from machineconfig.utils.schemas.layouts.layout_types import TabConfig, LayoutConfig
-from machineconfig.utils.utils2 import randstr
-import random
-# import time
-
-AGENTS: TypeAlias = Literal[
-    "cursor-agent", "gemini", "crush", "q", "onlyPrepPromptFiles"
-    # warp terminal
-]
-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.
-
-    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)
-        except OSError:
-            # Skip unreadable file
-            continue
-    return matches
+from machineconfig.utils.options import choose_one_option
+from machineconfig.utils.ve import get_repo_root
+
+SEARCH_STRATEGIES: TypeAlias = Literal["file_path", "keyword_search", "filename_pattern"]
 
 
 def _write_list_file(target: Path, files: Iterable[Path]) -> None:
@@ -71,164 +27,121 @@ def _write_list_file(target: Path, files: Iterable[Path]) -> None:
     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) -> list[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: list[TabConfig] = []
-    tmp_dir = repo_root / ".ai" / f"tmp_prompts/{randstr()}"
-    tmp_dir.mkdir(parents=True, exist_ok=True)
-
-    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"
-                # 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 "onlyPrepPromptFiles":
-                cmd = f"""
-echo "Prepared prompt file at {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.append(TabConfig(tabName=f"Agent{idx}", startDir=str(repo_root), command=fire_cmd))
-
-    print(f"Launching a template with #{len(tab_config)} agents")
-    return tab_config
-
-
-def main():  # noqa: C901 - (complexity acceptable for CLI glue)
-    repo_root = Path.cwd()
-    print(f"Operating @ {repo_root}")
-
-    file_path_input = input("Enter path to target file [press Enter to generate it from searching]: ").strip()
-    if file_path_input == "":
+def get_prompt_material(search_strategy: SEARCH_STRATEGIES, repo_root: Path) -> tuple[Path, str]:
+    if search_strategy == "file_path":
+        file_path_input = input("Enter path to target file: ").strip()
+        if not file_path_input:
+            print("No file path provided. Exiting.")
+            sys.exit(1)
+        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}")
+            sys.exit(1)
+        separator = input("Enter separator [\\n]: ").strip() or "\n"
+    elif search_strategy == "keyword_search":
         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)
+            sys.exit(1)
+        matching_files = search_python_files(repo_root, keyword)
         if not matching_files:
             print(f"💥 No .py files found containing keyword: {keyword}")
-            return
+            sys.exit(1)
         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)
+        target_file_path = repo_root / ".ai" / "target_file.txt"
+        _write_list_file(target_file_path, matching_files)
+        separator = "\n"
+    elif search_strategy == "filename_pattern":
+        pattern = input("Enter filename pattern (e.g., '*.py', '*test*', 'config.*'): ").strip()
+        if not pattern:
+            print("No pattern supplied. Exiting.")
+            sys.exit(1)
+        matching_files = search_files_by_pattern(repo_root, pattern)
+        if not matching_files:
+            print(f"💥 No files found matching pattern: {pattern}")
+            sys.exit(1)
+        for idx, mf in enumerate(matching_files):
+            print(f"{idx:>3}: {mf}")
+        print(f"\nFound {len(matching_files)} files matching pattern: {pattern}")
+        target_file_path = repo_root / ".ai" / "target_file.txt"
+        _write_list_file(target_file_path, matching_files)
         separator = "\n"
-        source_text = target_list_file.read_text(encoding="utf-8", errors="ignore")
     else:
-        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")
-
-    raw_prompts = source_text.split(separator)
-    print(f"Loaded {len(raw_prompts)} raw prompts from source.")
-    prefix = input("Enter prefix prompt: ")
-    combined_prompts = _chunk_prompts(raw_prompts, DEFAULT_AGENT_CAP)
-    combined_prompts = [prefix + "\n" + p for p in combined_prompts]
+        raise ValueError(f"Unknown search strategy: {search_strategy}")
+    return target_file_path, separator
 
-    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
+def main():  # noqa: C901 - (complexity acceptable for CLI glue)
+    repo_root = get_repo_root(Path.cwd())
+    if repo_root is None:
+        print("💥 Could not determine the repository root. Please run this script from within a git repository.")
+        sys.exit(1)
+    print(f"Operating @ {repo_root}")
 
-    from machineconfig.utils.utils2 import randstr
+    search_strategy = cast(SEARCH_STRATEGIES, choose_one_option(header="Choose search strategy:", options=get_args(SEARCH_STRATEGIES)))
+    splitting_strategy = cast(SPLITTING_STRATEGY, choose_one_option(header="Choose prompt splitting strategy:", options=get_args(SPLITTING_STRATEGY)))
+    agent_selected = cast(AGENTS, choose_one_option(header="Select agent type", options=get_args(AGENTS)))
+    print("Enter prefix prompt (end with Ctrl-D / Ctrl-Z):")
+    prompt_prefix = "\n".join(sys.stdin.readlines())
+    job_name = input("Enter job name [AI_AGENTS]: ") or "AI_Agents"
+    keep_material_in_separate_file_input = input("Keep prompt material in separate file? [y/N]: ").strip().lower() == "y"
+
+    prompt_material_path, separator = get_prompt_material(search_strategy=search_strategy, repo_root=repo_root)
+    match splitting_strategy:
+        case "agent_cap":
+            agent_cap_input = input(f"Enter maximum number of agents/splits [default: {DEFAULT_AGENT_CAP}]: ").strip()
+            agent_cap = int(agent_cap_input) if agent_cap_input else DEFAULT_AGENT_CAP
+            task_rows = None
+        case "task_rows":
+            task_rows_input: str = input("Enter number of rows/tasks per agent [13]: ").strip() or "13"
+            task_rows = int(task_rows_input)
+            agent_cap = None
+    prompt_material_re_splitted = chunk_prompts(prompt_material_path, splitting_strategy, agent_cap=agent_cap, task_rows=task_rows, joiner=separator)
+
+    agents_dir = prep_agent_launch(repo_root=repo_root, prompts_material=prompt_material_re_splitted, keep_material_in_separate_file=keep_material_in_separate_file_input, prompt_prefix=prompt_prefix, agent=agent_selected, job_name=job_name)
+    layoutfile = get_agents_launch_layout(session_root=agents_dir)
+
+    regenerate_py_code = f"""
+#!/usr/bin/env uv run --python 3.13 --with machineconfig
+#!/usr/bin/env uv run --project $HOME/code/machineconfig
+
+from machineconfig.scripts.python.fire_agents import *
+
+repo_root = Path("{repo_root}")
+search_strategy = "{search_strategy}"
+splitting_strategy = "{splitting_strategy}"
+agent_selected = "{agent_selected}"
+prompt_prefix = '''{prompt_prefix}'''
+job_name = "{job_name}"
+keep_material_in_separate_file_input = {keep_material_in_separate_file_input}
+separator = "{separator}"
+prompt_material_path = Path("{prompt_material_path}")
+agent_cap = {agent_cap}
+task_rows = {task_rows}
+
+prompt_material_re_splitted = chunk_prompts(prompt_material_path, splitting_strategy, agent_cap=agent_cap, task_rows=task_rows, joiner=separator)
+agents_dir = prep_agent_launch(repo_root=repo_root, prompts_material=prompt_material_re_splitted, keep_material_in_separate_file=keep_material_in_separate_file_input, prompt_prefix=prompt_prefix, agent=agent_selected, job_name=job_name)
+layout = get_agents_launch_layout(session_root=agents_dir)
+
+(agents_dir / "aa_agents_relaunch.py").write_text(data=regenerate_py_code, encoding="utf-8")
+(agents_dir / "layout.json").write_text(data=json.dumps(layout, indent=2), encoding="utf-8")
+
+if len(layout["layoutTabs"]) > 25:
+    print("Too many agents (>25) to launch. Skipping launch.")
+    sys.exit(0)
+manager = ZellijLocalManager(session_layouts=[layout])
+manager.start_all_sessions()
+manager.run_monitoring_routine()
 
-    random_name = randstr(length=3)
-    manager = ZellijLocalManager(session_layouts=[LayoutConfig(layoutName="Agents", layoutTabs=tab_config)], session_name_prefix=random_name)
+"""
+    (agents_dir / "aa_agents_relaunch.py").write_text(data=regenerate_py_code, encoding="utf-8")
+    (agents_dir / "layout.json").write_text(data=json.dumps(layoutfile, indent=2), encoding="utf-8")
+    if len(layoutfile["layouts"][0]["layoutTabs"]) > 25:
+        print("Too many agents (>25) to launch. Skipping launch.")
+        sys.exit(0)
+    manager = ZellijLocalManager(session_layouts=layoutfile["layouts"])
     manager.start_all_sessions()
     manager.run_monitoring_routine()
 

machineconfig/scripts/python/fire_agents_help_launch.py

@@ -0,0 +1,142 @@
+
+from machineconfig.utils.utils2 import randstr
+
+import random
+import shlex
+from pathlib import Path
+from typing import Literal, TypeAlias
+
+
+AGENTS: TypeAlias = Literal[
+    "cursor-agent", "gemini", "crush", "q", "onlyPrepPromptFiles"
+    # warp terminal
+]
+AGENT_NAME_FORMATTER = "agent_{idx}_cmd.sh"  # e.g., agent_0_cmd.sh
+
+
+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)
+    print(f"Found {len(res)} Gemini API keys configured.")
+    return res
+
+def prep_agent_launch(repo_root: Path, prompts_material: list[str], prompt_prefix: str, keep_material_in_separate_file: bool,  agent: AGENTS, *, job_name: str) -> Path:
+    session_root = repo_root / ".ai" / f"tmp_prompts/{job_name}_{randstr()}"
+    session_root.mkdir(parents=True, exist_ok=True)
+    prompt_folder = session_root / "prompts"
+    prompt_folder.mkdir(parents=True, exist_ok=True)
+
+    all_materials_scripts: list[Path] = []
+    for idx, a_prompt_material in enumerate(prompts_material):
+        prompt_root = prompt_folder / f"agent_{idx}"
+        prompt_root.mkdir(parents=True, exist_ok=True)
+        prompt_path = prompt_root / f"agent_{idx}_prompt.txt"
+        if keep_material_in_separate_file:
+            prompt_material_path = prompt_root / f"agent_{idx}_material.txt"
+            prompt_material_path.write_text(a_prompt_material, encoding="utf-8")
+            prompt_path.write_text(prompt_prefix + f"""\nPlease only look @ {prompt_material_path}. You don't need to do any other work beside the content of this material file.""", encoding="utf-8")
+            all_materials_scripts.append(prompt_material_path)
+        else:
+            prompt_material_path = prompt_path
+            prompt_path.write_text(prompt_prefix + """\nPlease only look @ the following:\n""" + a_prompt_material, encoding="utf-8")
+
+        agent_cmd_launch_path = prompt_root / AGENT_NAME_FORMATTER.format(idx=idx)  # e.g., agent_0_cmd.sh
+        random_sleep_time = random.uniform(0, 5)
+        cmd_prefix = f"""
+#!/usr/bin/env bash
+
+# AGENT-{idx}-LAUNCH-SCRIPT
+# Auto-generated by fire_agents.py
+
+export FIRE_AGENTS_AGENT_NAME="{agent}"
+export FIRE_AGENTS_JOB_NAME="{job_name}"
+export FIRE_AGENTS_PROMPT_FILE="{prompt_path}"
+export FIRE_AGENTS_MATERIAL_FILE="{prompt_material_path}"
+export FIRE_AGENTS_AGENT_LAUNCHER="{agent_cmd_launch_path}"
+
+echo "Sleeping for {random_sleep_time:.2f} seconds to stagger agent startups..."
+sleep {random_sleep_time:.2f}
+echo "Launching agent {agent} with prompt from {prompt_path}"
+echo "Launching agent {agent} with command from {agent_cmd_launch_path}"
+echo "--------START OF AGENT OUTPUT--------"
+sleep 0.1
+
+"""
+        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"
+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"""
+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_postfix = """
+sleep 0.1
+echo "---------END OF AGENT OUTPUT---------"
+"""
+        agent_cmd_launch_path.write_text(cmd_prefix + cmd + cmd_postfix, encoding="utf-8")
+
+
+    # print(f"Launching a template with #{len(tab_config)} agents")
+    if len(all_materials_scripts) > 0:
+        all_materials_list_path = session_root / "all_materials_redistributed.txt"
+        all_materials_list_path.write_text("\n".join(str(p) for p in all_materials_scripts), encoding="utf-8")
+        print(f"All prompt materials listed @ {all_materials_list_path}")
+    return session_root
+
+
+def get_agents_launch_layout(session_root: Path):
+    from machineconfig.utils.schemas.layouts.layout_types import TabConfig, LayoutConfig, LayoutsFile
+    tab_config: list[TabConfig] = []
+    prompt_root = session_root / "prompts"
+    all_dirs_under_prompts = [d for d in prompt_root.iterdir() if d.is_dir()]
+    launch_agents_squentially = ""
+    for a_prompt_dir in all_dirs_under_prompts:
+        idx = a_prompt_dir.name.split("_")[-1]  # e.g., agent_0 -> 0
+        agent_cmd_path = a_prompt_dir / AGENT_NAME_FORMATTER.format(idx=idx)
+        fire_cmd = f"bash {shlex.quote(str(agent_cmd_path))}"
+        tab_config.append(TabConfig(tabName=f"Agent{idx}", startDir=str(session_root.parent.parent.parent), command=fire_cmd))
+        launch_agents_squentially += f". {shlex.quote(str(agent_cmd_path))}\n"
+    layout = LayoutConfig(layoutName="Agents", layoutTabs=tab_config)
+    (session_root / "launch_all_agents_sequentially.sh").write_text(launch_agents_squentially, encoding="utf-8")
+    layouts_file: LayoutsFile = LayoutsFile(version="1.0", layouts=[layout])
+    return layouts_file

machineconfig/scripts/python/fire_agents_help_search.py

@@ -0,0 +1,82 @@
+
+from machineconfig.utils.source_of_truth import EXCLUDE_DIRS
+import fnmatch
+from pathlib import Path
+
+
+def search_files_by_pattern(repo_root: Path, pattern: str) -> list[Path]:
+    """Return all files under repo_root whose filename matches the given pattern.
+
+    Notes:
+      - Uses glob-style pattern matching (e.g., "*.py", "*test*", "config.*")
+      - Skips any paths that reside under directories listed in EXCLUDE_DIRS at any depth.
+    """
+    matches: list[Path] = []
+
+    def _should_skip_dir(dir_path: Path) -> bool:
+        """Check if directory should be skipped based on EXCLUDE_DIRS."""
+        return any(part in EXCLUDE_DIRS for part in dir_path.parts)
+
+    def _walk_and_filter(current_path: Path) -> None:
+        """Recursively walk directories, filtering out excluded ones early."""
+        try:
+            if not current_path.is_dir():
+                return
+
+            # Skip if current directory is in exclude list
+            if _should_skip_dir(current_path):
+                return
+
+            for item in current_path.iterdir():
+                if item.is_dir():
+                    _walk_and_filter(item)
+                elif item.is_file() and fnmatch.fnmatch(item.name, pattern):
+                    matches.append(item)
+        except (OSError, PermissionError):
+            # Skip directories we can't read
+            return
+
+    _walk_and_filter(repo_root)
+    return matches
+
+
+def search_python_files(repo_root: Path, keyword: str) -> list[Path]:
+    """Return all Python files under repo_root whose text contains keyword.
+
+    Notes:
+      - Skips any paths that reside under directories listed in EXCLUDE_DIRS at any depth.
+      - Errors reading individual files are ignored (decoded with 'ignore').
+    """
+    keyword_lower = keyword.lower()
+    matches: list[Path] = []
+
+    def _should_skip_dir(dir_path: Path) -> bool:
+        """Check if directory should be skipped based on EXCLUDE_DIRS."""
+        return any(part in EXCLUDE_DIRS for part in dir_path.parts)
+
+    def _walk_and_filter(current_path: Path) -> None:
+        """Recursively walk directories, filtering out excluded ones early."""
+        try:
+            if not current_path.is_dir():
+                return
+
+            # Skip if current directory is in exclude list
+            if _should_skip_dir(current_path):
+                return
+
+            for item in current_path.iterdir():
+                if item.is_dir():
+                    _walk_and_filter(item)
+                elif item.is_file() and item.suffix == ".py":
+                    try:
+                        if keyword_lower in item.read_text(encoding="utf-8", errors="ignore").lower():
+                            matches.append(item)
+                    except OSError:
+                        # Skip unreadable file
+                        continue
+        except (OSError, PermissionError):
+            # Skip directories we can't read
+            return
+
+    _walk_and_filter(repo_root)
+    return matches

machineconfig/scripts/python/fire_agents_load_balancer.py

@@ -0,0 +1,52 @@
+
+
+from typing import Literal, TypeAlias
+from math import ceil
+from pathlib import Path
+
+
+SPLITTING_STRATEGY: TypeAlias = Literal[
+    "agent_cap",  # User decides number of agents, rows/tasks determined automatically
+    "task_rows"   # User decides number of rows/tasks, number of agents determined automatically
+]
+DEFAULT_AGENT_CAP = 6
+
+
+def chunk_prompts(prompt_material_path: Path, strategy: SPLITTING_STRATEGY, joiner: str, *, agent_cap: int | None, task_rows: int | None) -> list[str]:
+    """Chunk prompts based on splitting strategy.
+    
+    Args:
+        prompts: List of prompts to chunk
+        strategy: Either 'agent_cap' or 'task_rows'  
+        agent_cap: Maximum number of agents (used with 'agent_cap' strategy)
+        task_rows: Number of rows/tasks per agent (used with 'task_rows' strategy)
+    """
+    prompts = [p for p in prompt_material_path.read_text(encoding="utf-8", errors="ignore").split(joiner) if p.strip() != ""]  # drop blank entries
+    
+    if strategy == "agent_cap":
+        if agent_cap is None:
+            raise ValueError("agent_cap must be provided when using 'agent_cap' strategy")
+        
+        if len(prompts) <= agent_cap:
+            return prompts
+        
+        print(f"Chunking {len(prompts)} prompts into groups for up to {agent_cap} agents because it exceeds the cap.")
+        chunk_size = ceil(len(prompts) / agent_cap)
+        grouped: list[str] = []
+        for i in range(0, len(prompts), chunk_size):
+            grouped.append(joiner.join(prompts[i : i + chunk_size]))
+        return grouped
+    
+    elif strategy == "task_rows":
+        if task_rows is None:
+            raise ValueError("task_rows must be provided when using 'task_rows' strategy")
+        if task_rows >= len(prompts):
+            return prompts
+        print(f"Chunking {len(prompts)} prompts into groups of {task_rows} rows/tasks each.")
+        grouped: list[str] = []
+        for i in range(0, len(prompts), task_rows):
+            grouped.append(joiner.join(prompts[i : i + task_rows]))
+        return grouped
+    
+    else:
+        raise ValueError(f"Unknown splitting strategy: {strategy}")

machineconfig/scripts/python/fire_jobs.py

@@ -21,6 +21,7 @@ from machineconfig.utils.utils2 import randstr, read_toml
 from machineconfig.scripts.python.fire_jobs_args_helper import get_args, FireJobArgs, extract_kwargs
 import platform
 from typing import Optional
+from pathlib import Path
 # import os
 
 
@@ -42,7 +43,7 @@ def route(args: FireJobArgs) -> None:
         choice_file = PathExtended(choice_file)
     else:
         choice_file = path_obj
-    repo_root = get_repo_root(str(choice_file))
+    repo_root = get_repo_root(Path(choice_file))
     print(f"💾 Selected file: {choice_file}.\nRepo root: {repo_root}")
     ve_root_from_file, ipy_profile = get_ve_path_and_ipython_profile(choice_file)
     if ipy_profile is None:

machineconfig/scripts/python/helpers/cloud_helpers.py

@@ -1,14 +1,12 @@
 from pathlib import Path
 from machineconfig.utils.utils2 import pprint, read_json, read_ini
-from pydantic import ConfigDict
-from pydantic.dataclasses import dataclass
 from typing import Optional
 import os
 from machineconfig.utils.source_of_truth import DEFAULTS_PATH
 from rich.console import Console
 from rich.panel import Panel
 from rich import box  # Import box
-
+from dataclasses import dataclass
 
 console = Console()
 
@@ -26,8 +24,7 @@ class ArgsDefaults:
     key = None
     pwd = None
 
-
-@dataclass(config=ConfigDict(extra="forbid", frozen=False))
+@dataclass
 class Args:
     cloud: Optional[str] = None
 

machineconfig/scripts/python/repos.py

@@ -8,7 +8,7 @@ in the event that username@github.com is not mentioned in the remote url.
 from machineconfig.utils.source_of_truth import CONFIG_PATH, DEFAULTS_PATH
 from machineconfig.utils.path_reduced import PathExtended as PathExtended
 from machineconfig.utils.utils2 import randstr, read_ini
-from machineconfig.scripts.python.devops_update_repos import update_repository
+from machineconfig.scripts.python.repos_helper_update import update_repository
 from machineconfig.scripts.python.repos_helper_record import main as record_repos
 
 import argparse