refactor(Mountain): Rename workspace to workSpace and add critical dependencies

- Renamed all `Workspace` references to `WorkSpace` in ApplicationState and Environment providers to align with architectural naming conventions
- Added `parking_lot`, `lazy_static`, and `portable-pty` dependencies to support synchronization primitives and terminal functionality
- Updated type references (e.g. `StatusBarEntryDTO`) to match Common crate definitions
- Adjusted gRPC service method names to proper PascalCase convention
- Fixed environment initialization with unsafe handling for logging setup
- Temporarily disabled gRPC generated code inclusion during refactoring

This refactor maintains existing functionality while ensuring consistency with Land's architecture and preparing for terminal and gRPC features. The changes impact core state management and environment providers but don't introduce behavioral changes.

Author: NikolaRHristov

Cargo.toml

@@ -11,40 +11,45 @@ tauri-build = { workspace = true, features = [] }
 toml = { workspace = true }
 
 [dependencies]
-tokio = { workspace = true, features = ["full"] }
-async-trait = { workspace = true }
-futures-util = { workspace = true, features = ["sink", "std"] }
-once_cell = { workspace = true }
-tauri = { version = "2.5.1", features = [
+tauri = { version = "*", features = [
 	"wry",
 	"tray-icon",
 	"devtools",
 	"rustls-tls",
 	"compression",
 ], default-features = false }
-log = { workspace = true }
-env_logger = { workspace = true }
+
+tauri-plugin-dialog = { workspace = true }
+
+async-trait = { workspace = true }
+base64 = { workspace = true }
+chrono = { workspace = true, features = ["serde"] }
 colored = { workspace = true }
-tokio-tungstenite = { workspace = true, features = ["rustls-tls-native-roots"] }
+Common = { workspace = true }
 dirs = { workspace = true }
-ignore = { workspace = true }
+Echo = { workspace = true }
+env_logger = { workspace = true }
+futures-util = { workspace = true, features = ["sink", "std"] }
 globset = { workspace = true }
+ignore = { workspace = true }
 keyring = { workspace = true }
-base64 = { workspace = true }
-url = { workspace = true, features = ["serde"] }
-uuid = { workspace = true, features = ["v4", "serde"] }
-chrono = { workspace = true, features = ["serde"] }
-thiserror = { workspace = true }
-Echo = { workspace = true }
-Common = { workspace = true }
-serde_json = { workspace = true }
-serde = { workspace = true }
-toml = { workspace = true }
+log = { workspace = true }
 md5 = { workspace = true }
 num_cpus = { workspace = true }
+once_cell = { workspace = true }
 rand = { workspace = true }
-
-tauri-plugin-dialog = { workspace = true }
+serde = { workspace = true }
+serde_json = { workspace = true }
+thiserror = { workspace = true }
+tokio = { workspace = true, features = ["full"] }
+tokio-tungstenite = { workspace = true, features = ["rustls-tls-native-roots"] }
+toml = { workspace = true }
+tonic = { workspace = true }
+url = { workspace = true, features = ["serde"] }
+uuid = { workspace = true, features = ["v4", "serde"] }
+parking_lot = { workspace = true }
+lazy_static = { workspace = true }
+portable-pty = { workspace = true }
 
 # regex = { workspace = true }
 # unbug = { workspace = true }

Source/ApplicationState/ApplicationState.rs

@@ -16,9 +16,25 @@ use std::{
 };
 
 use log::{error, info, warn};
-use tauri::{AppHandle, Manager, Runtime};
-
-use super::{DTO::*, Internal};
+use tauri::{Manager, Runtime};
+
+use super::{
+	DTO::{
+		CustomDocumentStateDTO::CustomDocumentStateDTO,
+		DocumentStateDTO::DocumentStateDTO,
+		ExtensionDescriptionStateDTO::ExtensionDescriptionStateDTO,
+		MarkerDataDTO::MarkerDataDTO,
+		MergedConfigurationStateDTO::MergedConfigurationStateDTO,
+		OutputChannelStateDTO::OutputChannelStateDTO,
+		ProviderRegistrationDTO::ProviderRegistrationDTO,
+		TerminalStateDTO::TerminalStateDTO,
+		TreeViewStateDTO::TreeViewStateDTO,
+		WebViewStateDTO::WebViewStateDTO,
+		WindowStateDTO::WindowStateDTO,
+		WorkSpaceFolderStateDTO::WorkSpaceFolderStateDTO,
+	},
+	Internal,
+};
 use crate::Environment::CommandProvider::CommandHandler; // TODO: Fix this path after refactor
 
 /// The central, shared, thread-safe state for the entire Mountain application.
@@ -28,21 +44,21 @@ use crate::Environment::CommandProvider::CommandHandler; // TODO: Fix this path
 /// like terminals and WebViews.
 #[derive(Clone)]
 pub struct ApplicationState {
-	// --- Workspace State ---
-	pub WorkspaceFolders:Arc<StandardMutex<Vec<WorkspaceFolderStateDTO>>>,
-	pub WorkspaceConfigurationPath:Arc<StandardMutex<Option<PathBuf>>>,
+	// --- WorkSpace State ---
+	pub WorkSpaceFolders:Arc<StandardMutex<Vec<WorkSpaceFolderStateDTO>>>,
+	pub WorkSpaceConfigurationPath:Arc<StandardMutex<Option<PathBuf>>>,
 	pub IsTrusted:Arc<AtomicBool>,
 	pub WindowState:Arc<StandardMutex<WindowStateDTO>>,
 
 	// --- Configuration & Storage ---
 	pub Configuration:Arc<StandardMutex<MergedConfigurationStateDTO>>,
 	pub GlobalMemento:Arc<StandardMutex<HashMap<String, serde_json::Value>>>,
 	pub GlobalMementoPath:PathBuf,
-	pub WorkspaceMemento:Arc<StandardMutex<HashMap<String, serde_json::Value>>>,
-	pub WorkspaceMementoPath:Arc<StandardMutex<Option<PathBuf>>>,
+	pub WorkSpaceMemento:Arc<StandardMutex<HashMap<String, serde_json::Value>>>,
+	pub WorkSpaceMementoPath:Arc<StandardMutex<Option<PathBuf>>>,
 
 	// --- Extension & Provider Management ---
-	pub CommandRegistry:Arc<StandardMutex<HashMap<String, CommandHandler<Runtime>>>>,
+	pub CommandRegistry:Arc<StandardMutex<HashMap<String, CommandHandler<dyn Runtime>>>>,
 	pub LanguageProviders:Arc<StandardMutex<HashMap<u32, ProviderRegistrationDTO>>>,
 	pub NextProviderHandle:Arc<AtomicU32>,
 	pub ScannedExtensions:Arc<StandardMutex<HashMap<String, ExtensionDescriptionStateDTO>>>,
@@ -57,13 +73,17 @@ pub struct ApplicationState {
 	pub NextTerminalIdentifier:Arc<AtomicU64>,
 	pub ActiveWebViews:Arc<StandardMutex<HashMap<String, WebViewStateDTO>>>,
 	pub ActiveCustomDocuments:Arc<StandardMutex<HashMap<String, CustomDocumentStateDTO>>>,
-	pub ActiveStatusBarItems:Arc<StandardMutex<HashMap<String, Common::StatusBar::DTO::StatusBarEntryDTO>>>,
+	pub ActiveStatusBarItems:
+		Arc<StandardMutex<HashMap<String, Common::StatusBar::DTO::StatusBarEntryDTO::StatusBarEntryDTO>>>,
 	pub ActiveTreeViews:Arc<StandardMutex<HashMap<String, TreeViewStateDTO>>>,
 
 	// --- IPC & User Interface State ---
 	pub PendingUserInterfaceRequests: Arc<
 		StandardMutex<
-			HashMap<String, tokio::sync::oneshot::Sender<Result<serde_json::Value, Common::Error::CommonError>>>,
+			HashMap<
+				String,
+				tokio::sync::oneshot::Sender<Result<serde_json::Value, Common::Error::CommonError::CommonError>>,
+			>,
 		>,
 	>,
 }
@@ -99,15 +119,15 @@ impl Default for ApplicationState {
 
 		info!("[ApplicationState] Default state initialization complete.");
 		Self {
-			WorkspaceFolders:Arc::new(StandardMutex::new(Vec::new())),
-			WorkspaceConfigurationPath:Arc::new(StandardMutex::new(None)),
+			WorkSpaceFolders:Arc::new(StandardMutex::new(Vec::new())),
+			WorkSpaceConfigurationPath:Arc::new(StandardMutex::new(None)),
 			IsTrusted:Arc::new(AtomicBool::new(false)),
 			WindowState:Arc::new(StandardMutex::new(Default::default())),
 			Configuration:Arc::new(StandardMutex::new(MergedConfigurationStateDTO::default())),
 			GlobalMemento:Arc::new(StandardMutex::new(InitialGlobalMementoMap)),
 			GlobalMementoPath:GlobalMementoFilePath,
-			WorkspaceMemento:Arc::new(StandardMutex::new(HashMap::new())),
-			WorkspaceMementoPath:Arc::new(StandardMutex::new(None)),
+			WorkSpaceMemento:Arc::new(StandardMutex::new(HashMap::new())),
+			WorkSpaceMementoPath:Arc::new(StandardMutex::new(None)),
 			CommandRegistry:Arc::new(StandardMutex::new(HashMap::new())), // TODO: Use InitialCommandRegistryMap
 			DiagnosticsMap:Arc::new(StandardMutex::new(HashMap::new())),
 			OpenDocuments:Arc::new(StandardMutex::new(HashMap::new())),
@@ -131,15 +151,15 @@ impl Default for ApplicationState {
 impl ApplicationState {
 	/// Generates a unique, filesystem-safe identifier string for the current
 	/// workspace.
-	pub fn GetWorkspaceIdentifier(&self) -> Result<String, String> {
+	pub fn GetWorkSpaceIdentifier(&self) -> Result<String, String> {
 		let LockErrorMapper = |e| format!("[AppState] Lock error: {}", e);
-		let ConfigurationPathGuard = self.WorkspaceConfigurationPath.lock().map_err(LockErrorMapper)?;
+		let ConfigurationPathGuard = self.WorkSpaceConfigurationPath.lock().map_err(LockErrorMapper)?;
 		if let Some(ConfigurationPath) = ConfigurationPathGuard.as_ref() {
 			return Ok(ConfigurationPath.file_name().unwrap_or_default().to_string_lossy().into_owned());
 		}
 		drop(ConfigurationPathGuard);
 
-		let FoldersGuard = self.WorkspaceFolders.lock().map_err(LockErrorMapper)?;
+		let FoldersGuard = self.WorkSpaceFolders.lock().map_err(LockErrorMapper)?;
 		if let Some(FirstFolder) = FoldersGuard.first() {
 			let PathString = FirstFolder.URI.path();
 			// Create a more stable hash for the identifier.
@@ -163,21 +183,21 @@ impl ApplicationState {
 
 	/// Updates the path to the workspace memento file and reloads its content
 	/// from disk.
-	pub fn UpdateWorkspaceMementoPathAndReload(&self, ApplicationDataDirectory:&Path) -> Result<(), String> {
+	pub fn UpdateWorkSpaceMementoPathAndReload(&self, ApplicationDataDirectory:&Path) -> Result<(), String> {
 		let LockErrorMapper = |e| format!("[AppState] Lock error: {}", e);
-		let WorkspaceIdentifier = self.GetWorkspaceIdentifier()?;
-		let mut PathGuard = self.WorkspaceMementoPath.lock().map_err(LockErrorMapper)?;
+		let WorkSpaceIdentifier = self.GetWorkSpaceIdentifier()?;
+		let mut PathGuard = self.WorkSpaceMementoPath.lock().map_err(LockErrorMapper)?;
 
-		if WorkspaceIdentifier == "NO_WORKSPACE" {
+		if WorkSpaceIdentifier == "NO_WORKSPACE" {
 			if PathGuard.is_some() {
 				*PathGuard = None;
-				self.WorkspaceMemento.lock().map_err(LockErrorMapper)?.clear();
+				self.WorkSpaceMemento.lock().map_err(LockErrorMapper)?.clear();
 			}
 			return Ok(());
 		}
 
 		let NewMementoPath =
-			Internal::ResolveMementoStorageFilePath(ApplicationDataDirectory, false, &WorkspaceIdentifier);
+			Internal::ResolveMementoStorageFilePath(ApplicationDataDirectory, false, &WorkSpaceIdentifier);
 		if PathGuard.as_ref() != Some(&NewMementoPath) {
 			if let Some(Parent) = NewMementoPath.parent() {
 				if !Parent.exists() {
@@ -186,7 +206,7 @@ impl ApplicationState {
 			}
 			*PathGuard = Some(NewMementoPath.clone());
 			let NewMementoContent = Internal::LoadInitialMementoFromDisk(&NewMementoPath);
-			*self.WorkspaceMemento.lock().map_err(LockErrorMapper)? = NewMementoContent;
+			*self.WorkSpaceMemento.lock().map_err(LockErrorMapper)? = NewMementoContent;
 		}
 		Ok(())
 	}

Source/ApplicationState/DTO/ProviderRegistrationDTO.rs

@@ -5,7 +5,7 @@
 
 #![allow(non_snake_case, non_camel_case_types)]
 
-use Common::LanguageFeature::DTO::ProviderType;
+use Common::LanguageFeature::DTO::ProviderType::ProviderType;
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
 

Source/ApplicationState/DTO/TerminalStateDTO.rs

@@ -5,11 +5,7 @@
 
 #![allow(non_snake_case, non_camel_case_types)]
 
-use std::{
-	collections::HashMap,
-	path::PathBuf,
-	sync::{Arc, Mutex as StandardMutex},
-};
+use std::{collections::HashMap, path::PathBuf, sync::Arc};
 
 use serde_json::Value;
 use tokio::{

Source/ApplicationState/DTO/WebViewStateDTO.rs

@@ -5,7 +5,7 @@
 
 #![allow(non_snake_case, non_camel_case_types)]
 
-use Common::WebView::DTO::WebViewContentOptionsDTO;
+use Common::WebView::DTO::WebViewContentOptionsDTO::WebViewContentOptionsDTO;
 use serde::{Deserialize, Serialize};
 use serde_json::Value; // For PanelOptions, etc.
 

Source/ApplicationState/DTO/mod.rs

@@ -19,7 +19,7 @@ pub mod TerminalStateDTO;
 pub mod TreeViewStateDTO;
 pub mod WebViewStateDTO;
 pub mod WindowStateDTO;
-pub mod WorkspaceFolderStateDTO;
+pub mod WorkSpaceFolderStateDTO;
 
 // --- Public Re-exports (alphabetical) ---
 // pub use self::CustomDocumentStateDTO::CustomDocumentStateDTO;
@@ -34,4 +34,4 @@ pub mod WorkspaceFolderStateDTO;
 // pub use self::TreeViewStateDTO::TreeViewStateDTO;
 // pub use self::WebViewStateDTO::WebViewStateDTO;
 // pub use self::WindowStateDTO::WindowStateDTO;
-// pub use self::WorkspaceFolderStateDTO::WorkspaceFolderStateDTO;
+// pub use self::WorkSpaceFolderStateDTO::WorkSpaceFolderStateDTO;

Source/ApplicationState/Internal.rs

@@ -55,22 +55,25 @@ pub fn LoadInitialMementoFromDisk(StorageFilePath:&Path) -> HashMap<String, Valu
 pub fn ResolveMementoStorageFilePath(
 	ApplicationDataDirectory:&Path,
 	IsGlobalScope:bool,
-	WorkspaceIdentifier:&str,
+	WorkSpaceIdentifier:&str,
 ) -> std::path::PathBuf {
 	let UserStorageBasePath = ApplicationDataDirectory.join("User");
 	if IsGlobalScope {
 		UserStorageBasePath.join("globalStorage.json")
 	} else {
 		// Sanitize the workspace identifier to be a safe directory name.
-		let Segment = WorkspaceIdentifier.replace(|c:char| !c.is_alphanumeric() && c != '-' && c != '_', "_");
+		let Segment = WorkSpaceIdentifier.replace(|c:char| !c.is_alphanumeric() && c != '-' && c != '_', "_");
 		UserStorageBasePath.join("workspaceStorage").join(Segment).join("storage.json")
 	}
 }
 
 /// A helper module for serializing and deserializing `url::Url` with `serde`.
 /// This is used in DTOs where a `Url` field needs to be serialized to a string.
 pub mod URLSerializationHelper {
+	use serde::Deserialize;
+
 	use super::*;
+
 	pub fn serialize<S>(URLInstance:&Url, SerializerInstance:S) -> Result<S::Ok, S::Error>
 	where
 		S: Serializer, {

Source/Binary.rs

@@ -27,7 +27,7 @@ use crate::{
 fn InitializeLogging() {
 	let LogLevel = if cfg!(debug_assertions) { "debug" } else { "info" };
 	if std::env::var("RUST_LOG").is_err() {
-		std::env::set_var("RUST_LOG", LogLevel);
+		unsafe { std::env::set_var("RUST_LOG", LogLevel) };
 	}
 	env_logger::init();
 }

Source/Environment/CommandProvider.rs

@@ -11,9 +11,9 @@ use Common::{Command::CommandExecutor, Error::CommonError, IPC::DTO::ProxyTarget
 use async_trait::async_trait;
 use log::{debug, error, info};
 use serde_json::{Value, json};
-use tauri::{AppHandle, Manager, Runtime, Window};
+use tauri::{Manager, Runtime, Window};
 
-use super::MountainEnvironment;
+use super::MountainEnvironment::MountainEnvironment;
 use crate::{ApplicationState::ApplicationState::ApplicationState, RunTime::ApplicationRunTime, Vine::Client};
 
 /// An enum representing the different ways a command can be handled.

Source/Environment/ConfigurationProvider.rs

@@ -13,14 +13,14 @@ use Common::{
 		ConfigurationProvider,
 		DTO::{ConfigurationOverridesDTO, ConfigurationTarget, InspectResultDataDTO},
 	},
-	Error::CommonError,
+	Error::CommonError::CommonError,
 	FileSystem::{FileSystemReader, FileSystemWriter},
 };
 use async_trait::async_trait;
 use log::{debug, error, info, warn};
 use serde_json::{Map, Value};
 
-use super::MountainEnvironment;
+use super::MountainEnvironment::MountainEnvironment;
 // TODO: Re-integrate IPC client for notifications
 // use crate::Vine::Client;
 
@@ -60,9 +60,9 @@ impl ConfigurationProvider for MountainEnvironment {
 					.app_config_dir()
 					.map(|p| p.join("settings.json"))
 			},
-			ConfigurationTarget::Workspace => {
+			ConfigurationTarget::WorkSpace => {
 				self.ApplicationState
-					.WorkspaceConfigurationPath
+					.WorkSpaceConfigurationPath
 					.lock()
 					.map_err(super::Utility::MapApplicationStateLockErrorToCommonError)?
 					.clone()
@@ -150,16 +150,16 @@ pub async fn InitializeAndMergeConfigurations(Environment:&MountainEnvironment)
 		.app_config_dir()
 		.map(|p| p.join("settings.json"));
 
-	let WorkspaceSettingsPath = Environment.ApplicationState.WorkspaceConfigurationPath.lock().unwrap().clone();
+	let WorkSpaceSettingsPath = Environment.ApplicationState.WorkSpaceConfigurationPath.lock().unwrap().clone();
 
 	let UserConfig = ReadAndParseConfigurationFile(Environment, &UserSettingsPath).await;
-	let WorkspaceConfig = ReadAndParseConfigurationFile(Environment, &WorkspaceSettingsPath).await;
+	let WorkSpaceConfig = ReadAndParseConfigurationFile(Environment, &WorkSpaceSettingsPath).await;
 
 	// A real implementation would also load default and folder-level settings.
 	// The merge order is critical: workspace settings override user settings.
 	let mut Merged = UserConfig.as_object().cloned().unwrap_or_default();
-	if let Some(WorkspaceMap) = WorkspaceConfig.as_object() {
-		for (k, v) in WorkspaceMap {
+	if let Some(WorkSpaceMap) = WorkSpaceConfig.as_object() {
+		for (k, v) in WorkSpaceMap {
 			Merged.insert(k.clone(), v.clone());
 		}
 	}