machineconfig 6.82__py3-none-any.whl → 8.51__py3-none-any.whl

machineconfig/scripts/python/helpers_devops/cli_share_server.py

@@ -1,104 +0,0 @@
-from pathlib import Path
-from typing import Optional, Annotated
-import typer
-
-
-def display_share_url(local_ip_v4: str, port: int, protocol: str = "http") -> None:
-    """Display a flashy, unmissable share URL announcement."""
-    from rich.console import Console
-    from rich.panel import Panel
-    from rich.text import Text
-    from rich.align import Align
-    console = Console()
-    # Create the main message with styling
-    url_text = Text(f"{protocol}://{local_ip_v4}:{port}", style="bold bright_cyan underline")
-    message = Text.assemble(
-        ("🚀 ", "bright_red"),
-        ("Share server is now accessible at: ", "bright_white bold"),
-        url_text,
-        (" 🚀", "bright_red")
-    )
-    # Create a fancy panel with borders and styling
-    panel = Panel(
-        Align.center(message),
-        title="[bold bright_green]🌐 SHARE SERVER READY 🌐[/bold bright_green]",
-        subtitle="[italic bright_yellow]⚡ Click the link above to access your shared files! ⚡[/italic bright_yellow]",
-        border_style="bright_magenta",
-        padding=(1, 2),
-        expand=False
-    )
-    # Print with extra spacing and attention-grabbing elements
-    console.print(panel)
-
-
-def main(
-    path: Annotated[str, typer.Argument(help="Path to the file or directory to share")],
-    port: Annotated[Optional[int], typer.Option("--port", "-p", help="Port to run the share server on (default: 8080)")] = None,
-    username: Annotated[Optional[str], typer.Option("--username", "-u", help="Username for share access (default: current user)")] = None,
-    password: Annotated[Optional[str], typer.Option("--password", "-w", help="Password for share access (default: from ~/dotfiles/creds/passwords/quick_password)")] = None,
-    over_internet: Annotated[bool, typer.Option("--over-internet", "-i", help="Expose the share server over the internet using ngrok")] = False
-) -> None:
-    from machineconfig.utils.installer_utils.installer import install_if_missing
-    install_if_missing(which="easy-sharing")
-    if over_internet: install_if_missing(which="ngrok", )
-    if username is None:
-        import getpass
-        username = getpass.getuser()
-    if password is None:
-        pwd_path = Path.home().joinpath("dotfiles/creds/passwords/quick_password")
-        if pwd_path.exists():
-            password = pwd_path.read_text(encoding="utf-8").strip()
-        else:
-            # raise ValueError("Password not provided and default password file does not exist.")
-            typer.echo(f"⚠️  WARNING: Password not provided and default password file does not exist.\nPath: {pwd_path}\nUsing default password: 'quick_password' (insecure!)", err=True)
-            typer.Exit(code=1)
-
-    if port is None:
-        port = 8080  # Default port for ezshare
-
-    import socket
-    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-    s.connect(('8.8.8.8',80))
-    local_ip_v4 = s.getsockname()[0]
-    s.close()
-
-    # Display the flashy share announcement  
-    protocol = "http"
-    display_share_url(local_ip_v4, port, protocol)
-    import subprocess
-    import time
-    # Build ezshare command
-    ezshare_cmd = f"""easy-sharing --port {port} --username {username} --password "{password}" {path}"""
-    ezshare_process = subprocess.Popen(ezshare_cmd, shell=True)
-    processes = [ezshare_process]
-    
-    if over_internet:
-        ngrok_process = subprocess.Popen(f"ngrok http {port}", shell=True)
-        processes.append(ngrok_process)
-        time.sleep(3)
-        try:
-            import requests
-            response = requests.get("http://localhost:4040/api/tunnels")
-            data = response.json()
-            public_url = data['tunnels'][0]['public_url']
-            print(f"🌐 Ngrok tunnel ready: {public_url}")
-        except Exception as e:
-            print(f"Could not retrieve ngrok URL: {e}")
-    
-    try:
-        while True:
-            print("Share server is running. Press Ctrl+C to stop.")
-            time.sleep(2)
-    except KeyboardInterrupt:
-        print("\nTerminating processes...")
-        for p in processes:
-            p.terminate()
-            p.wait()
-
-
-def main_with_parser():
-    typer.run(main)
-
-
-if __name__ == "__main__":
-    pass

machineconfig/scripts/python/helpers_devops/cli_utils.py

@@ -1,221 +0,0 @@
-
-
-import typer
-from typing import Annotated, Literal, Optional, TypedDict
-from pathlib import Path
-
-
-def download(
-    url: Annotated[Optional[str], typer.Argument(..., help="The URL to download the file from.")] = None,
-    decompress: Annotated[bool, typer.Option("--decompress", "-d", help="Decompress the file if it's an archive.")] = False,
-    output: Annotated[Optional[str], typer.Option("--output", "-o", help="The output file path.")] = None,
-) -> None:
-    if url is None:
-        typer.echo("❌ Error: URL is required.", err=True)
-        raise typer.Exit(code=1)
-    typer.echo(f"📥 Downloading from: {url}")    
-    download_path = Path(output) if output else Path(url.split("/")[-1])
-    import requests
-    import subprocess
-    try:
-        response = requests.get(url, allow_redirects=True, stream=True, timeout=60)
-        response.raise_for_status()
-        
-        total_size = int(response.headers.get('content-length', 0))
-        
-        with open(download_path, 'wb') as f:
-            if total_size == 0:
-                f.write(response.content)
-            else:
-                downloaded = 0
-                chunk_size = 8192
-                for chunk in response.iter_content(chunk_size=chunk_size):
-                    if chunk:
-                        f.write(chunk)
-                        downloaded += len(chunk)
-                        progress = (downloaded / total_size) * 100
-                        typer.echo(f"\r⏬ Progress: {progress:.1f}% ({downloaded}/{total_size} bytes)", nl=False)
-                typer.echo()
-        
-        typer.echo(f"✅ Downloaded to: {download_path}")
-    except requests.exceptions.RequestException as e:
-        typer.echo(f"❌ Download failed: {e}", err=True)
-        raise typer.Exit(code=1)
-    except OSError as e:
-        typer.echo(f"❌ File write error: {e}", err=True)
-        raise typer.Exit(code=1)
-    
-    if decompress:
-        typer.echo(f"📦 Decompressing: {download_path}")
-        
-        base_name = download_path.name
-        parts = base_name.split('.')
-        base_name = parts[0] if parts else download_path.stem
-        
-        extract_dir = download_path.parent / base_name
-        extract_dir.mkdir(parents=True, exist_ok=True)
-        
-        try:
-            subprocess.run(
-                ["ouch", "decompress", str(download_path), "--dir", str(extract_dir)],
-                check=True,
-                capture_output=True,
-                text=True
-            )
-            typer.echo(f"✅ Decompressed to: {extract_dir}")
-            
-            if download_path.exists():
-                download_path.unlink()
-                typer.echo(f"🗑️  Removed archive: {download_path}")
-                
-        except subprocess.CalledProcessError as e:
-            typer.echo(f"❌ Decompression failed: {e.stderr}", err=True)
-            raise typer.Exit(code=1)
-        except FileNotFoundError:
-            typer.echo("❌ Error: ouch command not found. Please install ouch.", err=True)
-            typer.echo("💡 Install with: cargo install ouch", err=True)
-            raise typer.Exit(code=1)
-
-
-def merge_pdfs(
-        pdfs: Annotated[list[str], typer.Argument(..., help="Paths to the PDF files to merge.")],
-        output: Annotated[Optional[str], typer.Option("--output", "-o", help="Output merged PDF file path.")] = None,
-        compress: Annotated[bool, typer.Option("--compress", "-c", help="Compress the output PDF.")] = False,
-    ) -> None:
-    def merge_pdfs_internal(pdfs: list[str], output: str | None, compress: bool) -> None:
-        from pypdf import PdfReader, PdfWriter
-        writer = PdfWriter()
-        for pdf_path in pdfs:
-            reader = PdfReader(pdf_path)
-            for page in reader.pages:
-                writer.add_page(page)
-        output_path = output if output else "merged.pdf"
-        if compress:
-            try:
-                for p in writer.pages:
-                    try:
-                        # PageObject.compress_content_streams exists in pypdf
-                        p.compress_content_streams()
-                    except Exception:
-                        # best-effort: ignore per-page compression failures
-                        continue
-            except Exception:
-                pass
-            try:
-                writer.compress_identical_objects()
-            except Exception:
-                # non-fatal if this fails
-                pass
-        writer.write(output_path)
-        print(f"✅ Merged PDF saved to: {output_path}")
-    from machineconfig.utils.meta import lambda_to_python_script
-    code = lambda_to_python_script(lambda : merge_pdfs_internal(pdfs=pdfs, output=output, compress=compress), in_global=True, import_module=False)
-    from machineconfig.utils.code import run_shell_script, get_uv_command_executing_python_script
-    uv_command, _py_file = get_uv_command_executing_python_script(python_script=code, uv_with=["pypdf"], uv_project_dir=None)
-    run_shell_script(uv_command)
-
-
-def compress_pdf(
-        pdf_input: Annotated[str, typer.Argument(..., help="Path to the input PDF file to compress.")],
-        output: Annotated[Optional[str], typer.Option("--output", "-o", help="Output compressed PDF file path.")] = None,
-        quality: Annotated[int, typer.Option("--quality", "-q", help="JPEG quality for image compression (0-100, 0=no change, 100=best).")] = 85,
-        image_dpi: Annotated[int, typer.Option("--image-dpi", "-d", help="Target DPI for image resampling. If set, images above this DPI will be downsampled.")] = 0,
-        # remove_images: Annotated[bool, typer.Option("--remove-images", "-r", help="Remove all images from the PDF.")] = False,
-        compress_streams: Annotated[bool, typer.Option("--compress-streams", "-c", help="Compress uncompressed streams.")] = True,
-        use_objstms: Annotated[bool, typer.Option("--object-streams", "-s", help="Use object streams for additional compression.")] = True,
-    ) -> None:
-    def compress_pdf_internal(pdf_input: str, output: str | None, quality: int, image_dpi: int, compress_streams: bool, use_objstms: bool) -> None:
-        import pymupdf
-        from pathlib import Path
-        output_path = output if output else pdf_input.replace(".pdf", "_compressed.pdf")
-        doc = pymupdf.open(pdf_input)
-        try:
-            # if remove_images:
-            #     for page in doc:
-            #         page.remove_images()
-            if quality > 0 or image_dpi > 0:
-                doc.rewrite_images(
-                    dpi_threshold=image_dpi if image_dpi > 0 else None,
-                    dpi_target=max(72, image_dpi - 10) if image_dpi > 72 else 72,
-                    quality=quality,
-                    lossy=True,
-                    lossless=True,
-                )
-            doc.save(
-                output_path,
-                deflate=compress_streams,
-                garbage=3,
-                use_objstms=1 if use_objstms else 0,
-            )
-            input_size = Path(pdf_input).stat().st_size
-            output_size = Path(output_path).stat().st_size
-            ratio = (1 - output_size / input_size) * 100
-            print(f"✅ Compressed PDF saved to: {output_path}")
-            print(f"   Original: {input_size / 1024 / 1024:.2f} MB")
-            print(f"   Compressed: {output_size / 1024 / 1024:.2f} MB")
-            print(f"   Reduction: {ratio:.1f}%")
-        finally:
-            doc.close()
-    from machineconfig.utils.meta import lambda_to_python_script
-    code = lambda_to_python_script(
-        lambda: compress_pdf_internal(pdf_input=pdf_input, output=output, quality=quality, image_dpi=image_dpi, compress_streams=compress_streams, use_objstms=use_objstms),
-        in_global=True,
-        import_module=False,
-    )
-    from machineconfig.utils.code import run_shell_script, get_uv_command_executing_python_script
-    uv_command, _py_file = get_uv_command_executing_python_script(python_script=code, uv_with=["pymupdf"], uv_project_dir=None)
-    run_shell_script(uv_command)
-
-
-class MachineSpecs(TypedDict):
-    system: str
-    distro: str
-    home_dir: str
-def get_machine_specs() -> MachineSpecs:
-    """Write print and return the local machine specs."""
-    import platform
-    UV_RUN_CMD = "$HOME/.local/bin/uv run" if platform.system() != "Windows" else """& "$env:USERPROFILE/.local/bin/uv" run"""
-    command = f"""{UV_RUN_CMD} --with distro python -c "import distro; print(distro.name(pretty=True))" """
-    import subprocess
-    distro = subprocess.run(command, shell=True, capture_output=True, text=True).stdout.strip()
-    specs: MachineSpecs = {
-        "system": platform.system(),
-        "distro": distro,
-        "home_dir": str(Path.home()),
-    }
-    print(specs)
-    from machineconfig.utils.source_of_truth import CONFIG_ROOT
-    path = CONFIG_ROOT.joinpath("machine_specs.json")
-    CONFIG_ROOT.mkdir(parents=True, exist_ok=True)
-    import json
-    path.write_text(json.dumps(specs, indent=4), encoding="utf-8")
-    return specs
-
-
-def init_project(python: Annotated[Literal["3.13", "3.14"], typer.Option("--python", "-p", help="Python version for the uv virtual environment.")]= "3.13") -> None:
-    _ = python
-    repo_root = Path.cwd()
-    if not (repo_root / "pyproject.toml").exists():
-        typer.echo("❌ Error: pyproject.toml not found.", err=True)
-        raise typer.Exit(code=1)
-    print(f"Adding group `plot` with common data science and plotting packages...")
-    script = """
-uv add --group plot \
-    # Data & computation
-    numpy pandas polars duckdb-engine python-magic \
-    # Plotting / visualization
-    matplotlib plotly kaleido \
-    # Notebooks / interactive
-    ipython ipykernel jupyterlab nbformat marimo \
-    # Code analysis / type checking / linting
-    mypy pyright ruff pylint pyrefly \
-    # Packaging / build / dev
-    cleanpy \
-    # CLI / debugging / utilities
-    ipdb pudb \
-    # Type hints for packages
-    types-python-dateutil types-pyyaml types-requests types-tqdm \
-    types-mysqlclient types-paramiko types-pytz types-sqlalchemy types-toml types-urllib3 \
-"""
-    from machineconfig.utils.code import run_shell_script
-    run_shell_script(script)

machineconfig/scripts/python/helpers_devops/devops_backup_retrieve.py

@@ -1,80 +0,0 @@
-"""BR: Backup and Retrieve"""
-
-# import subprocess
-from machineconfig.utils.io import read_ini
-from machineconfig.utils.path_extended import PathExtended
-from machineconfig.utils.source_of_truth import LIBRARY_ROOT, DEFAULTS_PATH
-from machineconfig.utils.code import print_code
-from machineconfig.utils.options import choose_cloud_interactively, choose_from_options
-from machineconfig.scripts.python.helpers_cloud.helpers2 import ES
-from platform import system
-from typing import Any, Literal, Optional
-from rich.console import Console
-from rich.panel import Panel
-import tomllib
-
-
-OPTIONS = Literal["BACKUP", "RETRIEVE"]
-
-
-def main_backup_retrieve(direction: OPTIONS, which: Optional[str], cloud: Optional[str]) -> None:
-    console = Console()
-    try:
-        cloud = read_ini(DEFAULTS_PATH)["general"]["rclone_config_name"]
-        console.print(Panel(f"⚠️  DEFAULT CLOUD CONFIGURATION\n🌥️  Using default cloud: {cloud}", title="[bold blue]Cloud Configuration[/bold blue]", border_style="blue"))
-    except (FileNotFoundError, KeyError, IndexError):
-        console.print(Panel("🔍 DEFAULT CLOUD NOT FOUND\n🔄 Please select a cloud configuration from the options below", title="[bold red]Error: Cloud Not Found[/bold red]", border_style="red"))
-        cloud = choose_cloud_interactively()
-    bu_file: dict[str, Any] = tomllib.loads(LIBRARY_ROOT.joinpath("profile/backup.toml").read_text(encoding="utf-8"))
-    console.print(Panel(f"🧰 LOADING BACKUP CONFIGURATION\n📄 File: {LIBRARY_ROOT.joinpath('profile/backup.toml')}", title="[bold blue]Backup Configuration[/bold blue]", border_style="blue"))
-
-    if system() == "Linux":
-        bu_file = {key: val for key, val in bu_file.items() if "windows" not in key}
-        console.print(Panel(f"🐧 LINUX ENVIRONMENT DETECTED\n🔍 Filtering out Windows-specific entries\n✅ Found {len(bu_file)} applicable backup configuration entries", title="[bold blue]Linux Environment[/bold blue]", border_style="blue"))
-    elif system() == "Windows":
-        bu_file = {key: val for key, val in bu_file.items() if "linux" not in key}
-        console.print(Panel(f"🪟 WINDOWS ENVIRONMENT DETECTED\n🔍 Filtering out Linux-specific entries\n✅ Found {len(bu_file)} applicable backup configuration entries", title="[bold blue]Windows Environment[/bold blue]", border_style="blue"))
-
-    if which is None:
-        console.print(Panel(f"🔍 SELECT {direction} ITEMS\n📋 Choose which configuration entries to process", title="[bold blue]Select Items[/bold blue]", border_style="blue"))
-        choices = choose_from_options(multi=True, msg=f"WHICH FILE of the following do you want to {direction}?", options=["all"] + list(bu_file.keys()))
-    else:
-        choices = which.split(",") if which else []
-        console.print(Panel(f"🔖 PRE-SELECTED ITEMS\n📝 Using: {', '.join(choices)}", title="[bold blue]Pre-selected Items[/bold blue]", border_style="blue"))
-
-    if "all" in choices:
-        items = bu_file
-        console.print(Panel(f"📋 PROCESSING ALL ENTRIES\n🔢 Total entries to process: {len(bu_file)}", title="[bold blue]Process All Entries[/bold blue]", border_style="blue"))
-    else:
-        items = {key: val for key, val in bu_file.items() if key in choices}
-        console.print(Panel(f"📋 PROCESSING SELECTED ENTRIES\n🔢 Total entries to process: {len(items)}", title="[bold blue]Process Selected Entries[/bold blue]", border_style="blue"))
-    program = f"""$cloud = "{cloud}:{ES}" \n """ if system() == "Windows" else f"""cloud="{cloud}:{ES}" \n """
-    console.print(Panel(f"🚀 GENERATING {direction} SCRIPT\n🌥️  Cloud: {cloud}\n🗂️  Items: {len(items)}", title="[bold blue]Script Generation[/bold blue]", border_style="blue"))
-    for item_name, item in items.items():
-        flags = ""
-        flags += "z" if item["zip"] == "True" else ""
-        flags += "e" if item["encrypt"] == "True" else ""
-        flags += "r" if item["rel2home"] == "True" else ""
-        flags += "o" if system().lower() in item_name else ""
-        console.print(Panel(f"📦 PROCESSING: {item_name}\n📂 Path: {PathExtended(item['path']).as_posix()}\n🏳️  Flags: {flags or 'None'}", title=f"[bold blue]Processing Item: {item_name}[/bold blue]", border_style="blue"))
-        if flags:
-            flags = "-" + flags
-        if direction == "BACKUP":
-            program += f"""\ncloud_copy "{PathExtended(item["path"]).as_posix()}" $cloud {flags}\n"""
-        elif direction == "RETRIEVE":
-            program += f"""\ncloud_copy $cloud "{PathExtended(item["path"]).as_posix()}" {flags}\n"""
-        else:
-            console.print(Panel('❌ ERROR: INVALID DIRECTION\n⚠️  Direction must be either "BACKUP" or "RETRIEVE"', title="[bold red]Error: Invalid Direction[/bold red]", border_style="red"))
-            raise RuntimeError(f"Unknown direction: {direction}")
-        if item_name == "dotfiles" and system() == "Linux":
-            program += """\nchmod 700 ~/.ssh/*\n"""
-            console.print(Panel("🔒 SPECIAL HANDLING: SSH PERMISSIONS\n🛠️  Setting secure permissions for SSH files\n📝 Command: chmod 700 ~/.ssh/*", title="[bold blue]Special Handling: SSH Permissions[/bold blue]", border_style="blue"))
-    print_code(program, lexer="shell", desc=f"{direction} script")
-    console.print(Panel(f"✅ {direction} SCRIPT GENERATION COMPLETE\n🚀 Ready to execute the operations", title="[bold green]Script Generation Complete[/bold green]", border_style="green"))
-    import subprocess
-
-    subprocess.run(program, shell=True, check=True)
-
-
-if __name__ == "__main__":
-    pass

machineconfig/scripts/python/helpers_devops/themes/choose_starship_theme.bash

@@ -1,3 +0,0 @@
-
-
-

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

@@ -1,37 +0,0 @@
-
-from pathlib import Path
-# import shlex
-from typing import Optional
-from machineconfig.scripts.python.helpers_fire.fire_agents_helper_types import HOST, PROVIDER, MODEL
-
-
-def fire_crush(api_key: Optional[str], model: MODEL, provider: PROVIDER, machine: HOST, prompt_path: Path, repo_root: Path) -> str:
-    match machine:
-        case "local":
-            cmd = f"""
-crush run {prompt_path}
-"""
-        case "docker":
-            assert 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}", api_key).replace("{model}", model).replace("{provider}", provider)
-            import tempfile
-            temp_config_file_local = tempfile.mkstemp(suffix=".json")[1]
-            Path(temp_config_file_local).write_text(json_filled, encoding="utf-8")            
-            cmd = f"""
-
-#   -e "PATH_PROMPT=$PATH_PROMPT"
-#   opencode --model "{provider}/{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: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_fire/agentic_frameworks/fire_gemini.py

@@ -1,44 +0,0 @@
-
-from pathlib import Path
-import shlex
-from machineconfig.scripts.python.helpers_fire.fire_agents_helper_types import HOST
-from typing import Optional, Literal
-
-
-def fire_gemini(api_key: Optional[str], model: Literal["gemini-2.5-pro"], provider: Literal["google"], machine: HOST, prompt_path: Path, repo_root: Path) -> str:
-    _ = provider
-    # 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))
-
-    match machine:
-        case "local":
-            # Export the environment variable so it's available to subshells
-            if api_key is not None:
-                define_api_key = f"""export GEMINI_API_KEY="{shlex.quote(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 api_key is not None, "When using docker, api_key must be provided."
-            cmd = f"""
-docker run -it --rm \
-  -e GEMINI_API_KEY="{api_key}" \
-  -v "{repo_root}:/workspace/{repo_root.name}" \
-  -w "/workspace/{repo_root.name}" \
-  statistician/machineconfig:latest  \
-  gemini --prompt "$PATH_PROMPT"
-"""
-    return cmd
-            

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

@@ -1,43 +0,0 @@
-
-from pathlib import Path
-import shlex
-from machineconfig.scripts.python.helpers_fire.fire_agents_helper_types import HOST
-from typing import Optional, Literal
-
-
-def fire_qwen(config_dir: Optional[str], model: Literal["qwen"], provider: Literal["qwen"], machine: HOST, prompt_path: Path, repo_root: Path) -> str:
-    # assert model == "qwen", "Only qwen is supported currently."
-    # assert provider == "qwen", "Only qwen is supported currently."
-    # model = "qwen"
-    # model = "gemini-2.5-flash-lite"
-    # model = None  # auto-select
-    # if model is None:
-    #     model_arg = ""
-    # else:
-    _ = provider
-    # 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))
-
-    match machine:
-        case "local":
-            # Export the environment variable so it's available to subshells
-            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:latest \
-  qwen --prompt "$PATH_PROMPT"
-"""
-    return cmd

machineconfig/scripts/python/helpers_fire/prompt.txt

@@ -1,2 +0,0 @@
-
-please read the code then explain it in English, put your answer in a markdown file with random name at repo root.

machineconfig/scripts/python/helpers_fire/template.sh

@@ -1,15 +0,0 @@
-
-#!/bin/bash
-# set -e # Exit immediately if a command exits with a non-zero status.
-
-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_navigator/__init__.py

@@ -1,20 +0,0 @@
-"""
-Helper modules for the devops navigator TUI application.
-"""
-
-from machineconfig.scripts.python.helpers_navigator.data_models import CommandInfo, ArgumentInfo
-from machineconfig.scripts.python.helpers_navigator.command_builder import CommandBuilderScreen
-from machineconfig.scripts.python.helpers_navigator.command_tree import CommandTree
-from machineconfig.scripts.python.helpers_navigator.command_detail import CommandDetail
-from machineconfig.scripts.python.helpers_navigator.search_bar import SearchBar
-from machineconfig.scripts.python.helpers_navigator.main_app import CommandNavigatorApp
-
-__all__ = [
-    "CommandInfo",
-    "ArgumentInfo",
-    "CommandBuilderScreen",
-    "CommandTree",
-    "CommandDetail",
-    "SearchBar",
-    "CommandNavigatorApp",
-]

machineconfig/scripts/python/helpers_navigator/command_detail.py

@@ -1,44 +0,0 @@
-"""
-Command detail widget for displaying command information.
-"""
-
-from typing import Optional
-from textual.widgets import Static
-from rich.panel import Panel
-from rich.text import Text
-from machineconfig.scripts.python.helpers_navigator.data_models import CommandInfo
-
-
-class CommandDetail(Static):
-    """Widget for displaying command details."""
-
-    def __init__(self, *, id: str) -> None:  # type: ignore
-        super().__init__(id=id)
-        self.command_info: Optional[CommandInfo] = None
-
-    def update_command(self, command_info: Optional[CommandInfo]) -> None:
-        """Update displayed command information."""
-        self.command_info = command_info
-        if command_info is None:
-            self.update("Select a command to view details")
-            return
-
-        content = Text()
-        content.append(f"{'🗂️  Group' if command_info.is_group else '⚡ Command'}: ", style="bold cyan")
-        content.append(f"{command_info.name}\n\n", style="bold yellow")
-
-        content.append("Description: ", style="bold green")
-        content.append(f"{command_info.description}\n\n", style="white")
-
-        content.append("Command: ", style="bold blue")
-        content.append(f"{command_info.command}\n\n", style="bold white")
-
-        if command_info.help_text:
-            content.append("Usage: ", style="bold magenta")
-            content.append(f"{command_info.help_text}\n\n", style="white")
-
-        if command_info.module_path:
-            content.append("Module: ", style="bold red")
-            content.append(f"{command_info.module_path}\n", style="white")
-
-        self.update(Panel(content, title=f"[bold]{command_info.name}[/bold]", border_style="blue"))