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

machineconfig/scripts/python/helpers_devops/devops_update_repos.py

@@ -0,0 +1,269 @@
+"""Update repositories with fancy output"""
+
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from pathlib import Path
+
+import git
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+
+from machineconfig.scripts.python.helpers_repos.update import RepositoryUpdateResult, run_uv_sync, update_repository
+from machineconfig.utils.io import read_ini
+from machineconfig.utils.source_of_truth import DEFAULTS_PATH
+
+
+console = Console()
+
+
+def _process_single_repo(expanded_path: Path, allow_password_prompt: bool) -> tuple[RepositoryUpdateResult, Path | None]:
+    """Process a single repository and return the result."""
+    try:
+        repo = git.Repo(str(expanded_path), search_parent_directories=True)
+        # Update repository and get detailed results
+        result = update_repository(repo, allow_password_prompt=allow_password_prompt, auto_uv_sync=True)
+        
+        # Keep track of repos with dependency changes for additional uv sync
+        repo_path = None
+        if result["dependencies_changed"] and not result["uv_sync_ran"]:
+            repo_path = Path(repo.working_dir)
+        
+        return result, repo_path
+
+    except Exception as ex:
+        # Create a result for failed repos
+        error_result: RepositoryUpdateResult = {
+            "repo_path": str(expanded_path),
+            "status": "error",
+            "had_uncommitted_changes": False,
+            "uncommitted_files": [],
+            "commit_before": "",
+            "commit_after": "",
+            "commits_changed": False,
+            "pyproject_changed": False,
+            "dependencies_changed": False,
+            "uv_sync_ran": False,
+            "uv_sync_success": False,
+            "remotes_processed": [],
+            "remotes_skipped": [],
+            "error_message": str(ex),
+            "is_machineconfig_repo": False,
+            "permissions_updated": False,
+        }
+        console.print(
+            Panel(
+                "\n".join(
+                    [
+                        f"❌ Repository error: {expanded_path}",
+                        f"Exception: {ex}",
+                    ]
+                ),
+                border_style="red",
+                padding=(1, 2),
+            )
+        )
+        return error_result, None
+
+
+def _display_summary(results: list[RepositoryUpdateResult]) -> None:
+    """Display a comprehensive summary of all repository update operations."""
+
+    console.rule("[bold blue]📊 Repository Update Summary[/bold blue]")
+
+    total_repos = len(results)
+    successful_repos = sum(1 for r in results if r["status"] == "success")
+    error_repos = sum(1 for r in results if r["status"] == "error")
+    skipped_repos = sum(1 for r in results if r["status"] == "skipped")
+    auth_failed_repos = sum(1 for r in results if r["status"] == "auth_failed")
+
+    repos_with_changes = sum(1 for r in results if r["commits_changed"])
+    repos_with_uncommitted = sum(1 for r in results if r["had_uncommitted_changes"])
+    repos_with_dep_changes = sum(1 for r in results if r["dependencies_changed"])
+    uv_sync_runs = sum(1 for r in results if r["uv_sync_ran"])
+    uv_sync_successes = sum(1 for r in results if r["uv_sync_ran"] and r["uv_sync_success"])
+
+    overview_lines = [
+        f"[bold]Total repositories processed:[/] {total_repos}",
+        f"✅ Successful updates: {successful_repos}",
+        f"❌ Failed updates: {error_repos}",
+        f"⏭️  Skipped: {skipped_repos}",
+    ]
+    if auth_failed_repos > 0:
+        overview_lines.append(f"🔐 Authentication failed: {auth_failed_repos}")
+
+    console.print(
+        Panel(
+            "\n".join(overview_lines),
+            title="� Overview",
+            border_style="blue",
+            padding=(1, 2),
+        )
+    )
+
+    changes_lines = [
+        f"Repositories with new commits: {repos_with_changes}",
+        f"Repositories with dependency changes: {repos_with_dep_changes}",
+        f"Repositories with uncommitted changes: {repos_with_uncommitted}",
+    ]
+    console.print(
+        Panel(
+            "\n".join(changes_lines),
+            title="� Changes",
+            border_style="magenta",
+            padding=(1, 2),
+        )
+    )
+
+    uv_sync_lines = [
+        f"uv sync operations attempted: {uv_sync_runs}",
+        f"uv sync operations successful: {uv_sync_successes}",
+    ]
+    if uv_sync_runs > uv_sync_successes:
+        uv_sync_lines.append(f"uv sync operations failed: {uv_sync_runs - uv_sync_successes}")
+
+    console.print(
+        Panel(
+            "\n".join(uv_sync_lines),
+            title="📦 uv sync",
+            border_style="cyan",
+            padding=(1, 2),
+        )
+    )
+
+    table = Table(title="📋 Detailed Results", show_lines=True, header_style="bold blue")
+    table.add_column("Repository", style="bold")
+    table.add_column("Status")
+    table.add_column("Details", overflow="fold")
+
+    for result in results:
+        repo_name = Path(result["repo_path"]).name
+        status_icon = {"success": "✅", "error": "❌", "skipped": "⏭️", "auth_failed": "🔐"}.get(result["status"], "❓")
+        status_label = result["status"].replace("_", " ").title()
+
+        detail_lines: list[str] = []
+
+        if result["status"] == "error" and result["error_message"]:
+            detail_lines.append(f"💥 Error: {result['error_message']}")
+
+        if result["commits_changed"]:
+            detail_lines.append(f"🔄 Updated: {result['commit_before'][:8]} → {result['commit_after'][:8]}")
+        elif result["status"] == "success":
+            detail_lines.append("📍 Already up to date")
+
+        if result["had_uncommitted_changes"]:
+            files_str = ", ".join(result["uncommitted_files"])
+            detail_lines.append(f"⚠️  Uncommitted changes: {files_str}")
+
+        if result["dependencies_changed"]:
+            changes = []
+            if result["pyproject_changed"]:
+                changes.append("pyproject.toml")
+            if changes:
+                detail_lines.append(f"📋 Dependencies changed: {', '.join(changes)}")
+
+        if result["uv_sync_ran"]:
+            sync_status = "✅" if result["uv_sync_success"] else "❌"
+            detail_lines.append(f"📦 uv sync: {sync_status}")
+
+        if result["is_machineconfig_repo"] and result["permissions_updated"]:
+            detail_lines.append("🛠  Updated permissions for machineconfig files")
+
+        if result["remotes_processed"]:
+            detail_lines.append(f"📡 Processed remotes: {', '.join(result['remotes_processed'])}")
+        if result["remotes_skipped"]:
+            detail_lines.append(f"⏭️  Skipped remotes: {', '.join(result['remotes_skipped'])}")
+
+        table.add_row(f"{status_icon} {repo_name}", status_label, "\n".join(detail_lines) or "—")
+
+    console.print(table)
+
+    if error_repos == 0 and auth_failed_repos == 0:
+        summary_text = Text("🎉 All repositories processed successfully!", style="green", justify="center")
+        border = "green"
+    elif successful_repos > 0:
+        summary_text = Text(
+            f"⚠️  {successful_repos}/{total_repos} repositories processed successfully",
+            style="yellow",
+            justify="center",
+        )
+        border = "yellow"
+    else:
+        summary_text = Text("❌ No repositories were successfully processed", style="red", justify="center")
+        border = "red"
+
+    console.print(Panel(summary_text, title="Summary", border_style=border, padding=(1, 2)))
+
+
+def main(verbose: bool = True, allow_password_prompt: bool = False) -> None:
+    """Main function to update all configured repositories."""
+    _ = verbose
+    repos: list[Path] = []
+    try:
+        tmp = read_ini(DEFAULTS_PATH)["general"]["repos"].split(",")
+        if tmp[-1] == "":
+            tmp = tmp[:-1]
+        for item in tmp:
+            item_obj = Path(item).expanduser()
+            if item_obj not in repos:
+                repos.append(item_obj)
+    except (FileNotFoundError, KeyError, IndexError):
+        console.print(
+            Panel(
+                "\n".join(
+                    [
+                        f"🚫 Configuration error: missing {DEFAULTS_PATH} or the [general] section / repos key.",
+                        "ℹ️  Using default repositories instead.",
+                    ]
+                ),
+                title="Configuration Missing",
+                border_style="red",
+                padding=(1, 2),
+            )
+        )
+        console.print(
+            Panel(
+                "\n".join(
+                    [
+                        "✨ Example configuration:",
+                        "",
+                        "[general]",
+                        "repos = ~/code/repo1,~/code/repo2",
+                        "rclone_config_name = onedrivePersonal",
+                        "email_config_name = Yahoo3",
+                        "to_email = myemail@email.com",
+                    ]
+                ),
+                border_style="cyan",
+                padding=(1, 2),
+            )
+        )
+    update_repos(repos, allow_password_prompt)
+
+
+def update_repos(repos: list[Path], allow_password_prompt: bool) -> None:
+    # Process repositories in parallel
+    results: list[RepositoryUpdateResult] = []
+    repos_with_changes = []
+    with ThreadPoolExecutor(max_workers=min(len(repos), 8)) as executor:
+        # Submit all tasks
+        future_to_repo = {
+            executor.submit(_process_single_repo, expanded_path, allow_password_prompt): expanded_path 
+            for expanded_path in repos
+        }
+        
+        # Collect results as they complete
+        for future in as_completed(future_to_repo):
+            result, repo_path = future.result()
+            results.append(result)
+            if repo_path is not None:
+                repos_with_changes.append(repo_path)
+    # Run uv sync for repositories where pyproject.toml changed but sync wasn't run yet
+    for repo_path in repos_with_changes:
+        run_uv_sync(repo_path)
+    # Generate and display summary
+    _display_summary(results)
+
+
+if __name__ == "__main__":
+    main()

machineconfig/scripts/python/helpers_devops/themes/choose_pwsh_theme.ps1

@@ -0,0 +1,81 @@
+# Requires: fzf, oh-my-posh
+# Purpose: Interactive Oh My Posh theme chooser with live preview
+
+# Path to your Oh My Posh themes directory
+$themesDir = "$env:LOCALAPPDATA\Programs\oh-my-posh\themes"
+
+if (-not (Test-Path $themesDir)) {
+    Write-Host "Themes directory not found at $themesDir" -ForegroundColor Red
+    exit 1
+}
+
+# Get all theme files and extract just the theme names for display
+$themes = Get-ChildItem $themesDir -Filter "*.omp.json" | ForEach-Object {
+    [PSCustomObject]@{
+        Name = $_.BaseName
+        Path = $_.FullName
+    }
+}
+
+# Create a simple preview command that shows theme name and a sample prompt
+$previewCommand = "pwsh -NoProfile -Command `"Write-Host 'Theme: ' -NoNewline -ForegroundColor Cyan; Write-Host (Split-Path '{}' -Leaf); Write-Host ''; oh-my-posh print primary --config '{}' 2>`$null`""
+
+# Run fzf with preview
+$selectedThemeName = $themes | ForEach-Object { $_.Path } |
+    fzf --height 80% --border --ansi --reverse `
+        --header "Select an Oh My Posh theme (Ctrl+C to cancel)" `
+        --preview $previewCommand `
+        --preview-window=right:60%:wrap
+
+# After fzf selection
+if ($selectedThemeName) {
+    Write-Host "`nYou selected:" -ForegroundColor Green
+    Write-Host (Split-Path $selectedThemeName -Leaf) -ForegroundColor Yellow
+    Write-Host "`nApplying theme..." -ForegroundColor Cyan
+    
+    # Apply the theme to current session
+    oh-my-posh init pwsh --config $selectedThemeName | Invoke-Expression
+    
+    Write-Host "`nTheme applied to current session!" -ForegroundColor Green
+    
+    # Safely update the PowerShell profile
+    $profilePath = $PROFILE
+    $ompLine = "oh-my-posh init pwsh --config '$selectedThemeName' | Invoke-Expression"
+    
+    # Create profile directory if it doesn't exist
+    $profileDir = Split-Path $profilePath -Parent
+    if (-not (Test-Path $profileDir)) {
+        New-Item -ItemType Directory -Path $profileDir -Force | Out-Null
+    }
+    
+    # Read existing profile content or create empty array
+    if (Test-Path $profilePath) {
+        $profileContent = Get-Content $profilePath -Raw
+    } else {
+        $profileContent = ""
+    }
+    
+    # Check if oh-my-posh line already exists and replace it
+    if ($profileContent -match "oh-my-posh init pwsh[^\r\n]*") {
+        # Replace existing oh-my-posh line
+        $profileContent = $profileContent -replace "oh-my-posh init pwsh[^\r\n]*", $ompLine
+    } else {
+        # Add the oh-my-posh line with proper newlines
+        if ($profileContent.Length -gt 0 -and -not $profileContent.EndsWith("`n")) {
+            $profileContent += "`n"
+        }
+        if ($profileContent.Length -gt 0) {
+            $profileContent += "`n"
+        }
+        $profileContent += $ompLine
+        $profileContent += "`n"
+    }
+    
+    # Write back to profile
+    $profileContent | Set-Content $profilePath -Encoding UTF8 -NoNewline
+    
+    Write-Host "Profile updated successfully!" -ForegroundColor Green
+    Write-Host "The theme will be applied automatically in future PowerShell sessions." -ForegroundColor Cyan
+} else {
+    Write-Host "`nNo theme selected." -ForegroundColor DarkGray
+}

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

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

machineconfig/scripts/python/{choose_wezterm_theme.py → helpers_devops/themes/choose_wezterm_theme.py}

@@ -52,14 +52,14 @@ def main2():
 
 def set_theme(theme: str):
     print(f"🔄 Setting WezTerm theme to: {theme}")
-    txt_lines = PathExtended("~/.config/wezterm/wezterm.lua").expanduser().read_text(encoding="utf-8").splitlines()
+    txt_lines = PathExtended.home().joinpath(".config/wezterm/wezterm.lua").expanduser().read_text(encoding="utf-8").splitlines()
     res_lines = []
     for line in txt_lines:
         if "config.color_scheme = " in line:
             res_lines.append(f"config.color_scheme = '{theme}'")
         else:
             res_lines.append(line)
-    PathExtended("~/.config/wezterm/wezterm.lua").expanduser().write_text("\n".join(res_lines), encoding="utf-8")
+    PathExtended.home().joinpath(".config/wezterm/wezterm.lua").expanduser().write_text("\n".join(res_lines), encoding="utf-8")
     time.sleep(0.1)
     print("💾 Configuration saved")
 

machineconfig/scripts/python/{helpers/helpers4.py → helpers_fire_command/file_wrangler.py}

@@ -1,38 +1,7 @@
-from typing import Any, Callable, Optional
-import inspect
+from typing import Optional
 import os
-
-from machineconfig.utils.path_extended import PathExtended as PathExtended
-
-
-def search_for_files_of_interest(path_obj: PathExtended):
-    if path_obj.joinpath(".venv").exists():
-        path_objects = path_obj.search("*", not_in=[".venv"])
-        files: list[PathExtended] = []
-        for a_path_obj in path_objects:
-            files += search_for_files_of_interest(path_obj=a_path_obj)
-        return files
-    if path_obj.is_file():
-        return [path_obj]
-    py_files = path_obj.search(pattern="*.py", not_in=["__init__.py"], r=True)
-    ps_files = path_obj.search(pattern="*.ps1", r=True)
-    sh_files = path_obj.search(pattern="*.sh", r=True)
-    files = py_files + ps_files + sh_files
-    return files
-
-
-def convert_kwargs_to_fire_kwargs_str(kwargs: dict[str, Any]) -> str:
-    # https://google.github.io/python-fire/guide/
-    # https://github.com/google/python-fire/blob/master/docs/guide.md#argument-parsing
-    if not kwargs:  # empty dict
-        kwargs_str = ""
-    else:
-        # For fire module, all keyword arguments should be passed as --key value pairs
-        tmp_list: list[str] = []
-        for k, v in kwargs.items():
-            tmp_list.append(f"--{k} {v}")
-        kwargs_str = " " + " ".join(tmp_list) + " "
-    return kwargs_str
+from pathlib import Path
+import platform
 
 
 def parse_pyfile(file_path: str):
@@ -43,7 +12,7 @@ def parse_pyfile(file_path: str):
     func_args: list[list[args_spec]] = [[]]  # this firt prepopulated dict is for the option 'RUN AS MAIN' which has no args
     import ast
 
-    parsed_ast = ast.parse(PathExtended(file_path).read_text(encoding="utf-8"))
+    parsed_ast = ast.parse(Path(file_path).read_text(encoding="utf-8"))
     functions = [node for node in ast.walk(parsed_ast) if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef))]
     module__doc__ = ast.get_docstring(parsed_ast)
     main_option = f"RUN AS MAIN -- {module__doc__ if module__doc__ is not None else 'NoDocs'}"
@@ -84,58 +53,6 @@ def parse_pyfile(file_path: str):
     return options, func_args
 
 
-def interactively_run_function(func: Callable[[Any], Any]):
-    sig = inspect.signature(func)
-    params = list(sig.parameters.values())
-    args = []
-    kwargs = {}
-    for param in params:
-        if param.annotation is not inspect.Parameter.empty:
-            hint = f" ({param.annotation.__name__})"
-        else:
-            hint = ""
-        if param.default is not inspect.Parameter.empty:
-            default = param.default
-            value = input(f"Please enter a value for argument `{param.name}` (type = {hint}) (default = {default}) : ")
-            if value == "":
-                value = default
-        else:
-            value = input(f"Please enter a value for argument `{param.name}` (type = {hint}) : ")
-        try:
-            if param.annotation is not inspect.Parameter.empty:
-                value = param.annotation
-        except (TypeError, ValueError) as err:
-            raise ValueError(f"Invalid input: {value} is not of type {param.annotation}") from err
-        if param.kind == inspect.Parameter.KEYWORD_ONLY:
-            kwargs[param.name] = value
-        else:
-            args.append((param.name, value))
-    args_to_kwargs = dict(args)
-    return args_to_kwargs, kwargs
-
-
-def get_attrs_recursively(obj: Any):
-    if hasattr(obj, "__dict__"):
-        res = {}
-        for k, v in obj.__dict__.items():
-            res[k] = get_attrs_recursively(v)
-        return res
-    return obj
-
-
-# def run_on_remote(func_file: str, args: argparse.Namespace):
-#     host = choose_ssh_host(multi=False)
-#     assert isinstance(host, str), f"host must be a string. Got {type(host)}"
-#     from machineconfig.cluster.remote_machine import RemoteMachine, RemoteMachineConfig
-#     config = RemoteMachineConfig(copy_repo=True, update_repo=False, update_essential_repos=True,
-#                                  notify_upon_completion=True, ssh_params=dict(host=host),
-#                                  # to_email=None, email_config_name='enaut',
-#                                  data=[],
-#                                  ipython=False, interactive=args.interactive, pdb=False, pudb=args.debug, wrap_in_try_except=False,
-#                                  transfer_method="sftp")
-#     m = RemoteMachine(func=func_file, func_kwargs=None, config=config)
-#     m.run()
-
 
 def find_repo_root_path(start_path: str) -> Optional[str]:
     root_files = ["setup.py", "pyproject.toml", ".git"]
@@ -176,3 +93,56 @@ def get_import_module_code(module_path: str):
         module_name = "IncorrectModuleName"
     # TODO: use py_compile to check if the statement is valid code to avoid syntax errors that can't be caught.
     return f"from {module_name} import *"
+
+
+def wrap_import_in_try_except(import_line: str, pyfile: str, repo_root: Optional[str] = None) -> None:
+    try:
+        exec(import_line)  # type: ignore
+    except (ImportError, ModuleNotFoundError) as ex:
+        print(fr"❌ Failed to import `{pyfile}` as a module: {ex} ")
+        print("⚠️ Attempting import with ad-hoc `$PATH` manipulation. DO NOT pickle any objects in this session as correct deserialization cannot be guaranteed.")
+        import sys
+        sys.path.append(str(Path(pyfile).parent))
+        if repo_root is not None:
+            sys.path.append(repo_root)
+        exec(f"from {Path(pyfile).stem} import *")
+        print(fr"✅ Successfully imported `{pyfile}`")
+
+
+def add_to_path(path_variable: str, directory: str) -> str:
+    """
+    Generate shell script to add directory to path_variable.
+    Handles both Windows (cmd) and Unix-like systems (bash/zsh).
+    Checks if variable exists before appending, otherwise creates it.
+    """
+    system = platform.system()
+    
+    if system == "Windows":
+        script = f"""# Check if {path_variable} is defined
+if (Test-Path env:{path_variable}) {{
+    Write-Host "Adding {directory} to existing {path_variable}"
+    $currentValue = [Environment]::GetEnvironmentVariable("{path_variable}", "User")
+    $newValue = "$currentValue;{directory}"
+    [Environment]::SetEnvironmentVariable("{path_variable}", $newValue, "User")
+    $env:{path_variable} = $newValue
+}} else {{
+    Write-Host "Creating new {path_variable} variable"
+    [Environment]::SetEnvironmentVariable("{path_variable}", "{directory}", "User")
+    $env:{path_variable} = "{directory}"
+}}
+Write-Host "{path_variable} is now: $env:{path_variable}\""""
+        return script
+    else:
+        script = f"""#!/bin/bash
+# Check if {path_variable} is defined and not empty
+if [ -z "${{{path_variable}}}" ]; then
+    echo "Creating new {path_variable} variable"
+    export {path_variable}="{directory}"
+else
+    echo "Adding {directory} to existing {path_variable}"
+    export {path_variable}="${{{path_variable}}}:{directory}"
+fi
+echo "{path_variable} is now: ${{{path_variable}}}"
+"""
+        return script
+

machineconfig/scripts/python/helpers_fire_command/fire_jobs_args_helper.py

@@ -0,0 +1,145 @@
+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
+    marimo: 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
+    zellij_tab: Optional[str] = None
+    watch: bool = False
+
+
+def extract_kwargs(args: FireJobArgs) -> dict[str, object]:
+    """Extract kwargs from command line arguments in Fire format.
+    
+    Parses Fire-like arguments (e.g., --a=2, --name=value) from sys.argv
+    and returns them as a dictionary.
+    
+    Returns:
+        Dictionary mapping argument names to their values
+    """
+    import sys
+    
+    kwargs: dict[str, object] = {}
+    
+    # Look for Fire-style arguments in sys.argv
+    for arg in sys.argv:
+        # Skip the -- separator
+        if arg == '--':
+            continue
+            
+        # Match patterns like --key=value or --key value (but we'll focus on --key=value)
+        if arg.startswith('--') and '=' in arg:
+            key, value = arg[2:].split('=', 1)  # Remove -- prefix and split on first =
+            
+            # Try to convert value to appropriate type
+            kwargs[key] = _convert_value_type(value)
+        elif arg.startswith('--') and '=' not in arg:
+            # Handle boolean flags like --debug
+            key = arg[2:]  # Remove -- prefix
+            
+            # Skip empty key (this would happen if someone just used '--')
+            if not key:
+                continue
+                
+            # Check if next argument exists and doesn't start with --
+            arg_index = sys.argv.index(arg)
+            if arg_index + 1 < len(sys.argv) and not sys.argv[arg_index + 1].startswith('--'):
+                # Next argument is the value
+                value = sys.argv[arg_index + 1]
+                kwargs[key] = _convert_value_type(value)
+            else:
+                # It's a boolean flag
+                kwargs[key] = True
+                
+    return kwargs
+
+
+def _convert_value_type(value: str) -> object:
+    """Convert string value to appropriate Python type."""
+    # Try to convert to int
+    try:
+        if '.' not in value and 'e' not in value.lower():
+            return int(value)
+    except ValueError:
+        pass
+    
+    # Try to convert to float
+    try:
+        return float(value)
+    except ValueError:
+        pass
+    
+    # Try to convert boolean strings
+    if value.lower() in ('true', '1', 'yes', 'on'):
+        return True
+    elif value.lower() in ('false', '0', 'no', 'off'):
+        return False
+    
+    # Try to convert None
+    if value.lower() == 'none':
+        return None
+    
+    # Try to parse as list (comma-separated values)
+    if ',' in value:
+        items = [_convert_value_type(item.strip()) for item in value.split(',')]
+        return items
+    
+    # Return as string if no conversion possible
+    return value
+
+
+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 ''