projectdevsetup 1.0.0__py3-none-any.whl

projectdevsetup/__init__.py

@@ -0,0 +1,11 @@
+"""
+@project  projectdevsetup
+@org      Zenith Open Source Projects
+@license  MIT License
+@author   roshhellwett
+"""
+
+__version__ = "1.0.0"
+__author__ = "roshhellwett"
+__org__ = "Zenith Open Source Projects"
+__email__ = "roshhellwett@icloud.com"

projectdevsetup/__main__.py

@@ -0,0 +1,31 @@
+"""
+@project  projectdevsetup
+@org      Zenith Open Source Projects
+@license  MIT License
+"""
+
+import sys
+from projectdevsetup.wizard import run
+from projectdevsetup.utils.logger import error
+
+
+def main():
+    try:
+        run()
+    except KeyboardInterrupt:
+        print("\n")
+        error(
+            "Setup cancelled by user. Run 'python -m projectdevsetup' to start again."
+        )
+        sys.exit(0)
+    except Exception as e:
+        error(
+            "Something unexpected went wrong. "
+            "Please report this issue at:\n"
+            "  https://github.com/zenith-open-source/projectdevsetup/issues"
+        )
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

projectdevsetup/detector.py

@@ -0,0 +1,102 @@
+"""
+@project  projectdevsetup
+@org      Zenith Open Source Projects
+@license  MIT License
+"""
+
+import subprocess
+import platform
+import shutil
+from projectdevsetup.utils.logger import already_installed, info
+
+
+def is_installed(command: str, version_flag: str = "--version") -> bool:
+    """
+    Check if a command-line tool is installed and working.
+    Returns True if tool exists and responds to version flag.
+    """
+    try:
+        if not shutil.which(command):
+            return False
+        result = subprocess.run(
+            [command, version_flag], capture_output=True, text=True, timeout=10
+        )
+        return result.returncode == 0
+    except (subprocess.TimeoutExpired, FileNotFoundError, OSError):
+        return False
+
+
+def check_python() -> bool:
+    cmds = ["python3", "python"]
+    for cmd in cmds:
+        if is_installed(cmd):
+            return True
+    return False
+
+
+def check_gcc() -> bool:
+    return is_installed("gcc")
+
+
+def check_gpp() -> bool:
+    return is_installed("g++")
+
+
+def check_java() -> bool:
+    return is_installed("java", "-version")
+
+
+def check_node() -> bool:
+    return is_installed("node")
+
+
+def check_npm() -> bool:
+    return is_installed("npm")
+
+
+def check_rust() -> bool:
+    return is_installed("rustc")
+
+
+def check_cargo() -> bool:
+    return is_installed("cargo")
+
+
+def check_go() -> bool:
+    return is_installed("go", "version")
+
+
+def check_vscode() -> bool:
+    """Check if VSCode (code command) is available."""
+    return bool(shutil.which("code"))
+
+
+def check_winget() -> bool:
+    return is_installed("winget", "--version")
+
+
+def check_brew() -> bool:
+    return is_installed("brew", "--version")
+
+
+def check_snap() -> bool:
+    return is_installed("snap", "--version")
+
+
+def get_installed_summary() -> dict:
+    """Return a full summary of what is installed."""
+    return {
+        "python": check_python(),
+        "gcc": check_gcc(),
+        "gpp": check_gpp(),
+        "java": check_java(),
+        "node": check_node(),
+        "npm": check_npm(),
+        "rust": check_rust(),
+        "cargo": check_cargo(),
+        "go": check_go(),
+        "vscode": check_vscode(),
+        "winget": check_winget(),
+        "brew": check_brew(),
+        "snap": check_snap(),
+    }

projectdevsetup/installer.py

@@ -0,0 +1,447 @@
+"""
+@project  projectdevsetup
+@org      Zenith Open Source Projects
+@license  MIT License
+"""
+
+import subprocess
+import platform
+import os
+from pathlib import Path
+from projectdevsetup.detector import (
+    check_gcc,
+    check_gpp,
+    check_java,
+    check_node,
+    check_npm,
+    check_rust,
+    check_cargo,
+    check_go,
+    check_python,
+)
+from projectdevsetup.network import download_file, get_temp_dir
+from projectdevsetup.path_manager import add_to_path, verify_in_path
+from projectdevsetup.utils.logger import (
+    info,
+    success,
+    error,
+    warning,
+    already_installed,
+    step,
+)
+from projectdevsetup.utils.os_detect import detect_system, SystemInfo
+
+URLS = {
+    "jdk_windows": "https://download.oracle.com/java/21/latest/jdk-21_windows-x64_bin.exe",
+    "jdk_mac_arm": "https://download.oracle.com/java/21/latest/jdk-21_macos-aarch64_bin.dmg",
+    "jdk_mac_x64": "https://download.oracle.com/java/21/latest/jdk-21_macos-x64_bin.dmg",
+    "node_windows": "https://nodejs.org/dist/latest/node-latest-x86.msi",
+    "go_windows": "https://go.dev/dl/go1.22.0.windows-amd64.msi",
+    "go_mac": "https://go.dev/dl/go1.22.0.darwin-amd64.pkg",
+}
+
+
+class Installer:
+    def __init__(self):
+        self.sys_info: SystemInfo = detect_system()
+
+    def install_for_language(self, language: str) -> bool:
+        """
+        Install all required tools for a given language.
+        Returns True if installation succeeded.
+        """
+        lang = language.lower()
+        handlers = {
+            "python": self._install_python,
+            "c": self._install_gcc,
+            "cpp": self._install_gcc,
+            "java": self._install_java,
+            "html": self._install_html,
+            "javascript": self._install_node,
+            "rust": self._install_rust,
+            "go": self._install_go,
+        }
+        handler = handlers.get(lang)
+        if handler:
+            return handler()
+        error(f"Unknown language: {language}")
+        return False
+
+    def _install_python(self) -> bool:
+        if check_python():
+            already_installed("Python")
+            return True
+        info("Installing Python...")
+        os_name = self.sys_info.os_name
+        if os_name == "windows":
+            return self._install_python_windows()
+        elif os_name == "linux":
+            return self._install_via_package_manager(
+                ["python3", "python3-pip", "python3-venv"], "Python"
+            )
+        elif os_name == "mac":
+            return self._install_via_brew("python3", "Python")
+        return False
+
+    def _install_python_windows(self) -> bool:
+        tmp = get_temp_dir()
+        arch = "amd64" if self.sys_info.is_64bit else "win32"
+        url = f"https://www.python.org/ftp/python/3.12.0/python-3.12.0-{arch}.exe"
+        installer = tmp / "python_installer.exe"
+        if not download_file(url, installer, "Python"):
+            return False
+        try:
+            subprocess.run(
+                [
+                    str(installer),
+                    "/quiet",
+                    "InstallAllUsers=1",
+                    "PrependPath=1",
+                    "Include_test=0",
+                ],
+                timeout=300,
+            )
+            if check_python():
+                success("Python installed successfully!")
+                return True
+        except Exception:
+            pass
+        self._show_manual_install("Python", "https://www.python.org/downloads/")
+        return False
+
+    def _install_gcc(self) -> bool:
+        if check_gcc() and check_gpp():
+            already_installed("GCC / G++")
+            return True
+        info("Installing GCC and G++...")
+        os_name = self.sys_info.os_name
+        if os_name == "windows":
+            return self._install_gcc_windows()
+        elif os_name == "linux":
+            return self._install_via_package_manager(
+                ["gcc", "g++", "build-essential"]
+                if self.sys_info.package_manager == "apt"
+                else ["gcc", "g++"],
+                "GCC",
+            )
+        elif os_name == "mac":
+            return self._install_xcode_cli_tools()
+        return False
+
+    def _install_gcc_windows(self) -> bool:
+        """Install MSYS2 + GCC on Windows."""
+        info("Installing MSYS2 (includes GCC for Windows)...")
+        tmp = get_temp_dir()
+        arch = "x86_64" if self.sys_info.is_64bit else "i686"
+        url = (
+            f"https://github.com/msys2/msys2-installer/releases/download/"
+            f"2024-01-13/msys2-{arch}-20240113.exe"
+        )
+        installer = tmp / "msys2_installer.exe"
+        if not download_file(url, installer, "MSYS2 (GCC)"):
+            self._show_manual_install(
+                "GCC for Windows (MSYS2)", "https://www.msys2.org/"
+            )
+            return False
+        try:
+            subprocess.run(
+                [
+                    str(installer),
+                    "install",
+                    "--root",
+                    "C:\\msys64",
+                    "--confirm-command",
+                ],
+                timeout=600,
+            )
+            subprocess.run(
+                [
+                    "C:\\msys64\\usr\\bin\\pacman.exe",
+                    "-S",
+                    "--noconfirm",
+                    "mingw-w64-x86_64-gcc",
+                ],
+                timeout=300,
+            )
+            add_to_path("C:\\msys64\\mingw64\\bin", "GCC")
+            if verify_in_path("gcc"):
+                success("GCC installed successfully!")
+                return True
+        except Exception:
+            pass
+        self._show_manual_install("GCC (MSYS2)", "https://www.msys2.org/")
+        return False
+
+    def _install_xcode_cli_tools(self) -> bool:
+        """Install Xcode Command Line Tools on Mac (includes GCC)."""
+        info("Installing Xcode Command Line Tools (includes GCC)...")
+        try:
+            subprocess.run(["xcode-select", "--install"], timeout=30)
+            warning(
+                "A popup appeared asking to install developer tools. "
+                "Please click 'Install' and wait for it to finish. "
+                "Then run this tool again."
+            )
+            return False
+        except Exception:
+            self._show_manual_install(
+                "Xcode Command Line Tools", "https://developer.apple.com/xcode/"
+            )
+            return False
+
+    def _install_java(self) -> bool:
+        if check_java():
+            already_installed("Java JDK")
+            return True
+        info("Installing Java JDK 21 LTS...")
+        os_name = self.sys_info.os_name
+        if os_name == "windows":
+            return self._install_java_windows()
+        elif os_name == "linux":
+            return self._install_via_package_manager(
+                ["default-jdk"]
+                if self.sys_info.package_manager == "apt"
+                else ["java-21-openjdk"],
+                "Java JDK",
+            )
+        elif os_name == "mac":
+            return self._install_via_brew("openjdk@21", "Java JDK 21")
+        return False
+
+    def _install_java_windows(self) -> bool:
+        tmp = get_temp_dir()
+        url = URLS["jdk_windows"]
+        installer = tmp / "jdk_installer.exe"
+        if not download_file(url, installer, "Java JDK 21"):
+            self._show_manual_install("Java JDK", "https://adoptium.net/")
+            return False
+        try:
+            subprocess.run([str(installer), "/s"], timeout=300)
+            warning(
+                "Java JDK installed. "
+                "Please restart your terminal for it to be available."
+            )
+            return True
+        except Exception:
+            self._show_manual_install("Java JDK", "https://adoptium.net/")
+            return False
+
+    def _install_html(self) -> bool:
+        success(
+            "HTML and CSS do not need any installation! "
+            "Just VSCode with Live Server extension is enough."
+        )
+        return True
+
+    def _install_node(self) -> bool:
+        if check_node() and check_npm():
+            already_installed("Node.js and npm")
+            return True
+        info("Installing Node.js (includes npm)...")
+        os_name = self.sys_info.os_name
+        if os_name == "windows":
+            return self._install_node_windows()
+        elif os_name == "linux":
+            return self._install_node_linux()
+        elif os_name == "mac":
+            return self._install_via_brew("node", "Node.js")
+        return False
+
+    def _install_node_windows(self) -> bool:
+        tmp = get_temp_dir()
+        arch = "x64" if self.sys_info.is_64bit else "x86"
+        url = f"https://nodejs.org/dist/latest/node-latest-{arch}.msi"
+        installer = tmp / "node_installer.msi"
+        if not download_file(url, installer, "Node.js"):
+            self._show_manual_install("Node.js", "https://nodejs.org/")
+            return False
+        try:
+            subprocess.run(["msiexec", "/i", str(installer), "/quiet"], timeout=300)
+            if check_node():
+                success("Node.js installed successfully!")
+                return True
+        except Exception:
+            pass
+        self._show_manual_install("Node.js", "https://nodejs.org/")
+        return False
+
+    def _install_node_linux(self) -> bool:
+        try:
+            setup = subprocess.run(
+                [
+                    "bash",
+                    "-c",
+                    "curl -fsSL https://deb.nodesource.com/setup_lts.x"
+                    " | sudo -E bash -",
+                ],
+                timeout=120,
+            )
+            return self._install_via_package_manager(["nodejs"], "Node.js")
+        except Exception:
+            return self._install_via_package_manager(["nodejs", "npm"], "Node.js")
+
+    def _install_rust(self) -> bool:
+        if check_rust() and check_cargo():
+            already_installed("Rust and Cargo")
+            return True
+        info("Installing Rust via rustup...")
+        os_name = self.sys_info.os_name
+        if os_name == "windows":
+            return self._install_rust_windows()
+        else:
+            return self._install_rust_unix()
+
+    def _install_rust_windows(self) -> bool:
+        tmp = get_temp_dir()
+        url = "https://win.rustup.rs/x86_64"
+        installer = tmp / "rustup-init.exe"
+        if not download_file(url, installer, "Rust (rustup)"):
+            self._show_manual_install("Rust", "https://rustup.rs/")
+            return False
+        try:
+            subprocess.run([str(installer), "-y"], timeout=600)
+            cargo_bin = Path.home() / ".cargo" / "bin"
+            add_to_path(str(cargo_bin), "Rust/Cargo")
+            if check_rust():
+                success("Rust installed successfully!")
+                return True
+        except Exception:
+            pass
+        self._show_manual_install("Rust", "https://rustup.rs/")
+        return False
+
+    def _install_rust_unix(self) -> bool:
+        try:
+            subprocess.run(
+                [
+                    "bash",
+                    "-c",
+                    "curl --proto '=https' --tlsv1.2 "
+                    "-sSf https://sh.rustup.rs | sh -s -- -y",
+                ],
+                timeout=600,
+            )
+            cargo_bin = Path.home() / ".cargo" / "bin"
+            add_to_path(str(cargo_bin), "Rust/Cargo")
+            if check_rust():
+                success("Rust installed successfully!")
+                return True
+        except Exception:
+            pass
+        self._show_manual_install("Rust", "https://rustup.rs/")
+        return False
+
+    def _install_go(self) -> bool:
+        if check_go():
+            already_installed("Go")
+            return True
+        info("Installing Go...")
+        os_name = self.sys_info.os_name
+        if os_name == "windows":
+            return self._install_go_windows()
+        elif os_name == "linux":
+            return self._install_via_package_manager(["golang-go"], "Go")
+        elif os_name == "mac":
+            return self._install_via_brew("go", "Go")
+        return False
+
+    def _install_go_windows(self) -> bool:
+        tmp = get_temp_dir()
+        arch = "amd64" if self.sys_info.is_64bit else "386"
+        url = f"https://go.dev/dl/go1.22.0.windows-{arch}.msi"
+        installer = tmp / "go_installer.msi"
+        if not download_file(url, installer, "Go"):
+            self._show_manual_install("Go", "https://go.dev/dl/")
+            return False
+        try:
+            subprocess.run(["msiexec", "/i", str(installer), "/quiet"], timeout=300)
+            add_to_path("C:\\Go\\bin", "Go")
+            if check_go():
+                success("Go installed successfully!")
+                return True
+        except Exception:
+            pass
+        self._show_manual_install("Go", "https://go.dev/dl/")
+        return False
+
+    def _install_via_package_manager(self, packages: list, tool_name: str) -> bool:
+        """Install packages using the system package manager."""
+        pm = self.sys_info.package_manager
+        pkg_commands = {
+            "apt": ["sudo", "apt-get", "install", "-y"],
+            "pacman": ["sudo", "pacman", "-S", "--noconfirm"],
+            "dnf": ["sudo", "dnf", "install", "-y"],
+            "yum": ["sudo", "yum", "install", "-y"],
+            "zypper": ["sudo", "zypper", "install", "-y"],
+            "apk": ["sudo", "apk", "add"],
+        }
+        cmd_prefix = pkg_commands.get(pm)
+        if not cmd_prefix:
+            warning(
+                f"No supported package manager found to install {tool_name}. "
+                "Please install it manually."
+            )
+            return False
+        try:
+            if pm == "apt":
+                subprocess.run(
+                    ["sudo", "apt-get", "update"], capture_output=True, timeout=60
+                )
+            result = subprocess.run(cmd_prefix + packages, timeout=300)
+            if result.returncode == 0:
+                success(f"{tool_name} installed successfully!")
+                return True
+        except subprocess.TimeoutExpired:
+            error(
+                f"Installation of {tool_name} took too long. "
+                "Please try again or install manually."
+            )
+        except Exception:
+            pass
+        self._show_manual_install(tool_name, "")
+        return False
+
+    def _install_via_brew(self, formula: str, tool_name: str) -> bool:
+        """Install via Homebrew on Mac."""
+        from projectdevsetup.detector import check_brew
+
+        if not check_brew():
+            warning("Homebrew is not installed. Installing Homebrew first...")
+            try:
+                subprocess.run(
+                    [
+                        "/bin/bash",
+                        "-c",
+                        "$(curl -fsSL https://raw.githubusercontent.com/"
+                        "Homebrew/install/HEAD/install.sh)",
+                    ],
+                    timeout=600,
+                )
+            except Exception:
+                self._show_manual_install("Homebrew", "https://brew.sh")
+                return False
+        try:
+            result = subprocess.run(["brew", "install", formula], timeout=300)
+            if result.returncode == 0:
+                success(f"{tool_name} installed successfully!")
+                return True
+        except Exception:
+            pass
+        self._show_manual_install(tool_name, "")
+        return False
+
+    def _show_manual_install(self, tool_name: str, url: str):
+        """Show a beginner-friendly message for manual install."""
+        warning(f"Could not install {tool_name} automatically.")
+        if url:
+            print(
+                f"\n  Please download and install {tool_name} manually:\n"
+                f"  {url}\n"
+                f"\n  After installing, run this tool again.\n"
+            )
+            try:
+                import webbrowser
+
+                webbrowser.open(url)
+            except Exception:
+                pass

projectdevsetup/network.py

@@ -0,0 +1,80 @@
+"""
+@project  projectdevsetup
+@org      Zenith Open Source Projects
+@license  MIT License
+"""
+
+import urllib.request
+import urllib.error
+import os
+import tempfile
+from pathlib import Path
+from projectdevsetup.utils.logger import info, error, warning
+
+
+def check_internet() -> bool:
+    """
+    Check if internet is available.
+    Tries to reach multiple hosts in case one is down.
+    """
+    hosts = [
+        "https://www.google.com",
+        "https://www.cloudflare.com",
+        "https://www.microsoft.com",
+    ]
+    for host in hosts:
+        try:
+            urllib.request.urlopen(host, timeout=5)
+            return True
+        except Exception:
+            continue
+    return False
+
+
+def download_file(
+    url: str, destination: Path, description: str, retries: int = 3
+) -> bool:
+    """
+    Download a file with retry logic and progress indication.
+    Returns True on success, False on failure.
+    Shows beginner-friendly messages throughout.
+    """
+    for attempt in range(1, retries + 1):
+        try:
+            info(f"Downloading {description}... (attempt {attempt}/{retries})")
+
+            def progress_hook(count, block_size, total_size):
+                if total_size > 0:
+                    percent = min(int(count * block_size * 100 / total_size), 100)
+                    print(f"\r  Progress: {percent}%   ", end="", flush=True)
+
+            urllib.request.urlretrieve(url, str(destination), reporthook=progress_hook)
+            print()
+            return True
+
+        except urllib.error.URLError:
+            warning(
+                f"Download attempt {attempt} failed. "
+                f"Checking your internet connection..."
+            )
+            if not check_internet():
+                error(
+                    "No internet connection detected. "
+                    "Please connect to the internet and try again."
+                )
+                return False
+        except Exception as e:
+            warning(f"Download attempt {attempt} failed. Retrying...")
+
+    error(
+        f"Could not download {description} after {retries} attempts. "
+        "Please check your internet connection and try again."
+    )
+    return False
+
+
+def get_temp_dir() -> Path:
+    """Return a safe temp directory for downloads."""
+    tmp = Path(tempfile.gettempdir()) / "projectdevsetup"
+    tmp.mkdir(parents=True, exist_ok=True)
+    return tmp