machineconfig 4.1__py3-none-any.whl → 4.4__py3-none-any.whl

machineconfig/cluster/sessions_managers/utils/load_balancer.py

@@ -1,162 +1,47 @@
 
 from machineconfig.utils.schemas.layouts.layout_types import TabConfig, LayoutConfig
-from machineconfig.utils.accessories import split_list
-from typing import Literal
+# from machineconfig.utils.accessories import split_list
+from typing import Literal, Protocol
+from machineconfig.cluster.sessions_managers.utils.load_balancer_helper import restrict_num_tabs_helper1, restrict_num_tabs_helper2, restrict_num_tabs_helper3, restrict_num_tabs_helper4
 
+class COMMAND_SPLITTER(Protocol):
+    def __call__(self, command: str, to: int) -> list[str]: ...
 
 
-def split_tabs_by_weight(tabs: list[TabConfig], max_weight: int) -> list[list[TabConfig]]:
-    """Split tabs into chunks where each chunk's total weight <= max_weight."""
-    chunks: list[list[TabConfig]] = []
-    current_chunk: list[TabConfig] = []
-    current_weight = 0
-    for tab in tabs:
-        tab_weight = tab.get("tabWeight", 1)
-        if current_weight + tab_weight > max_weight and current_chunk:
-            chunks.append(current_chunk)
-            current_chunk = [tab]
-            current_weight = tab_weight
-        else:
-            current_chunk.append(tab)
-            current_weight += tab_weight
-    
-    if current_chunk:
-        chunks.append(current_chunk)
-    
-    return chunks
-
-
-def combine_tabs_into_super_tabs(tabs: list[TabConfig], num_super_tabs: int) -> list[TabConfig]:
-    """Combine tabs into num_super_tabs super tabs with combined commands."""
-    if len(tabs) <= num_super_tabs:
-        return tabs  # No need to combine
-    
-    tab_groups = split_list(tabs, to=num_super_tabs)
-    super_tabs: list[TabConfig] = []
-    for idx, group in enumerate(tab_groups):
-        if len(group) == 1:
-            super_tabs.append(group[0])
-        else:
-            combined_command = "; ".join(tab["command"] for tab in group)
-            combined_name = f"super_tab_{idx+1}"
-            # Use startDir of the first tab
-            start_dir = group[0]["startDir"]
-            # Sum weights
-            total_weight = sum(tab.get("tabWeight", 1) for tab in group)
-            super_tabs.append({
-                "tabName": combined_name,
-                "startDir": start_dir,
-                "command": combined_command,
-                "tabWeight": total_weight
-            })
-    return super_tabs
-
-
-def combine_tabs_by_weight_into_super_tabs(tabs: list[TabConfig], max_weight: int) -> list[TabConfig]:
-    """Combine tabs into super tabs where each super tab has weight <= max_weight."""
-    tab_groups = split_tabs_by_weight(tabs, max_weight=max_weight)
-    super_tabs: list[TabConfig] = []
-    for idx, group in enumerate(tab_groups):
-        if len(group) == 1:
-            super_tabs.append(group[0])
-        else:
-            combined_command = "; ".join(tab["command"] for tab in group)
-            combined_name = f"super_tab_{idx+1}"
-            start_dir = group[0]["startDir"]
-            total_weight = sum(tab.get("tabWeight", 1) for tab in group)
-            super_tabs.append({
-                "tabName": combined_name,
-                "startDir": start_dir,
-                "command": combined_command,
-                "tabWeight": total_weight
-            })
-    return super_tabs
-
-
-def restrict_num_tabs(layout_configs: list[LayoutConfig], max_thresh: int, threshold_type: Literal["number", "weight"], breaking_method: Literal["moreLayouts", "combineTabs"]) -> list[LayoutConfig]:
+def limit_tab_num(layout_configs: list[LayoutConfig], max_thresh: int, threshold_type: Literal["number", "weight"], breaking_method: Literal["moreLayouts", "combineTabs"]) -> list[LayoutConfig]:
     match threshold_type, breaking_method:
         case "number", "moreLayouts":
-            return _restrict_num_tabs_helper1(layout_configs=layout_configs, max_thresh=max_thresh, threshold_type=threshold_type, breaking_method=breaking_method)
+            return restrict_num_tabs_helper1(layout_configs=layout_configs, max_thresh=max_thresh, threshold_type=threshold_type, breaking_method=breaking_method)
         case "number", "combineTabs":
-            return _restrict_num_tabs_helper2(layout_configs=layout_configs, max_thresh=max_thresh, threshold_type=threshold_type, breaking_method=breaking_method)
+            return restrict_num_tabs_helper2(layout_configs=layout_configs, max_thresh=max_thresh, threshold_type=threshold_type, breaking_method=breaking_method)
         case "weight", "moreLayouts":
-            return _restrict_num_tabs_helper3(layout_configs=layout_configs, max_thresh=max_thresh, threshold_type=threshold_type, breaking_method=breaking_method)
+            return restrict_num_tabs_helper3(layout_configs=layout_configs, max_thresh=max_thresh, threshold_type=threshold_type, breaking_method=breaking_method)
         case "weight", "combineTabs":
-            return _restrict_num_tabs_helper4(layout_configs=layout_configs, max_thresh=max_thresh, threshold_type=threshold_type, breaking_method=breaking_method)
+            return restrict_num_tabs_helper4(layout_configs=layout_configs, max_thresh=max_thresh, threshold_type=threshold_type, breaking_method=breaking_method)
         case _:
             raise NotImplementedError(f"The combination {threshold_type}, {breaking_method} is not implemented")
-
-
-def _restrict_num_tabs_helper1(layout_configs: list[LayoutConfig], max_thresh: int, threshold_type: Literal["number"], breaking_method: Literal["moreLayouts"]) -> list[LayoutConfig]:
-    """When threshold is exceeded, create more layouts with max_thresh tabs each."""
-    new_layout_configs: list[LayoutConfig] = []
-    for a_layout_config in layout_configs:
-        if len(a_layout_config["layoutTabs"]) > max_thresh:
-            print(f"Layout '{a_layout_config['layoutName']}' has too many tabs ({len(a_layout_config['layoutTabs'])} > {max_thresh}). Splitting into multiple layouts.")
-            tab_chunks = split_list(a_layout_config["layoutTabs"], every=max_thresh)
-            for idx, tab_chunk in enumerate(tab_chunks):
-                new_layout_configs.append({
-                    "layoutName": f"{a_layout_config['layoutName']}_part{idx+1}",
-                    "layoutTabs": tab_chunk
-                })
-        else:
-            print(f"Layout '{a_layout_config['layoutName']}' has acceptable number of tabs ({len(a_layout_config['layoutTabs'])} <= {max_thresh}). Keeping as is.")
-            new_layout_configs.append(a_layout_config)
-    return new_layout_configs
-
-
-def _restrict_num_tabs_helper2(layout_configs: list[LayoutConfig], max_thresh: int, threshold_type: Literal["number"], breaking_method: Literal["combineTabs"]) -> list[LayoutConfig]:
-    """When threshold is exceeded, combine tabs into super tabs to reduce count to max_thresh."""
-    new_layout_configs: list[LayoutConfig] = []
-    for a_layout_config in layout_configs:
-        num_tabs = len(a_layout_config["layoutTabs"])
-        if num_tabs > max_thresh:
-            print(f"Layout '{a_layout_config['layoutName']}' has too many tabs ({num_tabs} > {max_thresh}). Combining into {max_thresh} super tabs.")
-            super_tabs = combine_tabs_into_super_tabs(a_layout_config["layoutTabs"], num_super_tabs=max_thresh)
-            new_layout_configs.append({
-                "layoutName": a_layout_config["layoutName"],
-                "layoutTabs": super_tabs
-            })
-        else:
-            print(f"Layout '{a_layout_config['layoutName']}' has acceptable number of tabs ({num_tabs} <= {max_thresh}). Keeping as is.")
-            new_layout_configs.append(a_layout_config)
-    return new_layout_configs
-
-
-def _restrict_num_tabs_helper3(layout_configs: list[LayoutConfig], max_thresh: int, threshold_type: Literal["weight"], breaking_method: Literal["moreLayouts"]) -> list[LayoutConfig]:
-    """When threshold is exceeded, create more layouts with max_thresh total weight each."""
-    new_layout_configs: list[LayoutConfig] = []
-    for a_layout_config in layout_configs:
-        layout_weight = sum(tab.get("tabWeight", 1) for tab in a_layout_config["layoutTabs"])
-        if layout_weight > max_thresh:
-            print(f"Layout '{a_layout_config['layoutName']}' has too much weight ({layout_weight} > {max_thresh}). Splitting into multiple layouts.")
-            tab_chunks = split_tabs_by_weight(a_layout_config["layoutTabs"], max_weight=max_thresh)
-            for idx, tab_chunk in enumerate(tab_chunks):
-                new_layout_configs.append({
-                    "layoutName": f"{a_layout_config['layoutName']}_part{idx+1}",
-                    "layoutTabs": tab_chunk
-                })
-        else:
-            print(f"Layout '{a_layout_config['layoutName']}' has acceptable total weight ({layout_weight} <= {max_thresh}). Keeping as is.")
-            new_layout_configs.append(a_layout_config)
-    return new_layout_configs
-
-
-def _restrict_num_tabs_helper4(layout_configs: list[LayoutConfig], max_thresh: int, threshold_type: Literal["weight"], breaking_method: Literal["combineTabs"]) -> list[LayoutConfig]:
-    """When threshold is exceeded, combine tabs into super tabs with weight <= max_thresh."""
+def limit_tab_weight(layout_configs: list[LayoutConfig], max_weight: int, command_splitter: COMMAND_SPLITTER) -> list[LayoutConfig]:
     new_layout_configs: list[LayoutConfig] = []
     for a_layout_config in layout_configs:
-        layout_weight = sum(tab.get("tabWeight", 1) for tab in a_layout_config["layoutTabs"])
-        if layout_weight > max_thresh:
-            print(f"Layout '{a_layout_config['layoutName']}' has too much weight ({layout_weight} > {max_thresh}). Combining into super tabs with weight <= {max_thresh}.")
-            super_tabs = combine_tabs_by_weight_into_super_tabs(a_layout_config["layoutTabs"], max_weight=max_thresh)
-            new_layout_configs.append({
-                "layoutName": a_layout_config["layoutName"],
-                "layoutTabs": super_tabs
-            })
-        else:
-            print(f"Layout '{a_layout_config['layoutName']}' has acceptable total weight ({layout_weight} <= {max_thresh}). Keeping as is.")
-            new_layout_configs.append(a_layout_config)
+        new_tabs: list[TabConfig] = []
+        for tab in a_layout_config["layoutTabs"]:
+            tab_weight = tab.get("tabWeight", 1)
+            if tab_weight > max_weight:
+                print(f"Tab '{tab['tabName']}' in layout '{a_layout_config['layoutName']}' has too much weight ({tab_weight} > {max_weight}). Splitting command.")
+                split_commands = command_splitter(tab["command"], to=max_weight)
+                for idx, cmd in enumerate(split_commands):
+                    new_tabs.append({
+                        "tabName": f"{tab['tabName']}_part{idx+1}",
+                        "startDir": tab["startDir"],
+                        "command": cmd,
+                        "tabWeight": max_weight
+                    })
+            else:
+                new_tabs.append(tab)
+        new_layout_configs.append({
+            "layoutName": a_layout_config["layoutName"],
+            "layoutTabs": new_tabs
+        })
     return new_layout_configs
 
 

machineconfig/cluster/sessions_managers/utils/load_balancer_helper.py

@@ -0,0 +1,145 @@
+from machineconfig.utils.accessories import split_list
+from machineconfig.utils.schemas.layouts.layout_types import TabConfig, LayoutConfig
+
+from typing import Literal
+
+
+def split_tabs_by_weight(tabs: list[TabConfig], max_weight: int) -> list[list[TabConfig]]:
+    """Split tabs into chunks where each chunk's total weight <= max_weight."""
+    chunks: list[list[TabConfig]] = []
+    current_chunk: list[TabConfig] = []
+    current_weight = 0
+    for tab in tabs:
+        tab_weight = tab.get("tabWeight", 1)
+        if current_weight + tab_weight > max_weight and current_chunk:
+            chunks.append(current_chunk)
+            current_chunk = [tab]
+            current_weight = tab_weight
+        else:
+            current_chunk.append(tab)
+            current_weight += tab_weight
+    
+    if current_chunk:
+        chunks.append(current_chunk)
+    
+    return chunks
+
+
+def combine_tabs_into_super_tabs(tabs: list[TabConfig], num_super_tabs: int) -> list[TabConfig]:
+    """Combine tabs into num_super_tabs super tabs with combined commands."""
+    if len(tabs) <= num_super_tabs:
+        return tabs  # No need to combine
+    
+    tab_groups = split_list(tabs, to=num_super_tabs)
+    super_tabs: list[TabConfig] = []
+    for idx, group in enumerate(tab_groups):
+        if len(group) == 1:
+            super_tabs.append(group[0])
+        else:
+            combined_command = "; ".join(tab["command"] for tab in group)
+            combined_name = f"super_tab_{idx+1}"
+            # Use startDir of the first tab
+            start_dir = group[0]["startDir"]
+            # Sum weights
+            total_weight = sum(tab.get("tabWeight", 1) for tab in group)
+            super_tabs.append({
+                "tabName": combined_name,
+                "startDir": start_dir,
+                "command": combined_command,
+                "tabWeight": total_weight
+            })
+    return super_tabs
+
+
+def combine_tabs_by_weight_into_super_tabs(tabs: list[TabConfig], max_weight: int) -> list[TabConfig]:
+    """Combine tabs into super tabs where each super tab has weight <= max_weight."""
+    tab_groups = split_tabs_by_weight(tabs, max_weight=max_weight)
+    super_tabs: list[TabConfig] = []
+    for idx, group in enumerate(tab_groups):
+        if len(group) == 1:
+            super_tabs.append(group[0])
+        else:
+            combined_command = "; ".join(tab["command"] for tab in group)
+            combined_name = f"super_tab_{idx+1}"
+            start_dir = group[0]["startDir"]
+            total_weight = sum(tab.get("tabWeight", 1) for tab in group)
+            super_tabs.append({
+                "tabName": combined_name,
+                "startDir": start_dir,
+                "command": combined_command,
+                "tabWeight": total_weight
+            })
+    return super_tabs
+
+
+def restrict_num_tabs_helper1(layout_configs: list[LayoutConfig], max_thresh: int, threshold_type: Literal["number"], breaking_method: Literal["moreLayouts"]) -> list[LayoutConfig]:
+    """When threshold is exceeded, create more layouts with max_thresh tabs each."""
+    new_layout_configs: list[LayoutConfig] = []
+    for a_layout_config in layout_configs:
+        if len(a_layout_config["layoutTabs"]) > max_thresh:
+            print(f"Layout '{a_layout_config['layoutName']}' has too many tabs ({len(a_layout_config['layoutTabs'])} > {max_thresh}). Splitting into multiple layouts.")
+            tab_chunks = split_list(a_layout_config["layoutTabs"], every=max_thresh)
+            for idx, tab_chunk in enumerate(tab_chunks):
+                new_layout_configs.append({
+                    "layoutName": f"{a_layout_config['layoutName']}_part{idx+1}",
+                    "layoutTabs": tab_chunk
+                })
+        else:
+            print(f"Layout '{a_layout_config['layoutName']}' has acceptable number of tabs ({len(a_layout_config['layoutTabs'])} <= {max_thresh}). Keeping as is.")
+            new_layout_configs.append(a_layout_config)
+    return new_layout_configs
+
+
+def restrict_num_tabs_helper2(layout_configs: list[LayoutConfig], max_thresh: int, threshold_type: Literal["number"], breaking_method: Literal["combineTabs"]) -> list[LayoutConfig]:
+    """When threshold is exceeded, combine tabs into super tabs to reduce count to max_thresh."""
+    new_layout_configs: list[LayoutConfig] = []
+    for a_layout_config in layout_configs:
+        num_tabs = len(a_layout_config["layoutTabs"])
+        if num_tabs > max_thresh:
+            print(f"Layout '{a_layout_config['layoutName']}' has too many tabs ({num_tabs} > {max_thresh}). Combining into {max_thresh} super tabs.")
+            super_tabs = combine_tabs_into_super_tabs(a_layout_config["layoutTabs"], num_super_tabs=max_thresh)
+            new_layout_configs.append({
+                "layoutName": a_layout_config["layoutName"],
+                "layoutTabs": super_tabs
+            })
+        else:
+            print(f"Layout '{a_layout_config['layoutName']}' has acceptable number of tabs ({num_tabs} <= {max_thresh}). Keeping as is.")
+            new_layout_configs.append(a_layout_config)
+    return new_layout_configs
+
+
+def restrict_num_tabs_helper3(layout_configs: list[LayoutConfig], max_thresh: int, threshold_type: Literal["weight"], breaking_method: Literal["moreLayouts"]) -> list[LayoutConfig]:
+    """When threshold is exceeded, create more layouts with max_thresh total weight each."""
+    new_layout_configs: list[LayoutConfig] = []
+    for a_layout_config in layout_configs:
+        layout_weight = sum(tab.get("tabWeight", 1) for tab in a_layout_config["layoutTabs"])
+        if layout_weight > max_thresh:
+            print(f"Layout '{a_layout_config['layoutName']}' has too much weight ({layout_weight} > {max_thresh}). Splitting into multiple layouts.")
+            tab_chunks = split_tabs_by_weight(a_layout_config["layoutTabs"], max_weight=max_thresh)
+            for idx, tab_chunk in enumerate(tab_chunks):
+                new_layout_configs.append({
+                    "layoutName": f"{a_layout_config['layoutName']}_part{idx+1}",
+                    "layoutTabs": tab_chunk
+                })
+        else:
+            print(f"Layout '{a_layout_config['layoutName']}' has acceptable total weight ({layout_weight} <= {max_thresh}). Keeping as is.")
+            new_layout_configs.append(a_layout_config)
+    return new_layout_configs
+
+
+def restrict_num_tabs_helper4(layout_configs: list[LayoutConfig], max_thresh: int, threshold_type: Literal["weight"], breaking_method: Literal["combineTabs"]) -> list[LayoutConfig]:
+    """When threshold is exceeded, combine tabs into super tabs with weight <= max_thresh."""
+    new_layout_configs: list[LayoutConfig] = []
+    for a_layout_config in layout_configs:
+        layout_weight = sum(tab.get("tabWeight", 1) for tab in a_layout_config["layoutTabs"])
+        if layout_weight > max_thresh:
+            print(f"Layout '{a_layout_config['layoutName']}' has too much weight ({layout_weight} > {max_thresh}). Combining into super tabs with weight <= {max_thresh}.")
+            super_tabs = combine_tabs_by_weight_into_super_tabs(a_layout_config["layoutTabs"], max_weight=max_thresh)
+            new_layout_configs.append({
+                "layoutName": a_layout_config["layoutName"],
+                "layoutTabs": super_tabs
+            })
+        else:
+            print(f"Layout '{a_layout_config['layoutName']}' has acceptable total weight ({layout_weight} <= {max_thresh}). Keeping as is.")
+            new_layout_configs.append(a_layout_config)
+    return new_layout_configs

machineconfig/scripts/python/fire_agents.py

@@ -1,4 +1,12 @@
-"""Utility to launch multiple AI agent prompts in a Zellij session.
+"""Utilitfrom pathlib import Path
+from typing import cast, get_args, Iterable, Optional, TypeAlias, Literal
+import json
+import typer
+
+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
+from machineconfig.utils.accessories import get_repo_rootch multiple AI agent prompts in a Zellij session.
 
 Improved design notes:
   * Clear separation of: input collection, prompt preparation, agent launch.
@@ -8,146 +16,145 @@ Improved design notes:
 """
 
 from pathlib import Path
-from typing import cast, get_args, Iterable, TypeAlias, Literal
+from typing import cast, Iterable, Optional, TypeAlias, Literal, get_args
 import json
-import sys
+import time
+import typer
 
 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.utils.options import choose_from_options
+from machineconfig.scripts.python.fire_agents_load_balancer import chunk_prompts
+from machineconfig.utils.schemas.layouts.layout_types import LayoutsFile
 from machineconfig.utils.accessories import get_repo_root
 
 SEARCH_STRATEGIES: TypeAlias = Literal["file_path", "keyword_search", "filename_pattern"]
 
+app = typer.Typer()
+
 
 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 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()
+@app.command()
+def create(
+    context_path: Optional[Path] = typer.Option(None, help="Path to the context file"),
+    keyword_search: Optional[str] = typer.Option(None, help="Keyword to search in Python files"),
+    filename_pattern: Optional[str] = typer.Option(None, help="Filename pattern to match"),
+    separator: str = typer.Option("\n", help="Separator for context"),
+    tasks_per_prompt: int = typer.Option(13, help="Number of tasks per prompt"),
+    agent: AGENTS = typer.Option(..., help=f"Agent type. One of {', '.join(get_args(AGENTS))}"),
+    prompt: Optional[str] = typer.Option(None, help="Prompt prefix as string"),
+    prompt_path: Optional[Path] = typer.Option(None, help="Path to prompt file"),
+    job_name: str = typer.Option("AI_Agents", help="Job name"),
+    keep_separate: bool = typer.Option(True, help="Keep prompt material in separate file to the context."),
+    output_path: Optional[Path] = typer.Option(None, help="Path to write the layout.json file"),
+):
+    # validate mutual exclusive
+    context_options = [context_path, keyword_search, filename_pattern]
+    provided_context = [opt for opt in context_options if opt is not None]
+    if len(provided_context) != 1:
+        raise typer.BadParameter("Exactly one of --context-path, --keyword-search, --filename-pattern must be provided")
+    
+    prompt_options = [prompt, prompt_path]
+    provided_prompt = [opt for opt in prompt_options if opt is not None]
+    if len(provided_prompt) != 1:
+        raise typer.BadParameter("Exactly one of --prompt or --prompt-path must be provided")
+    
+    repo_root = get_repo_root(Path.cwd())
+    if repo_root is None:
+        typer.echo("💥 Could not determine the repository root. Please run this script from within a git repository.")
+        raise typer.Exit(1)
+    typer.echo(f"Operating @ {repo_root}")
+    
+    search_strategy = ""
+    prompt_material_path = Path("")
+    
+    if context_path is not None:
+        search_strategy = "file_path"
+        target_file_path = context_path.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.")
-            sys.exit(1)
-        matching_files = search_python_files(repo_root, keyword)
+            raise typer.BadParameter(f"Invalid file path: {target_file_path}")
+        prompt_material_path = target_file_path
+    elif keyword_search is not None:
+        search_strategy = "keyword_search"
+        matching_files = search_python_files(repo_root, keyword_search)
         if not matching_files:
-            print(f"💥 No .py files found containing keyword: {keyword}")
-            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}")
+            typer.echo(f"💥 No .py files found containing keyword: {keyword_search}")
+            raise typer.Exit(1)
         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)
+        prompt_material_path = target_file_path
+    elif filename_pattern is not None:
+        search_strategy = "filename_pattern"
+        matching_files = search_files_by_pattern(repo_root, filename_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}")
+            typer.echo(f"💥 No files found matching pattern: {filename_pattern}")
+            raise typer.Exit(1)
         target_file_path = repo_root / ".ai" / "target_file.txt"
         _write_list_file(target_file_path, matching_files)
-        separator = "\n"
+        prompt_material_path = target_file_path
+    
+    if prompt_path is not None:
+        prompt_prefix = prompt_path.read_text(encoding="utf-8")
     else:
-        raise ValueError(f"Unknown search strategy: {search_strategy}")
-    return target_file_path, separator
-
-
-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}")
-
-    search_strategy = cast(SEARCH_STRATEGIES, choose_from_options(multi=False, msg="Choose one option", header="Choose search strategy:", options=get_args(SEARCH_STRATEGIES)))
-    splitting_strategy = cast(SPLITTING_STRATEGY, choose_from_options(multi=False, msg="Choose one option", header="Choose prompt splitting strategy:", options=get_args(SPLITTING_STRATEGY)))
-    agent_selected = cast(AGENTS, choose_from_options(multi=False, msg="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)
-
+        prompt_prefix = cast(str, prompt)
+    agent_selected = agent
+    keep_material_in_separate_file_input = keep_separate
+    prompt_material_re_splitted = chunk_prompts(prompt_material_path, tasks_per_prompt=tasks_per_prompt, 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)
-
+    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 --no-dev --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()
-
+fire_agents create --context-path "{prompt_material_path}" \\
+    --{search_strategy} "{context_path or keyword_search or filename_pattern}" \\
+    --prompt-path "{prompt_path or ''}" \\
+    --agent "{agent_selected}" \\
+    --job-name "{job_name}" \\
+    --tasks-per-prompt {tasks_per_prompt} \\
+    --separator "{separator}" \\
+    {"--keep-separate" if keep_material_in_separate_file_input else ""}
 """
     (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")
-
-    MAX_TABS = 10
-    if len(layoutfile["layouts"][0]["layoutTabs"]) > MAX_TABS:
-        print(f"Too many tabs (>{MAX_TABS}) to launch. Skipping launch.")
-        sys.exit(0)
+    layout_output_path = output_path if output_path is not None else agents_dir / "layout.json"
+    layout_output_path.write_text(data=json.dumps(layoutfile, indent=4), encoding="utf-8")
+    typer.echo(f"Created agents in {agents_dir}")
+
+
+@app.command()
+def run(layout_path: Path = typer.Argument(..., help="Path to the layout.json file"),
+        max_tabs: int = typer.Option(6, help="Maximum number of tabs to launch"),
+        sleep_between_layouts: float = typer.Option(1.0, help="Sleep time in seconds between launching layouts")):
+    layoutfile: LayoutsFile = json.loads(layout_path.read_text())
+    if len(layoutfile["layouts"][0]["layoutTabs"]) > max_tabs:
+        typer.echo(f"Too many tabs (>{max_tabs}) to launch. Skipping launch.")
+        raise typer.Exit(0)
     from machineconfig.cluster.sessions_managers.zellij_local_manager import ZellijLocalManager
-
-    manager = ZellijLocalManager(session_layouts=layoutfile["layouts"])
-    manager.start_all_sessions(poll_interval=2, poll_seconds=2)
-    manager.run_monitoring_routine(wait_ms=2000)
+    for i, a_layouts in enumerate(layoutfile["layouts"]):
+        manager = ZellijLocalManager(session_layouts=[a_layouts])
+        manager.start_all_sessions(poll_interval=2, poll_seconds=2)
+        manager.run_monitoring_routine(wait_ms=2000)
+        if i < len(layoutfile["layouts"]) - 1:  # Don't sleep after the last layout
+            time.sleep(sleep_between_layouts)
+
+
+@app.command(help="Adjust layout file to limit max tabs per layout, etc.")
+def load_balance(layout_path: Path = typer.Argument(..., help="Path to the layout.json file"),
+           max_thresh: int = typer.Option(..., help="Maximum tabs per layout"),
+           thresh_type: Literal['number', 'weight'] = typer.Option(..., help="Threshold type"),
+           breaking_method: Literal['moreLayouts', 'combineTabs'] = typer.Option(..., help="Breaking method"),
+           output_path: Optional[Path] = typer.Option(None, help="Path to write the adjusted layout.json file")):
+    layoutfile: LayoutsFile = json.loads(layout_path.read_text())
+    layout_configs = layoutfile["layouts"]
+    from machineconfig.cluster.sessions_managers.utils.load_balancer import limit_tab_num
+    new_layouts = limit_tab_num(layout_configs=layout_configs, max_thresh=max_thresh, threshold_type=thresh_type, breaking_method=breaking_method)
+    layoutfile["layouts"] = new_layouts
+    target_file = output_path if output_path is not None else layout_path.parent / f'{layout_path.stem}_adjusted_{max_thresh}_{thresh_type}_{breaking_method}.json'
+    target_file.write_text(data=json.dumps(layoutfile, indent=4), encoding="utf-8")
+    typer.echo(f"Adjusted layout saved to {target_file}")
 
 
 if __name__ == "__main__":  # pragma: no cover
-    main()
+    app()

machineconfig/scripts/python/fire_agents_help_launch.py

@@ -7,7 +7,7 @@ from typing import Literal, TypeAlias
 
 
 AGENTS: TypeAlias = Literal[
-    "cursor-agent", "gemini", "crush", "q", "onlyPrepPromptFiles"
+    "cursor-agent", "gemini", "crush", "q"
     # warp terminal
 ]
 AGENT_NAME_FORMATTER = "agent_{idx}_cmd.sh"  # e.g., agent_0_cmd.sh
@@ -34,7 +34,6 @@ def prep_agent_launch(repo_root: Path, prompts_material: list[str], prompt_prefi
     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)
@@ -43,7 +42,6 @@ def prep_agent_launch(repo_root: Path, prompts_material: list[str], prompt_prefi
             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")
@@ -87,7 +85,7 @@ sleep 0.1
                 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'
+gemini {model_arg} --yolo --prompt {safe_path}
 """
             case "cursor-agent":
                 # As originally implemented
@@ -103,10 +101,6 @@ 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}")
@@ -116,11 +110,6 @@ 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
 
 
@@ -130,14 +119,11 @@ def get_agents_launch_layout(session_root: Path):
     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_load_balancer.py

@@ -1,16 +1,8 @@
-from typing import Literal, TypeAlias
-from math import ceil
+# 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]:
+def chunk_prompts(prompt_material_path: Path, joiner: str, *, tasks_per_prompt: int) -> list[str]:
     """Chunk prompts based on splitting strategy.
 
     Args:
@@ -20,31 +12,11 @@ def chunk_prompts(prompt_material_path: Path, strategy: SPLITTING_STRATEGY, join
         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}")
+    if tasks_per_prompt >= len(prompts):
+        print("No need to chunk prompts, as tasks_per_prompt >= total prompts.", f"({tasks_per_prompt} >= {len(prompts)})")
+        return prompts
+    print(f"Chunking {len(prompts)} prompts into groups of {tasks_per_prompt} rows/tasks each.")
+    grouped: list[str] = []
+    for i in range(0, len(prompts), tasks_per_prompt):
+        grouped.append(joiner.join(prompts[i : i + tasks_per_prompt]))
+    return grouped

machineconfig/utils/schemas/fire_agents/fire_agents_input.py

@@ -6,7 +6,6 @@ capturing all user inputs collected during interactive execution.
 
 from pathlib import Path
 from typing import TypedDict, Literal, NotRequired
-from machineconfig.scripts.python.fire_agents_load_balancer import SPLITTING_STRATEGY
 from machineconfig.scripts.python.fire_agents_help_launch import AGENTS
 
 SEARCH_STRATEGIES = Literal["file_path", "keyword_search", "filename_pattern"]
@@ -21,26 +20,17 @@ class FilePathSearchInput(TypedDict):
 
 class KeywordSearchInput(TypedDict):
     """Input for keyword_search strategy."""
-
     keyword: str
 
 
 class FilenamePatternSearchInput(TypedDict):
     """Input for filename_pattern search strategy."""
-
     pattern: str  # e.g., '*.py', '*test*', 'config.*'
 
 
-class AgentCapSplittingInput(TypedDict):
-    """Input for agent_cap splitting strategy."""
-
-    agent_cap: int  # Default: 6
-
-
-class TaskRowsSplittingInput(TypedDict):
-    """Input for task_rows splitting strategy."""
-
-    task_rows: int  # Default: 13
+class TasksPerPromptSplittingInput(TypedDict):
+    """Input for tasks_per_prompt splitting strategy."""
+    tasks_per_prompt: int  # Default: 13
 
 
 class FireAgentsMainInput(TypedDict):
@@ -49,7 +39,6 @@ class FireAgentsMainInput(TypedDict):
     # Core configuration
     repo_root: Path
     search_strategy: SEARCH_STRATEGIES
-    splitting_strategy: SPLITTING_STRATEGY
     agent_selected: AGENTS
     prompt_prefix: str
     job_name: str  # Default: "AI_Agents"
@@ -62,8 +51,7 @@ class FireAgentsMainInput(TypedDict):
     filename_pattern_input: NotRequired[FilenamePatternSearchInput]
 
     # Splitting strategy specific inputs (only one will be present based on splitting_strategy)
-    agent_cap_input: NotRequired[AgentCapSplittingInput]
-    task_rows_input: NotRequired[TaskRowsSplittingInput]
+    tasks_per_prompt: TasksPerPromptSplittingInput
 
 
 class FireAgentsRuntimeData(TypedDict):

{machineconfig-4.1.dist-info → machineconfig-4.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: machineconfig
-Version: 4.1
+Version: 4.4
 Summary: Dotfiles management package
 Author-email: Alex Al-Saffar <programmer@usa.com>
 License: Apache 2.0
@@ -26,6 +26,7 @@ Requires-Dist: rclone-python>=0.1.23
 Requires-Dist: pyjson5>=1.6.9
 Requires-Dist: typer-slim>=0.19.2
 Requires-Dist: questionary>=2.1.1
+Requires-Dist: typer>=0.19.2
 Provides-Extra: windows
 Requires-Dist: pywin32; extra == "windows"
 Provides-Extra: docs

{machineconfig-4.1.dist-info → machineconfig-4.4.dist-info}/RECORD

@@ -20,7 +20,8 @@ machineconfig/cluster/sessions_managers/zellij_local_manager.py,sha256=4ap0Gtd8w
 machineconfig/cluster/sessions_managers/zellij_remote.py,sha256=3gz-wgqVW7B-4CgvJq0fiDh8691h4yeK3Xh3CfSPc2s,8749
 machineconfig/cluster/sessions_managers/zellij_remote_manager.py,sha256=T-j1KMV7mDTeGSHC5To0_JmqNtjSR_LVZT9VanP4lyI,8313
 machineconfig/cluster/sessions_managers/utils/enhanced_command_runner.py,sha256=3vcQVg-HHa_WTxBGPtKMAdoSqJVa2EO5KAtrY8a6I3c,5264
-machineconfig/cluster/sessions_managers/utils/load_balancer.py,sha256=ODnYCkMwpnD9ooMemJsaADAnmFSGELTW5QKJwepajL4,9051
+machineconfig/cluster/sessions_managers/utils/load_balancer.py,sha256=q9k3ofvgcZzx_oKtaymWf75JpDAs5pagwRRYzfVgu30,3176
+machineconfig/cluster/sessions_managers/utils/load_balancer_helper.py,sha256=i5TRittC1IWTgMZNyG8AR5qq-3WrGp3xgIx2m5ktT7g,7526
 machineconfig/cluster/sessions_managers/wt_utils/layout_generator.py,sha256=CFGcZPFTZQJtFf0OvMUHhadZ0qbImCP3wxvbWYVcVYo,7445
 machineconfig/cluster/sessions_managers/wt_utils/process_monitor.py,sha256=Mitm7mKiKl5lT0OiEUHAqVg2Q21RjsKO1-hpJTHJ5lM,15196
 machineconfig/cluster/sessions_managers/wt_utils/remote_executor.py,sha256=lApUy67_WhfaBXqt0meZSx_QvwiXjN0YLdyE3c7kP_s,6744
@@ -154,10 +155,10 @@ machineconfig/scripts/python/devops_backup_retrieve.py,sha256=jZe5Vki7E2GCMG8hvq
 machineconfig/scripts/python/devops_devapps_install.py,sha256=QbRQhNdDRLLtgJwaRl2pbLmWvajb1b_Xte2ql8N3JRs,9096
 machineconfig/scripts/python/devops_update_repos.py,sha256=c5qBc9cuTGDEqDHufkjDT4d_vvJsswv3tlqk9MAulYk,8063
 machineconfig/scripts/python/dotfile.py,sha256=SRcX-9Ak1jRvF-killBTTm2IWcsNxfiLucH6ZsytAFA,2202
-machineconfig/scripts/python/fire_agents.py,sha256=BgWyzac_yXzp4xpzcEOQ62UeVIiH-KR-KURAwaiAF-4,7936
-machineconfig/scripts/python/fire_agents_help_launch.py,sha256=sTdjNz2pDinDMMjUAMN7OqH-KAUeHh6Aihr_zUvtM6k,6128
+machineconfig/scripts/python/fire_agents.py,sha256=An6OE2dVyni_XGt3V-5kMhPxDSfXOnJuO2N6AokQHyo,8860
+machineconfig/scripts/python/fire_agents_help_launch.py,sha256=TpuARLC_9b3SNMYeYIi_h1qKCSifT074QEvZ-ZK967M,5264
 machineconfig/scripts/python/fire_agents_help_search.py,sha256=qIfSS_su2YJ1Gb0_lu4cbjlJlYMBw0v52NTGiSrGjk8,2991
-machineconfig/scripts/python/fire_agents_load_balancer.py,sha256=QPiCbQq9j5REHStPdYqQcGNkz_rp5CjotqOpMY3v5TM,2099
+machineconfig/scripts/python/fire_agents_load_balancer.py,sha256=mpqx3uaQdBXYieuvhdK-qsvLepf9oIMo3pwPj9mSEDI,1079
 machineconfig/scripts/python/fire_jobs.py,sha256=qD_9JtoNTjOjAyX0_QPysfHNQ-qq55t-Tv9ctEK17MI,20569
 machineconfig/scripts/python/fire_jobs_args_helper.py,sha256=VsyPgjWRByZgXz65vmmpyR-2mJo6KwNgwrWFYd3EYqc,2075
 machineconfig/scripts/python/fire_jobs_layout_helper.py,sha256=LHLyp5HxKwut19x2OYKQq8gy4EKon6wNb-jlxx5DoVM,4134
@@ -401,12 +402,12 @@ machineconfig/utils/installer_utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQ
 machineconfig/utils/installer_utils/github_release_bulk.py,sha256=vK5WJ-a566egAIEHdKsn3iOAh5LBqeY4zPDHPgqHVcE,6887
 machineconfig/utils/installer_utils/installer_abc.py,sha256=3jjLHL1xqTPowx52r7BfhjpzF6LQA7CRudjN2QYJP34,10551
 machineconfig/utils/installer_utils/installer_class.py,sha256=6IQswaC9mxIdeaMG-rOt-vqyKGYibBRMvC0UglZ_3mI,20268
-machineconfig/utils/schemas/fire_agents/fire_agents_input.py,sha256=CCs5ebomW1acKWZRpv9dyDzM-W6pwvVplikcutE2D8I,2339
+machineconfig/utils/schemas/fire_agents/fire_agents_input.py,sha256=pTxvLzIpD5RF508lUUBBkWcc4V1B10J4ylvVgVGkcM0,2037
 machineconfig/utils/schemas/installer/installer_types.py,sha256=DLagmIe0G5-xg7HZ9VrlFCDk1gIbwvX7O4gZjwq0wh0,1326
 machineconfig/utils/schemas/layouts/layout_types.py,sha256=TcqlZdGVoH8htG5fHn1KWXhRdPueAcoyApppZsPAPto,2020
 machineconfig/utils/schemas/repos/repos_types.py,sha256=ECVr-3IVIo8yjmYmVXX2mnDDN1SLSwvQIhx4KDDQHBQ,405
-machineconfig-4.1.dist-info/METADATA,sha256=b3JCS_zyxDLbFlIDEu5k4EdmkuOHwIIclgCSorz6Jdg,7031
-machineconfig-4.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-machineconfig-4.1.dist-info/entry_points.txt,sha256=c6ea0waVseT1rbfz1bw3k-eph2yVaB67x9hx64Mpvfs,1066
-machineconfig-4.1.dist-info/top_level.txt,sha256=porRtB8qms8fOIUJgK-tO83_FeH6Bpe12oUVC670teA,14
-machineconfig-4.1.dist-info/RECORD,,
+machineconfig-4.4.dist-info/METADATA,sha256=lyni_bLaEQayMHJkaaRhSCbb0g7svm5l25Ek_EaQ7lw,7060
+machineconfig-4.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+machineconfig-4.4.dist-info/entry_points.txt,sha256=fhSTJGrT7JZ7PcN-F3nrb5xXIohicZo57rbM23Mdblk,1065
+machineconfig-4.4.dist-info/top_level.txt,sha256=porRtB8qms8fOIUJgK-tO83_FeH6Bpe12oUVC670teA,14
+machineconfig-4.4.dist-info/RECORD,,

{machineconfig-4.1.dist-info → machineconfig-4.4.dist-info}/entry_points.txt

@@ -7,7 +7,7 @@ cloud_sync = machineconfig.scripts.python.cloud_sync:arg_parser
 croshell = machineconfig.scripts.python.croshell:arg_parser
 devops = machineconfig.scripts.python.devops:app
 fire = machineconfig.scripts.python.fire_jobs:main_from_parser
-fire_agents = machineconfig.scripts.python.fire_agents:main
+fire_agents = machineconfig.scripts.python.fire_agents:app
 ftpx = machineconfig.scripts.python.ftpx:main_from_parser
 initai = machineconfig.scripts.python.ai.initai:main
 kill_process = machineconfig.utils.procs:main