Moved files to common/

1 files changed, 0 insertions, 917 deletions

diff --git a/common/nvim/neovim.ps1 b/common/nvim/neovim.ps1
deleted file mode 100755
index a63965e..0000000
--- a/common/nvim/neovim.ps1
+++ /dev/null
@@ -1,917 +0,0 @@
-# Neovim Installation Script for Windows (PowerShell)
-# Created By: srdusr (PowerShell port)
-# Project: Install/update/uninstall/change version Neovim script for Windows
-
-#Requires -Version 5.1
-
-param(
-    [switch]$Force,
-    [switch]$NoPrompt
-)
-
-# Color definitions
-$Colors = @{
-    Red = "Red"
-    Green = "Green"
-    Yellow = "Yellow"
-    Cyan = "Cyan"
-}
-
-# Global variables
-$Script:DownloadCommand = $null
-$Script:IsAdmin = $false
-$Script:ShowPrompt = $true
-$Script:NeovimPath = "$env:LOCALAPPDATA\nvim"
-$Script:NeovimBin = "$Script:NeovimPath\bin"
-$Script:NeovimExe = "$Script:NeovimBin\nvim.exe"
-
-# Handle errors
-function Write-ErrorMessage {
-    param([string]$Message)
-    Write-Host "Error: $Message" -ForegroundColor $Colors.Red
-}
-
-# Handle success messages
-function Write-SuccessMessage {
-    param([string]$Message)
-    Write-Host $Message -ForegroundColor $Colors.Green
-}
-
-# Handle info messages
-function Write-InfoMessage {
-    param([string]$Message)
-    Write-Host $Message -ForegroundColor $Colors.Cyan
-}
-
-# Check if running as administrator
-function Test-Administrator {
-    $currentUser = [Security.Principal.WindowsIdentity]::GetCurrent()
-    $principal = New-Object Security.Principal.WindowsPrincipal($currentUser)
-    return $principal.IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator)
-}
-
-# Check if necessary dependencies are installed
-function Test-Dependencies {
-    Write-InfoMessage "Checking dependencies..."
-    
-    # Check for download tools
-    if (Get-Command curl -ErrorAction SilentlyContinue) {
-        $Script:DownloadCommand = "curl"
-        Write-InfoMessage "Found curl"
-    } elseif (Get-Command wget -ErrorAction SilentlyContinue) {
-        $Script:DownloadCommand = "wget"
-        Write-InfoMessage "Found wget"
-    } else {
-        Write-InfoMessage "Neither curl nor wget found. Will use PowerShell's Invoke-WebRequest"
-        $Script:DownloadCommand = "powershell"
-    }
-
-    # Check for admin privileges
-    $Script:IsAdmin = Test-Administrator
-    if (-not $Script:IsAdmin) {
-        Write-Host "Warning: Not running as administrator. Some operations may fail." -ForegroundColor $Colors.Yellow
-        if (-not $NoPrompt) {
-            $continue = Read-Host "Continue anyway? (y/n)"
-            if ($continue -notin @('y', 'yes', 'Y', 'Yes')) {
-                exit 1
-            }
-        }
-    }
-
-    return $true
-}
-
-# Find all Neovim installations
-function Find-AllNeovimInstallations {
-    $installations = @()
-    
-    # Check common installation paths
-    $commonPaths = @(
-        "$env:LOCALAPPDATA\nvim",
-        "$env:ProgramFiles\Neovim",
-        "$env:ProgramFiles(x86)\Neovim",
-        "$env:APPDATA\nvim",
-        "$env:USERPROFILE\nvim",
-        "C:\tools\neovim",
-        "C:\neovim"
-    )
-    
-    foreach ($path in $commonPaths) {
-        # Check for nvim.exe in bin subdirectory
-        if (Test-Path "$path\bin\nvim.exe") {
-            $installations += @{
-                Path = $path
-                BinPath = "$path\bin"
-                Type = "Portable"
-                Version = Get-NeovimVersion -Path "$path\bin\nvim.exe"
-            }
-        }
-        # Check for nvim.exe directly in path
-        elseif (Test-Path "$path\nvim.exe") {
-            $installations += @{
-                Path = $path
-                BinPath = $path
-                Type = "Portable"
-                Version = Get-NeovimVersion -Path "$path\nvim.exe"
-            }
-        }
-        # Check for nvim-win64 subdirectory (common structure)
-        elseif (Test-Path "$path\nvim-win64\bin\nvim.exe") {
-            $installations += @{
-                Path = "$path\nvim-win64"
-                BinPath = "$path\nvim-win64\bin"
-                Type = "Portable"
-                Version = Get-NeovimVersion -Path "$path\nvim-win64\bin\nvim.exe"
-            }
-        }
-    }
-    
-    # Check for MSI installations in registry
-    try {
-        $uninstallKeys = @(
-            "HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\*",
-            "HKCU:\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\*"
-        )
-        
-        foreach ($keyPath in $uninstallKeys) {
-            Get-ItemProperty $keyPath -ErrorAction SilentlyContinue | Where-Object { 
-                $_.DisplayName -like "*Neovim*" -or $_.DisplayName -like "*nvim*" 
-            } | ForEach-Object {
-                $installations += @{
-                    Path = $_.InstallLocation
-                    BinPath = "$($_.InstallLocation)\bin"
-                    Type = "MSI"
-                    Version = $_.DisplayVersion
-                    UninstallString = $_.UninstallString
-                    ProductCode = $_.PSChildName
-                }
-            }
-        }
-    }
-    catch {
-        Write-InfoMessage "Could not check registry for MSI installations"
-    }
-    
-    # Check PATH for nvim.exe - this is crucial for detecting installations
-    $pathDirs = $env:PATH -split ';' | Where-Object { $_ -ne "" }
-    foreach ($dir in $pathDirs) {
-        $dir = $dir.Trim()
-        if (Test-Path "$dir\nvim.exe") {
-            # Determine the installation root
-            $installRoot = $dir
-            if ($dir -like "*\bin") {
-                $installRoot = Split-Path -Parent $dir
-            }
-            
-            # Check if we already found this installation
-            $alreadyFound = $false
-            foreach ($existing in $installations) {
-                if ($existing.Path -eq $installRoot -or $existing.BinPath -eq $dir) {
-                    $alreadyFound = $true
-                    break
-                }
-            }
-            
-            if (-not $alreadyFound) {
-                $installations += @{
-                    Path = $installRoot
-                    BinPath = $dir
-                    Type = "PATH"
-                    Version = Get-NeovimVersion -Path "$dir\nvim.exe"
-                }
-            }
-        }
-    }
-    
-    return $installations
-}
-
-# Get Neovim version from executable
-function Get-NeovimVersion {
-    param([string]$Path)
-    
-    try {
-        $versionOutput = & $Path --version 2>$null | Select-String "NVIM v(\d+\.\d+\.\d+)" | ForEach-Object { $_.Matches[0].Groups[1].Value }
-        return $versionOutput
-    }
-    catch {
-        return "Unknown"
-    }
-}
-
-# Complete uninstall of all Neovim instances
-function Uninstall-AllNeovim {
-    param([switch]$Silent)
-    
-    Write-InfoMessage "Searching for all Neovim installations..."
-    $installations = Find-AllNeovimInstallations
-    
-    if ($installations.Count -eq 0) {
-        Write-InfoMessage "No Neovim installations found."
-        return $true
-    }
-    
-    if (-not $Silent) {
-        Write-Host "Found $($installations.Count) Neovim installation(s):" -ForegroundColor $Colors.Yellow
-        for ($i = 0; $i -lt $installations.Count; $i++) {
-            Write-Host "  $($i + 1). $($installations[$i].Type) - $($installations[$i].Path) (v$($installations[$i].Version))"
-        }
-        
-        if (-not $NoPrompt) {
-            $confirm = Read-Host "Remove all installations? (y/n)"
-            if ($confirm -notin @('y', 'yes', 'Y', 'Yes')) {
-                Write-InfoMessage "Uninstall cancelled."
-                return $false
-            }
-        }
-    }
-    
-    $success = $true
-    foreach ($installation in $installations) {
-        Write-InfoMessage "Removing $($installation.Type) installation: $($installation.Path)"
-        
-        try {
-            if ($installation.Type -eq "MSI") {
-                # Uninstall MSI package
-                if ($installation.UninstallString) {
-                    if ($installation.UninstallString -like "*msiexec*") {
-                        # Extract the product code from the uninstall string
-                        $productCode = $installation.ProductCode
-                        if ($productCode -and $productCode -match "^\{.*\}$") {
-                            $uninstallArgs = "/x `"$productCode`" /quiet /norestart"
-                            Write-InfoMessage "Uninstalling MSI with product code: $productCode"
-                            Start-Process -FilePath "msiexec.exe" -ArgumentList $uninstallArgs -Wait -NoNewWindow
-                        } else {
-                            # Fallback to parsing the uninstall string
-                            $uninstallArgs = $installation.UninstallString -replace "MsiExec.exe", "" -replace "/I\{", "/x{"
-                            $uninstallArgs += " /quiet /norestart"
-                            Write-InfoMessage "Uninstalling MSI with args: $uninstallArgs"
-                            Start-Process -FilePath "msiexec.exe" -ArgumentList $uninstallArgs -Wait -NoNewWindow
-                        }
-                    } else {
-                        # Direct uninstall command
-                        Write-InfoMessage "Running uninstall command: $($installation.UninstallString)"
-                        Invoke-Expression $installation.UninstallString
-                    }
-                    
-                    if ($LASTEXITCODE -eq 0 -or $LASTEXITCODE -eq $null) {
-                        Write-SuccessMessage "Successfully uninstalled MSI package"
-                    } else {
-                        Write-ErrorMessage "MSI uninstall failed with exit code: $LASTEXITCODE"
-                        $success = $false
-                    }
-                } else {
-                    Write-ErrorMessage "No uninstall string found for MSI package"
-                    $success = $false
-                }
-            } else {
-                # Remove portable installation
-                if (Test-Path $installation.Path) {
-                    Write-InfoMessage "Removing directory: $($installation.Path)"
-                    # Force kill any processes that might be using files in the directory
-                    Get-Process -Name "nvim*" -ErrorAction SilentlyContinue | Stop-Process -Force -ErrorAction SilentlyContinue
-                    
-                    # Try to remove the directory
-                    Remove-Item -Path $installation.Path -Recurse -Force -ErrorAction Stop
-                    Write-SuccessMessage "Successfully removed directory: $($installation.Path)"
-                } else {
-                    Write-InfoMessage "Directory already removed: $($installation.Path)"
-                }
-            }
-        }
-        catch {
-            Write-ErrorMessage "Failed to remove $($installation.Path): $_"
-            # Try alternative removal methods
-            try {
-                Write-InfoMessage "Attempting alternative removal method..."
-                if (Test-Path $installation.Path) {
-                    # Use robocopy to move and delete (works around file locks)
-                    $tempDir = "$env:TEMP\nvim_removal_$(Get-Random)"
-                    robocopy "$($installation.Path)" "$tempDir" /E /MOVE /NFL /NDL /NJH /NJS /NC /NS /NP
-                    Remove-Item -Path $tempDir -Recurse -Force -ErrorAction SilentlyContinue
-                    Write-SuccessMessage "Successfully removed using alternative method: $($installation.Path)"
-                }
-            }
-            catch {
-                Write-ErrorMessage "Alternative removal also failed: $_"
-                $success = $false
-            }
-        }
-    }
-    
-    # Clean up PATH environment variable
-    Write-InfoMessage "Cleaning up PATH environment variable..."
-    
-    # Get both user and system PATH
-    $userPath = [Environment]::GetEnvironmentVariable("PATH", "User")
-    $systemPath = ""
-    
-    if ($Script:IsAdmin) {
-        try {
-            $systemPath = [Environment]::GetEnvironmentVariable("PATH", "Machine")
-        }
-        catch {
-            Write-InfoMessage "Could not access system PATH"
-        }
-    }
-    
-    # Create patterns for all found installations
-    $nvimPathPatterns = @()
-    foreach ($installation in $installations) {
-        $nvimPathPatterns += [regex]::Escape($installation.BinPath)
-        $nvimPathPatterns += [regex]::Escape($installation.Path)
-    }
-    
-    # Add common patterns
-    $nvimPathPatterns += @(
-        [regex]::Escape($Script:NeovimBin),
-        [regex]::Escape("$env:ProgramFiles\Neovim\bin"),
-        [regex]::Escape("$env:ProgramFiles(x86)\Neovim\bin"),
-        [regex]::Escape("C:\tools\neovim\nvim-win64\bin"),
-        [regex]::Escape("C:\tools\neovim\nvim-win64")
-    )
-    
-    # Clean user PATH
-    $originalUserPath = $userPath
-    foreach ($pattern in $nvimPathPatterns) {
-        $userPath = $userPath -replace ";$pattern;", ";"
-        $userPath = $userPath -replace "^$pattern;", ""
-        $userPath = $userPath -replace ";$pattern$", ""
-        $userPath = $userPath -replace "^$pattern$", ""
-    }
-    
-    if ($userPath -ne $originalUserPath) {
-        try {
-            [Environment]::SetEnvironmentVariable("PATH", $userPath, "User")
-            Write-InfoMessage "Cleaned up user PATH"
-        }
-        catch {
-            Write-ErrorMessage "Failed to clean up user PATH: $_"
-        }
-    }
-    
-    # Clean system PATH if running as admin
-    if ($Script:IsAdmin -and $systemPath) {
-        $originalSystemPath = $systemPath
-        foreach ($pattern in $nvimPathPatterns) {
-            $systemPath = $systemPath -replace ";$pattern;", ";"
-            $systemPath = $systemPath -replace "^$pattern;", ""
-            $systemPath = $systemPath -replace ";$pattern$", ""
-            $systemPath = $systemPath -replace "^$pattern$", ""
-        }
-        
-        if ($systemPath -ne $originalSystemPath) {
-            try {
-                [Environment]::SetEnvironmentVariable("PATH", $systemPath, "Machine")
-                Write-InfoMessage "Cleaned up system PATH"
-            }
-            catch {
-                Write-ErrorMessage "Failed to clean up system PATH: $_"
-            }
-        }
-    }
-    
-    if ($success) {
-        Write-SuccessMessage "All Neovim installations have been removed successfully!"
-    } else {
-        Write-Host "Some installations could not be removed completely." -ForegroundColor $Colors.Yellow
-    }
-    
-    Write-InfoMessage "You may need to restart your shell for PATH changes to take effect."
-    return $success
-}
-
-# Check if Neovim is already installed
-function Test-NeovimInstalled {
-    if (Test-Path $Script:NeovimExe) {
-        return $true
-    }
-    
-    # Check if nvim is in PATH
-    if (Get-Command nvim -ErrorAction SilentlyContinue) {
-        return $true
-    }
-    
-    return $false
-}
-
-# Download a file - FIXED VERSION
-function Get-FileDownload {
-    param(
-        [string]$Url,
-        [string]$OutputPath
-    )
-
-    Write-InfoMessage "Downloading from: $Url"
-    Write-InfoMessage "Saving to: $OutputPath"
-
-    try {
-        switch ($Script:DownloadCommand) {
-            "curl" {
-                # Use Start-Process instead of cmd /c for better compatibility
-                $curlArgs = @("-L", "--progress-bar", "-o", $OutputPath, $Url)
-                $process = Start-Process -FilePath "curl" -ArgumentList $curlArgs -Wait -NoNewWindow -PassThru
-                if ($process.ExitCode -ne 0) { 
-                    throw "Curl download failed with exit code: $($process.ExitCode)" 
-                }
-            }
-            "wget" {
-                # Use Start-Process instead of cmd /c for better compatibility
-                $wgetArgs = @("--progress=bar", "--show-progress", "-O", $OutputPath, $Url)
-                $process = Start-Process -FilePath "wget" -ArgumentList $wgetArgs -Wait -NoNewWindow -PassThru
-                if ($process.ExitCode -ne 0) { 
-                    throw "Wget download failed with exit code: $($process.ExitCode)" 
-                }
-            }
-            "powershell" {
-                # Enhanced PowerShell download with progress
-                Write-InfoMessage "Using PowerShell's Invoke-WebRequest..."
-                $ProgressPreference = 'Continue'
-                
-                # Create a WebClient for better progress reporting
-                $webClient = New-Object System.Net.WebClient
-                $webClient.Headers.Add("User-Agent", "PowerShell Neovim Installer")
-                
-                # Register progress event
-                Register-ObjectEvent -InputObject $webClient -EventName DownloadProgressChanged -Action {
-                    $Global:DownloadProgress = $Event.SourceEventArgs.ProgressPercentage
-                    Write-Progress -Activity "Downloading Neovim" -Status "Progress: $($Event.SourceEventArgs.ProgressPercentage)%" -PercentComplete $Event.SourceEventArgs.ProgressPercentage
-                } | Out-Null
-                
-                # Download the file
-                try {
-                    $webClient.DownloadFile($Url, $OutputPath)
-                    Write-Progress -Activity "Downloading Neovim" -Completed
-                }
-                finally {
-                    $webClient.Dispose()
-                    # Clean up event handlers
-                    Get-EventSubscriber | Where-Object { $_.SourceObject -eq $webClient } | Unregister-Event
-                }
-            }
-        }
-        
-        # Verify the file was downloaded
-        if (-not (Test-Path $OutputPath)) {
-            throw "Downloaded file not found at: $OutputPath"
-        }
-        
-        $fileSize = (Get-Item $OutputPath).Length
-        if ($fileSize -eq 0) {
-            throw "Downloaded file is empty"
-        }
-        
-        Write-InfoMessage "Download completed successfully. File size: $($fileSize / 1MB) MB"
-        return $true
-    }
-    catch {
-        Write-ErrorMessage "Download failed: $_"
-        # Clean up partial download
-        if (Test-Path $OutputPath) {
-            Remove-Item -Path $OutputPath -Force -ErrorAction SilentlyContinue
-        }
-        return $false
-    }
-}
-
-# Get available versions from GitHub API
-function Get-AvailableVersions {
-    try {
-        $apiUrl = "https://api.github.com/repos/neovim/neovim/releases"
-        $response = Invoke-RestMethod -Uri $apiUrl -UseBasicParsing
-        return $response | ForEach-Object { $_.tag_name }
-    }
-    catch {
-        Write-ErrorMessage "Failed to fetch available versions: $_"
-        return @()
-    }
-}
-
-# Check if a specific version exists
-function Test-VersionExists {
-    param([string]$Version)
-    
-    if ($Version -notmatch "^v") {
-        $Version = "v$Version"
-    }
-    
-    $versions = Get-AvailableVersions
-    return $versions -contains $Version
-}
-
-# Get the latest stable version
-function Get-LatestStableVersion {
-    try {
-        $apiUrl = "https://api.github.com/repos/neovim/neovim/releases/latest"
-        $response = Invoke-RestMethod -Uri $apiUrl -UseBasicParsing
-        return $response.tag_name
-    }
-    catch {
-        Write-ErrorMessage "Failed to fetch latest version: $_"
-        return $null
-    }
-}
-
-# Download specific version
-function Get-SpecificVersion {
-    param([string]$Version)
-    
-    if ($Version -notmatch "^v") {
-        $Version = "v$Version"
-    }
-    
-    try {
-        $apiUrl = "https://api.github.com/repos/neovim/neovim/releases/tags/$Version"
-        $response = Invoke-RestMethod -Uri $apiUrl -UseBasicParsing
-        
-        # Look for Windows assets
-        $asset = $response.assets | Where-Object { 
-            $_.name -match "nvim-win64\.zip$" -or 
-            $_.name -match "nvim-win64\.msi$" -or
-            $_.name -match "nvim-windows\.zip$"
-        } | Select-Object -First 1
-        
-        if (-not $asset) {
-            Write-ErrorMessage "No Windows asset found for version ${Version}"
-            return $null
-        }
-        
-        $fileName = $asset.name
-        $downloadUrl = $asset.browser_download_url
-        
-        Write-InfoMessage "Found asset: $fileName"
-        
-        if (Get-FileDownload -Url $downloadUrl -OutputPath $fileName) {
-            return $fileName
-        }
-    }
-    catch {
-        Write-ErrorMessage "Failed to download version ${Version}: $_"
-    }
-    
-    return $null
-}
-
-# Install Neovim from downloaded file
-function Install-NeovimFromFile {
-    param(
-        [string]$FilePath,
-        [string]$Version = "Unknown",
-        [switch]$CleanInstall
-    )
-    
-    try {
-        if ($CleanInstall) {
-            Write-InfoMessage "Performing clean installation - removing existing installations..."
-            Uninstall-AllNeovim -Silent
-        }
-        
-        Write-InfoMessage "Installing Neovim ${Version}..."
-        
-        $fileExtension = [System.IO.Path]::GetExtension($FilePath).ToLower()
-        
-        if ($fileExtension -eq ".msi") {
-            # Handle MSI installation
-            Write-InfoMessage "Installing from MSI package..."
-            $installArgs = @(
-                "/i", "`"$FilePath`""
-                "/quiet"
-                "/norestart"
-            )
-            
-            Start-Process -FilePath "msiexec.exe" -ArgumentList $installArgs -Wait -NoNewWindow
-            
-            if ($LASTEXITCODE -eq 0) {
-                Write-SuccessMessage "Neovim ${Version} installed successfully via MSI!"
-                
-                # MSI typically installs to Program Files, add to PATH if needed
-                $programFiles = "${env:ProgramFiles}\Neovim\bin"
-                $programFilesX86 = "${env:ProgramFiles(x86)}\Neovim\bin"
-                
-                $nvimPath = ""
-                if (Test-Path "$programFiles\nvim.exe") {
-                    $nvimPath = $programFiles
-                } elseif (Test-Path "$programFilesX86\nvim.exe") {
-                    $nvimPath = $programFilesX86
-                }
-                
-                if ($nvimPath) {
-                    $currentPath = [Environment]::GetEnvironmentVariable("PATH", "User")
-                    if ($currentPath -notlike "*$nvimPath*") {
-                        [Environment]::SetEnvironmentVariable("PATH", "$currentPath;$nvimPath", "User")
-                        Write-InfoMessage "Added Neovim to PATH: $nvimPath"
-                    }
-                }
-            } else {
-                Write-ErrorMessage "MSI installation failed with exit code: $LASTEXITCODE"
-                return $false
-            }
-        }
-        elseif ($fileExtension -eq ".zip") {
-            # Handle ZIP installation
-            Write-InfoMessage "Installing from ZIP archive..."
-            
-            # Create installation directory
-            if (Test-Path $Script:NeovimPath) {
-                Remove-Item -Path $Script:NeovimPath -Recurse -Force
-            }
-            New-Item -Path $Script:NeovimPath -ItemType Directory -Force | Out-Null
-            
-            # Extract zip file
-            Write-InfoMessage "Extracting archive..."
-            Add-Type -AssemblyName System.IO.Compression.FileSystem
-            [System.IO.Compression.ZipFile]::ExtractToDirectory($FilePath, $Script:NeovimPath)
-            
-            # Find the nvim.exe in the extracted files
-            $nvimExe = Get-ChildItem -Path $Script:NeovimPath -Name "nvim.exe" -Recurse | Select-Object -First 1
-            if (-not $nvimExe) {
-                Write-ErrorMessage "Could not find nvim.exe in extracted files"
-                return $false
-            }
-            
-            $nvimDir = Split-Path -Path (Get-ChildItem -Path $Script:NeovimPath -Name "nvim.exe" -Recurse | Select-Object -First 1).FullName
-            
-            # Move files to proper location if needed
-            if ($nvimDir -ne $Script:NeovimBin) {
-                if (Test-Path $Script:NeovimBin) {
-                    Remove-Item -Path $Script:NeovimBin -Recurse -Force
-                }
-                Move-Item -Path $nvimDir -Destination $Script:NeovimBin -Force
-            }
-            
-            # Add to PATH if not already there
-            $currentPath = [Environment]::GetEnvironmentVariable("PATH", "User")
-            if ($currentPath -notlike "*$Script:NeovimBin*") {
-                [Environment]::SetEnvironmentVariable("PATH", "$currentPath;$Script:NeovimBin", "User")
-                Write-InfoMessage "Added Neovim to PATH"
-            }
-            
-            Write-SuccessMessage "Neovim ${Version} installed successfully!"
-            Write-InfoMessage "Location: $Script:NeovimBin"
-        }
-        else {
-            Write-ErrorMessage "Unsupported file type: $fileExtension"
-            return $false
-        }
-        
-        # Clean up downloaded file
-        Remove-Item -Path $FilePath -Force -ErrorAction SilentlyContinue
-        
-        Write-InfoMessage "You may need to restart your shell for PATH changes to take effect."
-        return $true
-    }
-    catch {
-        Write-ErrorMessage "Installation failed: $_"
-        return $false
-    }
-}
-
-# Install nightly version
-function Install-NightlyVersion {
-    param([switch]$CleanInstall)
-    
-    Write-InfoMessage "Installing Neovim Nightly..."
-    $url = "https://github.com/neovim/neovim/releases/download/nightly/nvim-win64.zip"
-    $fileName = "nvim-nightly.zip"
-    
-    if (Get-FileDownload -Url $url -OutputPath $fileName) {
-        return Install-NeovimFromFile -FilePath $fileName -Version "Nightly" -CleanInstall:$CleanInstall
-    }
-    return $false
-}
-
-# Install stable version
-function Install-StableVersion {
-    param([switch]$CleanInstall)
-    
-    Write-InfoMessage "Installing Neovim Stable..."
-    $latestVersion = Get-LatestStableVersion
-    if (-not $latestVersion) {
-        Write-ErrorMessage "Could not determine latest stable version"
-        return $false
-    }
-    
-    $fileName = Get-SpecificVersion -Version $latestVersion
-    if ($fileName) {
-        return Install-NeovimFromFile -FilePath $fileName -Version "Stable ($latestVersion)" -CleanInstall:$CleanInstall
-    }
-    return $false
-}
-
-# Install specific version
-function Install-SpecificVersionWrapper {
-    param(
-        [string]$Version,
-        [switch]$CleanInstall
-    )
-    
-    Write-InfoMessage "Installing Neovim ${Version}..."
-    
-    if (-not (Test-VersionExists -Version $Version)) {
-        Write-ErrorMessage "Version ${Version} does not exist"
-        return $false
-    }
-    
-    $fileName = Get-SpecificVersion -Version $Version
-    if ($fileName) {
-        return Install-NeovimFromFile -FilePath $fileName -Version $Version -CleanInstall:$CleanInstall
-    }
-    return $false
-}
-
-# Update/Install version menu
-function Show-UpdateMenu {
-    # Check if there are existing installations
-    $installations = Find-AllNeovimInstallations
-    $hasExistingInstalls = $installations.Count -gt 0
-    
-    if ($hasExistingInstalls) {
-        Write-Host "Existing Neovim installations found:" -ForegroundColor $Colors.Yellow
-        for ($i = 0; $i -lt $installations.Count; $i++) {
-            Write-Host "  - $($installations[$i].Type) - $($installations[$i].Path) (v$($installations[$i].Version))"
-        }
-        Write-Host ""
-        
-        if (-not $NoPrompt) {
-            $cleanInstall = Read-Host "Perform clean installation (remove existing installations)? (y/n)"
-            $shouldClean = $cleanInstall -in @('y', 'yes', 'Y', 'Yes')
-        } else {
-            $shouldClean = $true
-        }
-    } else {
-        $shouldClean = $false
-    }
-    
-    $validChoice = $false
-    while (-not $validChoice) {
-        Write-Host ""
-        Write-Host "Select version to install/update to:"
-        Write-Host "  1. Nightly"
-        Write-Host "  2. Stable"
-        Write-Host "  3. Choose specific version by tag"
-        
-        $choice = Read-Host "Enter the number corresponding to your choice (1/2/3)"
-        
-        switch ($choice) {
-            "1" {
-                $result = Install-NightlyVersion -CleanInstall:$shouldClean
-                $validChoice = $true
-				$env:PATH = [System.Environment]::GetEnvironmentVariable("PATH","Machine") + ";" + [System.Environment]::GetEnvironmentVariable("PATH","User")
-            }
-            "2" {
-                $result = Install-StableVersion -CleanInstall:$shouldClean
-                $validChoice = $true
-				$env:PATH = [System.Environment]::GetEnvironmentVariable("PATH","Machine") + ";" + [System.Environment]::GetEnvironmentVariable("PATH","User")
-            }
-            "3" {
-                $version = Read-Host "Enter the specific version (e.g., v0.9.0)"
-                $result = Install-SpecificVersionWrapper -Version $version -CleanInstall:$shouldClean
-                $validChoice = $true
-				$env:PATH = [System.Environment]::GetEnvironmentVariable("PATH","Machine") + ";" + [System.Environment]::GetEnvironmentVariable("PATH","User")
-            }
-            default {
-                Write-ErrorMessage "Invalid choice. Please enter 1, 2, or 3."
-            }
-        }
-    }
-    
-    return $result
-}
-
-# Uninstall Neovim (wrapper for backward compatibility)
-function Uninstall-Neovim {
-    return Uninstall-AllNeovim
-}
-
-# Check if Neovim is running
-function Test-NeovimRunning {
-    $nvimProcesses = Get-Process -Name "nvim" -ErrorAction SilentlyContinue
-    if ($nvimProcesses) {
-        Write-Host "Error: Neovim is currently running. Please close Neovim before proceeding." -ForegroundColor $Colors.Red
-        
-        if (-not $NoPrompt) {
-            $choice = Read-Host "Do you want to forcefully terminate Neovim and continue? (y/n)"
-            if ($choice -in @('y', 'yes', 'Y', 'Yes')) {
-                $nvimProcesses | Stop-Process -Force
-                Write-InfoMessage "Neovim processes terminated"
-            } else {
-                Write-InfoMessage "Exiting..."
-                exit 1
-            }
-        } else {
-            $nvimProcesses | Stop-Process -Force
-            Write-InfoMessage "Neovim processes terminated"
-        }
-    }
-}
-
-# Check for updates
-function Test-Updates {
-    Write-InfoMessage "Checking for updates..."
-    
-    try {
-        $latestVersion = Get-LatestStableVersion
-        if (-not $latestVersion) {
-            Write-ErrorMessage "Could not fetch latest version information"
-            return
-        }
-        
-        Write-InfoMessage "Latest stable version: $latestVersion"
-        
-        $installations = Find-AllNeovimInstallations
-        if ($hasExistingInstalls) {
-            Write-InfoMessage "Found $($installations.Count) installation(s):"
-            foreach ($installation in $installations) {
-                Write-InfoMessage "  - $($installation.Type): v$($installation.Version) at $($installation.Path)"
-                if ($installation.Version -ne "Unknown" -and "v$($installation.Version)" -ne $latestVersion) {
-                    Write-SuccessMessage "    Update available: v$($installation.Version) → $latestVersion"
-                } elseif ("v$($installation.Version)" -eq $latestVersion) {
-                    Write-InfoMessage "    Up to date"
-                }
-            }
-        } else {
-            Write-InfoMessage "Neovim is not installed"
-        }
-    }
-    catch {
-        Write-ErrorMessage "Failed to check for updates: $_"
-    }
-}
-
-# Main function
-function Main {
-    Write-Host "Neovim Installation Script for Windows" -ForegroundColor $Colors.Cyan
-    Write-Host "=======================================" -ForegroundColor $Colors.Cyan
-    
-    # Check dependencies
-    if (-not (Test-Dependencies)) {
-        exit 1
-    }
-    
-    # Check if Neovim is running
-    Test-NeovimRunning
-    
-    # Check if Neovim is installed
-    $installations = Find-AllNeovimInstallations
-    if ($installations.Count -gt 0) {
-        Write-SuccessMessage "Found $($installations.Count) Neovim installation(s):"
-        foreach ($installation in $installations) {
-            Write-InfoMessage "  - $($installation.Type): v$($installation.Version) at $($installation.Path)"
-        }
-    } else {
-        Write-Host "Neovim is not installed." -ForegroundColor $Colors.Red
-        if (-not $NoPrompt) {
-            $choice = Read-Host "Install Neovim? (y/n)"
-            if ($choice -in @('y', 'yes', 'Y', 'Yes')) {
-                Show-UpdateMenu
-                return
-            } else {
-                Write-InfoMessage "Exiting..."
-                return
-            }
-        }
-    }
-    
-    # Main menu loop
-    while ($Script:ShowPrompt) {
-        Write-Host ""
-        Write-Host "Select an option:"
-        Write-Host "  1. Install/update Neovim"
-        Write-Host "  2. Check for updates"
-        Write-Host "  3. Uninstall all Neovim installations"
-        Write-Host "  4. Run Neovim"
-        Write-Host "  5. Quit"
-        
-        $choice = Read-Host "Enter a number or press 'q' to quit"
-        
-        switch ($choice) {
-            "1" {
-                Show-UpdateMenu
-            }
-            "2" {
-                Test-Updates
-            }
-            "3" {
-                Uninstall-AllNeovim
-            }
-            "4" {
-                if ($installations.Count -gt 0 -or (Get-Command nvim -ErrorAction SilentlyContinue)) {
-                    Write-InfoMessage "Starting Neovim..."
-                    & nvim
-                } else {
-                    Write-ErrorMessage "Neovim is not installed"
-                }
-            }
-            { $_ -in @("5", "q", "Q", "quit", "exit") } {
-                Write-InfoMessage "Exiting..."
-                $Script:ShowPrompt = $false
-            }
-            default {
-                Write-ErrorMessage "Invalid choice. Please choose a valid option by entering the corresponding number or press 'q' to quit."
-            }
-        }
-    }
-}
-
-# Run the main function
-Main