Re-Sync

Author: NikolaRHristov

Source/command/CommandExecutor.rs

@@ -0,0 +1,39 @@
+use async_trait::async_trait;
+use serde_json::Value;
+
+/// @module CommandExecutor
+/// @description Defines the abstract service trait for command management
+/// capabilities.
+use crate::environment::Environment;
+use crate::error::CommonError;
+
+/// An abstract service contract for an environment component that can execute
+/// and manage commands within the application.
+///
+/// This trait is implemented by `MountainEnvironment` and provides the core
+/// logic for the command palette and programmatic command execution. It can
+/// handle both native commands implemented in Rust and proxied commands
+/// implemented in sidecars.
+#[async_trait]
+pub trait CommandExecutor: Environment + Send + Sync {
+	/// Executes a command with the given ID and arguments.
+	///
+	/// @param CommandIdentifier - The unique ID of the command to execute.
+	/// @param Argument - A `serde_json::Value` containing the arguments for
+	/// the command. @returns A `Result` containing the command's return value
+	/// as a `serde_json::Value`.
+	async fn ExecuteCommand(&self, CommandIdentifier:String, Argument:Value) -> Result<Value, CommonError>;
+
+	/// Registers a command that is implemented in an external sidecar process.
+	///
+	/// @param SidecarIdentifier - The ID of the sidecar where the command logic
+	/// resides. @param CommandIdentifier - The unique ID of the command being
+	/// registered.
+	async fn RegisterCommand(&self, SidecarIdentifier:String, CommandIdentifier:String) -> Result<(), CommonError>;
+
+	/// Unregisters a previously registered command.
+	async fn UnregisterCommand(&self, SidecarIdentifier:String, CommandIdentifier:String) -> Result<(), CommonError>;
+
+	/// Retrieves a list of all currently registered command IDs.
+	async fn GetAllCommands(&self) -> Result<Vec<String>, CommonError>;
+}

Source/command/ExecuteCommand.rs

@@ -0,0 +1,41 @@
+use std::sync::Arc;
+
+use serde_json::Value;
+
+/// @module ExecuteCommand
+/// @description Defines the ActionEffect for executing a command.
+use super::CommandExecutor::CommandExecutor;
+use crate::{
+	effect::{ActionEffect, AppRuntime},
+	environment::Requires,
+	error::CommonError,
+};
+
+/// Creates an effect that, when executed, will run a command by its unique ID.
+///
+/// It uses the `CommandExecutor` capability from the environment to dispatch
+/// the command to the appropriate handler, whether native or proxied.
+///
+/// @param CommandIdentifier - The unique ID of the command to execute.
+/// @param Argument - A `serde_json::Value` containing the arguments for the
+/// command.
+///
+/// @returns An `ActionEffect` that resolves with the command's return value as
+/// a `serde_json::Value`.
+pub fn ExecuteCommand<Runtime>(
+	CommandIdentifier:String,
+	Argument:Value,
+) -> ActionEffect<Arc<Runtime>, CommonError, Value>
+where
+	Runtime: AppRuntime + Send + Sync + 'static,
+	Runtime::EnvironmentType: Requires<Arc<dyn CommandExecutor>>, {
+	ActionEffect::New(Arc::new(move |Runtime:Arc<Runtime>| {
+		let CommandIdentifierClone = CommandIdentifier.clone();
+		let ArgumentClone = Argument.clone();
+		Box::pin(async move {
+			let Environment = Runtime.GetEnvironment();
+			let Executor:Arc<dyn CommandExecutor> = Environment.Require();
+			Executor.ExecuteCommand(CommandIdentifierClone, ArgumentClone).await
+		})
+	}))
+}

Source/command/GetAllCommands.rs

@@ -0,0 +1,32 @@
+use std::sync::Arc;
+
+/// @module GetAllCommands
+/// @description Defines the ActionEffect for retrieving all registered command
+/// IDs.
+use super::CommandExecutor::CommandExecutor;
+use crate::{
+	effect::{ActionEffect, AppRuntime},
+	environment::Requires,
+	error::CommonError,
+};
+
+/// Creates an effect that, when executed, will retrieve a list of all currently
+/// registered command identifiers, including both native and proxied commands.
+///
+/// It uses the `CommandExecutor` capability from the environment to perform the
+/// operation.
+///
+/// @returns An `ActionEffect` that resolves with a `Vec<String>` of command
+/// IDs.
+pub fn GetAllCommands<Runtime>() -> ActionEffect<Arc<Runtime>, CommonError, Vec<String>>
+where
+	Runtime: AppRuntime + Send + Sync + 'static,
+	Runtime::EnvironmentType: Requires<Arc<dyn CommandExecutor>>, {
+	ActionEffect::New(Arc::new(move |Runtime:Arc<Runtime>| {
+		Box::pin(async move {
+			let Environment = Runtime.GetEnvironment();
+			let Executor:Arc<dyn CommandExecutor> = Environment.Require();
+			Executor.GetAllCommands().await
+		})
+	}))
+}

Source/command/RegisterCommand.rs

@@ -0,0 +1,42 @@
+use std::sync::Arc;
+
+/// @module RegisterCommand
+/// @description Defines the ActionEffect for registering a command that is
+/// implemented in an external sidecar process.
+use super::CommandExecutor::CommandExecutor;
+use crate::{
+	effect::{ActionEffect, AppRuntime},
+	environment::Requires,
+	error::CommonError,
+};
+
+/// Creates an effect that, when executed, will register a command that is
+/// implemented in a sidecar process like Cocoon.
+///
+/// This allows the host application (`Mountain`) to know about commands
+/// contributed by extensions so they can be displayed in the command palette
+/// and invoked correctly. The `CommandExecutor` implementation will store this
+/// as a `Proxied` command.
+///
+/// @param SidecarIdentifier - The unique ID of the sidecar where the command
+/// logic resides. @param CommandIdentifier - The unique ID of the command
+/// itself (e.g., "myExtension.doSomething").
+///
+/// @returns An `ActionEffect` that resolves to `()` on success.
+pub fn RegisterCommand<Runtime>(
+	SidecarIdentifier:String,
+	CommandIdentifier:String,
+) -> ActionEffect<Arc<Runtime>, CommonError, ()>
+where
+	Runtime: AppRuntime + Send + Sync + 'static,
+	Runtime::EnvironmentType: Requires<Arc<dyn CommandExecutor>>, {
+	ActionEffect::New(Arc::new(move |Runtime:Arc<Runtime>| {
+		let SidecarIdentifierClone = SidecarIdentifier.clone();
+		let CommandIdentifierClone = CommandIdentifier.clone();
+		Box::pin(async move {
+			let Environment = Runtime.GetEnvironment();
+			let Executor:Arc<dyn CommandExecutor> = Environment.Require();
+			Executor.RegisterCommand(SidecarIdentifierClone, CommandIdentifierClone).await
+		})
+	}))
+}

Source/command/UnregisterCommand.rs

@@ -0,0 +1,39 @@
+use std::sync::Arc;
+
+/// @module UnregisterCommand
+/// @description Defines the ActionEffect for unregistering a command.
+use super::CommandExecutor::CommandExecutor;
+use crate::{
+	effect::{ActionEffect, AppRuntime},
+	environment::Requires,
+	error::CommonError,
+};
+
+/// Creates an effect that, when executed, will unregister a command from the
+/// host's command registry.
+///
+/// This is typically called when an extension is deactivated or disposes of a
+/// command registration.
+///
+/// @param SidecarIdentifier - The unique ID of the sidecar that originally
+/// registered the command. @param CommandIdentifier - The unique ID of the
+/// command to unregister.
+///
+/// @returns An `ActionEffect` that resolves to `()` on success.
+pub fn UnregisterCommand<Runtime>(
+	SidecarIdentifier:String,
+	CommandIdentifier:String,
+) -> ActionEffect<Arc<Runtime>, CommonError, ()>
+where
+	Runtime: AppRuntime + Send + Sync + 'static,
+	Runtime::EnvironmentType: Requires<Arc<dyn CommandExecutor>>, {
+	ActionEffect::New(Arc::new(move |Runtime:Arc<Runtime>| {
+		let SidecarIdentifierClone = SidecarIdentifier.clone();
+		let CommandIdentifierClone = CommandIdentifier.clone();
+		Box::pin(async move {
+			let Environment = Runtime.GetEnvironment();
+			let Executor:Arc<dyn CommandExecutor> = Environment.Require();
+			Executor.UnregisterCommand(SidecarIdentifierClone, CommandIdentifierClone).await
+		})
+	}))
+}

Source/command/mod.rs

@@ -0,0 +1,25 @@
+
+
+/**
+ * @module command
+ * @description This module defines the abstract contract for the Command service.
+ * It includes the `CommandExecutor` trait and the `ActionEffect` constructors for
+ * all command operations.
+ */
+
+#![allow(non_snake_case, non_camel_case_types)]
+
+// --- Trait Definition ---
+mod CommandExecutor;
+pub use self::CommandExecutor::CommandExecutor;
+
+// --- Effect Constructors ---
+mod ExecuteCommand;
+mod GetAllCommands;
+mod RegisterCommand;
+mod UnregisterCommand;
+
+pub use self::ExecuteCommand::ExecuteCommand;
+pub use self::GetAllCommands::GetAllCommands;
+pub use self::RegisterCommand::RegisterCommand;
+pub use self::UnregisterCommand::UnregisterCommand;

Source/config/ConfigInspector.rs

@@ -0,0 +1,30 @@
+use async_trait::async_trait;
+
+/// @module ConfigInspector
+/// @description Defines the abstract service trait for inspecting the sources
+/// of configuration values.
+use super::dto::{ConfigurationOverridesDto, InspectResultDataDto};
+use crate::{environment::Environment, error::CommonError};
+
+/// An abstract service contract for an environment component that can inspect
+/// a configuration key to provide details about its value in all relevant
+/// scopes (e.g., default, user, workspace) and its final effective value.
+///
+/// This is used to power the "Settings" UI, which often shows where a
+/// particular setting is defined.
+#[async_trait]
+pub trait ConfigInspector: Environment + Send + Sync {
+	/// Inspects a configuration key to get its value from all relevant scopes.
+	///
+	/// @param Key - The dot-separated configuration key to inspect.
+	/// @param Overrides - A DTO specifying scope overrides (e.g., for a
+	/// specific resource).
+	///
+	/// @returns A `Result` containing an `Option<InspectResultDataDto>`, which
+	/// holds   the detailed breakdown of the key's values across all scopes.
+	async fn InspectConfigurationValue(
+		&self,
+		Key:String,
+		Overrides:ConfigurationOverridesDto,
+	) -> Result<Option<InspectResultDataDto>, CommonError>;
+}

Source/config/ConfigProvider.rs

@@ -0,0 +1,49 @@
+use async_trait::async_trait;
+use serde_json::Value;
+
+/// @module ConfigProvider
+/// @description Defines the abstract service trait for providing and updating
+/// configuration values.
+use super::dto::{ConfigurationOverridesDto, ConfigurationTarget};
+use crate::{environment::Environment, error::CommonError};
+
+/// An abstract service contract for an environment component that can provide
+/// the final, merged configuration values and handle requests to update those
+/// values in their persistent storage (i.e., `settings.json` files).
+#[async_trait]
+pub trait ConfigProvider: Environment + Send + Sync {
+	/// Retrieves a configuration value for a given section/key, applying
+	/// specified overrides. This should return the final, effective value
+	/// after merging all configuration sources.
+	///
+	/// @param Section - An optional, dot-separated key to a specific
+	/// configuration section.   If `None`, the entire configuration object
+	/// should be returned. @param Overrides - A DTO specifying scope overrides
+	/// (e.g., for a specific resource).
+	///
+	/// @returns A `Result` containing the requested configuration as a
+	/// `serde_json::Value`.
+	async fn GetConfigurationValue(
+		&self,
+		Section:Option<String>,
+		Overrides:ConfigurationOverridesDto,
+	) -> Result<Value, CommonError>;
+
+	/// Updates a configuration value at a specific key and target scope.
+	///
+	/// @param Key - The dot-separated configuration key to update.
+	/// @param ValueToSet - The new `serde_json::Value` to set for the key.
+	/// @param Target - The `ConfigurationTarget` enum specifying which scope to
+	/// write to   (e.g., User, Workspace).
+	/// @param Overrides - A DTO for scope overrides.
+	/// @param ScopeToLanguage - An optional flag related to language-specific
+	/// settings.
+	async fn UpdateConfigurationValue(
+		&self,
+		Key:String,
+		ValueToSet:Value,
+		Target:ConfigurationTarget,
+		Overrides:ConfigurationOverridesDto,
+		ScopeToLanguage:Option<bool>,
+	) -> Result<(), CommonError>;
+}

Source/config/GetConfiguration.rs

@@ -0,0 +1,54 @@
+use std::sync::Arc;
+
+use serde_json::Value;
+
+/// @module GetConfiguration
+/// @description Defines the ActionEffect for retrieving a configuration value
+/// or section.
+use super::{ConfigProvider::ConfigProvider, dto::ConfigurationOverridesDto};
+use crate::{
+	effect::{ActionEffect, AppRuntime},
+	environment::Requires,
+	error::CommonError,
+};
+
+/// Creates an effect that, when executed, will retrieve the final, merged
+/// configuration value for a given section, applying any specified overrides.
+///
+/// It uses the `ConfigProvider` capability from the environment to perform the
+/// operation.
+///
+/// @param Section - An optional, dot-separated key to a specific configuration
+/// section.   If `None`, the entire configuration object is returned.
+/// @param OverridesValue - A `serde_json::Value` representing the
+/// `ConfigurationOverridesDto`,   which can specify a resource or language
+/// scope.
+///
+/// @returns An `ActionEffect` that resolves with a `serde_json::Value`
+/// containing the   requested configuration.
+pub fn GetConfiguration<Runtime>(
+	Section:Option<String>,
+	OverridesValue:Value,
+) -> ActionEffect<Arc<Runtime>, CommonError, Value>
+where
+	Runtime: AppRuntime + Send + Sync + 'static,
+	Runtime::EnvironmentType: Requires<Arc<dyn ConfigProvider>>, {
+	ActionEffect::New(Arc::new(move |Runtime:Arc<Runtime>| {
+		let SectionClone = Section.clone();
+		let OverridesValueClone = OverridesValue.clone();
+		Box::pin(async move {
+			let Environment = Runtime.GetEnvironment();
+			let Provider:Arc<dyn ConfigProvider> = Environment.Require();
+
+			let OverridesParsed:ConfigurationOverridesDto =
+				serde_json::from_value(OverridesValueClone).map_err(|e| {
+					CommonError::InvalidArg {
+						ArgumentName:"OverridesValue".to_string(),
+						Reason:format!("Failed to parse ConfigurationOverridesDto: {}", e),
+					}
+				})?;
+
+			Provider.GetConfigurationValue(SectionClone, OverridesParsed).await
+		})
+	}))
+}