machineconfig 1.96__py3-none-any.whl → 2.0__py3-none-any.whl

machineconfig/scripts/python/fire_agents.py

@@ -1,63 +1,205 @@
 
+"""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 __future__ import annotations
 
 from pathlib import Path
-# from machineconfig.cluster.sessions_managers.zellij_local import run_zellij_layout
+import shlex
+from math import ceil
+from typing import Literal, TypeAlias, get_args, Iterable
+
 from machineconfig.cluster.sessions_managers.zellij_local_manager import ZellijLocalManager
+from machineconfig.utils.utils2 import randstr
+
+AGENTS: TypeAlias = Literal["cursor-agent", "gemini", "crush"]
+TabConfig = dict[str, tuple[str, str]]  # tab name -> (cwd, command)
+DEFAULT_AGENT_CAP = 6
+
+
+def get_gemini_api_keys() -> list[str]:
+    from machineconfig.utils.utils2 import read_ini
+    config = read_ini(Path.home().joinpath("dotfiles/creds/llm/gemini/api_keys.ini"))
+    res: list[str] = []
+    for a_section_name in list(config.sections()):
+        a_section = config[a_section_name]
+        if "api_key" in a_section:
+            api_key = a_section["api_key"].strip()
+            if api_key:
+                res.append(api_key)
+    # res = [v for k, v in config.items("api_keys") if k.startswith("key") and v.strip() != ""]
+    print(f"Found {len(res)} Gemini API keys configured.")
+    return res
+
+
+def _search_python_files(repo_root: Path, keyword: str) -> list[Path]:
+    """Return all Python files under repo_root whose text contains keyword.
+
+    Errors reading individual files are ignored (decoded with 'ignore').
+    """
+    py_files = list(repo_root.rglob("*.py"))
+    keyword_lower = keyword.lower()
+    matches: list[Path] = []
+    for f in py_files:
+        try:
+            if keyword_lower in f.read_text(encoding="utf-8", errors="ignore").lower():
+                matches.append(f)
+        except OSError:
+            # Skip unreadable file
+            continue
+    return matches
+
+
+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 _chunk_prompts(prompts: list[str], max_agents: int) -> list[str]:
+    prompts = [p for p in prompts if p.strip() != ""]  # drop blank entries
+    if len(prompts) <= max_agents:
+        return prompts
+    print(f"Chunking {len(prompts)} prompts into groups for up to {max_agents} agents because it exceeds the cap.")
+    chunk_size = ceil(len(prompts) / max_agents)
+    grouped: list[str] = []
+    for i in range(0, len(prompts), chunk_size):
+        grouped.append("\nTargeted Locations:\n".join(prompts[i : i + chunk_size]))
+    return grouped
+def _confirm(message: str, default_no: bool = True) -> bool:
+    suffix = "[y/N]" if default_no else "[Y/n]"
+    answer = input(f"{message} {suffix} ").strip().lower()
+    if answer in {"y", "yes"}:
+        return True
+    if not default_no and answer == "":
+        return True
+    return False
+
 
+def launch_agents(repo_root: Path, prompts: list[str], agent: AGENTS, *, max_agents: int = DEFAULT_AGENT_CAP) -> TabConfig:
+    """Create tab configuration for a set of agent prompts.
+
+    If number of prompts exceeds max_agents, ask user for confirmation.
+    (Original behavior raised an error; now interactive override.)
+    """
+    if not prompts:
+        raise ValueError("No prompts provided")
+
+    if len(prompts) > max_agents:
+        proceed = _confirm(
+            message=(
+                f"You are about to launch {len(prompts)} agents which exceeds the cap ({max_agents}). Proceed?"
+            )
+        )
+        if not proceed:
+            print("Aborting per user choice.")
+            return {}
+
+    tab_config: TabConfig = {}
+    tmp_dir = repo_root / ".ai" / f"tmp_prompts/{randstr()}"
+    tmp_dir.mkdir(parents=True, exist_ok=True)
 
-def launch_agents(repo_root: Path, prompts: list[str]):
-    tab_config: dict[str, tuple[str, str]] = {}
     for idx, a_prompt in enumerate(prompts):
-        tmp_file_path = repo_root.joinpath(f".ai/tmp_prompts/agent{idx}.txt")
-        tmp_file_path.parent.mkdir(parents=True, exist_ok=True)
-        Path(tmp_file_path).write_text(a_prompt)
-        tab_config[f"Agent{idx}"] = (str(repo_root), f"cursor-agent --print --output-format text < .ai/tmp_prompts/agent{idx}.txt")
-    if len(tab_config) > 15:
-        raise RuntimeError(f"Too many agents (#{len(tab_config)}), please cut them down to 15 or less")
+        prompt_path = tmp_dir / f"agent{idx}_prompt.txt"
+        prompt_path.write_text(a_prompt, encoding="utf-8")
+        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"
+echo "Launching gemini agent with prompt from {shlex.quote(str(prompt_path))}"
+cat {prompt_path}
+GEMINI_API_KEY={shlex.quote(api_key)} bash -lc 'cat {safe_path} | gemini {model_arg} --yolo --prompt'
+"""
+            case "cursor-agent":
+                # As originally implemented
+                cmd = f"""
+echo "Launching cursor-agent with prompt from {shlex.quote(str(prompt_path))}"
+cat {prompt_path}
+cursor-agent --print --output-format text < {prompt_path}
+"""
+            case "crush":
+                cmd = f"""
+echo "Launching crush with prompt from {shlex.quote(str(prompt_path))}"
+cat {prompt_path}
+cat {prompt_path} | crush run
+"""
+            case _:
+                raise ValueError(f"Unsupported agent type: {agent}")
+        cmd_path = tmp_dir / f"agent{idx}_cmd.sh"
+        cmd_path.write_text(cmd, encoding="utf-8")
+        fire_cmd = f"bash {shlex.quote(str(cmd_path))}"
+        tab_config[f"Agent{idx}"] = (str(repo_root), fire_cmd)
+
     print(f"Launching a template with #{len(tab_config)} agents")
     return tab_config
 
 
-def main():
+def main():  # noqa: C901 - (complexity acceptable for CLI glue)
     repo_root = Path.cwd()
     print(f"Operating @ {repo_root}")
-    file_path = input("Enter path to target file [press Enter to generate it from searching]: ")
-    if file_path == "":
-        keyword = input("Enter keyword to search recursively for all .py files containing it. ")
-        py_files = list(repo_root.rglob("*.py"))
-        matching_files = [
-            f for f in py_files
-            if keyword in f.read_text(encoding='utf-8', errors='ignore')
-        ]
+
+    file_path_input = input("Enter path to target file [press Enter to generate it from searching]: ").strip()
+    if file_path_input == "":
+        keyword = input("Enter keyword to search recursively for all .py files containing it: ").strip()
+        if not keyword:
+            print("No keyword supplied. Exiting.")
+            return
+        matching_files = _search_python_files(repo_root, keyword)
         if not matching_files:
             print(f"💥 No .py files found containing keyword: {keyword}")
             return
-        print(f"Found {len(matching_files)} .py files containing keyword: {keyword}")
-        file_path = repo_root.joinpath(".ai", "target_file.txt")
-        file_path.parent.mkdir(parents=True, exist_ok=True)
-        file_path.write_text("\n".join(str(f) for f in matching_files), encoding='utf-8')
+        for idx, mf in enumerate(matching_files):
+            print(f"{idx:>3}: {mf}")
+        print(f"\nFound {len(matching_files)} .py files containing keyword: {keyword}")
+        target_list_file = repo_root / ".ai" / "target_file.txt"
+        _write_list_file(target_list_file, matching_files)
         separator = "\n"
+        source_text = target_list_file.read_text(encoding="utf-8", errors="ignore")
     else:
-        separator = input("Enter separator [\\n]: ") or "\n"
+        target_file_path = Path(file_path_input).expanduser().resolve()
+        if not target_file_path.exists() or not target_file_path.is_file():
+            print(f"Invalid file path: {target_file_path}")
+            return
+        separator = input("Enter separator [\\n]: ").strip() or "\n"
+        if not target_file_path.exists():
+            print(f"File does not exist: {target_file_path}")
+            return
+        source_text = target_file_path.read_text(encoding="utf-8", errors="ignore")
 
-    err_file = Path(file_path).expanduser().absolute().read_text(encoding='utf-8', errors='ignore')
+    raw_prompts = source_text.split(separator)
+    print(f"Loaded {len(raw_prompts)} raw prompts from source.")
     prefix = input("Enter prefix prompt: ")
-    prompts = [item for item in err_file.split(separator)]
-    # Dynamically choose chunk size so we end up with <= 15 combined prompts.
-    # If we already have 15 or fewer, keep them as-is.
-    if len(prompts) <= 15:
-        combined_prompts = prompts
-    else:
-        # Compute minimal chunk size so that number_of_chunks <= 15.
-        # number_of_chunks = ceil(len(prompts)/chunk_size) <= 15
-        # => chunk_size >= len(prompts)/15 -> choose ceil(len/15)
-        from math import ceil
-        chunk_size = ceil(len(prompts) / 15)
-        combined_prompts: list[str] = []
-        for i in range(0, len(prompts), chunk_size):
-            combined_prompts.append("\nTargeted Locations:\n".join(prompts[i:i+chunk_size]))
-    combined_prompts = [prefix + "\n" + item for item in combined_prompts]
-    tab_config = launch_agents(repo_root=repo_root, prompts=combined_prompts)
+    combined_prompts = _chunk_prompts(raw_prompts, DEFAULT_AGENT_CAP)
+    combined_prompts = [prefix + "\n" + p for p in combined_prompts]
+
+    from machineconfig.utils.options import choose_one_option
+    agent_selected = choose_one_option(header="Select agent type", options=get_args(AGENTS))
+
+    tab_config = launch_agents(
+        repo_root=repo_root,
+        prompts=combined_prompts,
+        agent=agent_selected,
+        max_agents=DEFAULT_AGENT_CAP,
+    )
+    if not tab_config:
+        return
+
     from machineconfig.utils.utils2 import randstr
     random_name = randstr(length=3)
     manager = ZellijLocalManager(session2zellij_tabs={"Agents": tab_config}, session_name_prefix=random_name)
@@ -65,5 +207,5 @@ def main():
     manager.run_monitoring_routine()
 
 
-if __name__ == "__main__":
+if __name__ == "__main__":  # pragma: no cover
     main()

machineconfig/scripts/python/fire_jobs.py

@@ -30,7 +30,6 @@ def main() -> None:
     parser = argparse.ArgumentParser()
     parser.add_argument("path",     nargs='?', type=str, help="The directory containing the jobs", default=".")
     parser.add_argument("function", nargs='?', type=str, help="Fuction to run", default=None)
-    # parser.add_argument("--function", "-f", type=str, help="The function to run", default="")
     parser.add_argument("--ve",              "-v", type=str, help="virtual enviroment name", default="")
     parser.add_argument("--cmd",             "-B", action="store_true", help="Create a cmd fire command to launch the the job asynchronously.")
     parser.add_argument("--interactive",     "-i", action="store_true", help="Whether to run the job interactively using IPython")
@@ -57,13 +56,15 @@ def main() -> None:
         print(f"❌ Failed to parse arguments: {ex}")
         parser.print_help()
         raise ex
-    path_obj = sanitize_path(PathExtended(args.path))
+    path_obj = sanitize_path(args.path)
+    # print(f"Passed path sanitied to {path_obj}")
     if not path_obj.exists():
         path_obj = match_file_name(sub_string=args.path, search_root=PathExtended.cwd())
     else: pass
     if 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_one_option(options=files, fzf=True)
         choice_file = PathExtended(choice_file)
     else:
@@ -107,13 +108,15 @@ def main() -> None:
                     kwargs[item.name] = input(f"Please enter a value for argument `{item.name}` (type = {item.type}) (default = {item.default}) : ") or item.default
         elif choice_file.suffix == ".sh":  # in this case, we choos lines.
             options = []
-            for line in choice_file.read_text().splitlines():
+            for line in choice_file.read_text(encoding="utf-8").splitlines():
                 if line.startswith("#"): continue
                 if line == "": continue
                 if line.startswith("echo"): continue
                 options.append(line)
             chosen_lines = display_options(msg="Choose a line to run", options=options, fzf=True, multi=True)
-            choice_file = PathExtended.tmpfile(suffix=".sh").write_text("\n".join(chosen_lines))
+            choice_file = PathExtended.tmpfile(suffix=".sh")
+            choice_file.parent.mkdir(parents=True, exist_ok=True)
+            choice_file.write_text("\n".join(chosen_lines), encoding="utf-8")
             choice_function = None
     else:
         choice_function = args.function
@@ -157,7 +160,7 @@ def main() -> None:
                             secrets_template["auth"]["redirect_uri"] = host_url
                             secrets_template["auth"]["cookie_secret"] = randstr(35)
                             secrets_template["auth"]["auth0"]["redirect_uri"] = host_url
-                            save_toml(obj=secrets_template, path=secrets_path)                        
+                            save_toml(obj=secrets_template, path=secrets_path)
                         except Exception as ex:
                             print(ex)
                             raise ex
@@ -169,7 +172,7 @@ def main() -> None:
             # exe = f"cd '{choice_file.parent}'; " + exe
         elif args.interactive is False: exe = "python"
         elif args.jupyter: exe = "jupyter-lab"
-        else:            
+        else:
             exe = f"ipython -i --no-banner --profile {ipy_profile} "
     elif choice_file.suffix == ".ps1" or choice_file.suffix == ".sh":
         exe = "."
@@ -214,7 +217,7 @@ except ImportError as _ex:
 """ + txt
         choice_file = PathExtended.tmp().joinpath(f'tmp_scripts/python/{PathExtended(choice_file).parent.name}_{PathExtended(choice_file).stem}_{randstr()}.py')
         choice_file.parent.mkdir(parents=True, exist_ok=True)
-        choice_file.write_text(txt)
+        choice_file.write_text(txt, encoding="utf-8")
 
     # =========================  determining basic command structure: putting together exe & choice_file & choice_function & pdb
     if args.debug:
@@ -271,13 +274,13 @@ python -m machineconfig.cluster.templates.cli_click --file {choice_file} """
         #     sub_command = f"{command} --idx={an_arg} --idx_max={args.Nprocess}"
         #     if args.optimized:
         #         sub_command = sub_command.replace("python ", "python -OO ")
-        #     sub_command_path = PathExtended.tmpfile(suffix=".sh").write_text(sub_command)
+        #     sub_command_path = PathExtended.tmpfile(suffix=".sh").write_text(sub_command, encoding="utf-8")
         #     lines.append(f"""zellij action new-pane -- bash {sub_command_path}  """)
         #     lines.append("sleep 5")  # python tends to freeze if you launch instances within 1 microsecond of each other
         # command = "\n".join(lines)
         tab_config = {}
         for an_arg in range(args.Nprocess):
-            tab_config[f"tab{an_arg}"] = (str(PathExtended.cwd()), f"uv run python -m fire {choice_file} {choice_function} --idx={an_arg} --idx_max={args.Nprocess}")
+            tab_config[f"tab{an_arg}"] = (str(PathExtended.cwd()), f"uv run -m fire {choice_file} {choice_function} --idx={an_arg} --idx_max={args.Nprocess}")
         from machineconfig.cluster.sessions_managers.zellij_local import run_zellij_layout
         run_zellij_layout(tab_config=tab_config, session_name=None)
         return None
@@ -294,7 +297,9 @@ python -m machineconfig.cluster.templates.cli_click --file {choice_file} """
     console = Console()
 
     if args.zellij_tab is not None:
-        comman_path__ = PathExtended.tmpfile(suffix=".sh").write_text(command)
+        comman_path__ = PathExtended.tmpfile(suffix=".sh")
+        comman_path__.parent.mkdir(parents=True, exist_ok=True)
+        comman_path__.write_text(command, encoding="utf-8")
         console.print(Panel(Syntax(command, lexer="shell"), title=f"🔥 fire command @ {comman_path__}: "), style="bold red")
         import subprocess
         existing_tab_names = subprocess.run(["zellij", "action", "query-tab-names"], capture_output=True, text=True, check=True).stdout.splitlines()
@@ -329,7 +334,8 @@ python -m machineconfig.cluster.templates.cli_click --file {choice_file} """
             raise NotImplementedError(f"Platform {platform.system()} not supported.")
         command = command + f"\n. {program_path}"
     console.print(Panel(Syntax(command, lexer="shell"), title=f"🔥 fire command @ {program_path}: "), style="bold red")
-    program_path.write_text(command)
+    program_path.parent.mkdir(parents=True, exist_ok=True)
+    program_path.write_text(command, encoding="utf-8")
 
 
 if __name__ == '__main__':

machineconfig/scripts/python/ftpx.py

@@ -6,7 +6,7 @@ Currently, the only way to work around this is to predifine the host in ~/.ssh/c
 """
 
 import argparse
-from crocodile.meta import SSH
+from machineconfig.utils.ssh import SSH
 from machineconfig.utils.path_reduced import P as PathExtended
 from machineconfig.scripts.python.helpers.helpers2 import ES
 from machineconfig.utils.utils2 import pprint
@@ -86,7 +86,7 @@ def main():
 ┌────────────────────────────────────────────────────────────────
 │ 🔑 Authentication Failed
 │    Trying manual authentication...
-│ 
+│
 │ ⚠️  Caution: Ensure that username is passed appropriately
 │    This exception only handles password authentication
 └────────────────────────────────────────────────────────────────""")

machineconfig/scripts/python/gh_models.py

@@ -1,104 +1,104 @@
-# 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
+# # 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,
-)
+# 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 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})
+# def interactive_chat():
+#     conversation_history = []
+#     model_index = 0
+#     model_name = model_name_preferences[model_index]
 
-                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
+#     print("""
+# ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+# ┃ 🚀 Interactive Chat Started
+# ┃    Type your message and press Enter to chat
+# ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━""")
 
-                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
+#     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})
 
-if __name__ == "__main__":
-    interactive_chat()
+#                 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()

machineconfig/scripts/python/helpers/cloud_helpers.py

@@ -79,7 +79,7 @@ def absolute(path: str) -> Path:
 def get_secure_share_cloud_config(interactive: bool, cloud: Optional[str]) -> Args:
     console = Console()
     console.print(Panel("🔐 Secure Share Cloud Configuration", expand=False))
-    
+
     if cloud is None:
         if os.environ.get("CLOUD_CONFIG_NAME") is not None:
             default_cloud = os.environ.get("CLOUD_CONFIG_NAME")
@@ -100,7 +100,7 @@ def get_secure_share_cloud_config(interactive: bool, cloud: Optional[str]) -> Ar
 
     default_password_path = Path.home().joinpath("dotfiles/creds/passwords/quick_password")
     if default_password_path.exists():
-        pwd = default_password_path.read_text().strip()
+        pwd = default_password_path.read_text(encoding="utf-8").strip()
         default_message = "defaults to quick_password"
     else:
         pwd = ""
@@ -110,7 +110,7 @@ def get_secure_share_cloud_config(interactive: bool, cloud: Optional[str]) -> Ar
                pwd=pwd, encrypt=True,
                zip=True, overwrite=True, share=True,
                rel2home=True, root="myshare", os_specific=False,)
-    
+
     display_success("Using SecureShare cloud config")
     pprint(res.__dict__, "SecureShare Config")
     return res

machineconfig/scripts/python/helpers/helpers2.py

@@ -48,7 +48,7 @@ def parse_cloud_source_target(args: Args, source: str, target: str) -> tuple[str
         # consider activating it by a flag, and also not not overriding explicitly passed args options.
         assert ES not in target, "Not Implemented here yet."
         path = absolute(target)
-        if maybe_config is None:  
+        if maybe_config is None:
             tmp_maybe_config: Optional[Args] = find_cloud_config(path=path)
             maybe_config = tmp_maybe_config