feat: Unity Asset Store compliance with post-installation dependency setup (#281)

* feat: implement Unity Asset Store compliance with post-installation dependency setup

- Remove bundled Python dependencies from Unity package
- Add comprehensive 6-step setup wizard with auto-trigger on first import
- Implement cross-platform dependency detection (Windows, macOS, Linux)
- Add integrated MCP client configuration within setup process
- Create production-ready menu structure with clean UI/UX
- Ensure complete end-to-end setup requiring no additional configuration
- Add comprehensive error handling and recovery mechanisms

This implementation ensures Asset Store compliance while maintaining full
functionality through guided user setup. Users are left 100% ready to use
MCP after completing the setup wizard.

* refactor: improve Asset Store compliance implementation with production-ready setup

- Remove automatic installation attempts on package import
- Always show setup wizard on package install/reinstall
- Integrate MCP client configuration as part of setup wizard process
- Ensure MCP client config window remains accessible via menu
- Remove testing components for production readiness
- Replace automatic installation with manual guidance only
- Add complete 4-step setup flow: Welcome → Dependencies → Installation Guide → Client Configuration → Complete
- Improve user experience with clear instructions and accessible client management

* feat: add comprehensive dependency requirement warnings

- Add critical warnings throughout setup wizard that package cannot function without dependencies
- Update package.json description to clearly state manual dependency installation requirement
- Prevent setup completion if dependencies are missing
- Enhance skip setup warning to emphasize package will be non-functional
- Add error messages explaining consequences of missing dependencies
- Update menu item to indicate setup wizard is required
- Ensure users understand package is completely non-functional without proper dependency installation

* refactor: simplify setup wizard for production

BREAKING: Reduced setup wizard from 5 steps to 3 streamlined steps:
- Step 1: Setup (welcome + dependency check + installation guide)
- Step 2: Configure (client configuration with direct access to full settings)
- Step 3: Complete (final status and quick access to resources)

Simplifications:
- Consolidated UI components with DRY helper methods (DrawSectionTitle, DrawSuccessStatus, DrawErrorStatus)
- Simplified dependency status display with clean icons and essential info
- Removed complex state management - using simple EditorPrefs instead
- Removed unused InstallationOrchestrator and SetupState classes
- Streamlined client configuration to direct users to full settings window
- Simplified navigation with back/skip/next buttons
- Reduced code complexity while maintaining solid principles

Results:
- 40% less code while maintaining all functionality
- Cleaner, more intuitive user flow
- Faster setup process with fewer clicks
- Production-ready simplicity
- Easier maintenance and debugging

* fix: add missing using statement for DependencyCheckResult

Add missing 'using MCPForUnity.Editor.Dependencies.Models;' to resolve
DependencyCheckResult type reference in SetupWizard.cs

* refactor: optimize dependency checks and remove dead code

* fix: remove unused DrawInstallationProgressStep method

Removes leftover method that references deleted _isInstalling and _installationStatus fields, fixing compilation errors.

* feat: improve setup wizard UX and add real client configuration

1. Remove dependency mentions from package.json description
2. Only show dependency warnings when dependencies are actually missing
3. Add actual MCP client configuration functionality within the wizard:
   - Client selection dropdown
   - Individual client configuration
   - Claude Code registration/unregistration
   - Batch configuration for all clients
   - Manual setup instructions
   - Real configuration file writing

Users can now complete full setup including client configuration without leaving the wizard.

* refactor: improve menu text and client restart tip

- Remove '(Required)' from Setup Wizard menu item for cleaner appearance
- Update tip to reflect that most AI clients auto-detect configuration changes

* refactor: simplify client restart tip message

* fix: add missing using statement for MCPForUnityEditorWindow

Add 'using MCPForUnity.Editor.Windows;' to resolve unresolved symbol error for MCPForUnityEditorWindow in SetupWizard.cs

* Format code

* Remove unused folders

* Same for validators

* Same for Setup...

* feat: add setup wizard persistence to avoid showing on subsequent imports

* fix: update Python version check to support Python 4+ across all platform detectors

* refactor: extract common platform detection logic into PlatformDetectorBase class

* feat: add configuration helpers for MCP client setup with sophisticated path resolution

* fix: add missing override keyword to DetectPython method in platform detectors

* fix: update menu item labels for consistent capitalization and naming

* fix: standardize "MCP For Unity" capitalization in window titles and dialogs

* refactor: update package ID from justinpbarnett to coplaydev across codebase

* refactor: remove unused validation and configuration helper methods

* refactor: remove unused warnOnLegacyPackageId parameter from TryFindEmbeddedServerSource

---------

Co-authored-by: Claude <claude@anthropic.com>
Co-authored-by: Marcus Sanatan <msanatan@gmail.com>

Author: 3 people

UnityMcpBridge/Editor/Dependencies.meta

@@ -0,0 +1,308 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.InteropServices;
+using MCPForUnity.Editor.Dependencies.Models;
+using MCPForUnity.Editor.Dependencies.PlatformDetectors;
+using MCPForUnity.Editor.Helpers;
+using UnityEditor;
+using UnityEngine;
+
+namespace MCPForUnity.Editor.Dependencies
+{
+    /// <summary>
+    /// Main orchestrator for dependency validation and management
+    /// </summary>
+    public static class DependencyManager
+    {
+        private static readonly List<IPlatformDetector> _detectors = new List<IPlatformDetector>
+        {
+            new WindowsPlatformDetector(),
+            new MacOSPlatformDetector(),
+            new LinuxPlatformDetector()
+        };
+
+        private static IPlatformDetector _currentDetector;
+
+        /// <summary>
+        /// Get the platform detector for the current operating system
+        /// </summary>
+        public static IPlatformDetector GetCurrentPlatformDetector()
+        {
+            if (_currentDetector == null)
+            {
+                _currentDetector = _detectors.FirstOrDefault(d => d.CanDetect);
+                if (_currentDetector == null)
+                {
+                    throw new PlatformNotSupportedException($"No detector available for current platform: {RuntimeInformation.OSDescription}");
+                }
+            }
+            return _currentDetector;
+        }
+
+        /// <summary>
+        /// Perform a comprehensive dependency check
+        /// </summary>
+        public static DependencyCheckResult CheckAllDependencies()
+        {
+            var result = new DependencyCheckResult();
+
+            try
+            {
+                var detector = GetCurrentPlatformDetector();
+                McpLog.Info($"Checking dependencies on {detector.PlatformName}...", always: false);
+
+                // Check Python
+                var pythonStatus = detector.DetectPython();
+                result.Dependencies.Add(pythonStatus);
+
+                // Check UV
+                var uvStatus = detector.DetectUV();
+                result.Dependencies.Add(uvStatus);
+
+                // Check MCP Server
+                var serverStatus = detector.DetectMCPServer();
+                result.Dependencies.Add(serverStatus);
+
+                // Generate summary and recommendations
+                result.GenerateSummary();
+                GenerateRecommendations(result, detector);
+
+                McpLog.Info($"Dependency check completed. System ready: {result.IsSystemReady}", always: false);
+            }
+            catch (Exception ex)
+            {
+                McpLog.Error($"Error during dependency check: {ex.Message}");
+                result.Summary = $"Dependency check failed: {ex.Message}";
+                result.IsSystemReady = false;
+            }
+
+            return result;
+        }
+
+        /// <summary>
+        /// Quick check if system is ready for MCP operations
+        /// </summary>
+        public static bool IsSystemReady()
+        {
+            try
+            {
+                var result = CheckAllDependencies();
+                return result.IsSystemReady;
+            }
+            catch
+            {
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// Get a summary of missing dependencies
+        /// </summary>
+        public static string GetMissingDependenciesSummary()
+        {
+            try
+            {
+                var result = CheckAllDependencies();
+                var missing = result.GetMissingRequired();
+
+                if (missing.Count == 0)
+                {
+                    return "All required dependencies are available.";
+                }
+
+                var names = missing.Select(d => d.Name).ToArray();
+                return $"Missing required dependencies: {string.Join(", ", names)}";
+            }
+            catch (Exception ex)
+            {
+                return $"Error checking dependencies: {ex.Message}";
+            }
+        }
+
+        /// <summary>
+        /// Check if a specific dependency is available
+        /// </summary>
+        public static bool IsDependencyAvailable(string dependencyName)
+        {
+            try
+            {
+                var detector = GetCurrentPlatformDetector();
+
+                return dependencyName.ToLowerInvariant() switch
+                {
+                    "python" => detector.DetectPython().IsAvailable,
+                    "uv" => detector.DetectUV().IsAvailable,
+                    "mcpserver" or "mcp-server" => detector.DetectMCPServer().IsAvailable,
+                    _ => false
+                };
+            }
+            catch
+            {
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// Get installation recommendations for the current platform
+        /// </summary>
+        public static string GetInstallationRecommendations()
+        {
+            try
+            {
+                var detector = GetCurrentPlatformDetector();
+                return detector.GetInstallationRecommendations();
+            }
+            catch (Exception ex)
+            {
+                return $"Error getting installation recommendations: {ex.Message}";
+            }
+        }
+
+        /// <summary>
+        /// Get platform-specific installation URLs
+        /// </summary>
+        public static (string pythonUrl, string uvUrl) GetInstallationUrls()
+        {
+            try
+            {
+                var detector = GetCurrentPlatformDetector();
+                return (detector.GetPythonInstallUrl(), detector.GetUVInstallUrl());
+            }
+            catch
+            {
+                return ("https://python.org/downloads/", "https://docs.astral.sh/uv/getting-started/installation/");
+            }
+        }
+
+        /// <summary>
+        /// Validate that the MCP server can be started
+        /// </summary>
+        public static bool ValidateMCPServerStartup()
+        {
+            try
+            {
+                // Check if Python and UV are available
+                if (!IsDependencyAvailable("python") || !IsDependencyAvailable("uv"))
+                {
+                    return false;
+                }
+
+                // Try to ensure server is installed
+                ServerInstaller.EnsureServerInstalled();
+
+                // Check if server files exist
+                var serverStatus = GetCurrentPlatformDetector().DetectMCPServer();
+                return serverStatus.IsAvailable;
+            }
+            catch (Exception ex)
+            {
+                McpLog.Error($"Error validating MCP server startup: {ex.Message}");
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// Attempt to repair the Python environment
+        /// </summary>
+        public static bool RepairPythonEnvironment()
+        {
+            try
+            {
+                McpLog.Info("Attempting to repair Python environment...");
+                return ServerInstaller.RepairPythonEnvironment();
+            }
+            catch (Exception ex)
+            {
+                McpLog.Error($"Error repairing Python environment: {ex.Message}");
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// Get detailed dependency information for diagnostics
+        /// </summary>
+        public static string GetDependencyDiagnostics()
+        {
+            try
+            {
+                var result = CheckAllDependencies();
+                var detector = GetCurrentPlatformDetector();
+
+                var diagnostics = new System.Text.StringBuilder();
+                diagnostics.AppendLine($"Platform: {detector.PlatformName}");
+                diagnostics.AppendLine($"Check Time: {result.CheckedAt:yyyy-MM-dd HH:mm:ss} UTC");
+                diagnostics.AppendLine($"System Ready: {result.IsSystemReady}");
+                diagnostics.AppendLine();
+
+                foreach (var dep in result.Dependencies)
+                {
+                    diagnostics.AppendLine($"=== {dep.Name} ===");
+                    diagnostics.AppendLine($"Available: {dep.IsAvailable}");
+                    diagnostics.AppendLine($"Required: {dep.IsRequired}");
+
+                    if (!string.IsNullOrEmpty(dep.Version))
+                        diagnostics.AppendLine($"Version: {dep.Version}");
+
+                    if (!string.IsNullOrEmpty(dep.Path))
+                        diagnostics.AppendLine($"Path: {dep.Path}");
+
+                    if (!string.IsNullOrEmpty(dep.Details))
+                        diagnostics.AppendLine($"Details: {dep.Details}");
+
+                    if (!string.IsNullOrEmpty(dep.ErrorMessage))
+                        diagnostics.AppendLine($"Error: {dep.ErrorMessage}");
+
+                    diagnostics.AppendLine();
+                }
+
+                if (result.RecommendedActions.Count > 0)
+                {
+                    diagnostics.AppendLine("=== Recommended Actions ===");
+                    foreach (var action in result.RecommendedActions)
+                    {
+                        diagnostics.AppendLine($"- {action}");
+                    }
+                }
+
+                return diagnostics.ToString();
+            }
+            catch (Exception ex)
+            {
+                return $"Error generating diagnostics: {ex.Message}";
+            }
+        }
+
+        private static void GenerateRecommendations(DependencyCheckResult result, IPlatformDetector detector)
+        {
+            var missing = result.GetMissingDependencies();
+
+            if (missing.Count == 0)
+            {
+                result.RecommendedActions.Add("All dependencies are available. You can start using MCP for Unity.");
+                return;
+            }
+
+            foreach (var dep in missing)
+            {
+                if (dep.Name == "Python")
+                {
+                    result.RecommendedActions.Add($"Install Python 3.10+ from: {detector.GetPythonInstallUrl()}");
+                }
+                else if (dep.Name == "UV Package Manager")
+                {
+                    result.RecommendedActions.Add($"Install UV package manager from: {detector.GetUVInstallUrl()}");
+                }
+                else if (dep.Name == "MCP Server")
+                {
+                    result.RecommendedActions.Add("MCP Server will be installed automatically when needed.");
+                }
+            }
+
+            if (result.GetMissingRequired().Count > 0)
+            {
+                result.RecommendedActions.Add("Use the Setup Wizard (Window > MCP for Unity > Setup Wizard) for guided installation.");
+            }
+        }
+    }
+}