fix: more changes related to package manager

Author: qubka

content/1.introduction/1.quick-start.md

@@ -8,7 +8,7 @@ icon: lucide:rocket
   The documentation is currently under development and may contain inaccuracies.  
 ::
 
-Plugify is a powerful plugin and package manager designed to simplify multi-language plugin development. Whether you're a developer, modder, or integrator, this guide will help you get started quickly.
+Plugify is a powerful plugin manager designed to simplify multi-language plugin development. Whether you're a developer, modder, or integrator, this guide will help you get started quickly.
 
 ## General Information
 

content/1.introduction/2.overview.md

@@ -9,7 +9,7 @@ icon: lucide:book-open
 ## Key Features
 - **Multi-Language Support**: Write plugins in any supported language, including C++, C#, Python, Go, and JavaScript.
 - **Inter-Language Communication**: Enable plugins written in different languages to interact and share data effortlessly.
-- **Package Management**: Easily install, update, and manage plugins and language modules with the built-in package manager.
+- **Package Management**: Easily install, update, and manage plugins and language modules with the Mamba package manager.
 - **Cross-Platform Compatibility**: Works on Windows, Linux, macOS, PlayStation, Nintendo Switch, Android, and iOS.
 
 ## Why Choose Plugify?

content/1.introduction/3.features.md

@@ -4,7 +4,7 @@ description: What makes Plugify powerful and unique?
 icon: lucide:sparkles
 ---
 
-Plugify is a powerful and versatile plugin and package manager designed to simplify multi-language plugin development. Below is a detailed breakdown of its key features and capabilities.
+Plugify is a powerful and versatile plugin manager designed to simplify multi-language plugin development. Below is a detailed breakdown of its key features and capabilities.
 
 ## Multi-Language Support
 
@@ -15,6 +15,7 @@ Plugify supports plugins written in multiple programming languages, enabling dev
 - **Python**: Integration with Python 3.12 and above.
 - **Go**: Full support for Go plugins.
 - **JavaScript**: Integration with the V8 engine.
+- **DLang**: Support of D language.
 
 This flexibility allows teams to leverage their existing expertise and tools, making plugin development more accessible and efficient.
 
@@ -28,7 +29,7 @@ Plugify enables seamless communication between plugins written in different lang
 
 ## Package Management
 
-Plugify includes a robust package manager that simplifies the management of plugins and language modules. Key features include:
+Plugify could include the Mamba package manager that simplifies the management of plugins and language modules. Key features include:
 
 - **Local and Remote Packages**: Manage both locally stored packages and remote packages from online repositories.
 - **Dependency Resolution**: Automatically resolve and install dependencies for plugins and modules.

content/1.introduction/5.faq.md

@@ -11,7 +11,7 @@ icon: lucide:badge-help
 What is Plugify?
 
 #content
-Plugify is a **modern C++ plugin and package manager** designed to simplify and enhance plugin development across multiple programming languages. It provides a unified environment for creating, managing, and extending plugins, enabling seamless communication between plugins written in different languages. Plugify is ideal for game development, software extensibility, and cross-language projects.
+Plugify is a **modern C++ plugin manager** designed to simplify and enhance plugin development across multiple programming languages. It provides a unified environment for creating, managing, and extending plugins, enabling seamless communication between plugins written in different languages. Plugify is ideal for game development, software extensibility, and cross-language projects.
 ::
 
 ::accordion-item
@@ -102,7 +102,7 @@ Refer to the [Language Module Development Guide](/developer-guide) for detailed
 How do I manage plugins and packages?
 
 #content
-Plugify includes a robust **Package Manager** that handles:
+Plugify includes the **Mamba Package Manager** that handles:
 
 - **Local and Remote Packages**: Manage both locally stored packages and remote packages from online repositories.
 - **Dependency Resolution**: Automatically resolve and install dependencies for plugins and modules.
@@ -263,7 +263,7 @@ To uninstall Plugify:
 
 1. Remove the Plugify library from your project.
 2. Delete the `plugify.pconfig` file and the `res` folder (if no longer needed).
-3. If you installed Plugify system-wide, use your package manager or manually remove the installed files.
+3. If you installed Plugify system-wide, use Mamba package manager or manually remove the installed files.
 ::
 
 ::

content/1.introduction/6.requirements.md

@@ -72,7 +72,7 @@ Plugify has the following dependencies:
 ### Recommended Tools
 - **IDE**: Visual Studio 2022, CLion, or VS Code with C++ extensions.
 - **Debugging Tools**: GDB, LLDB, or Visual Studio Debugger.
-- **Package Managers**:
+- **Package Managers**: mamba, micromamba or conda
     - **Windows**: vcpkg or NuGet.
     - **Linux**: apt, dnf, or pacman.
     - **macOS**: Homebrew.

content/2.essentials/2.directory-structure.md

@@ -40,7 +40,7 @@ tree:
         - libplugify.so
         - other_binaries
     - res:
-        - plugins:
+        - extensions:
             - my-plugin:
                 - bin:
                     - my-plugin.dll
@@ -51,7 +51,6 @@ tree:
                     - another-plugin.dll
                     - libanother-plugin.so
                 - another-plugin.pplugin
-        - modules:
             - cpp-module:
                 - bin:
                     - cpp-module.dll

content/2.essentials/3.building.md

@@ -262,29 +262,24 @@ cmake -DCMAKE_BUILD_TYPE=MinSizeRel -G Ninja ..
 
 Plugify provides several CMake options for customization:
 
-| Option                               | Description                                                                                                    |
-|--------------------------------------|----------------------------------------------------------------------------------------------------------------|
-| `-DPLUGIFY_BUILD_TESTS=ON`           | Enable building tests                                                                                          |
-| `-DPLUGIFY_BUILD_JIT=OFF`            | Build JIT object library                                                                                       |
-| `-DPLUGIFY_BUILD_ASSEMBLY=OFF`       | Build assembly object library                                                                                  |
-| `-DPLUGIFY_BUILD_DOCS=OFF`           | Enable building with documentation                                                                             |
-| `-DPLUGIFY_BUILD_OBJECT_LIB=OFF`     | Build Plugify as an object library                                                                             |
-| `-DPLUGIFY_BUILD_SHARED_LIB=ON`      | Build Plugify as a shared library                                                                              |
-| `-DPLUGIFY_BUILD_SHARED_ASMJIT=OFF`  | Build AsmJit as a shared library                                                                               |
-| `-DPLUGIFY_BUILD_SHARED_CURL=OFF`    | Build cURL as a shared library                                                                                 |
-| `-DPLUGIFY_USE_EXTERNAL_ASMJIT=OFF`  | Use an external AsmJit library                                                                                 |
-| `-DPLUGIFY_USE_EXTERNAL_GLAZE=OFF`   | Use an external Glaze library                                                                                  |
-| `-DPLUGIFY_USE_EXTERNAL_CURL=ON`     | Use an external cURL library                                                                                   |
-| `-DPLUGIFY_USE_EXTERNAL_FMT=OFF`     | Use an external fmt library                                                                                    |
-| `-DPLUGIFY_INTERFACE=OFF`            | Build as a lightweight interface for language modules                                                          |
-| `-DPLUGIFY_DOWNLOADER=ON`            | Enable the downloader for the package manager                                                                  |
-| `-DPLUGIFY_LOGGING=ON`               | Enable the logging system                                                                                      |
-| `-DPLUGIFY_DEBUG=ON`                 | Enable debugging mode (asserts)                                                                                |
-| `-DPLUGIFY_USE_LIBCPP=OFF`           | Use libc++ by adding `-stdlib=libc++` flag if available                                                        |
-| `-DPLUGIFY_USE_STATIC_STDLIB=OFF`    | Enable static standard library linkage to avoid ABI issues by adding `-static-*` flags if available            |
-| `-DPLUGIFY_USE_SANITIZER=OFF`        | Enable sanitizers by adding `-fsanitize=address -fno-omit-frame-pointer -fsanitize=undefined` flags if available |
-| `-DPLUGIFY_USE_CLANG_TIDY=OFF`       | Enable static analysis with clang-tidy                                                                         |
-| `-DPLUGIFY_USE_ABI0=ON`              | Enable use of the older C++ ABI, which was the default in GCC versions before GCC 5                            |
+| Option                                | Description                                                                                                                    |
+|---------------------------------------|--------------------------------------------------------------------------------------------------------------------------------|
+| `-DPLUGIFY_BUILD_TESTS=ON`            | Enable building tests                                                                                                          |
+| `-DPLUGIFY_BUILD_DOCS=OFF`            | Enable building with documentation                                                                                             |
+| `-DPLUGIFY_BUILD_OBJECT_LIB=OFF`      | Build Plugify as an object library                                                                                             |
+| `-DPLUGIFY_BUILD_SHARED_LIB=ON`       | Build Plugify as a shared library                                                                                              |
+| `-DPLUGIFY_BUILD_SHARED_ASMJIT=OFF`   | Build AsmJit as a shared library                                                                                               |
+| `-DPLUGIFY_USE_EXTERNAL_ASMJIT=OFF`   | Use an external AsmJit library                                                                                                 |
+| `-DPLUGIFY_USE_EXTERNAL_GLAZE=OFF`    | Use an external Glaze library                                                                                                  |
+| `-PLUGIFY_USE_EXTERNAL_LIBSOLV=ON`    | Use an external LibSolv library                                                                                                |
+| `-DPLUGIFY_USE_EXTERNAL_FMT=OFF`      | Use an external fmt library                                                                                                    |
+| `-DPLUGIFY_USE_LIBCPP=OFF`            | Use libc++ by adding `-stdlib=libc++` flag if available                                                                        |
+| `-DPLUGIFY_USE_STATIC_STDLIB=OFF`     | Enable static standard library linkage to avoid ABI issues by adding `-static-*` flags if available                            |
+| `-DPLUGIFY_USE_SANITIZER=OFF`         | Enable sanitizers by adding `-fsanitize=*` flags if available                     |
+| `-PLUGIFY_SANITIZER_PATH=""`          | Path to sanitizes libraries.                                                                                                   |
+| `-PLUGIFY_ENABLED_SANITIZERS=address` | Semicolon separated list of sanitizer names. E.g 'address;leak'. Supported sanitizers are address, leak, undefined and thread. |
+| `-DPLUGIFY_USE_CLANG_TIDY=OFF`        | Enable static analysis with clang-tidy                                                                                         |
+| `-DPLUGIFY_USE_ABI0=ON`               | Enable use of the older C++ ABI, which was the default in GCC versions before GCC 5                                            |
 
 ## Testing the Build
 

content/2.essentials/4.integrating.md

@@ -93,46 +93,95 @@ In this setup, `thirdparty/plugify` should contain a complete copy of the Plugif
 
 ## Example: Initializing Plugify in Your Application
 
-Once integrated, you can initialize Plugify in your application as follows:
+This code creates an instance of the plugify::Plugify object. It sets up services, initializes the instance, and then interacts with a plugin manager. Error handling is included for initialization failures.
 
 ::code-group
 ```c++ [main.cpp]
+// Example 1: Simple usage with defaults
 int main() {
-   // Create a Plugify instance
-   std::shared_ptr<plugify::IPlugify> instance = plugify::MakePlugify();
-   if (instance) {
-	   // Set up logging
-	   auto logger = std::make_shared<CustomLogger>();
-	   instance->SetLogger(logger);
-	   logger->SetSeverity(plugify::Severity::Debug);
-
-		 // Initialize Plugify
-		 if (!instance->Initialize()) {
-			 std::cerr << "Failed to initialize Plugify!" << std::endl;
-			 return EXIT_FAILURE;
-		 }
-	   
-		 // Access the Package Manager
-		 if (auto packageManager = instance->GetPackageManager().lock()) {
-			 packageManager->Initialize();
-	   
-			 // Handle missing or conflicted packages
-			 if (packageManager->HasMissedPackages()) {
-				 std::cerr << "Plugin manager has missing packages." << std::endl;
-				 packageManager->InstallMissedPackages();
-			 }
-			 if (packageManager->HasConflictedPackages()) {
-				 std::cerr << "Plugin manager has conflicted packages." << std::endl;
-				 packageManager->UninstallConflictedPackages();
-			}
-		 }
-	   
-		 // Access the Plugin Manager
-		 if (auto pluginManager = instance->GetPluginManager().lock()) {
-			pluginManager->Initialize();
-		}
-	}
-	return EXIT_SUCCESS;
+    auto result = plugify::MakePlugify("./app");
+    if (!result) {
+        std::cerr << "Failed to create Plugify: " << result.error().message << std::endl;
+        return 1;
+    }
+
+    auto plugify = result.value();
+    if (auto initResult = plugify->Initialize(); !initResult) {
+        std::cerr << "Failed to initialize: " << initResult.error().message << std::endl;
+        return 1;
+    }
+
+    // Load extensions
+    const auto& manager = plugify->GetManager();
+    manager->Initialize();
+
+    // Main loop
+    bool running = true;
+    while (running) {
+        plugify->Update();
+        // Your application logic here
+    }
+
+    plugify->Terminate();
+    return 0;
+}
+```
+::
+
+::code-group
+```c++ [main.cpp]
+// Example 2: Advanced configuration
+int main() {
+    // Create custom logger
+    auto logger = std::make_shared<plugify::impl::AsyncLogger>(
+        std::make_shared<plugify::impl::FileLogger>("./logs/app.log")
+    );
+
+    // Configure plugin manager
+    plugify::Config config;
+    config.paths.baseDir = "./app";
+    config.paths.extensionsDir = "extensions";
+    config.loading.enableHotReload = true;
+    config.loading.parallelLoading = true;
+    config.runtime.updateInterval = std::chrono::milliseconds(16);
+
+    // Build Plugify instance
+    auto result = plugify::Plugify::CreateBuilder()
+        .WithConfig(config)
+        .WithLogger(logger)
+        .WithService<MyCustomService>(std::make_shared<MyCustomServiceImpl>())
+        .Build();
+
+    if (!result) {
+        std::cerr << "Failed: " << result.error().message << std::endl;
+        return 1;
+    }
+
+    auto plugify = result.value();
+
+    // Initialize asynchronously
+    auto initFuture = plugify->InitializeAsync();
+
+    // Do other initialization...
+
+    // Wait for initialization
+    if (auto initResult = initFuture.get(); !initResult) {
+        std::cerr << "Failed to initialize: " << initResult.error().message << std::endl;
+        return 1;
+    }
+
+    // Access service locator for convenient operations
+    auto logger = plugify->GetServices().Resolve<ILogger>();
+    logger->Log("Application started", Severity::Info);
+
+    // Main loop
+    bool running = true;
+    while (running) {
+        plugify->Update();
+    }
+
+    plugify->Terminate();
+    return 0;
 }
 ```
 ::

content/3.use-cases/1.metamod-plugin/2.installation.md

@@ -43,8 +43,7 @@ tree:
                             - ^plugify.dll^
                         - linuxsteamrt64:
                             - ^libplugify.so^
-                    - modules:
-                    - plugins:
+                    - extensions:
             - ^plugify.pconfig^
         - csgo_core:
         - csgo_imported:

content/3.use-cases/1.metamod-plugin/4.updating.md

@@ -34,7 +34,7 @@ The output should display the updated version of Plugify.
 
 ## **Automatic Update**
 
-Plugify seamlessly integrates with a **package manager**, a tool that automates the process of installing, upgrading, configuring, and removing packages (plugins and language modules) in a consistent manner. Each plugin and language module is considered a package, and the package manager simplifies the management of these components.
+Plugify seamlessly integrates with the **Mamba package manager**, a tool that automates the process of installing, upgrading, configuring, and removing packages (plugins and language modules) in a consistent manner. Each plugin and language module is considered a package, and the package manager simplifies the management of these components.
 
 ### **Using the Package Manager**
 To update plugins and language modules automatically, follow these steps:
@@ -67,9 +67,6 @@ To update plugins and language modules automatically, follow these steps:
    Restart your server to ensure that all updates are applied correctly.
 ::
 
-## **Important Note**
-The **package manager cannot update itself or the core Plugify library** at this time. To update Plugify, you must follow the **manual update process** described above.
-
 ## **Troubleshooting**
 
 ### **Common Issues**