machineconfig 4.8__py3-none-any.whl → 4.91__py3-none-any.whl

machineconfig/jobs/installer/package_groups.py

@@ -0,0 +1,157 @@
+from typing import Literal, TypeAlias, Union
+
+PACKAGES_NAMES_DEV = Literal[
+    "ngrok",
+    "Visual Studio Code",
+    "aider",
+    "github-copilot-cli",
+    "gemini",
+    "crush",
+    "opencode-ai",
+    "warp",
+    "q",
+    "cursor-cli",
+    "droid",
+    "Alacritty",
+    "Brave",
+    "bypass-paywalls-chrome",
+    "Cursor",
+    "espanso",
+    "Gorilla",
+    "lvim",
+    "nerdfont",
+    "Redis",
+    "Wezterm",
+    "winget",
+    "ytui-music",
+    "youtube-tui",
+    "termusic",
+    "kronos",
+    "transmission",
+    "nnn",
+    "exa",
+    "bytehound",
+    "atuin",
+    "browsh",
+    "carbonyl",
+    "patat",
+    "SqliteBrowser",
+    "DBeaver",
+    "rainfrog",
+    "duckdb",
+    "cpz",
+    "rmz",
+    "mermaid-cli",
+    "html2markdown",
+    "xcrawl3r",
+    "obsidian",
+    "marp",
+    "presenterm",
+    "pandoc",
+    "devcontainer",
+    "bitwarden",
+    "OBS Background removal",
+    "rustdesk",
+    "evcxr",
+    "forward-cli",
+    "bandwhich",
+    "ipinfo",
+    "dust",
+    "ots",
+    "ffsend",
+    "portal",
+    "qrcp",
+    "qrscan",
+    "termscp",
+    "qr",
+    "filebrowser",
+    "cloudreve",
+    "restic",
+    "syncthing",
+    "istio",
+    "openpomodoro-cli",
+    "rust-analyzer",
+    "kondo",
+    "tokei",
+    "lazygit",
+    "lazydocker",
+    "onefetch",
+    "gitcs",
+    "just",
+    "navi",
+    "tealdeer",
+    "sniffnet",
+    "hyperfine",
+    "ollama",
+    "cointop",
+    "vtm",
+    "edex-ui",
+    "extraterm",
+    "nushell",
+    "geckodriver",
+    "lolcatjs",
+    "figlet-cli",
+    "sharewifi",
+    "share-wifi",
+]
+
+PACKAGES_NAMES_ESSENTIAL = Literal[
+    "gh",
+    "hx",
+    "speedtest",
+    "pistol",
+    "diskonaut",
+    "xplr",
+    "btop",
+    "gotty",
+    "joshuto",
+    "zellij",
+    "boxes",
+    "ugrep",
+    "zoomit",
+    "ntop",
+    "devtunnel",
+    "bat",
+    "broot",
+    "btm",
+    "chatgpt",
+    "cloudflared",
+    "cpufetch",
+    "delta",
+    "dua",
+    "fastfetch",
+    "fd",
+    "fzf",
+    "gitui",
+    "glow",
+    "gum",
+    "lf",
+    "lsd",
+    "m365",
+    "mcfly",
+    "mods",
+    "mprocs",
+    "ouch",
+    "procs",
+    "rclone",
+    "rg",
+    "rga",
+    "starship",
+    "tere",
+    "topgrade",
+    "ttyd",
+    "viu",
+    "watchexec",
+    "yazi",
+    "zoxide",
+]
+
+PACKAGE_GROUPS: TypeAlias = Literal["ESSENTIAL", "DEV", "ESSENTIAL_SYSTEM", "DEV_SYSTEM"]
+PACKAGE_GROUP2NAMES: dict[PACKAGE_GROUPS, list[str]] = {
+    "ESSENTIAL": list(PACKAGES_NAMES_ESSENTIAL.__args__),
+    "DEV": list(PACKAGES_NAMES_DEV.__args__),
+    "ESSENTIAL_SYSTEM": [],
+    "DEV_SYSTEM": [],
+}
+
+_ = Union

machineconfig/scripts/linux/agents

@@ -0,0 +1,2 @@
+#!/usr/bin/env bash
+uv run --python 3.13 --no-dev --project $HOME/code/machineconfig agents "$@"

machineconfig/scripts/linux/sessions

@@ -0,0 +1,2 @@
+#!/usr/bin/env bash
+uv run --python 3.13 --no-dev --project $HOME/code/machineconfig sessions "$@"

machineconfig/scripts/python/{fire_agents.py → agents.py}

@@ -193,5 +193,12 @@ fire_agents collect $AGENTS_DIR "$REPO_ROOT/.ai/agents/$JOB_NAME/collected.txt"
     typer.echo(f"Template bash script written to {save_path}")
 
 
+def main_from_parser():
+    agents_app = typer.Typer(help="🤖 AI Agents management subcommands")
+    agents_app.command("create")(create)
+    agents_app.command("collect")(collect)
+    agents_app.command("template")(template)
+    return agents_app()
+
 if __name__ == "__main__":  # pragma: no cover
     pass

machineconfig/scripts/python/croshell.py

@@ -10,10 +10,10 @@ from machineconfig.utils.path_extended import PathExtended as PathExtended
 from machineconfig.utils.accessories import randstr
 
 from machineconfig.utils.options import choose_from_options
-from machineconfig.utils.ve import get_ve_activate_line
+# from machineconfig.utils.ve import get_ve_activate_line
 from rich.console import Console
 from rich.panel import Panel
-from rich.text import Text
+# from rich.text import Text
 
 console = Console()
 
@@ -173,41 +173,27 @@ print(f"🐊 Crocodile Shell | Running @ {Path.cwd()}")
         title = "Running Python File"
     else:
         title = "Executed code"
-    total_program = preprogram + add_print_header_pycode(str(pyfile), title=title) + program
-
-    pyfile.write_text(total_program, encoding="utf-8")
-
+    python_program = preprogram + add_print_header_pycode(str(pyfile), title=title) + program
+    pyfile.write_text(python_program, encoding="utf-8")
     # ve_root_from_file, ipython_profile = get_ve_path_and_ipython_profile(PathExtended(file))
     ipython_profile = ipython_profile if ipython_profile is not None else "default"
     # ve_activateion_line = get_ve_activate_line(ve_name=args.ve or ve_profile_suggested, a_path=str(PathExtended.cwd()))
-    activate_ve_line = get_ve_activate_line(ve_root="$HOME/code/machineconfig/.venv")
-    final_program = f"""
+    shell_program = """
 #!/bin/bash
 
-{activate_ve_line}
-
 """
     if jupyter:
         fire_line = f"code --new-window {str(pyfile)}"
     else:
-        fire_line = interpreter
-        if interpreter == "ipython":
-            fire_line += f" {interactivity} --profile {ipython_profile} --no-banner"
-        fire_line += f" {str(pyfile)}"
-
-    final_program += fire_line
-
-    title = "🚀 LAUNCHING SCRIPT"
-    text1 = f"📄 Script: {pyfile}"
-    text2 = f"🔥 Command: {fire_line}"
-    launch_message = f"{title}   \n{text1}\n{text2}"
-    console.print(Panel(Text(launch_message, justify="left"), expand=False, border_style="blue"))
-
-    # PROGRAM_PATH.write_text(data=final_program, encoding="utf-8")
-    # (PROGRAM_PATH + ".py").write_text(str(pyfile), encoding='utf-8')
+        fire_line = f"uv run --project $HOME/code/machineconfig/.venv {interpreter} {interactivity} "
+        if interpreter == "ipython": fire_line += f" --profile {ipython_profile} --no-banner"
+        fire_line += " " + str(pyfile)
+    shell_program += fire_line
+    from rich.syntax import Syntax
+    console.print(Syntax(shell_program, lexer="bash"))
+    print()
     import subprocess
-
-    subprocess.run(final_program, shell=True, check=True)
+    subprocess.run(shell_program, shell=True, check=True)
 
 
 def arg_parser() -> None:

machineconfig/scripts/python/devops.py

@@ -1,7 +1,5 @@
 """devops with emojis"""
 
-import machineconfig.scripts.python.fire_agents as fire_agents
-import machineconfig.scripts.python.fire_jobs_layout_helper as fire_jobs_layout_helper
 import machineconfig.scripts.python.devops_devapps_install as installer_entry_point
 import machineconfig.scripts.python.share_terminal as share_terminal
 import machineconfig.scripts.python.repos as repos
@@ -10,17 +8,6 @@ import typer
 
 app = typer.Typer(help="🛠️ DevOps operations with emojis", no_args_is_help=True)
 
-
-agents_app = typer.Typer(help="🤖 AI Agents management subcommands")
-agents_app.command("create")(fire_agents.create)
-agents_app.command("collect")(fire_agents.collect)
-app.add_typer(agents_app, name="agents")
-
-layouts_app = typer.Typer(help="Layouts management subcommands")
-layouts_app.command("launch")(fire_jobs_layout_helper.launch)
-layouts_app.command("load-balance")(fire_jobs_layout_helper.load_balance)
-app.add_typer(layouts_app, name="session")
-
 app.command(name="install", help="📦 Install essential packages")(installer_entry_point.main)
 app.command(name="share-terminal", help="📡 Share terminal via web browser")(share_terminal.main)
 app.command(name="repos", help="📁 Manage git repositories")(repos.main)

machineconfig/scripts/python/devops_devapps_install.py

@@ -1,85 +1,79 @@
 """Devops Devapps Install"""
 
+from machineconfig.utils.installer import get_installers_system_groups
 import typer
 from rich.progress import Progress, SpinnerColumn, TextColumn
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
 from platform import system
-from typing import Optional, Literal, TypeAlias, cast, get_args, Annotated
+from typing import Optional, cast, get_args
+from machineconfig.jobs.installer.package_groups import PACKAGE_GROUPS
 
-WHICH_CAT: TypeAlias = Literal["essentials", "essentialsDev", "systymPackages", "precheckedPackages", "ia"]
+console = Console()
 
 
 def _handle_installer_not_found(search_term: str, all_installers: list["InstallerData"]) -> None:  # type: ignore
     """Handle installer not found with friendly suggestions using fuzzy matching."""
     from difflib import get_close_matches
-    
-    # Get all possible names (both exe names and app names)
+
     all_names = []
     for inst in all_installers:
         exe_name = inst["appName"]
         all_names.append(exe_name)
-    
-    # Find close matches using fuzzy matching
     close_matches = get_close_matches(search_term, all_names, n=5, cutoff=0.4)
-    
-    print(f"\n❌ '{search_term}' was not found.")
-    
+    console.print(f"\n❌ '[red]{search_term}[/red]' was not found.", style="bold")
+
     if close_matches:
-        print("🤔 Did you mean one of these?")
+        console.print("🤔 Did you mean one of these?", style="yellow")
+        table = Table(show_header=False, box=None, pad_edge=False)
         for i, match in enumerate(close_matches, 1):
-            print(f"   {i}. {match}")
+            table.add_row(f"[cyan]{i}.[/cyan]", f"[green]{match}[/green]")
+        console.print(table)
     else:
-        print("📋 Here are some available options:")
+        console.print("📋 Here are some available options:", style="blue")
         # Show first 10 installers as examples
         sample_names = []
         for inst in all_installers[:10]:
             exe_name = inst["appName"]
-            sample_names.append(exe_name)        
+            sample_names.append(exe_name)
+
+        table = Table(show_header=False, box=None, pad_edge=False)
         for i, name in enumerate(sample_names, 1):
-            print(f"   {i}. {name}")
-        
+            table.add_row(f"[cyan]{i}.[/cyan]", f"[green]{name}[/green]")
+        console.print(table)
+
         if len(all_installers) > 10:
-            print(f"   ... and {len(all_installers) - 10} more")
-    
-    print("\n💡 Use 'ia' to interactively browse all available installers.")
-    print(f"💡 Use one of the categories: {list(get_args(WHICH_CAT))}")
+            console.print(f"   [dim]... and {len(all_installers) - 10} more[/dim]")
+
+    panel = Panel(
+        f"[bold blue]💡 Use 'ia' to interactively browse all available installers.[/bold blue]\n[bold blue]💡 Use one of the categories: {list(get_args(PACKAGE_GROUPS))}[/bold blue]", title="[yellow]Helpful Tips[/yellow]", border_style="yellow"
+    )
+    console.print(panel)
 
 
 def main_with_parser():
     import typer
+
     app = typer.Typer()
     app.command()(main)
     app()
 
 
-def main(which: Annotated[Optional[str], typer.Argument(help=f"Choose a category or program to install, {list(get_args(WHICH_CAT))} or <program_name> or list of programs names separated by comma.")]) -> None:
-    if which in get_args(WHICH_CAT):  # install by category
-        return get_programs_by_category(program_name=which)  # type: ignore
-    from machineconfig.utils.schemas.installer.installer_types import get_normalized_arch, get_os_name
-    from machineconfig.utils.installer import get_installers
-    from machineconfig.utils.installer_utils.installer_class import Installer
-    if which != "ia" and which is not None:  # install by name
-        total_messages: list[str] = []
-        for a_which in which.split(",") if type(which) == str else which:
-            all_installers = get_installers(os=get_os_name(), arch=get_normalized_arch(), which_cats=["GITHUB_ESSENTIAL", "CUSTOM_ESSENTIAL", "GITHUB_DEV", "CUSTOM_DEV"])
-
-            # Find installer by exe_name or name
-            selected_installer = None
-            for installer in all_installers:
-                exe_name = installer["appName"]
-                app_name = installer["appName"]
-                if exe_name == a_which or app_name == a_which:
-                    selected_installer = installer
-                    break
-
-            if selected_installer is None:
-                _handle_installer_not_found(a_which, all_installers)
-                return None
-            message = Installer(selected_installer).install_robust(version=None)  # finish the task
-            total_messages.append(message)
-        for a_message in total_messages:
-            print(a_message)
-        return None
-
+def main(
+    which: Optional[str] = typer.Option(None, "--which", "-w", help="Comma-separated list of program names to install."),
+    group: Optional[PACKAGE_GROUPS] = typer.Option(None, "--group", "-g", help=f"Group name (one of {list(get_args(PACKAGE_GROUPS))})"),
+    interactive: bool = typer.Option(False, "--interactive", "-ia", help="Interactive selection of programs to install."),
+) -> None:
+    if which is not None:
+        return install_clis(clis_names=[x.strip() for x in which.split(",") if x.strip() != ""])
+    if group is not None:
+        return get_programs_by_category(package_group=group)
+    if interactive:
+        return install_interactively()
+    typer.echo("❌ You must provide either --which, --group, or --interactive/-ia option.")
+    # typer.help(main)
+    raise typer.Exit(1)
 
 
 def install_interactively():
@@ -87,84 +81,131 @@ def install_interactively():
     from machineconfig.utils.schemas.installer.installer_types import get_normalized_arch, get_os_name
     from machineconfig.utils.installer import get_installers
     from machineconfig.utils.installer_utils.installer_class import Installer
-    installers = get_installers(os=get_os_name(), arch=get_normalized_arch(), which_cats=["GITHUB_ESSENTIAL", "CUSTOM_ESSENTIAL", "GITHUB_DEV", "CUSTOM_DEV"])
-    with Progress(SpinnerColumn(), TextColumn("[progress.description]{task.description}")) as progress:
-        task = progress.add_task("✅ Checking installed programs...", total=len(installers))
-        installer_options = []
-        for x in installers:
-            installer_options.append(Installer(installer_data=x).get_description())
-            progress.update(task, advance=1)
-    category_options = [f"📦 {cat}" for cat in get_args(WHICH_CAT)]
-    options = category_options + ["─" * 50] + installer_options    
+    installers = get_installers(os=get_os_name(), arch=get_normalized_arch(), which_cats=["ESSENTIAL", "DEV"])
+    installer_options = []
+    for x in installers:
+        installer_options.append(Installer(installer_data=x).get_description())
+    category_options = [f"📦 {cat}" for cat in get_args(PACKAGE_GROUPS)]
+    options = category_options + ["─" * 50] + installer_options
     program_names = choose_from_options(multi=True, msg="Categories are prefixed with 📦", options=options, header="🚀 CHOOSE DEV APP OR CATEGORY", default="📦 essentials", fzf=True)
     installation_messages: list[str] = []
     for _an_idx, a_program_name in enumerate(program_names):
-        if a_program_name.startswith("─"):
+        if a_program_name.startswith("─"):  # 50 dashes separator
             continue
         if a_program_name.startswith("📦 "):
             category_name = a_program_name[2:]  # Remove "📦 " prefix
-            if category_name in get_args(WHICH_CAT):
-                get_programs_by_category(program_name=cast(WHICH_CAT, category_name))
+            if category_name in get_args(PACKAGE_GROUPS):
+                get_programs_by_category(package_group=cast(PACKAGE_GROUPS, category_name))
         else:
             installer_idx = installer_options.index(a_program_name)
             an_installer_data = installers[installer_idx]
             status_message = Installer(an_installer_data).install_robust(version=None)  # finish the task - this returns a status message, not a command
             installation_messages.append(status_message)
-    print("\n📊 INSTALLATION SUMMARY:")
-    print("=" * 50)
-    for message in installation_messages:
-        print(message)
-
-
-def get_programs_by_category(program_name: WHICH_CAT):
-    print(f"""
-┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-┃ 📦 Installing Category: {program_name}
-┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━""")
-    from machineconfig.utils.source_of_truth import LIBRARY_ROOT
+    if installation_messages:
+        panel = Panel("\n".join([f"[blue]• {message}[/blue]" for message in installation_messages]), title="[bold green]📊 Installation Summary[/bold green]", border_style="green", padding=(1, 2))
+        console.print(panel)
+
+
+def get_programs_by_category(package_group: PACKAGE_GROUPS):
+    panel = Panel(f"[bold yellow]Installing programs from category: [green]{package_group}[/green][/bold yellow]", title="[bold blue]📦 Category Installation[/bold blue]", border_style="blue", padding=(1, 2))
+    console.print(panel)
     from machineconfig.utils.installer import get_installers, install_all
-    from machineconfig.utils.installer_utils.installer_abc import parse_apps_installer_linux, parse_apps_installer_windows
     from machineconfig.utils.schemas.installer.installer_types import get_normalized_arch, get_os_name
-    from machineconfig.utils.options import choose_from_options
-    match program_name:
-        case "essentials":
-            installers_ = get_installers(os=get_os_name(), arch=get_normalized_arch(), which_cats=["GITHUB_ESSENTIAL", "CUSTOM_ESSENTIAL"])
+    match package_group:
+        case "ESSENTIAL":
+            installers_ = get_installers(os=get_os_name(), arch=get_normalized_arch(), which_cats=["ESSENTIAL"])
             install_all(installers_data=installers_)
-        case "essentialsDev":
-            installers_ = get_installers(os=get_os_name(), arch=get_normalized_arch(), which_cats=["GITHUB_DEV", "CUSTOM_DEV", "GITHUB_ESSENTIAL", "CUSTOM_ESSENTIAL"])
+        case "DEV":
+            installers_ = get_installers(os=get_os_name(), arch=get_normalized_arch(), which_cats=["DEV", "ESSENTIAL"])
             install_all(installers_data=installers_)
-        case "systymPackages":
-            if system() == "Windows":
-                options_system = parse_apps_installer_windows(LIBRARY_ROOT.joinpath("setup_windows/apps.ps1").read_text(encoding="utf-8"))
-            elif system() == "Linux":
-                options_system_1 = parse_apps_installer_linux(LIBRARY_ROOT.joinpath("setup_linux/apps_dev.sh").read_text(encoding="utf-8"))
-                options_system_2 = parse_apps_installer_linux(LIBRARY_ROOT.joinpath("setup_linux/apps.sh").read_text(encoding="utf-8"))
-                options_system = {**options_system_1, **options_system_2}
-            else:
-                raise NotImplementedError(f"❌ System {system()} not supported")
-            program_names = choose_from_options(multi=True, msg="", options=sorted(list(options_system.keys())), header="🚀 CHOOSE DEV APP", fzf=True)
-            program = ""
-            for name in program_names:
-                print(f"""
-┌────────────────────────────────────────────────────
-│ ⚙️  Installing: {name}
-└────────────────────────────────────────────────────""")
-                sub_program = options_system[name]
-                if sub_program.startswith("#winget"):
-                    sub_program = sub_program[1:]
-                program += "\n" + sub_program
-        case "ia":
-            install_interactively()
-        case "precheckedPackages":
-            # from machineconfig.jobs.python.check_installations import precheckedPackages
-            # ci = precheckedPackages()
-            # ci.download_safe_apps(name="essentials")
-            # program = ""
-            raise NotImplementedError("precheckedPackages is not implemented yet.")
+        case "DEV_SYSTEM" | "ESSENTIAL_SYSTEM":
+            options_system = get_installers_system_groups()
+            from machineconfig.utils.schemas.installer.installer_types import get_normalized_arch, get_os_name
+            for an_item in options_system:
+                if an_item["appName"] == package_group:
+                    program = an_item["fileNamePattern"][get_normalized_arch()][get_os_name()]
+                    if program is not None:
+                        install_terminal_packages(program)
+
+
+def choose_from_system_package_groups(options_system: dict[str, tuple[str, str]]) -> str:
+    from machineconfig.utils.options import choose_from_options
+    display_options = []
+    for group_name, (description, _) in options_system.items():
+        if description:
+            display_options.append(f"{group_name:<20} - {description}")
+        else:
+            display_options.append(group_name)
+    program_names = choose_from_options(multi=True, msg="", options=sorted(display_options), header="🚀 CHOOSE DEV APP", fzf=True)
+    program = ""
+    for display_name in program_names:
+        # Extract the actual group name (everything before " - " if present)
+        group_name = display_name.split(" - ")[0].strip() if " - " in display_name else display_name.strip()
+        console.print(f"\n[bold cyan]⚙️  Installing: [yellow]{group_name}[/yellow][/bold cyan]", style="bold")
+        _, sub_program = options_system[group_name]  # Extract content from tuple
+        if sub_program.startswith("#winget"):
+            sub_program = sub_program[1:]
+        program += "\n" + sub_program
+    return program
+
+
+def install_terminal_packages(program: str):
+    from pathlib import Path
+
+    if system() == "Windows":
+        temp_script_path = Path("C:/Windows/Temp/temp_install_script.ps1")
+        lexer = "powershell"
+    else:
+        temp_script_path = Path("/tmp/temp_install_script.sh")
+        lexer = "bash"
+    temp_script_path.write_text(program, encoding="utf-8")
+    console.print(f"📝 [blue]Temporary script written to:[/blue] [green]{temp_script_path}[/green]")
+    from rich.syntax import Syntax
+
+    console.print(Panel(Syntax(code=program, lexer=lexer), title="📄 Installation Program", subtitle="shell code"), style="bold red")
+    console.print("🚀 [bold yellow]Starting installation...[/bold yellow]")
+    if system() == "Windows":
+        import subprocess
+
+        subprocess.run(["powershell", "-ExecutionPolicy", "Bypass", "-File", str(temp_script_path)], check=True)
+    elif system() == "Linux":
+        import subprocess
+
+        subprocess.run(["bash", str(temp_script_path)], check=True)
+    console.print("✅ [bold green]Installation completed.[/bold green]")
+    temp_script_path.unlink(missing_ok=True)
+
+
+def install_clis(clis_names: list[str]):
+    from machineconfig.utils.schemas.installer.installer_types import get_normalized_arch, get_os_name
+    from machineconfig.utils.installer import get_installers
+    from machineconfig.utils.installer_utils.installer_class import Installer
+
+    total_messages: list[str] = []
+    for a_which in clis_names:
+        all_installers = get_installers(os=get_os_name(), arch=get_normalized_arch(), which_cats=["ESSENTIAL", "DEV"])
+        selected_installer = None
+        for installer in all_installers:
+            exe_name = installer["appName"]
+            app_name = installer["appName"]
+            if exe_name == a_which or app_name == a_which:
+                selected_installer = installer
+                break
+        if selected_installer is None:
+            _handle_installer_not_found(a_which, all_installers)
+            return None
+        message = Installer(selected_installer).install_robust(version=None)  # finish the task
+        total_messages.append(message)
+    if total_messages:
+        console.print("\n[bold green]📊 Installation Results:[/bold green]")
+        for a_message in total_messages:
+            console.print(f"[blue]• {a_message}[/blue]")
+    return None
 
 
 if __name__ == "__main__":
     from machineconfig.utils.schemas.installer.installer_types import InstallerData
     from machineconfig.utils.installer_utils.installer_class import Installer
+
     _ = InstallerData, Installer
     pass