projectdevsetup 1.0.0__py3-none-any.whl

projectdevsetup/vscode.py

@@ -0,0 +1,386 @@
+"""
+@project  projectdevsetup
+@org      Zenith Open Source Projects
+@license  MIT License
+"""
+
+import subprocess
+import platform
+import webbrowser
+import os
+from pathlib import Path
+from projectdevsetup.detector import check_vscode
+from projectdevsetup.network import download_file, get_temp_dir
+from projectdevsetup.utils.logger import (
+    info,
+    success,
+    error,
+    warning,
+    already_installed,
+)
+from projectdevsetup.utils.os_detect import detect_system
+
+VSCODE_DOWNLOAD_PAGE = "https://code.visualstudio.com/Download"
+
+VSCODE_WINDOWS_URL = (
+    "https://code.visualstudio.com/sha/download?build=stable&os=win32-x64-user"
+)
+VSCODE_LINUX_DEB_URL = (
+    "https://code.visualstudio.com/sha/download?build=stable&os=linux-deb-x64"
+)
+VSCODE_LINUX_RPM_URL = (
+    "https://code.visualstudio.com/sha/download?build=stable&os=linux-rpm-x64"
+)
+VSCODE_MAC_URL = (
+    "https://code.visualstudio.com/sha/download?build=stable&os=darwin-universal"
+)
+
+EXTENSIONS = {
+    "python": ["ms-python.python", "ms-python.pylance"],
+    "c": ["ms-vscode.cpptools"],
+    "cpp": ["ms-vscode.cpptools"],
+    "java": ["vscjava.vscode-java-pack"],
+    "html": ["ritwickdey.liveserver", "esbenp.prettier-vscode"],
+    "javascript": ["dbaeumer.vscode-eslint", "esbenp.prettier-vscode"],
+    "rust": ["rust-lang.rust-analyzer"],
+    "go": ["golang.go"],
+}
+
+
+def ensure_vscode_installed(sys_info) -> bool:
+    """
+    Make sure VSCode is installed.
+    Returns True if VSCode is available after this function runs.
+    """
+    if check_vscode():
+        already_installed("Visual Studio Code")
+        return True
+
+    info("Visual Studio Code is not installed. Attempting to install...")
+
+    if sys_info.os_name == "windows":
+        return _install_vscode_windows(sys_info)
+    elif sys_info.os_name == "linux":
+        return _install_vscode_linux(sys_info)
+    elif sys_info.os_name == "mac":
+        return _install_vscode_mac(sys_info)
+    else:
+        _open_download_page()
+        return False
+
+
+def _install_vscode_windows(sys_info) -> bool:
+    """Try winget first, then direct download, then browser fallback."""
+    if sys_info.package_manager == "winget":
+        info("Installing VSCode via winget...")
+        try:
+            result = subprocess.run(
+                [
+                    "winget",
+                    "install",
+                    "--id",
+                    "Microsoft.VisualStudioCode",
+                    "--silent",
+                    "--accept-package-agreements",
+                    "--accept-source-agreements",
+                ],
+                capture_output=True,
+                text=True,
+                timeout=300,
+            )
+            if result.returncode == 0 and check_vscode():
+                success("Visual Studio Code installed successfully!")
+                return True
+        except Exception:
+            pass
+
+    if sys_info.package_manager == "choco":
+        info("Installing VSCode via Chocolatey...")
+        try:
+            result = subprocess.run(
+                ["choco", "install", "vscode", "-y"],
+                capture_output=True,
+                text=True,
+                timeout=300,
+            )
+            if result.returncode == 0 and check_vscode():
+                success("Visual Studio Code installed successfully!")
+                return True
+        except Exception:
+            pass
+
+    info("Downloading VSCode installer directly...")
+    tmp = get_temp_dir()
+    installer = tmp / "vscode_installer.exe"
+    if download_file(VSCODE_WINDOWS_URL, installer, "Visual Studio Code"):
+        try:
+            info("Running VSCode installer silently...")
+            subprocess.run(
+                [str(installer), "/VERYSILENT", "/MERGETASKS=!runcode"], timeout=300
+            )
+            if check_vscode():
+                success("Visual Studio Code installed successfully!")
+                return True
+        except Exception:
+            pass
+
+    _open_download_page()
+    return False
+
+
+def _install_vscode_linux(sys_info) -> bool:
+    """Try snap, then apt/rpm repo, then browser fallback."""
+    if sys_info.package_manager != "none" and _try_snap_install():
+        return True
+
+    if sys_info.package_manager == "apt":
+        if _try_apt_vscode():
+            return True
+
+    if sys_info.package_manager in ("dnf", "yum"):
+        if _try_rpm_vscode(sys_info.package_manager):
+            return True
+
+    if sys_info.package_manager == "apt":
+        tmp = get_temp_dir()
+        pkg = tmp / "vscode.deb"
+        if download_file(VSCODE_LINUX_DEB_URL, pkg, "Visual Studio Code"):
+            try:
+                subprocess.run(["sudo", "dpkg", "-i", str(pkg)], timeout=120)
+                subprocess.run(["sudo", "apt-get", "install", "-f", "-y"], timeout=120)
+                if check_vscode():
+                    success("Visual Studio Code installed successfully!")
+                    return True
+            except Exception:
+                pass
+
+    if not sys_info.has_display:
+        warning(
+            "No display detected. This appears to be a server. "
+            "VSCode cannot be installed on a headless server. "
+            "Skipping VSCode installation."
+        )
+        return False
+
+    _open_download_page()
+    return False
+
+
+def _try_snap_install() -> bool:
+    """Try installing VSCode via snap."""
+    try:
+        subprocess.run(
+            ["sudo", "systemctl", "start", "snapd"], capture_output=True, timeout=30
+        )
+        result = subprocess.run(
+            ["sudo", "snap", "install", "code", "--classic"],
+            capture_output=True,
+            text=True,
+            timeout=300,
+        )
+        if result.returncode == 0 and check_vscode():
+            success("Visual Studio Code installed successfully via snap!")
+            return True
+    except Exception:
+        pass
+    return False
+
+
+def _try_apt_vscode() -> bool:
+    """Add Microsoft apt repo and install VSCode."""
+    try:
+        commands = [
+            ["sudo", "apt-get", "install", "-y", "wget", "gpg", "apt-transport-https"],
+            [
+                "bash",
+                "-c",
+                "wget -qO- https://packages.microsoft.com/keys/microsoft.asc"
+                " | gpg --dearmor > /tmp/microsoft.gpg",
+            ],
+            [
+                "sudo",
+                "install",
+                "-D",
+                "-o",
+                "root",
+                "-g",
+                "root",
+                "-m",
+                "644",
+                "/tmp/microsoft.gpg",
+                "/etc/apt/keyrings/packages.microsoft.gpg",
+            ],
+            [
+                "bash",
+                "-c",
+                'echo "deb [arch=amd64 signed-by=/etc/apt/keyrings/'
+                "packages.microsoft.gpg] https://packages.microsoft.com/"
+                'repos/code stable main" | sudo tee '
+                "/etc/apt/sources.list.d/vscode.list",
+            ],
+            ["sudo", "apt-get", "update"],
+            ["sudo", "apt-get", "install", "-y", "code"],
+        ]
+        for cmd in commands:
+            result = subprocess.run(cmd, capture_output=True, text=True, timeout=120)
+            if result.returncode != 0:
+                return False
+        if check_vscode():
+            success("Visual Studio Code installed successfully!")
+            return True
+    except Exception:
+        pass
+    return False
+
+
+def _try_rpm_vscode(pkg_manager: str) -> bool:
+    """Install VSCode on Fedora/CentOS via rpm repo."""
+    try:
+        commands = [
+            [
+                "sudo",
+                "rpm",
+                "--import",
+                "https://packages.microsoft.com/keys/microsoft.asc",
+            ],
+            [
+                "bash",
+                "-c",
+                'echo -e "[code]\nname=Visual Studio Code\n'
+                "baseurl=https://packages.microsoft.com/yumrepos/vscode\n"
+                "enabled=1\ngpgcheck=1\ngpgkey=https://packages.microsoft.com"
+                '/keys/microsoft.asc" | sudo tee /etc/yum.repos.d/vscode.repo',
+            ],
+            ["sudo", pkg_manager, "install", "-y", "code"],
+        ]
+        for cmd in commands:
+            subprocess.run(cmd, capture_output=True, text=True, timeout=120)
+        if check_vscode():
+            success("Visual Studio Code installed successfully!")
+            return True
+    except Exception:
+        pass
+    return False
+
+
+def _install_vscode_mac(sys_info) -> bool:
+    """Try homebrew, then direct download, then browser fallback."""
+    from projectdevsetup.detector import check_brew
+
+    if check_brew():
+        info("Installing VSCode via Homebrew...")
+        try:
+            result = subprocess.run(
+                ["brew", "install", "--cask", "visual-studio-code"],
+                capture_output=True,
+                text=True,
+                timeout=300,
+            )
+            if result.returncode == 0 and check_vscode():
+                success("Visual Studio Code installed successfully!")
+                return True
+        except Exception:
+            pass
+
+    info("Homebrew not found. Installing Homebrew first...")
+    try:
+        brew_install = subprocess.run(
+            [
+                "/bin/bash",
+                "-c",
+                "$(curl -fsSL https://raw.githubusercontent.com/"
+                "Homebrew/install/HEAD/install.sh)",
+            ],
+            timeout=600,
+        )
+        if brew_install.returncode == 0:
+            subprocess.run(
+                ["brew", "install", "--cask", "visual-studio-code"], timeout=300
+            )
+            if check_vscode():
+                success("Visual Studio Code installed successfully!")
+                return True
+    except Exception:
+        pass
+
+    _open_download_page()
+    return False
+
+
+def _open_download_page():
+    """Open the VSCode download page in the user's browser."""
+    warning(
+        "Could not install VSCode automatically. "
+        "Opening the download page in your browser..."
+    )
+    print(
+        "\n  Please download and install VSCode from:\n"
+        f"  {VSCODE_DOWNLOAD_PAGE}\n"
+        "\n  After installing, run this command again.\n"
+    )
+    try:
+        webbrowser.open(VSCODE_DOWNLOAD_PAGE)
+    except Exception:
+        pass
+
+
+def install_extensions(language: str) -> bool:
+    """
+    Install VSCode extensions for a given language.
+    Returns True if all installed successfully.
+    """
+    if not check_vscode():
+        warning("VSCode is not installed. Skipping extension installation.")
+        return False
+
+    exts = EXTENSIONS.get(language.lower(), [])
+    if not exts:
+        return True
+
+    all_success = True
+    for ext in exts:
+        info(f"Installing VSCode extension: {ext}")
+        for attempt in range(1, 4):
+            try:
+                result = subprocess.run(
+                    ["code", "--install-extension", ext, "--force"],
+                    capture_output=True,
+                    text=True,
+                    timeout=120,
+                )
+                if result.returncode == 0:
+                    success(f"Extension {ext} installed.")
+                    break
+                else:
+                    if attempt == 3:
+                        warning(
+                            f"Could not install extension {ext} "
+                            "automatically.\n"
+                            f"  Please install it manually in VSCode:\n"
+                            f"  1. Open VSCode\n"
+                            f"  2. Press Ctrl+Shift+X\n"
+                            f"  3. Search for: {ext}\n"
+                            f"  4. Click Install\n"
+                        )
+                        all_success = False
+            except Exception:
+                if attempt == 3:
+                    all_success = False
+    return all_success
+
+
+def open_in_vscode(file_path: Path):
+    """Open a specific file in VSCode."""
+    if not check_vscode():
+        warning("VSCode is not available. Please open your file manually.")
+        return
+    try:
+        info(f"Opening {file_path.name} in VSCode...")
+        subprocess.Popen(["code", str(file_path)])
+        success(f"VSCode opened with {file_path.name}!")
+    except Exception:
+        warning(
+            f"Could not open VSCode automatically. "
+            f"Please open this file manually:\n"
+            f"  {file_path}"
+        )

projectdevsetup/wizard.py

@@ -0,0 +1,262 @@
+"""
+@project  projectdevsetup
+@org      Zenith Open Source Projects
+@license  MIT License
+"""
+
+import re
+import sys
+from pathlib import Path
+from projectdevsetup.utils.logger import (
+    header,
+    info,
+    success,
+    error,
+    warning,
+    divider,
+    step,
+    ask,
+)
+from projectdevsetup.utils.os_detect import detect_system
+from projectdevsetup.network import check_internet
+from projectdevsetup.permissions import (
+    check_disk_space,
+    assert_not_root,
+    handle_no_admin_windows,
+)
+from projectdevsetup.detector import get_installed_summary
+from projectdevsetup.installer import Installer
+from projectdevsetup.vscode import (
+    ensure_vscode_installed,
+    install_extensions,
+    open_in_vscode,
+)
+from projectdevsetup.utils.venv_helper import create_venv
+
+LANGUAGES = {
+    "1": ("Python", "python", ".py"),
+    "2": ("C", "c", ".c"),
+    "3": ("C++", "cpp", ".cpp"),
+    "4": ("Java", "java", ".java"),
+    "5": ("HTML / CSS", "html", ".html"),
+    "6": ("JavaScript", "javascript", ".js"),
+    "7": ("Rust", "rust", ".rs"),
+    "8": ("Go", "go", ".go"),
+    "9": ("All Languages", "all", ""),
+}
+
+TEMPLATE_MAP = {
+    "python": "hello.py",
+    "c": "hello.c",
+    "cpp": "hello.cpp",
+    "java": "Hello.java",
+    "html": "hello.html",
+    "javascript": "hello.js",
+    "rust": "hello.rs",
+    "go": "hello.go",
+}
+
+
+def run():
+    """Main entry point for the wizard."""
+    header()
+
+    _preflight_checks()
+
+    language_name, language_key = _select_language()
+
+    file_name = _get_file_name(language_key)
+
+    output_dir = _get_output_dir(file_name)
+
+    divider()
+    info(f"Setting up {language_name} environment...")
+    divider()
+
+    installer = Installer()
+    sys_info = installer.sys_info
+
+    total_steps = 4
+    current_step = 1
+
+    if language_key == "all":
+        for key, (name, lang_key, _) in LANGUAGES.items():
+            if lang_key != "all":
+                step(current_step, total_steps, f"Installing {name}")
+                installer.install_for_language(lang_key)
+                current_step += 1
+    else:
+        step(current_step, total_steps, f"Installing {language_name} tools")
+        installer.install_for_language(language_key)
+        current_step += 1
+
+    step(current_step, total_steps, "Setting up Visual Studio Code")
+    vscode_ok = ensure_vscode_installed(sys_info)
+    current_step += 1
+
+    step(current_step, total_steps, "Installing VSCode extensions")
+    if vscode_ok:
+        if language_key == "all":
+            for key, (name, lang_key, _) in LANGUAGES.items():
+                if lang_key != "all":
+                    install_extensions(lang_key)
+        else:
+            install_extensions(language_key)
+    current_step += 1
+
+    step(current_step, total_steps, "Creating your starter file")
+    created_files = []
+    if language_key == "all":
+        for key, (name, lang_key, ext) in LANGUAGES.items():
+            if lang_key != "all":
+                f = _create_starter_file(lang_key, "hello", output_dir)
+                if f:
+                    created_files.append(f)
+    else:
+        f = _create_starter_file(language_key, file_name, output_dir)
+        if f:
+            created_files.append(f)
+
+    if language_key in ("python", "all"):
+        create_venv(output_dir)
+
+    if vscode_ok and created_files:
+        open_in_vscode(created_files[0])
+
+    divider()
+    success("Everything is set up! Happy coding!")
+    success(f"Your files are in: {output_dir}")
+    print(
+        f"\n  Made with love by Zenith Open Source Projects\n"
+        f"  https://zenithopensourceprojects.vercel.app\n"
+    )
+
+
+def _preflight_checks():
+    """Run all pre-flight checks before doing anything."""
+    info("Running checks before we start...")
+
+    info("Checking internet connection...")
+    if not check_internet():
+        error(
+            "No internet connection detected. "
+            "Please connect to the internet and run this again."
+        )
+        sys.exit(1)
+    success("Internet connection OK.")
+
+    if not check_disk_space(required_gb=2.0):
+        sys.exit(1)
+
+    assert_not_root()
+
+    import platform
+
+    if platform.system() == "Windows":
+        from projectdevsetup.permissions import check_admin_windows
+
+        if not check_admin_windows():
+            warning(
+                "You are not running as administrator. "
+                "Some installations may fail. "
+                "If needed, restart as administrator."
+            )
+        else:
+            success("Administrator rights detected.")
+
+    success("All checks passed. Starting setup...")
+    divider()
+
+
+def _select_language() -> tuple:
+    """Show language menu and get user selection."""
+    print("  Which programming language do you want to set up?\n")
+    for num, (name, _, _) in LANGUAGES.items():
+        print(f"  {num}. {name}")
+    print()
+
+    while True:
+        choice = ask("Enter a number (1-9):").strip()
+        if choice in LANGUAGES:
+            name, key, _ = LANGUAGES[choice]
+            success(f"You selected: {name}")
+            return name, key
+        else:
+            warning("Please enter a number between 1 and 9.")
+
+
+def _get_file_name(language_key: str) -> str:
+    """Ask the user for their starter file name."""
+    if language_key == "all":
+        return "hello"
+
+    lang_ext = ""
+    for num, (name, key, ext) in LANGUAGES.items():
+        if key == language_key:
+            lang_ext = ext
+            break
+
+    print()
+    info(f"What do you want to name your file? (without extension)")
+    info(f"Example: if you type 'hello', your file will be 'hello{lang_ext}'")
+    print()
+
+    while True:
+        name = ask("File name:").strip()
+        if not name:
+            warning("Please enter a file name.")
+            continue
+        clean = re.sub(r"[^\w\-]", "_", name)
+        if clean != name:
+            warning(
+                f"Special characters removed. "
+                f"Your file will be named: {clean}{lang_ext}"
+            )
+        if clean:
+            return clean
+        warning("Please enter a valid file name.")
+
+
+def _get_output_dir(file_name: str) -> Path:
+    """Create and return the output directory for the project."""
+    output = Path.home() / "projectdevsetup_projects" / file_name
+    output.mkdir(parents=True, exist_ok=True)
+    return output
+
+
+def _create_starter_file(
+    language_key: str, file_name: str, output_dir: Path
+) -> Path | None:
+    """
+    Copy the correct template to the output directory
+    with the user's chosen file name.
+    """
+    template_name = TEMPLATE_MAP.get(language_key)
+    if not template_name:
+        return None
+
+    suffix = Path(template_name).suffix
+
+    if language_key == "java":
+        class_name = file_name.capitalize()
+        out_file = output_dir / f"{class_name}{suffix}"
+        template_content = (
+            f"// Hello, World! — Java\n"
+            f"// projectdevsetup by Zenith Open Source Projects\n\n"
+            f"public class {class_name} {{\n"
+            f"    public static void main(String[] args) {{\n"
+            f'        System.out.println("Hello, World!");\n'
+            f"    }}\n"
+            f"}}\n"
+        )
+        out_file.write_text(template_content)
+    else:
+        out_file = output_dir / f"{file_name}{suffix}"
+        try:
+            template_path = Path(__file__).parent / "templates" / template_name
+            out_file.write_text(template_path.read_text())
+        except Exception:
+            out_file.write_text(f"// Your {language_key} starter file\n")
+
+    success(f"Created: {out_file}")
+    return out_file