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

machineconfig/scripts/python/helpers/helpers_agents/agents_impl.py

@@ -0,0 +1,168 @@
+"""Pure Python implementations for agents commands - no typer dependencies."""
+
+from typing import Optional, cast
+from pathlib import Path
+
+
+def agents_create(
+    agent: str,
+    host: str,
+    model: str,
+    provider: str,
+    context_path: Optional[str],
+    separator: str,
+    agent_load: int,
+    prompt: Optional[str],
+    prompt_path: Optional[str],
+    job_name: str,
+    separate: bool,
+    output_path: Optional[str],
+    agents_dir: Optional[str],
+) -> None:
+    """Create agents layout file, ready to run."""
+    from machineconfig.scripts.python.helpers.helpers_agents.fire_agents_help_launch import prep_agent_launch, get_agents_launch_layout
+    from machineconfig.scripts.python.helpers.helpers_agents.fire_agents_load_balancer import chunk_prompts
+    from machineconfig.utils.accessories import get_repo_root, randstr
+    import json
+
+    prompt_options = [prompt, prompt_path]
+    provided_prompt = [opt for opt in prompt_options if opt is not None]
+    if len(provided_prompt) != 1:
+        raise ValueError("Exactly one of --prompt or --prompt-path must be provided")
+
+    repo_root = get_repo_root(Path.cwd())
+    if repo_root is None:
+        raise RuntimeError("💥 Could not determine the repository root. Please run this script from within a git repository.")
+
+    print(f"Operating @ {repo_root}")
+
+    if context_path is None:
+        context_path_resolved = Path(repo_root) / ".ai" / "todo"
+    else:
+        context_path_resolved = Path(context_path).expanduser().resolve()
+
+    if not context_path_resolved.exists():
+        raise ValueError(f"Path does not exist: {context_path_resolved}")
+
+    if context_path_resolved.is_file():
+        prompt_material_re_splitted = chunk_prompts(context_path_resolved, tasks_per_prompt=agent_load, joiner=separator)
+    elif context_path_resolved.is_dir():
+        files = [f for f in context_path_resolved.rglob("*") if f.is_file()]
+        if not files:
+            raise ValueError(f"No files found in directory: {context_path_resolved}")
+        concatenated = separator.join(f.read_text(encoding="utf-8") for f in files)
+        prompt_material_re_splitted = [concatenated]
+    else:
+        raise ValueError(f"Path is neither file nor directory: {context_path_resolved}")
+
+    if prompt_path is not None:
+        prompt_prefix = Path(prompt_path).read_text(encoding="utf-8")
+    else:
+        prompt_prefix = cast(str, prompt)
+
+    agent_selected = agent
+    if agents_dir is None:
+        agents_dir_obj = Path(repo_root) / ".ai" / f"tmp_prompts/{job_name}_{randstr()}"
+    else:
+        import shutil
+        if Path(agents_dir).exists():
+            shutil.rmtree(agents_dir)
+        agents_dir_obj = Path(agents_dir)
+
+    from machineconfig.scripts.python.helpers.helpers_agents.fire_agents_helper_types import HOST, AGENTS, PROVIDER
+    prep_agent_launch(
+        repo_root=repo_root,
+        agents_dir=agents_dir_obj,
+        prompts_material=prompt_material_re_splitted,
+        keep_material_in_separate_file=separate,
+        prompt_prefix=prompt_prefix,
+        machine=cast(HOST, host),
+        agent=cast(AGENTS, agent_selected),
+        model=model,
+        provider=cast(PROVIDER, provider),
+        job_name=job_name,
+    )
+    layoutfile = get_agents_launch_layout(session_root=agents_dir_obj)
+
+    layout_output_path = Path(output_path) if output_path is not None else agents_dir_obj / "layout.json"
+    layout_output_path.parent.mkdir(parents=True, exist_ok=True)
+    layout_output_path.write_text(data=json.dumps(layoutfile, indent=4), encoding="utf-8")
+    print(f"Created agents in {agents_dir_obj}")
+    print(f"Created layout in {layout_output_path}")
+
+
+def collect(agent_dir: str, output_path: str, separator: str) -> None:
+    """Collect all material files from an agent directory and concatenate them."""
+    if not Path(agent_dir).exists() or not Path(agent_dir).is_dir():
+        raise ValueError(f"Agent directory does not exist or is not a directory: {agent_dir}")
+
+    prompts_dir = Path(agent_dir) / "prompts"
+    if not prompts_dir.exists():
+        raise ValueError(f"Prompts directory not found: {prompts_dir}")
+
+    material_files: list[Path] = []
+    for agent_subdir in prompts_dir.iterdir():
+        if agent_subdir.is_dir() and agent_subdir.name.startswith("agent_"):
+            material_file = agent_subdir / f"{agent_subdir.name}_material.txt"
+            if material_file.exists():
+                material_files.append(material_file)
+
+    if not material_files:
+        print("No material files found in the agent directory.")
+        return
+
+    material_files.sort(key=lambda x: int(x.parent.name.split("_")[-1]))
+
+    concatenated_content: list[str] = []
+    for material_file in material_files:
+        content = material_file.read_text(encoding="utf-8")
+        concatenated_content.append(content)
+
+    result = separator.join(concatenated_content)
+
+    Path(output_path).parent.mkdir(parents=True, exist_ok=True)
+    Path(output_path).write_text(result, encoding="utf-8")
+    print(f"Concatenated material written to {output_path}")
+
+
+def make_agents_command_template() -> None:
+    """Create a template for fire agents."""
+    from platform import system
+    import machineconfig.scripts.python.helpers.helpers_agents as module
+
+    if system() == "Linux" or system() == "Darwin":
+        template_path = Path(module.__file__).parent / "templates/template.sh"
+    elif system() == "Windows":
+        template_path = Path(module.__file__).parent / "templates/template.ps1"
+    else:
+        raise ValueError(f"Unsupported OS: {system()}")
+
+    from machineconfig.utils.accessories import get_repo_root
+    repo_root = get_repo_root(Path.cwd())
+    if repo_root is None:
+        raise RuntimeError("💥 Could not determine the repository root. Please run this script from within a git repository.")
+
+    save_path_root = repo_root / ".ai" / "agents"
+
+    save_path_root.mkdir(parents=True, exist_ok=True)
+    save_path_root.joinpath("template_fire_agents.sh").write_text(template_path.read_text(encoding="utf-8"), encoding="utf-8")
+    print(f"Template bash script written to {save_path_root}")
+
+    from machineconfig.scripts.python.ai.utils.generate_files import make_todo_files
+    make_todo_files(
+        pattern=".py", repo=str(repo_root), strategy="name", output_path=str(save_path_root / "files.md"), split_every=None, split_to=None
+    )
+
+    prompt_path = Path(module.__file__).parent / "templates/prompt.txt"
+    save_path_root.joinpath("prompt.txt").write_text(prompt_path.read_text(encoding="utf-8"), encoding="utf-8")
+    print(f"Prompt template written to {save_path_root}")
+
+
+def init_config(root: Optional[str]) -> None:
+    """Initialize AI configurations in the current repository."""
+    from machineconfig.scripts.python.ai.initai import add_ai_configs
+    if root is None:
+        repo_root = Path.cwd()
+    else:
+        repo_root = Path(root).expanduser().resolve()
+    add_ai_configs(repo_root=repo_root)

machineconfig/scripts/python/{helpers_fire → helpers/helpers_agents}/fire_agents_help_launch.py

@@ -2,25 +2,30 @@
 import random
 import shlex
 from pathlib import Path
-from machineconfig.scripts.python.helpers_fire.fire_agents_helper_types import AGENTS, AGENT_NAME_FORMATTER, HOST, PROVIDER, MODEL
+from machineconfig.scripts.python.helpers.helpers_agents.fire_agents_helper_types import AGENTS, AGENT_NAME_FORMATTER, HOST, PROVIDER, AI_SPEC, API_SPEC
 
 
-def get_api_keys(provider: PROVIDER) -> list[str]:
+def get_api_keys(provider: PROVIDER) -> list[API_SPEC]:
     from machineconfig.utils.io import read_ini
     config = read_ini(Path.home().joinpath(f"dotfiles/creds/llm/{provider}/api_keys.ini"))
-    res: list[str] = []
+    res: list[API_SPEC] = []
     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.append(API_SPEC(
+                    api_key=api_key,
+                    api_name=a_section.get("api_name", ""),
+                    api_label=a_section_name,
+                    api_account=a_section.get("email", "")
+                ))
     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: MODEL, provider: PROVIDER, agent: AGENTS, *, job_name: str) -> None:
+                      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)
@@ -55,6 +60,7 @@ 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--------"
@@ -65,24 +71,37 @@ sleep 0.1
             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
-                from machineconfig.scripts.python.helpers_fire.agentic_frameworks.fire_gemini import fire_gemini
-                cmd = fire_gemini(api_key=api_key, prompt_path=prompt_path, machine=machine, model="gemini-2.5-pro", provider="google", repo_root=repo_root)
+                api_spec = api_keys[idx % len(api_keys)] if len(api_keys) > 0 else None
+                if api_spec is None:
+                    raise ValueError("No API keys found for Google Gemini. Please configure them in dotfiles/creds/llm/google/api_keys.ini")
+                ai_spec: AI_SPEC = AI_SPEC(provider=provider, model="gemini-2.5-pro", agent=agent, machine=machine, api_spec=api_spec)
+                from machineconfig.scripts.python.helpers.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":
-                from machineconfig.scripts.python.helpers_fire.agentic_frameworks.fire_cursor_agents import fire_cursor
-                cmd = fire_cursor(prompt_path=prompt_path, machine=machine, api_key=None)
+                api_spec = API_SPEC(api_key=None, api_name="", api_label="", api_account="")
+                ai_spec: AI_SPEC = AI_SPEC(provider=provider, model=model, agent=agent, machine=machine, api_spec=api_spec)
+                from machineconfig.scripts.python.helpers.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":
-                from machineconfig.scripts.python.helpers_fire.agentic_frameworks.fire_crush import fire_crush
                 api_keys = get_api_keys(provider=provider)
-                api_key = api_keys[idx % len(api_keys)] if len(api_keys) > 0 else None
-                cmd = fire_crush(api_key=api_key, prompt_path=prompt_path, machine=machine, repo_root=repo_root, model=model, provider=provider)
+                api_spec = api_keys[idx % len(api_keys)] if len(api_keys) > 0 else None
+                if api_spec is None:
+                    raise ValueError("No API keys found for Crush. Please configure them in dotfiles/creds/llm/crush/api_keys.ini")
+                ai_spec: AI_SPEC = AI_SPEC(provider=provider, model=model, agent=agent, machine=machine, api_spec=api_spec)
+                from machineconfig.scripts.python.helpers.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
+            #     from machineconfig.scripts.python.helpers.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_prefix += f"""
+echo "Running with api label:   {ai_spec['api_spec']['api_label']}"
+echo "Running with api acount:  {ai_spec['api_spec']['api_account']}"
+echo "Running with api name:    {ai_spec['api_spec']['api_name']}"
+echo "Running with api key:     {ai_spec['api_spec']['api_key']}"
+"""
         cmd_postfix = """
 sleep 0.1
 echo "---------END OF AGENT OUTPUT---------"
@@ -93,10 +112,13 @@ echo "---------END OF AGENT OUTPUT---------"
 
 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()]
+
+    import re
+    all_dirs_under_prompts = sorted(all_dirs_under_prompts, key=lambda path: [int(text) if text.isdigit() else text.lower() for text in re.split(r'(\d+)', path.name)])
+    print(all_dirs_under_prompts)
     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)

machineconfig/scripts/python/{helpers_fire → helpers/helpers_agents}/fire_agents_helper_types.py

@@ -19,24 +19,21 @@ from typing import Literal, TypeAlias, TypedDict
 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"]
-MODEL: TypeAlias = Literal["zai/glm-4.6", "anthropic/sonnet-4.5", "google/gemini-2.5-pro", "openai/gpt-5-codex",
-                           "openrouter/supernova", "x-ai/grok-4-fast:free",
-                           ]
-PROVIDER2MODEL: dict[PROVIDER, list[MODEL]] = {
-    "azure": ["zai/glm-4.6"],
-    "google": ["google/gemini-2.5-pro"],
-    "aws": [],
-    "openai": ["openai/gpt-5-codex"],
-    "anthropic": ["anthropic/sonnet-4.5"],
-    "openrouter": ["openrouter/supernova"],
-    "xai": ["x-ai/grok-4-fast:free"]
-}
+
+
+class API_SPEC(TypedDict):
+    api_key: str | None
+    api_name: str
+    api_label: str
+    api_account: str
+
 
 class AI_SPEC(TypedDict):
     provider: PROVIDER
-    model: MODEL
+    model: str
     agent: AGENTS
-    machine: HOST    
+    machine: HOST
+    api_spec: API_SPEC
 
 
 AGENT_NAME_FORMATTER = "agent_{idx}_cmd.sh"  # e.g., agent_0_cmd.sh

machineconfig/scripts/python/helpers/helpers_agents/privacy/configs/aichat/config.yaml

@@ -0,0 +1,5 @@
+save: false
+save_session: false
+save_shell_history: false
+user_agent: "Mozilla/5.0"
+sync_models_url: ""

machineconfig/scripts/python/helpers/helpers_agents/privacy/configs/aider/.aider.conf.yml

@@ -0,0 +1,2 @@
+analytics: false
+check-update: false

machineconfig/scripts/python/helpers/helpers_agents/privacy/configs/copilot/config.yml

@@ -0,0 +1 @@
+optional_usage_analytics: false

machineconfig/scripts/python/helpers/helpers_agents/privacy/configs/crush/crush.json

@@ -0,0 +1,10 @@
+{
+  "options": {
+    "disable_metrics": true,
+    "disable_provider_auto_update": true,
+    "attribution": {
+      "trailer_style": "none",
+      "generated_with": false
+    }
+  }
+}

machineconfig/scripts/python/helpers/helpers_agents/privacy/configs/gemini/settings.json

@@ -0,0 +1,12 @@
+{
+  "telemetry": {
+    "enabled": false,
+    "logPrompts": false,
+    "useCollector": false,
+    "target": "local",
+    "outfile": null
+  },
+  "advanced": {
+    "bugCommand": null
+  }
+}

machineconfig/scripts/python/helpers/helpers_agents/privacy/privacy.py

@@ -0,0 +1,109 @@
+"""
+
+create 18 tasks one per cli
+in each one, you do comprehensive search on internet on how to set up the cli/extension or whatever so we get max privacy and security (nothing shared everything is declined and is on the safe side)
+this is a moving space, everyday, there are new versions, new configs, new settings, new policies, new rules, new terms of service, new eula, new privacy policies etc etc
+so please search for latest and don't be complacent with the work done so far.
+
+do it one by one, don't research and implement next before finishing the task before it.
+
+I provided gemini cli solution as a reference (feel free to make it more flexible if you need mroe room to implement something more complex than what I did, its just a guide)
+remember that other cli's have different names and configs and locations etc, read official docs
+
+in the following cli how to set it for maximal prviacy *turn off any telemetry, reject any use of data, etc etc, please think of everything and read all theird docs and fine print
+    "aider",
+    "aichat",  # rust cli
+    "copilot",  # cli from github copilot extension
+    "gemini",  # gemini cli 
+    "crush",  # cli from charm team
+    "mods",  # cli from same people as crush (not agent) @ https://github.com/charmbracelet/mods
+    "opencode-ai",
+    "chatgpt",
+    "q",  # from aws
+    "qwen-code",  # fork of gemini cli
+    "cursor-cli",
+    "droid",
+    "kilocode",
+    "cline",  # cli from cline ai extension
+    "auggie",
+    "codex",  # from openai
+
+"""
+
+from typing import Optional
+
+
+def apply_max_privacy_and_security_rules_and_configs(overwrite: bool, repo_root: Optional[str]) -> None:
+    from machineconfig.utils.source_of_truth import LIBRARY_ROOT
+    root = LIBRARY_ROOT / "scripts/python/helpers_agents/privacy/configs"
+    from pathlib import Path
+
+    # Gemini privacy settings
+    gemini_settings_source = root.joinpath("gemini/settings.json")
+    gemini_settings_target_global = Path.home().joinpath(".gemini/settings.json")
+    if not gemini_settings_target_global.exists() or overwrite:
+        gemini_settings_target_global.parent.mkdir(parents=True, exist_ok=True)
+        gemini_settings_target_global.write_text(gemini_settings_source.read_text())
+    if repo_root:
+        gemini_settings_target_repo = Path(repo_root).joinpath(".gemini/settings.json")
+        if not gemini_settings_target_repo.exists() or overwrite:
+            gemini_settings_target_repo.parent.mkdir(parents=True, exist_ok=True)
+            gemini_settings_target_repo.write_text(gemini_settings_source.read_text())
+
+    # Aider privacy settings
+    aider_settings_source = root.joinpath("aider/.aider.conf.yml")
+    aider_settings_target_global = Path.home().joinpath(".aider.conf.yml")
+    if not aider_settings_target_global.exists() or overwrite:
+        aider_settings_target_global.parent.mkdir(parents=True, exist_ok=True)
+        aider_settings_target_global.write_text(aider_settings_source.read_text())
+
+    if repo_root:
+        aider_settings_target_repo = Path(repo_root).joinpath(".aider.conf.yml")
+        if not aider_settings_target_repo.exists() or overwrite:
+            aider_settings_target_repo.parent.mkdir(parents=True, exist_ok=True)
+            aider_settings_target_repo.write_text(aider_settings_source.read_text())
+
+    # Aichat privacy settings
+    aichat_settings_source = root.joinpath("aichat/config.yaml")
+    aichat_settings_target_global = Path.home().joinpath(".config/aichat/config.yaml")
+    if not aichat_settings_target_global.exists() or overwrite:
+        aichat_settings_target_global.parent.mkdir(parents=True, exist_ok=True)
+        aichat_settings_target_global.write_text(aichat_settings_source.read_text())
+
+    if repo_root:
+        aichat_settings_target_repo = Path(repo_root).joinpath(".config/aichat/config.yaml")
+        if not aichat_settings_target_repo.exists() or overwrite:
+            aichat_settings_target_repo.parent.mkdir(parents=True, exist_ok=True)
+            aichat_settings_target_repo.write_text(aichat_settings_source.read_text())
+
+    # Copilot privacy settings
+    copilot_settings_source = root.joinpath("copilot/config.yml")
+    copilot_settings_target_global = Path.home().joinpath(".config/gh-copilot/config.yml")
+    if not copilot_settings_target_global.exists() or overwrite:
+        copilot_settings_target_global.parent.mkdir(parents=True, exist_ok=True)
+        copilot_settings_target_global.write_text(copilot_settings_source.read_text())
+
+    if repo_root:
+        copilot_settings_target_repo = Path(repo_root).joinpath(".config/gh-copilot/config.yml")
+        if not copilot_settings_target_repo.exists() or overwrite:
+            copilot_settings_target_repo.parent.mkdir(parents=True, exist_ok=True)
+            copilot_settings_target_repo.write_text(copilot_settings_source.read_text())
+
+    # Crush privacy settings
+    crush_settings_source = root.joinpath("crush/crush.json")
+    crush_settings_target_global = Path.home().joinpath(".config/crush/crush.json")
+    if not crush_settings_target_global.exists() or overwrite:
+        crush_settings_target_global.parent.mkdir(parents=True, exist_ok=True)
+        crush_settings_target_global.write_text(crush_settings_source.read_text())
+
+    if repo_root:
+        crush_settings_target_repo = Path(repo_root).joinpath(".crush.json")
+        if not crush_settings_target_repo.exists() or overwrite:
+            crush_settings_target_repo.parent.mkdir(parents=True, exist_ok=True)
+            crush_settings_target_repo.write_text(crush_settings_source.read_text())
+
+    # next, cursh cli
+
+
+if __name__ == "__main__":
+    pass

machineconfig/scripts/python/helpers/helpers_agents/templates/prompt.txt

@@ -0,0 +1,10 @@
+
+Please inspect the following python files, and document which methods of PathExtended class have been used (if the class is used at all)
+please create a file next to this file on same dir called result.md and put your results in it.
+Like this:
+* File_NAME
+    * method1
+    * method2
+
+* File_NAME
+    * method x

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

@@ -0,0 +1,34 @@
+
+#!/bin/bash
+# set -e # Exit immediately if a command exits with a non-zero status.
+
+
+REPO_ROOT="$HOME/code/machineconfig"
+
+JOB_NAME="agentsTrial"
+CONTEXT_PATH="$REPO_ROOT/.ai/agents/files.md"
+PROMPT_PATH="$REPO_ROOT/.ai/agents/prompt.txt"
+AGENTS_DIR="$REPO_ROOT/.ai/agents/$JOB_NAME"
+rm -rfd "$AGENTS_DIR" || true
+
+agents create \
+    --agents gemini \
+    --host docker \
+    --model gemini-2.5-pro \
+    --provider google \
+    --agent-load 5 \
+    --context-path $CONTEXT_PATH \
+    --prompt-path $PROMPT_PATH \
+    --job-name $JOB_NAME \
+    --agents-dir $AGENTS_DIR
+
+sessions balance-load "$AGENTS_DIR/layout.json" \
+    --max-threshold 4 \
+    --breaking-method moreLayouts \
+    --threshold-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_cloud → helpers/helpers_cloud}/cloud_copy.py

@@ -2,26 +2,24 @@
 CC
 """
 
-from machineconfig.utils.path_extended import PathExtended
-from tenacity import retry, stop_after_attempt, wait_chain, wait_fixed
-import getpass
-import os
 from typing import Optional, Annotated
-
 import typer
 
-from machineconfig.scripts.python.helpers_cloud.helpers2 import parse_cloud_source_target
-from machineconfig.scripts.python.helpers_cloud.cloud_helpers import ArgsDefaults, Args
-from rich.console import Console
-from rich.panel import Panel
-from rich.progress import Progress
-from machineconfig.utils.accessories import pprint
+from tenacity import retry, stop_after_attempt, wait_chain, wait_fixed
 
-console = Console()
 
 
 @retry(stop=stop_after_attempt(3), wait=wait_chain(wait_fixed(1), wait_fixed(4), wait_fixed(9)))
 def get_securely_shared_file(url: Optional[str] = None, folder: Optional[str] = None) -> None:
+    from rich.console import Console
+    from rich.panel import Panel
+    from rich.progress import Progress
+    import getpass
+    import os
+    from machineconfig.utils.path_extended import PathExtended
+
+    console = Console()
+
     console.print(Panel("🚀 Secure File Downloader", title="[bold blue]Downloader[/bold blue]", border_style="blue"))
 
     folder_obj = PathExtended.cwd() if folder is None else PathExtended(folder)
@@ -54,7 +52,7 @@ def get_securely_shared_file(url: Optional[str] = None, folder: Optional[str] =
         tmp_folder = PathExtended.tmpdir(prefix="tmp_unzip")
         try:
             res = url_obj.decrypt(pwd=pwd, inplace=True).unzip(inplace=True, folder=tmp_folder)
-            for x in res.search("*"):
+            for x in res.glob("*"):
                 x.move(folder=folder_obj, overwrite=True)
         finally:
             # Clean up temporary folder
@@ -62,21 +60,30 @@ def get_securely_shared_file(url: Optional[str] = None, folder: Optional[str] =
                 tmp_folder.delete()
 
 
+
 def main(
     source: Annotated[str, typer.Argument(help="📂 file/folder path to be taken from here.")],
     target: Annotated[str, typer.Argument(help="🎯 file/folder path to be be sent to here.")],
-    overwrite: Annotated[bool, typer.Option("--overwrite", "-o", help="✍️ Overwrite existing file.")] = ArgsDefaults.overwrite,
-    share: Annotated[bool, typer.Option("--share", "-s", help="🔗 Share file / directory")] = ArgsDefaults.share,
-    rel2home: Annotated[bool, typer.Option("--relative2home", "-r", help="🏠 Relative to `myhome` folder")] = ArgsDefaults.rel2home,
-    root: Annotated[Optional[str], typer.Option("--root", "-R", help="🌳 Remote root. None is the default, unless rel2home is raied, making the default `myhome`.")] = ArgsDefaults.root,
-    key: Annotated[Optional[str], typer.Option("--key", "-k", help="🔑 Key for encryption")] = ArgsDefaults.key,
-    pwd: Annotated[Optional[str], typer.Option("--password", "-p", help="🔒 Password for encryption")] = ArgsDefaults.pwd,
-    encrypt: Annotated[bool, typer.Option("--encrypt", "-e", help="🔐 Encrypt before sending.")] = ArgsDefaults.encrypt,
-    zip_: Annotated[bool, typer.Option("--zip", "-z", help="📦 unzip after receiving.")] = ArgsDefaults.zip_,
-    os_specific: Annotated[bool, typer.Option("--os-specific", "-O", help="💻 choose path specific for this OS.")] = ArgsDefaults.os_specific,
+    overwrite: Annotated[bool, typer.Option("--overwrite", "-o", help="✍️ Overwrite existing file.")] = False,
+    share: Annotated[bool, typer.Option("--share", "-s", help="🔗 Share file / directory")] = False,
+    rel2home: Annotated[bool, typer.Option("--relative2home", "-r", help="🏠 Relative to `myhome` folder")] = False,
+    root: Annotated[Optional[str], typer.Option("--root", "-R", help="🌳 Remote root. None is the default, unless rel2home is raied, making the default `myhome`.")] = None,
+    key: Annotated[Optional[str], typer.Option("--key", "-k", help="🔑 Key for encryption")] = None,
+    pwd: Annotated[Optional[str], typer.Option("--password", "-p", help="🔒 Password for encryption")] = None,
+    encrypt: Annotated[bool, typer.Option("--encrypt", "-e", help="🔐 Encrypt before sending.")] = False,
+    zip_: Annotated[bool, typer.Option("--zip", "-z", help="📦 unzip after receiving.")] = False,
+    os_specific: Annotated[bool, typer.Option("--os-specific", "-O", help="💻 choose path specific for this OS.")] = False,
     config: Annotated[Optional[str], typer.Option("--config", "-c", help="⚙️ path to cloud.json file.")] = None,
 ) -> None:
     """📤 Upload or 📥 Download files/folders to/from cloud storage services like Google Drive, Dropbox, OneDrive, etc."""
+    from rich.console import Console
+    from rich.panel import Panel
+    from machineconfig.utils.path_extended import PathExtended
+    from machineconfig.scripts.python.helpers.helpers_cloud.helpers2 import parse_cloud_source_target
+    from machineconfig.scripts.python.helpers.helpers_cloud.cloud_helpers import Args
+    from machineconfig.utils.accessories import pprint
+
+    console = Console()
     console.print(Panel("☁️  Cloud Copy Utility", title="[bold blue]Cloud Copy[/bold blue]", border_style="blue", width=152))
     args_obj = Args(
         overwrite=overwrite,
@@ -100,7 +107,7 @@ def main(
                 print("🔄 Converting Google Drive link to direct download URL")
             else:
                 console.print(Panel("❌ Invalid Google Drive link format", title="[bold red]Error[/bold red]", border_style="red"))
-                raise ValueError("Invalid Google Drive link format")
+                raise typer.Exit(code=1)
         return get_securely_shared_file(url=source, folder=target)
 
     if args_obj.rel2home is True and args_obj.root is None:
@@ -115,7 +122,7 @@ def main(
 
     if args_obj.key is not None:
         console.print(Panel("❌ Key-based encryption is not supported yet", title="[bold red]Error[/bold red]", border_style="red"))
-        raise ValueError("Key-based encryption is not supported yet.")
+        raise typer.Exit(code=1)
 
     if cloud in source:
         console.print(Panel(f"📥 DOWNLOADING FROM CLOUD\n☁️  Cloud: {cloud}\n📂 Source: {source.replace(cloud + ':', '')}\n🎯 Target: {target}", title="[bold blue]Download[/bold blue]", border_style="blue", width=152))
@@ -152,7 +159,7 @@ def main(
             console.print(Panel(f"🔗 SHARE URL GENERATED\n📝 URL file: {share_url_path}\n🌍 {res.as_url_str()}", title="[bold blue]Share[/bold blue]", border_style="blue", width=152))
     else:
         console.print(Panel(f"❌ ERROR: Cloud '{cloud}' not found in source or target", title="[bold red]Error[/bold red]", border_style="red", width=152))
-        raise ValueError(f"Cloud `{cloud}` not found in source or target.")
+        raise typer.Exit(code=1)
 
 
 def arg_parser() -> None: