machineconfig 3.99__py3-none-any.whl → 7.66__py3-none-any.whl

machineconfig/scripts/python/ftpx.py

@@ -1,4 +1,3 @@
-#!/usr/bin/env -S uv run --no-dev --project /home/alex/code/machineconfig --script
 """Sx & Rx
 
 TODO: add support for cases in which source or target has non 22 default port number and is defineda as user@host:port:path which makes 2 colons in the string.
@@ -7,25 +6,41 @@ Currently, the only way to work around this is to predifine the host in ~/.ssh/c
 """
 
 import typer
-from typing_extensions import Annotated
-from machineconfig.utils.ssh import SSH
-from machineconfig.utils.path_extended import PathExtended as PathExtended
-from machineconfig.scripts.python.helpers.helpers2 import ES
-from machineconfig.utils.accessories import pprint
+from typing import Annotated
 
 
-def main(
+def ftpx(
     source: Annotated[str, typer.Argument(help="Source path (machine:path)")],
     target: Annotated[str, typer.Argument(help="Target path (machine:path)")],
     recursive: Annotated[bool, typer.Option("--recursive", "-r", help="Send recursively.")] = False,
     zipFirst: Annotated[bool, typer.Option("--zipFirst", "-z", help="Zip before sending.")] = False,
     cloud: Annotated[bool, typer.Option("--cloud", "-c", help="Transfer through the cloud.")] = False,
 ) -> None:
-    print("""
-┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-┃ 🚀 FTP File Transfer
-┃ 📋 Starting transfer process...
-┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━""")
+
+    from rich.console import Console
+    from rich.panel import Panel
+
+    from machineconfig.utils.ssh import SSH
+    from machineconfig.utils.path_extended import PathExtended
+    from machineconfig.scripts.python.helpers_cloud.helpers2 import ES
+    from machineconfig.utils.accessories import pprint
+
+
+    console = Console()
+
+    console.print(
+        Panel(
+            "\n".join(
+                [
+                    "🚀 FTP File Transfer",
+                    "📋 Starting transfer process...",
+                ]
+            ),
+            title="Transfer Initialisation",
+            border_style="blue",
+            padding=(1, 2),
+        )
+    )
     
     # Initialize variables
     resolved_source: str | None = None
@@ -92,77 +107,119 @@ def main(
     from paramiko.ssh_exception import AuthenticationException  # type: ignore
 
     try:
-        ssh = SSH(rf"{machine}")
+        ssh = SSH(host=rf"{machine}", username=None, hostname=None, ssh_key_path=None, password=None, port=22, enable_compression=True)
     except AuthenticationException:
-        print("""
-┌────────────────────────────────────────────────────────────────
-│ 🔑 Authentication Failed
-│    Trying manual authentication...
-│
-│ ⚠️  Caution: Ensure that username is passed appropriately
-│    This exception only handles password authentication
-└────────────────────────────────────────────────────────────────""")
+        console.print(
+            Panel(
+                "\n".join(
+                    [
+                        "🔑 Authentication failed. Trying manual authentication...",
+                        "⚠️  Ensure that the username is provided correctly; only password prompts are handled here.",
+                    ]
+                ),
+                title="Authentication Required",
+                border_style="yellow",
+                padding=(1, 2),
+            )
+        )
         import getpass
 
         pwd = getpass.getpass()
-        ssh = SSH(rf"{machine}", pwd=pwd)
+        ssh = SSH(host=rf"{machine}", username=None, hostname=None, ssh_key_path=None, password=pwd, port=22, enable_compression=True)
 
     if cloud:
-        print("""
-┌────────────────────────────────────────────────────────────────
-│ ☁️  Cloud Transfer Mode
-│    Uploading from remote to cloud...
-└────────────────────────────────────────────────────────────────""")
-        ssh.run(f"cloud_copy {resolved_source} :^", desc="Uploading from remote to the cloud.").print()
-        print("""
-┌────────────────────────────────────────────────────────────────
-│ ⬇️  Cloud Transfer Mode
-│    Downloading from cloud to local...
-└────────────────────────────────────────────────────────────────""")
-        ssh.run_locally(f"cloud_copy :^ {resolved_target}").print()
+        console.print(
+            Panel.fit(
+                "☁️  Cloud transfer mode — uploading from remote to cloud...",
+                title="Cloud Upload",
+                border_style="cyan",
+            )
+        )
+        ssh.run_shell(command=f"cloud_copy {resolved_source} :^", verbose_output=True, description="Uploading from remote to the cloud.", strict_stderr=False, strict_return_code=False)
+        console.print(
+            Panel.fit(
+                "⬇️  Cloud transfer mode — downloading from cloud to local...",
+                title="Cloud Download",
+                border_style="cyan",
+            )
+        )
+        ssh.run_locally(command=f"cloud_copy :^ {resolved_target}")
         received_file = PathExtended(resolved_target)  # type: ignore
     else:
         if source_is_remote:
-            assert resolved_source is not None, """
-❌ Path Error: Source must be a remote path (machine:path)"""
-            print(f"""
-┌────────────────────────────────────────────────────────────────
-│ 📥 Transfer Mode: Remote → Local
-│    Source: {resolved_source}
-│    Target: {resolved_target}
-│    Options: {"ZIP compression" if zipFirst else "No compression"}, {"Recursive" if recursive else "Non-recursive"}
-└────────────────────────────────────────────────────────────────""")
-            received_file = ssh.copy_to_here(source=resolved_source, target=resolved_target, z=zipFirst, r=recursive)
+            if resolved_source is None:
+                typer.echo("""❌ Path Error: Source must be a remote path (machine:path)""")
+                typer.Exit(code=1)
+                return                
+            target_display = resolved_target or "<auto>"
+            console.print(
+                Panel(
+                    "\n".join(
+                        [
+                            "📥 Transfer Mode: Remote → Local",
+                            f"Source: [cyan]{resolved_source}[/cyan]",
+                            f"Target: [cyan]{target_display}[/cyan]",
+                            f"Options: {'ZIP compression' if zipFirst else 'No compression'}, {'Recursive' if recursive else 'Non-recursive'}",
+                        ]
+                    ),
+                    title="Transfer Details",
+                    border_style="cyan",
+                    padding=(1, 2),
+                )
+            )
+            received_file = ssh.copy_to_here(source=resolved_source, target=resolved_target, compress_with_zip=zipFirst, recursive=recursive)
         else:
             assert resolved_source is not None, """
 ❌ Path Error: Target must be a remote path (machine:path)"""
-            print(f"""
-┌────────────────────────────────────────────────────────────────
-│ 📤 Transfer Mode: Local → Remote
-│    Source: {resolved_source}
-│    Target: {resolved_target}
-│    Options: {"ZIP compression" if zipFirst else "No compression"}, {"Recursive" if recursive else "Non-recursive"}
-└────────────────────────────────────────────────────────────────""")
-            received_file = ssh.copy_from_here(source=resolved_source, target=resolved_target, z=zipFirst, r=recursive)
+            target_display = resolved_target or "<auto>"
+            console.print(
+                Panel(
+                    "\n".join(
+                        [
+                            "📤 Transfer Mode: Local → Remote",
+                            f"Source: [cyan]{resolved_source}[/cyan]",
+                            f"Target: [cyan]{target_display}[/cyan]",
+                            f"Options: {'ZIP compression' if zipFirst else 'No compression'}, {'Recursive' if recursive else 'Non-recursive'}",
+                        ]
+                    ),
+                    title="Transfer Details",
+                    border_style="cyan",
+                    padding=(1, 2),
+                )
+            )
+            received_file = ssh.copy_from_here(source_path=resolved_source, target_rel2home=resolved_target, compress_with_zip=zipFirst, recursive=recursive, overwrite_existing=False)
 
     if source_is_remote and isinstance(received_file, PathExtended):
-        print(f"""
-┌────────────────────────────────────────────────────────────────
-│ 📁 File Received
-│    Parent: {repr(received_file.parent)}
-│    File: {repr(received_file)}
-└────────────────────────────────────────────────────────────────""")
-    print("""
-┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-┃ ✅ Transfer Complete
-┃    File transfer process finished successfully
-┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━""")
-
-
-def main_from_parser() -> None:
+        console.print(
+            Panel(
+                "\n".join(
+                    [
+                        "📁 File Received",
+                        f"Parent: [cyan]{repr(received_file.parent)}[/cyan]",
+                        f"File: [cyan]{repr(received_file)}[/cyan]",
+                    ]
+                ),
+                title="Transfer Result",
+                border_style="green",
+                padding=(1, 2),
+            )
+        )
+    console.print(
+        Panel(
+            "File transfer process finished successfully",
+            title="✅ Transfer Complete",
+            border_style="green",
+            padding=(1, 2),
+        )
+    )
+
+
+def main() -> None:
     """Entry point function that uses typer to parse arguments and call main."""
-    typer.run(main)
+    app = typer.Typer()
+    app.command(no_args_is_help=True, help="File transfer utility though SSH.")(ftpx)
+    app()
 
 
 if __name__ == "__main__":
-    main_from_parser()
+    main()

machineconfig/scripts/python/helpers_agents/agentic_frameworks/fire_crush.json

@@ -0,0 +1,14 @@
+{
+    "models": {
+        "large": {
+            "model": "{model}",
+            "provider": "{provider}",
+            "max_tokens": 100000
+        }
+    },
+    "providers": {
+        "openrouter": {
+            "api_key": "{api_key}"
+        }
+    }
+}

machineconfig/scripts/python/helpers_agents/agentic_frameworks/fire_crush.py

@@ -0,0 +1,37 @@
+
+from pathlib import Path
+# import shlex
+from machineconfig.scripts.python.helpers_agents.fire_agents_helper_types import AI_SPEC
+
+
+def fire_crush(ai_spec: AI_SPEC, prompt_path: Path, repo_root: Path) -> str:
+    match ai_spec["machine"]:
+        case "local":
+            cmd = f"""
+crush run {prompt_path}
+"""
+        case "docker":
+            assert ai_spec["api_key"] is not None, "API key is required for Crush agent in docker mode."
+            json_path = Path(__file__).parent / "fire_crush.json"
+            json_template = json_path.read_text(encoding="utf-8")
+            json_filled = json_template.replace("{api_key}", ai_spec["api_key"]).replace("{model}", ai_spec["model"]).replace("{provider}", ai_spec["provider"])
+            from machineconfig.utils.accessories import randstr
+            temp_config_file_local = Path.home().joinpath("tmp_results/tmp_files/crush_" + randstr(8) + ".json")
+            temp_config_file_local.parent.mkdir(parents=True, exist_ok=True)
+            Path(temp_config_file_local).write_text(json_filled, encoding="utf-8")            
+            cmd = f"""
+
+#   -e "PATH_PROMPT=$PATH_PROMPT"
+#   opencode --model "{ai_spec["provider"]}/{ai_spec["model"]}" run {prompt_path}
+  
+
+echo "Running prompt @ {prompt_path.relative_to(repo_root)} using Docker with Crush..."
+docker run -it --rm \
+  -v "{repo_root}:/workspace/{repo_root.name}" \
+  -v "{temp_config_file_local}:/root/.local/share/crush/crush.json" \
+  -w "/workspace/{repo_root.name}" \
+  statistician/machineconfig-ai:latest \
+  bash -i -c "source ~/.bashrc && cd /workspace/{repo_root.name} && cat /root/.local/share/crush/crush.json && crush run 'Please act on contents of this prompt ./{prompt_path.relative_to(repo_root)}'"
+
+"""
+    return cmd

machineconfig/scripts/python/helpers_agents/agentic_frameworks/fire_cursor_agents.py

@@ -0,0 +1,22 @@
+
+
+from pathlib import Path
+# import shlex
+from machineconfig.scripts.python.helpers_agents.fire_agents_helper_types import AI_SPEC
+
+def fire_cursor(ai_spec: AI_SPEC, prompt_path: Path) -> str:
+    match ai_spec["machine"]:
+        case "local":
+            # Export the environment variable so it's available to subshells
+            cmd = f"""
+
+cursor-agent --print --output-format text {prompt_path}
+
+"""
+        case "docker":
+            cmd = f"""
+
+cursor-agent --print --output-format text {prompt_path}
+
+"""
+    return cmd

machineconfig/scripts/python/helpers_agents/agentic_frameworks/fire_gemini.py

@@ -0,0 +1,42 @@
+
+from pathlib import Path
+import shlex
+from machineconfig.scripts.python.helpers_agents.fire_agents_helper_types import AI_SPEC
+
+
+def fire_gemini(ai_spec: AI_SPEC, prompt_path: Path, repo_root: Path) -> str:
+    _ = ai_spec["provider"]
+    # model = "gemini-2.5-flash-lite"
+    # model = None  # auto-select
+    # if model is None:
+    #     model_arg = ""
+    # else:
+    model_arg = f"--model {shlex.quote(ai_spec['model'])}"
+    # Need a real shell for the pipeline; otherwise '| gemini ...' is passed as args to 'cat'
+    safe_path = shlex.quote(str(prompt_path))
+
+    match ai_spec["machine"]:
+        case "local":
+            # Export the environment variable so it's available to subshells
+            if ai_spec["api_key"] is not None:
+                define_api_key = f"""export GEMINI_API_KEY="{shlex.quote(ai_spec['api_key'])}" """
+            else:
+                define_api_key = "echo 'Warning: No GEMINI_API_KEY provided, hoping it is set in the environment.'"
+            cmd = f"""
+{define_api_key}
+echo "Using Gemini API key $GEMINI_API_KEY"
+gemini {model_arg} --yolo --prompt {safe_path}
+"""
+            
+
+        case "docker":
+            assert ai_spec["api_key"] is not None, "When using docker, api_key must be provided."
+            cmd = f"""
+docker run -it --rm \
+  -e GEMINI_API_KEY="{ai_spec['api_key']}" \
+  -v "{repo_root}:/workspace/{repo_root.name}" \
+  -w "/workspace/{repo_root.name}" \
+  statistician/machineconfig-ai:latest  \
+  gemini --prompt "$PATH_PROMPT"
+"""
+    return cmd

machineconfig/scripts/python/helpers_agents/agentic_frameworks/fire_qwen.py

@@ -0,0 +1,30 @@
+
+from pathlib import Path
+import shlex
+from machineconfig.scripts.python.helpers_agents.fire_agents_helper_types import AI_SPEC
+
+
+def fire_qwen(ai_spec: AI_SPEC, prompt_path: Path, repo_root: Path, config_dir: str | None) -> str:
+    _ = ai_spec["provider"]
+    safe_path = shlex.quote(str(prompt_path))
+    match ai_spec["machine"]:
+        case "local":
+            cmd = f"""
+qwen --yolo --prompt {safe_path}
+    """
+        case "docker":
+            assert config_dir is not None, "When using docker, config_dir must be provided."
+            assert Path(config_dir).exists(), f"Provided config_dir {config_dir} does not exist."
+            oauth_creds = Path(config_dir).joinpath("oauth_creds.json")
+            settings = Path(config_dir).joinpath("settings.json")
+
+            cmd = f"""
+docker run -it --rm \
+  -v "{repo_root}:/workspace/{repo_root.name}" \
+  -v {shlex.quote(str(oauth_creds))}:/root/.qwen/oauth_creds.json \
+  -v {shlex.quote(str(settings))}:/root/.qwen/settings.json \
+  -w "/workspace/{repo_root.name}" \
+  statistician/machineconfig-ai:latest \
+  qwen --prompt "$PATH_PROMPT"
+"""
+    return cmd

machineconfig/scripts/python/helpers_agents/fire_agents_help_launch.py

@@ -0,0 +1,110 @@
+
+import random
+import shlex
+from pathlib import Path
+from machineconfig.scripts.python.helpers_agents.fire_agents_helper_types import AGENTS, AGENT_NAME_FORMATTER, HOST, PROVIDER, AI_SPEC
+
+
+def get_api_keys(provider: PROVIDER) -> list[str]:
+    from machineconfig.utils.io import read_ini
+    config = read_ini(Path.home().joinpath(f"dotfiles/creds/llm/{provider}/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)} {provider} API keys configured.")
+    return res
+
+
+def prep_agent_launch(repo_root: Path, agents_dir: Path, prompts_material: list[str], prompt_prefix: str, keep_material_in_separate_file: bool,
+                      machine: HOST, model: str, provider: PROVIDER, agent: AGENTS, *, job_name: str) -> None:
+    agents_dir.mkdir(parents=True, exist_ok=True)
+    prompt_folder = agents_dir / "prompts"
+    prompt_folder.mkdir(parents=True, exist_ok=True)
+
+    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.relative_to(repo_root)}. You don't need to do any other work beside the content of this material file.""", encoding="utf-8")
+        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
+
+echo "Using machine: {machine}, model: {model}, provider: {provider}, and agent: {agent}"
+echo "{job_name}-{idx} CMD {agent_cmd_launch_path}"
+echo "{job_name}-{idx} PROMPT {prompt_path}"
+echo "{job_name}-{idx} CONTEXT {prompt_material_path}"
+echo "Starting agent {agent} in 5 seconds... Press Ctrl+C to cancel."
+# sleep 5
+# timeout 3 copilot --banner
+
+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 "--------START OF AGENT OUTPUT--------"
+sleep 0.1
+
+"""
+        match agent:
+            case "gemini":
+                assert provider == "google", "Gemini agent only works with google provider."
+                api_keys = get_api_keys(provider="google")
+                api_key = api_keys[idx % len(api_keys)] if len(api_keys) > 0 else None
+                ai_spec: AI_SPEC = AI_SPEC(provider=provider, model="gemini-2.5-pro", agent=agent, machine=machine, api_key=api_key, api_name="gemini")
+                from machineconfig.scripts.python.helpers_agents.agentic_frameworks.fire_gemini import fire_gemini
+                cmd = fire_gemini(ai_spec=ai_spec, prompt_path=prompt_path, repo_root=repo_root)
+            case "cursor-agent":
+                ai_spec: AI_SPEC = AI_SPEC(provider=provider, model=model, agent=agent, machine=machine, api_key=None, api_name="cursor")
+                from machineconfig.scripts.python.helpers_agents.agentic_frameworks.fire_cursor_agents import fire_cursor
+                cmd = fire_cursor(ai_spec=ai_spec, prompt_path=prompt_path)
+                raise NotImplementedError("Cursor agent is not implemented yet, api key missing")
+            case "crush":
+                api_keys = get_api_keys(provider=provider)
+                api_key = api_keys[idx % len(api_keys)] if len(api_keys) > 0 else None
+                ai_spec: AI_SPEC = AI_SPEC(provider=provider, model=model, agent=agent, machine=machine, api_key=api_key, api_name="crush")
+                from machineconfig.scripts.python.helpers_agents.agentic_frameworks.fire_crush import fire_crush
+                cmd = fire_crush(ai_spec=ai_spec, prompt_path=prompt_path, repo_root=repo_root)
+            # case "q":
+            #     from machineconfig.scripts.python.helpers_fire.fire_q import fire_q
+            #     cmd = fire_q(api_key="", prompt_path=prompt_path, machine=machine)
+            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")
+    return None
+
+
+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()]
+    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))
+    layout = LayoutConfig(layoutName="Agents", layoutTabs=tab_config)
+    layouts_file: LayoutsFile = LayoutsFile(version="1.0", layouts=[layout])
+    return layouts_file

machineconfig/scripts/python/helpers_agents/fire_agents_helper_types.py

@@ -0,0 +1,34 @@
+
+from typing import Literal, TypeAlias, TypedDict
+
+
+# Vscode extensions for AI-assisted coding.
+# Github copilot
+# Roo
+# Cline
+# Kilocode
+# Continue
+# CodeGPT
+# qodo (and cli)
+
+# Editors based on AI
+# Kiro
+# Cursor
+# Warp
+
+AGENTS: TypeAlias = Literal["cursor-agent", "gemini", "qwen-code", "copilot", "crush", "q", "opencode", "kilocode", "cline", "auggie", "warp", "droid"]
+HOST: TypeAlias = Literal["local", "docker"]
+PROVIDER: TypeAlias = Literal["azure", "google", "aws", "openai", "anthropic", "openrouter", "xai"]
+
+class AI_SPEC(TypedDict):
+    provider: PROVIDER
+    model: str
+    agent: AGENTS
+    machine: HOST
+    api_key: str | None
+    api_name: str
+
+
+AGENT_NAME_FORMATTER = "agent_{idx}_cmd.sh"  # e.g., agent_0_cmd.sh
+SEARCH_STRATEGIES: TypeAlias = Literal["file_path", "keyword_search", "filename_pattern"]
+

machineconfig/scripts/python/helpers_agents/fire_agents_load_balancer.py

@@ -0,0 +1,22 @@
+# from math import ceil
+from pathlib import Path
+
+
+def chunk_prompts(prompt_material_path: Path, joiner: str, *, tasks_per_prompt: int) -> 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 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/scripts/python/helpers_agents/templates/prompt.txt

@@ -0,0 +1,6 @@
+
+please look if it is possible to easily relpace PathExtended with normal Path from pathlib
+if its one or two lines of code, then go ahead and make it standard and stop using the extended library
+you focus ont he methods used, 
+
+only look at the files below

machineconfig/scripts/python/helpers_agents/templates/template.ps1

@@ -0,0 +1,14 @@
+# Set error action preference to stop on error, like set -e
+$ErrorActionPreference = "Stop"
+
+$JOB_NAME = "outpatient_mapping"
+$REPO_ROOT = "$HOME/code/work/winter_planning/"
+$CONTEXT_PATH = "$REPO_ROOT/data/outpatient_mapping/op_services.csv"
+$PROMPT_PATH = "$REPO_ROOT/data/outpatient_mapping/prompt"
+$AGENTS_DIR = "$REPO_ROOT/.ai/agents/$JOB_NAME"
+
+agents create --agents crush --host docker --model x-ai/grok-4-fast:free --provider openrouter --context-path $CONTEXT_PATH --prompt-path $PROMPT_PATH --job-name $JOB_NAME --agents-dir $AGENTS_DIR
+sessions balance-load "$AGENTS_DIR/layout.json" --max-thresh 6 --breaking-method moreLayouts --thresh-type number --output-path "$AGENTS_DIR/layout_balanced.json"
+sessions run "$AGENTS_DIR/layout_balanced.json" --kill-upon-completion
+
+# agents collect $AGENTS_DIR "$REPO_ROOT/.ai/agents/$JOB_NAME/collected.txt"

machineconfig/scripts/python/helpers_agents/templates/template.sh

@@ -0,0 +1,24 @@
+
+#!/bin/bash
+# set -e # Exit immediately if a command exits with a non-zero status.
+
+JOB_NAME="outpatient_mapping"
+REPO_ROOT="$HOME/code/machineconfig"
+CONTEXT_PATH="$REPO_ROOT/.ai/todo/files.md"
+# agents make-todo --strategy keywords from machineconfig.utils.path_extended import PathExtended
+PROMPT_PATH="$REPO_ROOT/src/machineconfig/scripts/python/helpers_agents/templates/prompt.txt"
+AGENTS_DIR="$REPO_ROOT/.ai/agents/$JOB_NAME"
+
+agents create --agents crush \
+    --host docker \
+    --model x-ai/grok-4-fast:free \
+    --provider openrouter \
+    --context-path $CONTEXT_PATH \
+    --prompt-path $PROMPT_PATH \
+    --job-name $JOB_NAME \
+    --agents-dir $AGENTS_DIR
+sessions balance-load "$AGENTS_DIR/layout.json" --max-thresh 6 --breaking-method moreLayouts --thresh-type number --output-path "$AGENTS_DIR/layout_balanced.json"
+sessions run "$AGENTS_DIR/layout_balanced.json" --kill-upon-completion
+
+
+# agents collect $AGENTS_DIR "$REPO_ROOT/.ai/agents/$JOB_NAME/collected.txt"