machineconfig 3.92__py3-none-any.whl → 3.94__py3-none-any.whl

machineconfig/jobs/linux/msc/cli_agents.sh

@@ -2,10 +2,14 @@
 
 
 # Terminal-based CLI agents and tools for productivity and coding.
+npm install -g @github/copilot
 npm install -g @google/gemini-cli
 npm install -g @charmland/crush
 npm install -g opencode-ai@latest  # or curl -fsSL https://opencode.ai/install | bash
 uv tool install --force --python python3.12 --with pip aider-chat@latest
+curl -fsSL https://app.factory.ai/cli | sh
+# WARP TERMINAL CLI
+# droid
 
 
 # cursor-cli
@@ -29,4 +33,5 @@ rm -rfd q
 # Editors based on AI
 # Kiro
 # Cursor
+# Warp
 

machineconfig/scripts/python/ai/solutions/gemini/settings.json

@@ -69,7 +69,7 @@
   "customThemes": {
     "MyCustomTheme": {
       "name": "MyCustomTheme",
-      "type": "custom",
+      "type": "CMD",
       "Background": "#181818",
       "Foreground": "#F8F8F2",
       "AccentBlue": "#61AFEF",

machineconfig/scripts/python/devops_devapps_install.py

@@ -6,10 +6,11 @@ from rich.progress import Progress, SpinnerColumn, TextColumn
 from machineconfig.utils.source_of_truth import LIBRARY_ROOT
 from machineconfig.utils.options import choose_from_options
 from machineconfig.utils.installer import get_installers, install_all
+from machineconfig.utils.schemas.installer.installer_types import get_normalized_arch, get_os_name
 from platform import system
 from typing import Any, Optional, Literal, TypeAlias, get_args, Annotated
 
-WHICH_CAT: TypeAlias = Literal["essentials", "essentialsPlus", "systymPackages", "precheckedPackages"]
+WHICH_CAT: TypeAlias = Literal["essentials", "essentialsDev", "systymPackages", "precheckedPackages"]
 
 
 def main_with_parser():
@@ -26,8 +27,7 @@ def main(which: Annotated[Optional[str], typer.Argument(help=f"Choose a category
     if which is not None:  # install by name
         total_messages: list[str] = []
         for a_which in which.split(",") if type(which) == str else which:
-            # Use get_installers to get properly converted installer objects
-            all_installers = get_installers(system=system(), dev=False) + get_installers(system=system(), dev=True)
+            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
@@ -53,33 +53,43 @@ def main(which: Annotated[Optional[str], typer.Argument(help=f"Choose a category
             print(a_message)
         return None
 
-    # interactive installation - get all installers including dev ones
-    installers = get_installers(system=system(), dev=True)
-
+    installers = get_installers(os=get_os_name(), arch=get_normalized_arch(), which_cats=["GITHUB_ESSENTIAL", "CUSTOM_ESSENTIAL", "GITHUB_DEV", "CUSTOM_DEV"])
     # Check installed programs with progress indicator
     with Progress(SpinnerColumn(), TextColumn("[progress.description]{task.description}")) as progress:
         task = progress.add_task("✅ Checking installed programs...", total=len(installers))
-        options = []
+        installer_options = []
         for x in installers:
-            options.append(x.get_description())
+            installer_options.append(x.get_description())
             progress.update(task, advance=1)
 
-    options += list(get_args(WHICH_CAT))
-    # print("s"*1000)
-    program_names = choose_from_options(multi=True, msg="", options=options, header="🚀 CHOOSE DEV APP", default="essentials", fzf=True)
+    # Add category options at the beginning for better visibility
+    category_options = [f"📦 {cat}" for cat in get_args(WHICH_CAT)]
+    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)
 
     total_commands = ""
     installation_messages: list[str] = []
     for _an_idx, a_program_name in enumerate(program_names):
+        # Skip separator lines
+        if a_program_name.startswith("─"):
+            continue
+            
         print(f"""
 ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 ┃ 🔄 Processing: {a_program_name}
 ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━""")
-        if a_program_name in get_args(WHICH_CAT):
-            shell_commands = get_programs_by_category(program_name=a_program_name)  # type: ignore
-            total_commands += "\n" + shell_commands
+        
+        # Handle category options (remove emoji prefix)
+        if a_program_name.startswith("📦 "):
+            category_name = a_program_name[2:]  # Remove "📦 " prefix
+            if category_name in get_args(WHICH_CAT):
+                shell_commands = get_programs_by_category(program_name=category_name)  # type: ignore
+                total_commands += "\n" + shell_commands
         else:
-            an_installer = installers[options.index(a_program_name)]
+            # Handle individual installer options
+            installer_idx = installer_options.index(a_program_name)
+            an_installer = installers[installer_idx]
             status_message = an_installer.install_robust(version=None)  # finish the task - this returns a status message, not a command
             installation_messages.append(status_message)
 
@@ -103,13 +113,14 @@ def get_programs_by_category(program_name: WHICH_CAT):
 ┃ 📦 Installing Category: {program_name}
 ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━""")
     match program_name:
-        case "essentials" | "essentialsPlus":
-            installers_ = get_installers(dev=False, system=system())
-            if program_name == "essentialsPlus":
-                installers_ += get_installers(dev=True, system=system())
+        case "essentials":
+            installers_ = get_installers(os=get_os_name(), arch=get_normalized_arch(), which_cats=["GITHUB_ESSENTIAL", "CUSTOM_ESSENTIAL"])
+            install_all(installers=installers_)
+            program = ""
+        case "essentialsDev":
+            installers_ = get_installers(os=get_os_name(), arch=get_normalized_arch(), which_cats=["GITHUB_DEV", "CUSTOM_DEV", "GITHUB_ESSENTIAL", "CUSTOM_ESSENTIAL"])
             install_all(installers=installers_)
             program = ""
-
         case "systymPackages":
             if system() == "Windows":
                 options_system = parse_apps_installer_windows(LIBRARY_ROOT.joinpath("setup_windows/apps.ps1").read_text(encoding="utf-8"))

machineconfig/utils/installer.py

@@ -2,7 +2,7 @@
 
 from machineconfig.utils.installer_utils.installer_abc import LINUX_INSTALL_PATH
 from machineconfig.utils.installer_utils.installer_class import Installer
-from machineconfig.utils.schemas.installer.installer_types import APP_INSTALLER_CATEGORY, InstallerData, InstallerDataFiles
+from machineconfig.utils.schemas.installer.installer_types import APP_INSTALLER_CATEGORY, InstallerData, InstallerDataFiles, get_normalized_arch, get_os_name, OPERATING_SYSTEMS, CPU_ARCHITECTURES
 from rich.console import Console
 from rich.panel import Panel  # Added import
 
@@ -18,8 +18,7 @@ from joblib import Parallel, delayed
 def check_latest():
     console = Console()  # Added console initialization
     console.print(Panel("🔍  CHECKING FOR LATEST VERSIONS", title="Status", expand=False))  # Replaced print with Panel
-    installers = get_installers(system=platform.system(), dev=False)
-    # installers += get_installers(system=platform.system(), dev=True)
+    installers = get_installers(os=get_os_name(), arch=get_normalized_arch(), which_cats=["GITHUB_ESSENTIAL", "CUSTOM_ESSENTIAL"])
     installers_github = []
     for inst__ in installers:
         app_name = inst__.installer_data.get("appName", "unknown")
@@ -92,92 +91,30 @@ def get_installed_cli_apps():
     return apps
 
 
-def get_installers(system: str, dev: bool) -> list[Installer]:
+def get_installers(os: OPERATING_SYSTEMS, arch: CPU_ARCHITECTURES, which_cats: list[APP_INSTALLER_CATEGORY]) -> list[Installer]:
     print(f"\n{'=' * 80}\n🔍 LOADING INSTALLER CONFIGURATIONS 🔍\n{'=' * 80}")
-    res_all = get_all_installer_data_files(system=system)
-    if not dev:
-        print("ℹ️  Excluding development installers...")
-        del res_all["CUSTOM_DEV"]
-        del res_all["OS_SPECIFIC_DEV"]
-        del res_all["OS_GENERIC_DEV"]
-
-    # Flatten the installer data from all categories
+    res_all = get_all_installer_data_files(which_cats=which_cats)
     all_installers: list[InstallerData] = []
     for _category, installer_data_files in res_all.items():
-        all_installers.extend(installer_data_files["installers"])
-
+        suitable_installers = []
+        for an_installer in installer_data_files["installers"]:
+            if an_installer["fileNamePattern"][arch][os] is None:
+                continue
+            suitable_installers.append(an_installer)
+        all_installers.extend(suitable_installers)
     print(f"✅ Loaded {len(all_installers)} installer configurations\n{'=' * 80}")
     return [Installer(installer_data=installer_data) for installer_data in all_installers]
 
 
-def get_all_installer_data_files(system: str) -> dict[APP_INSTALLER_CATEGORY, InstallerDataFiles]:
+def get_all_installer_data_files(which_cats: list[APP_INSTALLER_CATEGORY]) -> dict[APP_INSTALLER_CATEGORY, InstallerDataFiles]:
     print(f"\n{'=' * 80}\n📂 LOADING CONFIGURATION FILES 📂\n{'=' * 80}")
-
-    print(f"🔍 Importing OS-specific installers for {system}...")
-    if system == "Windows":
-        import machineconfig.jobs.python_windows_installers as os_specific_installer
-    else:
-        import machineconfig.jobs.python_linux_installers as os_specific_installer
-
-    print("🔍 Importing generic installers...")
-    import machineconfig.jobs.python_generic_installers as generic_installer
-
-    path_os_specific = PathExtended(os_specific_installer.__file__).parent
-    path_os_generic = PathExtended(generic_installer.__file__).parent
-
-    path_os_specific_dev = path_os_specific.joinpath("dev")
-    path_os_generic_dev = path_os_generic.joinpath("dev")
-
+    import machineconfig.jobs.installer as module
+    from pathlib import Path
     print("📂 Loading configuration files...")
-    res_final: dict[APP_INSTALLER_CATEGORY, InstallerDataFiles] = {}
-
-    print(f"""📄 Loading OS-specific config from: {path_os_specific.joinpath("config.json")}""")
-    os_specific_data = read_json(path=path_os_specific.joinpath("config.json"))
-    res_final["OS_SPECIFIC"] = InstallerDataFiles(os_specific_data)
-
-    print(f"""📄 Loading OS-generic config from: {path_os_generic.joinpath("config.json")}""")
-    os_generic_data = read_json(path=path_os_generic.joinpath("config.json"))
-    res_final["OS_GENERIC"] = InstallerDataFiles(os_generic_data)
-
-    print(f"""📄 Loading OS-specific dev config from: {path_os_specific_dev.joinpath("config.json")}""")
-    os_specific_dev_data = read_json(path=path_os_specific_dev.joinpath("config.json"))
-    res_final["OS_SPECIFIC_DEV"] = InstallerDataFiles(os_specific_dev_data)
-
-    print(f"""📄 Loading OS-generic dev config from: {path_os_generic_dev.joinpath("config.json")}""")
-    os_generic_dev_data = read_json(path=path_os_generic_dev.joinpath("config.json"))
-    res_final["OS_GENERIC_DEV"] = InstallerDataFiles(os_generic_dev_data)
-
-    path_custom_installer = path_os_generic.with_name("python_custom_installers")
-    path_custom_installer_dev = path_custom_installer.joinpath("dev")
-
-    print(f"🔍 Loading custom installers from: {path_custom_installer}")
-    import runpy
-
-    res_custom_installers: list[InstallerData] = []
-    for item in path_custom_installer.search("*.py", r=False, not_in=["__init__"]):
-        try:
-            print(f"📄 Loading custom installer: {item.name}")
-            installer_data: InstallerData = runpy.run_path(str(item), run_name=None)["config_dict"]
-            res_custom_installers.append(installer_data)
-        except Exception as ex:
-            print(f"❌ Failed to load {item}: {ex}")
-
-    print(f"🔍 Loading custom dev installers from: {path_custom_installer_dev}")
-    res_custom_dev_installers: list[InstallerData] = []
-    for item in path_custom_installer_dev.search("*.py", r=False, not_in=["__init__"]):
-        try:
-            print(f"📄 Loading custom dev installer: {item.name}")
-            installer_data: InstallerData = runpy.run_path(str(item), run_name=None)["config_dict"]
-            res_custom_dev_installers.append(installer_data)
-        except Exception as ex:
-            print(f"❌ Failed to load {item}: {ex}")
-
-    res_final["CUSTOM"] = InstallerDataFiles({"version": "1", "installers": res_custom_installers})
-    res_final["CUSTOM_DEV"] = InstallerDataFiles({"version": "1", "installers": res_custom_dev_installers})
-
-    print(
-        f"✅ Configuration loading complete:\n - OS_SPECIFIC: {len(res_final['OS_SPECIFIC']['installers'])} items\n - OS_GENERIC: {len(res_final['OS_GENERIC']['installers'])} items\n - CUSTOM: {len(res_final['CUSTOM']['installers'])} items\n{'=' * 80}"
-    )
+    res_final: dict[APP_INSTALLER_CATEGORY, InstallerDataFiles] = {key: read_json(Path(module.__file__).parent.joinpath(f"packages_{key.lower()}.json")) for key in which_cats}
+    print(f"Loaded: {len(res_final)} installer categories")
+    for k, v in res_final.items():
+        print(f" - {k}: {len(v['installers'])} items")
     return res_final
 
 

machineconfig/utils/installer_utils/github_release_bulk.py

@@ -0,0 +1,198 @@
+#!/usr/bin/env python3
+"""
+Script to fetch GitHub release information from installer JSON files.
+Extracts GitHub repository URLs and fetches latest release data with rate limiting.
+"""
+
+import json
+import time
+import subprocess
+from pathlib import Path
+from typing import Any, Dict, Optional, Set
+from urllib.parse import urlparse
+
+
+def is_github_repo(url: str) -> bool:
+    """Check if URL is a GitHub repository URL."""
+    try:
+        parsed = urlparse(url)
+        return parsed.netloc == "github.com" and len(parsed.path.split("/")) >= 3
+    except Exception:
+        return False
+
+
+def extract_github_repos_from_json(json_file_path: Path) -> Set[str]:
+    """Extract GitHub repository URLs from installer JSON file."""
+    github_repos: Set[str] = set()
+    
+    try:
+        with open(json_file_path, 'r', encoding='utf-8') as file:
+            data = json.load(file)
+            
+        for installer in data.get("installers", []):
+            repo_url = installer.get("repoURL", "")
+            if is_github_repo(repo_url):
+                github_repos.add(repo_url)
+                
+    except (json.JSONDecodeError, FileNotFoundError) as e:
+        print(f"Error reading {json_file_path}: {e}")
+        
+    return github_repos
+
+
+def get_repo_name_from_url(repo_url: str) -> str:
+    """Extract owner/repo from GitHub URL."""
+    try:
+        parsed = urlparse(repo_url)
+        path_parts = parsed.path.strip("/").split("/")
+        return f"{path_parts[0]}/{path_parts[1]}"
+    except (IndexError, AttributeError):
+        return ""
+
+
+def fetch_github_release_data(repo_name: str) -> Optional[Dict[str, Any]]:
+    """Fetch latest release data from GitHub API using curl."""
+    try:
+        cmd = [
+            "curl", "-s",
+            f"https://api.github.com/repos/{repo_name}/releases/latest"
+        ]
+        
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            timeout=30
+        )
+        
+        if result.returncode != 0:
+            print(f"❌ Failed to fetch data for {repo_name}: {result.stderr}")
+            return None
+            
+        response_data = json.loads(result.stdout)
+        
+        # Check if API returned an error
+        if "message" in response_data:
+            if "API rate limit exceeded" in response_data.get("message", ""):
+                print(f"🚫 Rate limit exceeded for {repo_name}")
+                return None
+            elif "Not Found" in response_data.get("message", ""):
+                print(f"🔍 No releases found for {repo_name}")
+                return None
+                
+        return response_data
+        
+    except (subprocess.TimeoutExpired, json.JSONDecodeError, subprocess.SubprocessError) as e:
+        print(f"❌ Error fetching {repo_name}: {e}")
+        return None
+
+
+def extract_release_info(release_data: Dict[str, Any]) -> Dict[str, Any]:
+    """Extract relevant information from GitHub release data."""
+    if not release_data:
+        return {}
+        
+    asset_names = [asset["name"] for asset in release_data.get("assets", [])]
+    
+    return {
+        "tag_name": release_data.get("tag_name", ""),
+        "name": release_data.get("name", ""),
+        "published_at": release_data.get("published_at", ""),
+        "assets": asset_names,
+        "assets_count": len(asset_names)
+    }
+
+
+def main() -> None:
+    """Main function to process installer JSON files and fetch GitHub release data."""
+    # Define paths
+    current_dir = Path(__file__).parent
+    installer_dir = current_dir.parent.parent / "jobs" / "installer"
+    
+    standard_json = installer_dir / "packages_standard.json"
+    dev_json = installer_dir / "packages_dev.json"
+    output_json = current_dir / "github_releases.json"
+    
+    print("🔍 Starting GitHub release data extraction...")
+    print(f"📁 Processing files from: {installer_dir}")
+    
+    # Extract GitHub repositories from both files
+    all_github_repos: Set[str] = set()
+    
+    if standard_json.exists():
+        print(f"📄 Reading {standard_json.name}...")
+        repos = extract_github_repos_from_json(standard_json)
+        all_github_repos.update(repos)
+        print(f"   Found {len(repos)} GitHub repos")
+    else:
+        print(f"⚠️  File not found: {standard_json}")
+        
+    if dev_json.exists():
+        print(f"📄 Reading {dev_json.name}...")
+        repos = extract_github_repos_from_json(dev_json)
+        all_github_repos.update(repos)
+        print(f"   Found {len(repos)} GitHub repos")
+    else:
+        print(f"⚠️  File not found: {dev_json}")
+    
+    print(f"🎯 Total unique GitHub repositories found: {len(all_github_repos)}")
+    
+    if not all_github_repos:
+        print("❌ No GitHub repositories found. Exiting.")
+        return
+    
+    # Fetch release data with rate limiting
+    release_mapping: Dict[str, Any] = {}
+    total_repos = len(all_github_repos)
+    
+    print(f"\n🚀 Fetching release data for {total_repos} repositories...")
+    print("⏰ Rate limiting: 5 seconds between requests")
+    print("-" * 60)
+    
+    for i, repo_url in enumerate(sorted(all_github_repos), 1):
+        repo_name = get_repo_name_from_url(repo_url)
+        
+        if not repo_name:
+            print(f"⚠️  [{i:3d}/{total_repos}] Invalid repo URL: {repo_url}")
+            continue
+            
+        print(f"📡 [{i:3d}/{total_repos}] Fetching: {repo_name}", end=" ... ")
+        
+        release_data = fetch_github_release_data(repo_name)
+        
+        if release_data:
+            release_info = extract_release_info(release_data)
+            release_mapping[repo_url] = release_info
+            assets_count = release_info.get("assets_count", 0)
+            tag = release_info.get("tag_name", "unknown")
+            print(f"✅ {tag} ({assets_count} assets)")
+        else:
+            release_mapping[repo_url] = {}
+            print("❌ No data")
+        
+        # Rate limiting - wait 5 seconds between requests (except for the last one)
+        if i < total_repos:
+            time.sleep(5)
+    
+    # Save results
+    output_data = {
+        "generated_at": time.strftime("%Y-%m-%d %H:%M:%S UTC", time.gmtime()),
+        "total_repositories": len(all_github_repos),
+        "successful_fetches": len([v for v in release_mapping.values() if v]),
+        "releases": release_mapping
+    }
+    
+    with open(output_json, 'w', encoding='utf-8') as f:
+        json.dump(output_data, f, indent=2, ensure_ascii=False)
+    
+    successful = len([v for v in release_mapping.values() if v])
+    print("\n📊 Summary:")
+    print(f"   Total repositories processed: {len(all_github_repos)}")
+    print(f"   Successful fetches: {successful}")
+    print(f"   Failed fetches: {len(all_github_repos) - successful}")
+    print(f"   Output saved to: {output_json}")
+    print("✅ Done!")
+
+
+if __name__ == "__main__":
+    main()