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

machineconfig/scripts/python/fire_agents.py

@@ -1,175 +0,0 @@
-"""Utility to launch multiple AI agent prompts in a Zellij session.
-
-Improved design notes:
-  * Clear separation of: input collection, prompt preparation, agent launch.
-  * Configurable max agent cap (default 15) with interactive confirmation if exceeded.
-  * Added type aliases + docstrings for maintainability.
-  * Preserves original core behavior & command generation for each agent type.
-"""
-
-from pathlib import Path
-from typing import cast, get_args, Iterable, TypeAlias, Literal
-import json
-import sys
-
-from machineconfig.scripts.python.fire_agents_help_launch import prep_agent_launch, get_agents_launch_layout, AGENTS
-from machineconfig.scripts.python.fire_agents_help_search import search_files_by_pattern, search_python_files
-from machineconfig.scripts.python.fire_agents_load_balancer import chunk_prompts, SPLITTING_STRATEGY, DEFAULT_AGENT_CAP
-from machineconfig.utils.options import choose_from_options
-from machineconfig.utils.schemas.layouts.layout_types import TabConfig, LayoutConfig
-from machineconfig.utils.accessories import get_repo_root
-
-SEARCH_STRATEGIES: TypeAlias = Literal["file_path", "keyword_search", "filename_pattern"]
-
-
-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()
-        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)
-        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}")
-        target_file_path = repo_root / ".ai" / "target_file.txt"
-        _write_list_file(target_file_path, matching_files)
-        separator = "\n"
-    elif search_strategy == "filename_pattern":
-        pattern = input("Enter filename pattern (e.g., '*.py', '*test*', 'config.*'): ").strip()
-        if not pattern:
-            print("No pattern supplied. Exiting.")
-            sys.exit(1)
-        matching_files = search_files_by_pattern(repo_root, pattern)
-        if not matching_files:
-            print(f"💥 No files found matching pattern: {pattern}")
-            sys.exit(1)
-        for idx, mf in enumerate(matching_files):
-            print(f"{idx:>3}: {mf}")
-        print(f"\nFound {len(matching_files)} files matching pattern: {pattern}")
-        target_file_path = repo_root / ".ai" / "target_file.txt"
-        _write_list_file(target_file_path, matching_files)
-        separator = "\n"
-    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)
-
-    agents_dir = prep_agent_launch(repo_root=repo_root, prompts_material=prompt_material_re_splitted, keep_material_in_separate_file=keep_material_in_separate_file_input, prompt_prefix=prompt_prefix, agent=agent_selected, job_name=job_name)
-    layoutfile = get_agents_launch_layout(session_root=agents_dir)
-
-    regenerate_py_code = f"""
-#!/usr/bin/env uv run --python 3.13 --with machineconfig
-#!/usr/bin/env uv run --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()
-
-"""
-    (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)
-    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)
-
-
-def split_too_many_tabs_to_run_in_sequential_sessions(layout_tabs: list[TabConfig], every: int):
-    from machineconfig.utils.accessories import split_list
-    from machineconfig.cluster.sessions_managers.zellij_local_manager import ZellijLocalManager
-
-    for idx, layout_tabs_chunk in enumerate(split_list(layout_tabs, every=every, to=None)):
-        a_layout_file: LayoutConfig = {"layoutName": f"split_{idx}", "layoutTabs": layout_tabs_chunk}
-        manager = ZellijLocalManager(session_layouts=[a_layout_file])
-        manager.start_all_sessions(poll_interval=2, poll_seconds=2)
-        manager.run_monitoring_routine(wait_ms=2000)
-        manager.kill_all_sessions()
-
-
-def split_too_many_layouts_to_run_in_sequential_sessions(layouts: list[LayoutConfig], every: int):
-    from machineconfig.utils.accessories import split_list
-    from machineconfig.cluster.sessions_managers.zellij_local_manager import ZellijLocalManager
-    for _idx, layout_chunk in enumerate(split_list(layouts, every=every)):
-        manager = ZellijLocalManager(session_layouts=layout_chunk)
-        manager.start_all_sessions(poll_interval=2, poll_seconds=2)
-        manager.run_monitoring_routine(wait_ms=2000)
-
-
-if __name__ == "__main__":  # pragma: no cover
-    main()

machineconfig/scripts/python/fire_agents_help_launch.py

@@ -1,143 +0,0 @@
-from machineconfig.utils.accessories import randstr
-
-import random
-import shlex
-from pathlib import Path
-from typing import Literal, TypeAlias
-
-
-AGENTS: TypeAlias = Literal[
-    "cursor-agent", "gemini", "crush", "q", "onlyPrepPromptFiles"
-    # warp terminal
-]
-AGENT_NAME_FORMATTER = "agent_{idx}_cmd.sh"  # e.g., agent_0_cmd.sh
-
-
-def get_gemini_api_keys() -> list[str]:
-    from machineconfig.utils.io import read_ini
-
-    config = read_ini(Path.home().joinpath("dotfiles/creds/llm/gemini/api_keys.ini"))
-    res: list[str] = []
-    for a_section_name in list(config.sections()):
-        a_section = config[a_section_name]
-        if "api_key" in a_section:
-            api_key = a_section["api_key"].strip()
-            if api_key:
-                res.append(api_key)
-    print(f"Found {len(res)} Gemini API keys configured.")
-    return res
-
-
-def prep_agent_launch(repo_root: Path, prompts_material: list[str], prompt_prefix: str, keep_material_in_separate_file: bool, agent: AGENTS, *, job_name: str) -> Path:
-    session_root = repo_root / ".ai" / f"tmp_prompts/{job_name}_{randstr()}"
-    session_root.mkdir(parents=True, exist_ok=True)
-    prompt_folder = session_root / "prompts"
-    prompt_folder.mkdir(parents=True, exist_ok=True)
-
-    all_materials_scripts: list[Path] = []
-    for idx, a_prompt_material in enumerate(prompts_material):
-        prompt_root = prompt_folder / f"agent_{idx}"
-        prompt_root.mkdir(parents=True, exist_ok=True)
-        prompt_path = prompt_root / f"agent_{idx}_prompt.txt"
-        if keep_material_in_separate_file:
-            prompt_material_path = prompt_root / f"agent_{idx}_material.txt"
-            prompt_material_path.write_text(a_prompt_material, encoding="utf-8")
-            prompt_path.write_text(prompt_prefix + f"""\nPlease only look @ {prompt_material_path}. You don't need to do any other work beside the content of this material file.""", encoding="utf-8")
-            all_materials_scripts.append(prompt_material_path)
-        else:
-            prompt_material_path = prompt_path
-            prompt_path.write_text(prompt_prefix + """\nPlease only look @ the following:\n""" + a_prompt_material, encoding="utf-8")
-
-        agent_cmd_launch_path = prompt_root / AGENT_NAME_FORMATTER.format(idx=idx)  # e.g., agent_0_cmd.sh
-        random_sleep_time = random.uniform(0, 5)
-        cmd_prefix = f"""
-#!/usr/bin/env bash
-
-# AGENT-{idx}-LAUNCH-SCRIPT
-# Auto-generated by fire_agents.py
-
-export FIRE_AGENTS_AGENT_NAME="{agent}"
-export FIRE_AGENTS_JOB_NAME="{job_name}"
-export FIRE_AGENTS_PROMPT_FILE="{prompt_path}"
-export FIRE_AGENTS_MATERIAL_FILE="{prompt_material_path}"
-export FIRE_AGENTS_AGENT_LAUNCHER="{agent_cmd_launch_path}"
-
-echo "Sleeping for {random_sleep_time:.2f} seconds to stagger agent startups..."
-sleep {random_sleep_time:.2f}
-echo "Launching agent {agent} with prompt from {prompt_path}"
-echo "Launching agent {agent} with command from {agent_cmd_launch_path}"
-echo "--------START OF AGENT OUTPUT--------"
-sleep 0.1
-
-"""
-        match agent:
-            case "gemini":
-                model = "gemini-2.5-pro"
-                # model = "gemini-2.5-flash-lite"
-                # model = None  # auto-select
-                # if model is None:
-                #     model_arg = ""
-                # else:
-                model_arg = f"--model {shlex.quote(model)}"
-                # Need a real shell for the pipeline; otherwise '| gemini ...' is passed as args to 'cat'
-                safe_path = shlex.quote(str(prompt_path))
-                api_keys = get_gemini_api_keys()
-                api_key = api_keys[idx % len(api_keys)] if api_keys else ""
-                # Export the environment variable so it's available to subshells
-                cmd = f"""
-export GEMINI_API_KEY={shlex.quote(api_key)}
-echo "Using Gemini API key $GEMINI_API_KEY"
-bash -lc 'cat {safe_path} | gemini {model_arg} --yolo --prompt'
-"""
-            case "cursor-agent":
-                # As originally implemented
-                cmd = f"""
-
-cursor-agent --print --output-format text < {prompt_path}
-
-"""
-            case "crush":
-                cmd = f"""
-crush run {prompt_path}
-"""
-            case "q":
-                cmd = f"""
-q chat --no-interactive --trust-all-tools {prompt_path}
-"""
-            case "onlyPrepPromptFiles":
-                cmd = f"""
-echo "Prepared prompt file at {prompt_path}"
-"""
-            case _:
-                raise ValueError(f"Unsupported agent type: {agent}")
-        cmd_postfix = """
-sleep 0.1
-echo "---------END OF AGENT OUTPUT---------"
-"""
-        agent_cmd_launch_path.write_text(cmd_prefix + cmd + cmd_postfix, encoding="utf-8")
-
-    # print(f"Launching a template with #{len(tab_config)} agents")
-    if len(all_materials_scripts) > 0:
-        all_materials_list_path = session_root / "all_materials_redistributed.txt"
-        all_materials_list_path.write_text("\n".join(str(p) for p in all_materials_scripts), encoding="utf-8")
-        print(f"All prompt materials listed @ {all_materials_list_path}")
-    return session_root
-
-
-def get_agents_launch_layout(session_root: Path):
-    from machineconfig.utils.schemas.layouts.layout_types import TabConfig, LayoutConfig, LayoutsFile
-
-    tab_config: list[TabConfig] = []
-    prompt_root = session_root / "prompts"
-    all_dirs_under_prompts = [d for d in prompt_root.iterdir() if d.is_dir()]
-    launch_agents_squentially = ""
-    for a_prompt_dir in all_dirs_under_prompts:
-        idx = a_prompt_dir.name.split("_")[-1]  # e.g., agent_0 -> 0
-        agent_cmd_path = a_prompt_dir / AGENT_NAME_FORMATTER.format(idx=idx)
-        fire_cmd = f"bash {shlex.quote(str(agent_cmd_path))}"
-        tab_config.append(TabConfig(tabName=f"Agent{idx}", startDir=str(session_root.parent.parent.parent), command=fire_cmd))
-        launch_agents_squentially += f". {shlex.quote(str(agent_cmd_path))}\n"
-    layout = LayoutConfig(layoutName="Agents", layoutTabs=tab_config)
-    (session_root / "launch_all_agents_sequentially.sh").write_text(launch_agents_squentially, encoding="utf-8")
-    layouts_file: LayoutsFile = LayoutsFile(version="1.0", layouts=[layout])
-    return layouts_file

machineconfig/scripts/python/fire_agents_load_balancer.py

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

machineconfig/scripts/python/fire_jobs_args_helper.py

@@ -1,75 +0,0 @@
-from dataclasses import dataclass
-from typing import Optional, Any
-
-
-@dataclass
-class FireJobArgs:
-    """Type-safe dataclass for fire_jobs command line arguments."""
-
-    path: str = "."
-    function: Optional[str] = None
-    ve: str = ""
-    cmd: bool = False
-    interactive: bool = False
-    debug: bool = False
-    choose_function: bool = False
-    loop: bool = False
-    jupyter: bool = False
-    submit_to_cloud: bool = False
-    remote: bool = False
-    module: bool = False
-    streamlit: bool = False
-    environment: str = ""
-    holdDirectory: bool = False
-    PathExport: bool = False
-    git_pull: bool = False
-    optimized: bool = False
-    Nprocess: int = 1
-    zellij_tab: Optional[str] = None
-    watch: bool = False
-    layout: bool = False
-
-
-def extract_kwargs(args: FireJobArgs) -> dict[str, object]:
-    """Extract kwargs from command line using -- separator.
-    
-    Returns empty dict since kwargs are now parsed directly from sys.argv
-    using the -- separator pattern in the main function.
-    """
-    return {}
-
-
-def parse_fire_args_from_argv() -> str:
-    """Parse arguments after -- separator for Fire compatibility.
-    
-    Returns:
-        String of Fire-compatible arguments to append to command
-    """
-    import sys
-    
-    if '--' in sys.argv:
-        separator_index = sys.argv.index('--')
-        fire_args = sys.argv[separator_index + 1:]
-        # Join all Fire arguments - they should already be in Fire format
-        return ' '.join(fire_args) if fire_args else ''
-    
-    return ''
-
-
-def parse_fire_args_from_context(ctx: Any) -> str:
-    """Parse Fire arguments from typer context.
-    
-    Args:
-        ctx: Typer context containing raw arguments
-        
-    Returns:
-        String of Fire-compatible arguments to append to command
-    """
-    # Get remaining args that weren't consumed by typer
-    if hasattr(ctx, 'args') and ctx.args:
-        args = ctx.args
-        # Filter out the -- separator if present
-        if args and args[0] == '--':
-            args = args[1:]
-        return ' '.join(args)
-    return ''

machineconfig/scripts/python/fire_jobs_layout_helper.py

@@ -1,74 +0,0 @@
-from pathlib import Path
-from machineconfig.utils.schemas.layouts.layout_types import LayoutConfig, LayoutsFile
-from typing import Optional, TYPE_CHECKING
-from machineconfig.scripts.python.helpers.helpers4 import search_for_files_of_interest
-from machineconfig.utils.options import choose_from_options
-from machineconfig.utils.path_helper import match_file_name, sanitize_path
-from machineconfig.utils.path_extended import PathExtended as PathExtended
-
-if TYPE_CHECKING:
-    from machineconfig.scripts.python.fire_jobs_args_helper import FireJobArgs
-
-
-def select_layout(layouts_json_file: Path, layouts_name: Optional[list[str]]) -> list[LayoutConfig]:
-    import json
-    layout_file: LayoutsFile = json.loads(layouts_json_file.read_text(encoding="utf-8"))
-    if len(layout_file["layouts"]) == 0:
-        raise ValueError(f"No layouts found in {layouts_json_file}")
-    if layouts_name is None:
-        options = [layout["layoutName"] for layout in layout_file["layouts"]]
-        from machineconfig.utils.options import choose_from_options
-        layouts_name = choose_from_options(multi=True, options=options, prompt="Choose a layout configuration:", fzf=True, msg="Choose one option")
-    print(f"Selected layout(s): {layouts_name}")
-    # layout_chosen = next((layout for layout in layout_file["layouts"] if layout["layoutName"] == layouts_name), None)
-    # if layout_chosen is None:
-        # layout_chosen = next((layout for layout in layout_file["layouts"] if layout["layoutName"].lower() == layouts_name.lower()), None)
-    # if layout_chosen is None:
-        # available_layouts = [layout["layoutName"] for layout in layout_file["layouts"]]
-        # raise ValueError(f"Layout '{layouts_name}' not found. Available layouts: {available_layouts}")
-    layouts_chosen: list[LayoutConfig] = []
-    for name in layouts_name:
-        layout_chosen = next((layout for layout in layout_file["layouts"] if layout["layoutName"] == name), None)
-        if layout_chosen is None:
-            layout_chosen = next((layout for layout in layout_file["layouts"] if layout["layoutName"].lower() == name.lower()), None)
-        if layout_chosen is None:
-            available_layouts = [layout["layoutName"] for layout in layout_file["layouts"]]
-            raise ValueError(f"Layout '{name}' not found. Available layouts: {available_layouts}")
-        layouts_chosen.append(layout_chosen)
-    return layouts_chosen
-
-
-def launch_layout(layout_config: LayoutConfig) -> Optional[Exception]:
-    import platform
-    if platform.system() == "Linux" or platform.system() == "Darwin":
-        print("🧑‍💻 Launching layout using Zellij terminal multiplexer...")
-        from machineconfig.cluster.sessions_managers.zellij_local import run_zellij_layout
-        run_zellij_layout(layout_config=layout_config)
-    elif platform.system() == "Windows":
-        print("🧑‍💻 Launching layout using Windows Terminal...")
-        from machineconfig.cluster.sessions_managers.wt_local import run_wt_layout
-
-        run_wt_layout(layout_config=layout_config)
-    else:
-        print(f"❌ Unsupported platform: {platform.system()}")
-    return None
-
-
-def handle_layout_args(args: "FireJobArgs") -> None:
-    # args.function = args.path
-    # args.path = "layout.json"
-    path_obj = sanitize_path(args.path)
-    if not path_obj.exists():
-        choice_file = match_file_name(sub_string=args.path, search_root=PathExtended.cwd(), suffixes={".json"})
-    elif path_obj.is_dir():
-        print(f"🔍 Searching recursively for Python, PowerShell and Shell scripts in directory `{path_obj}`")
-        files = search_for_files_of_interest(path_obj)
-        print(f"🔍 Got #{len(files)} results.")
-        choice_file = choose_from_options(multi=False, options=files, fzf=True, msg="Choose one option")
-        choice_file = PathExtended(choice_file)
-    else:
-        choice_file = path_obj
-    if args.function is None: layouts_name = None
-    else: layouts_name = args.function.split(",")
-    for a_layout_config in select_layout(layouts_json_file=choice_file, layouts_name=layouts_name):
-        launch_layout(layout_config=a_layout_config)

machineconfig/scripts/python/get_zellij_cmd.py

@@ -1,15 +0,0 @@
-from pathlib import Path
-
-
-def get_zellij_cmd(wd1: Path, wd2: Path) -> str:
-    _ = wd1, wd2
-    lines = [
-        """ zellij action new-tab --name gitdiff""",
-        """zellij action new-pane --direction down --name local --cwd ./data """,
-        """zellij action write-chars "cd '{wd1}'; git status" """,
-        """zellij action move-focus up; zellij action close-pane """,
-        """zellij action new-pane --direction down --name remote --cwd code """,
-        """zellij action write-chars "cd '{wd2}' """,
-        """git status" """,
-    ]
-    return "; ".join(lines)

machineconfig/scripts/python/gh_models.py

@@ -1,104 +0,0 @@
-# # as per https://github.com/marketplace/models/azure-openai/o1-preview
-# from openai import OpenAI
-# from machineconfig.utils.path_reduced import P as PathExtended
-# from machineconfig.utils.utils2 import read_ini
-# from rich import print as rprint
-# from rich.panel import Panel
-# from typing import Any
-
-
-# gh_token = read_ini(PathExtended.home().joinpath("dotfiles/creds/git/git_host_tokens.ini"))['thisismygitrepo']['newLongterm']
-# endpoint = "https://models.inference.ai.azure.com"
-# model_name_preferences = ["o3-mini", "o1-preview", "o1-mini", "GPT-4o", "GPT-4-o-mini"]
-# client__ = OpenAI(
-#     base_url=endpoint,
-#     api_key=gh_token,
-# )
-
-
-# def get_response(client: Any, model_name: str, messages: list[dict[str, str]]):
-#     print(f"""
-# ┌────────────────────────────────────────────────────────────────
-# │ 🤖 Querying Model: {model_name}
-# │    Sending request to API...
-# └────────────────────────────────────────────────────────────────""")
-#     try:
-#         response = client.chat.completions.create(
-#             messages=messages,
-#             model=model_name
-#         )
-#         return response.choices
-#     except Exception as e:
-#         print(f"""
-# ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-# ┃ ❌ API Error with model {model_name}
-# ┃    {str(e)}
-# ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━""")
-#         return None
-
-
-# def interactive_chat():
-#     conversation_history = []
-#     model_index = 0
-#     model_name = model_name_preferences[model_index]
-
-#     print("""
-# ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-# ┃ 🚀 Interactive Chat Started
-# ┃    Type your message and press Enter to chat
-# ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━""")
-
-#     while True:
-#         header = f" 🤖 Using Model: {model_name} "
-#         print(f"\n{header.center(80, '═')}\n")
-
-#         while True:
-#             try:
-#                 user_input = input("💬 You: ")
-#                 conversation_history.append({"role": "user", "content": user_input})
-
-#                 while True:
-#                     choices = get_response(client__, model_name, conversation_history)
-#                     if choices is None:
-#                         model_index += 1
-#                         model_name = model_name_preferences[model_index % len(model_name_preferences)]
-#                         print(f"""
-# ┌────────────────────────────────────────────────────────────────
-# │ 🔄 Model Switch
-# │    Now using: {model_name}
-# └────────────────────────────────────────────────────────────────""")
-#                         continue
-#                     else:
-#                         break
-
-#                 for a_choice in choices:
-#                     response_content = a_choice.message.content
-#                     print("\n" * 2)
-#                     try:
-#                         rprint(Panel(
-#                             f"{response_content}",
-#                             title=f"🤖 AI ({model_name})",
-#                             border_style="blue"
-#                         ))
-#                     except Exception:
-#                         # Fallback if rich formatting fails
-#                         print(f"""
-# ┌────────────────────────────────────────────────────────────────
-# │ 🤖 AI ({model_name}):
-# │
-# {response_content}
-# └────────────────────────────────────────────────────────────────""")
-
-#                     conversation_history.append({"role": "assistant", "content": response_content})
-#                     print("\n")
-#             except KeyboardInterrupt:
-#                 print("""
-# ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-# ┃ 👋 Chat Session Ended
-# ┃    Thank you for using the interactive chat!
-# ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━""")
-#                 return
-
-
-# if __name__ == "__main__":
-#     interactive_chat()