Re-sync

Author: NikolaRHristov

Cargo.toml

@@ -36,11 +36,16 @@ 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 }
+md5 = { workspace = true }
+num_cpus = { workspace = true }
+rand = { workspace = true }
 
 tauri-plugin-dialog = { workspace = true }
+
 # regex = { workspace = true }
 # unbug = { workspace = true }
 

Source/ApplicationState/ApplicationState.rs

@@ -0,0 +1,193 @@
+//! # ApplicationState Struct
+//!
+//! Defines the main `ApplicationState` struct, which is the central, shared,
+//! thread-safe state container for the entire Mountain application. It is
+//! managed by Tauri and is accessible to all command handlers and Environment
+//! providers.
+
+use std::{
+	collections::HashMap,
+	path::{Path, PathBuf},
+	sync::{
+		Arc,
+		Mutex as StandardMutex,
+		atomic::{AtomicBool, AtomicU32, AtomicU64, Ordering as AtomicOrdering},
+	},
+};
+
+use log::{error, info, warn};
+use tauri::{AppHandle, Manager, Runtime};
+
+use super::{DTO::*, Internal};
+use crate::Environment::CommandProvider::CommandHandler; // TODO: Fix this path after refactor
+
+/// The central, shared, thread-safe state for the entire Mountain application.
+///
+/// This struct consolidates all dynamic state required by the backend, from
+/// workspace information and configuration to the state of active UI components
+/// like terminals and WebViews.
+#[derive(Clone)]
+pub struct ApplicationState {
+	// --- 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>>>,
+
+	// --- Extension & Provider Management ---
+	pub CommandRegistry:Arc<StandardMutex<HashMap<String, CommandHandler<Runtime>>>>,
+	pub LanguageProviders:Arc<StandardMutex<HashMap<u32, ProviderRegistrationDTO>>>,
+	pub NextProviderHandle:Arc<AtomicU32>,
+	pub ScannedExtensions:Arc<StandardMutex<HashMap<String, ExtensionDescriptionStateDTO>>>,
+	pub EnabledProposedAPIs:Arc<StandardMutex<HashMap<String, Vec<String>>>>,
+	pub ExtensionScanPaths:Arc<StandardMutex<Vec<PathBuf>>>,
+
+	// --- Feature-specific State ---
+	pub DiagnosticsMap:Arc<StandardMutex<HashMap<String, HashMap<String, Vec<MarkerDataDTO>>>>>,
+	pub OpenDocuments:Arc<StandardMutex<HashMap<String, DocumentStateDTO>>>,
+	pub OutputChannels:Arc<StandardMutex<HashMap<String, OutputChannelStateDTO>>>,
+	pub ActiveTerminals:Arc<StandardMutex<HashMap<u64, Arc<StandardMutex<TerminalStateDTO>>>>>,
+	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 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>>>,
+		>,
+	>,
+}
+
+impl Default for ApplicationState {
+	fn default() -> Self {
+		info!("[ApplicationState] Initializing default application state...");
+		let ApplicationNameForPaths = env!("CARGO_PKG_NAME");
+		let ApplicationDataDirectoryPath =
+			dirs::config_dir().map(|p| p.join(ApplicationNameForPaths)).unwrap_or_else(|| {
+				warn!(
+					"[ApplicationState] Could not get config dir. Using relative path '.{}-appdata'.",
+					ApplicationNameForPaths
+				);
+				PathBuf::from(format!(".{}-appdata", ApplicationNameForPaths))
+			});
+
+		// This must be synchronous because the async runtime isn't available yet.
+		if !ApplicationDataDirectoryPath.exists() {
+			if let Err(e) = std::fs::create_dir_all(&ApplicationDataDirectoryPath) {
+				error!(
+					"[ApplicationState] CRITICAL: Failed to create app data directory at '{}': {}.",
+					ApplicationDataDirectoryPath.display(),
+					e
+				);
+			}
+		}
+
+		let GlobalMementoFilePath = Internal::ResolveMementoStorageFilePath(&ApplicationDataDirectoryPath, true, "");
+		let InitialGlobalMementoMap = Internal::LoadInitialMementoFromDisk(&GlobalMementoFilePath);
+		// let InitialCommandRegistryMap =
+		// crate::Handler::Command::RegisterNativeCommands(); // TODO: Re-integrate
+
+		info!("[ApplicationState] Default state initialization complete.");
+		Self {
+			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)),
+			CommandRegistry:Arc::new(StandardMutex::new(HashMap::new())), // TODO: Use InitialCommandRegistryMap
+			DiagnosticsMap:Arc::new(StandardMutex::new(HashMap::new())),
+			OpenDocuments:Arc::new(StandardMutex::new(HashMap::new())),
+			OutputChannels:Arc::new(StandardMutex::new(HashMap::new())),
+			LanguageProviders:Arc::new(StandardMutex::new(HashMap::new())),
+			NextProviderHandle:Arc::new(AtomicU32::new(1)),
+			ScannedExtensions:Arc::new(StandardMutex::new(HashMap::new())),
+			EnabledProposedAPIs:Arc::new(StandardMutex::new(HashMap::new())),
+			ExtensionScanPaths:Arc::new(StandardMutex::new(Vec::new())),
+			ActiveTerminals:Arc::new(StandardMutex::new(HashMap::new())),
+			NextTerminalIdentifier:Arc::new(AtomicU64::new(1)),
+			PendingUserInterfaceRequests:Arc::new(StandardMutex::new(HashMap::new())),
+			ActiveWebViews:Arc::new(StandardMutex::new(HashMap::new())),
+			ActiveCustomDocuments:Arc::new(StandardMutex::new(HashMap::new())),
+			ActiveStatusBarItems:Arc::new(StandardMutex::new(HashMap::new())),
+			ActiveTreeViews:Arc::new(StandardMutex::new(HashMap::new())),
+		}
+	}
+}
+
+impl ApplicationState {
+	/// Generates a unique, filesystem-safe identifier string for the current
+	/// workspace.
+	pub fn GetWorkspaceIdentifier(&self) -> Result<String, String> {
+		let LockErrorMapper = |e| format!("[AppState] Lock error: {}", e);
+		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)?;
+		if let Some(FirstFolder) = FoldersGuard.first() {
+			let PathString = FirstFolder.URI.path();
+			// Create a more stable hash for the identifier.
+			let Hash = format!("{:x}", md5::compute(PathString));
+			return Ok(format!(
+				"{}-{}",
+				FirstFolder.Name.replace(|c:char| !c.is_alphanumeric(), "_"),
+				&Hash[..8]
+			));
+		}
+
+		Ok("NO_WORKSPACE".to_string())
+	}
+
+	/// Returns the next available unique identifier for a language provider
+	/// registration.
+	pub fn GetNextProviderHandle(&self) -> u32 { self.NextProviderHandle.fetch_add(1, AtomicOrdering::Relaxed) }
+
+	/// Returns the next available unique identifier for a terminal instance.
+	pub fn GetNextTerminalIdentifier(&self) -> u64 { self.NextTerminalIdentifier.fetch_add(1, AtomicOrdering::Relaxed) }
+
+	/// Updates the path to the workspace memento file and reloads its content
+	/// from disk.
+	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)?;
+
+		if WorkspaceIdentifier == "NO_WORKSPACE" {
+			if PathGuard.is_some() {
+				*PathGuard = None;
+				self.WorkspaceMemento.lock().map_err(LockErrorMapper)?.clear();
+			}
+			return Ok(());
+		}
+
+		let NewMementoPath =
+			Internal::ResolveMementoStorageFilePath(ApplicationDataDirectory, false, &WorkspaceIdentifier);
+		if PathGuard.as_ref() != Some(&NewMementoPath) {
+			if let Some(Parent) = NewMementoPath.parent() {
+				if !Parent.exists() {
+					std::fs::create_dir_all(Parent).map_err(|e| e.to_string())?;
+				}
+			}
+			*PathGuard = Some(NewMementoPath.clone());
+			let NewMementoContent = Internal::LoadInitialMementoFromDisk(&NewMementoPath);
+			*self.WorkspaceMemento.lock().map_err(LockErrorMapper)? = NewMementoContent;
+		}
+		Ok(())
+	}
+}

Source/ApplicationState/DTO/CustomDocumentStateDTO.rs

@@ -0,0 +1,42 @@
+//! # CustomDocumentStateDTO
+//!
+//! Defines the Data Transfer Object for storing the state of a single custom
+//! editor document.
+
+#![allow(non_snake_case, non_camel_case_types)]
+
+use std::collections::HashMap;
+
+use serde::{Deserialize, Serialize};
+use url::Url;
+
+use crate::ApplicationState::Internal::URLSerializationHelper;
+
+/// A struct that holds the state for a document being handled by a custom
+/// editor. This is stored in `ApplicationState` to track the lifecycle of
+/// custom documents.
+#[derive(Serialize, Deserialize, Debug, Clone)]
+#[serde(rename_all = "PascalCase")]
+pub struct CustomDocumentStateDTO {
+	/// The URI of the document resource being edited.
+	#[serde(with = "URLSerializationHelper")]
+	pub URI:Url,
+
+	/// The view type of the custom editor responsible for this document.
+	pub ViewType:String,
+
+	/// The identifier of the sidecar process where the custom editor provider
+	/// lives.
+	pub SidecarIdentifier:String,
+
+	/// A flag indicating if the document is currently editable by the user.
+	pub IsEditable:bool,
+
+	/// An optional identifier for a backup copy of the file's content.
+	#[serde(skip_serializing_if = "Option::is_none")]
+	pub BackupIdentifier:Option<String>,
+
+	/// A map to store edit history or other versioning information.
+	/// In a real implementation, this might hold a more structured edit type.
+	pub Edits:HashMap<u32, serde_json::Value>,
+}

Source/ApplicationState/DTO/DocumentStateDTO.rs

@@ -0,0 +1,101 @@
+//! # DocumentStateDTO
+//!
+//! Defines the Data Transfer Object for storing the state of a single open
+//! text document in memory.
+
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+use url::Url;
+
+use super::RPCModelContentChangeDTO::RPCModelContentChangeDTO;
+use crate::ApplicationState::Internal::{
+	AnalyzeTextLinesAndEOL,
+	URLSerializationHelper, /* DetectFileEncodingFromBytes,
+	                         * DetectLanguageIdentifierFromFilePath, */
+};
+
+/// Represents the complete in-memory state of a single text document.
+#[derive(Serialize, Deserialize, Clone, Debug)]
+#[serde(rename_all = "PascalCase")]
+pub struct DocumentStateDTO {
+	/// The unique resource identifier for this document.
+	#[serde(with = "URLSerializationHelper")]
+	pub URI:Url,
+	/// The VS Code language identifier (e.g., "rust", "typescript").
+	pub LanguageIdentifier:String,
+	/// The version number, incremented on each change.
+	pub Version:i64,
+	/// The content of the document, split into lines.
+	pub Lines:Vec<String>,
+	/// The detected end-of-line sequence (e.g., `\n` or `\r\n`).
+	pub EOL:String,
+	/// A flag indicating if the in-memory version has unsaved changes.
+	pub IsDirty:bool,
+	/// The detected file encoding (e.g., "utf8").
+	pub Encoding:String,
+}
+
+impl DocumentStateDTO {
+	/// Creates a new `DocumentStateDTO` from its initial content.
+	pub fn Create(URI:Url, LanguageIdentifier:Option<String>, Content:String) -> Self {
+		let (Lines, EOL) = AnalyzeTextLinesAndEOL(&Content);
+		// A real implementation would have more robust language/encoding detection.
+		let LanguageID = LanguageIdentifier.unwrap_or_else(|| "plaintext".to_string());
+		let Encoding = "utf8".to_string(); // Stub for encoding detection
+
+		Self {
+			URI,
+			LanguageIdentifier:LanguageID,
+			Version:1,
+			Lines,
+			EOL,
+			IsDirty:false,
+			Encoding,
+		}
+	}
+
+	/// Reconstructs the full text content of the document from its lines.
+	pub fn GetText(&self) -> String { self.Lines.join(&self.EOL) }
+
+	/// Converts the struct to a `serde_json::Value`, useful for notifications.
+	pub fn ToDTO(&self) -> Value { serde_json::to_value(self).unwrap_or(Value::Null) }
+
+	/// Applies a set of changes to the document.
+	///
+	/// This is a complex operation that simulates how a text buffer would be
+	/// updated. For this implementation, it is simplified.
+	pub fn ApplyChanges(&mut self, NewVersion:i64, ChangesValue:&Value) -> Result<(), String> {
+		if NewVersion <= self.Version {
+			return Ok(()); // Ignore stale changes
+		}
+
+		let RPCChanges:Vec<RPCModelContentChangeDTO> = match serde_json::from_value(ChangesValue.clone()) {
+			Ok(changes) => changes,
+			Err(_) => {
+				// Fallback for a full-content change, which is a common scenario.
+				if let Some(FullText) = ChangesValue.as_str() {
+					let (NewLines, NewEOL) = AnalyzeTextLinesAndEOL(FullText);
+					self.Lines = NewLines;
+					self.EOL = NewEOL;
+					self.Version = NewVersion;
+					self.IsDirty = true;
+					return Ok(());
+				}
+				return Err(format!("Invalid RPCModelContentChangeDTO for {}", self.URI));
+			},
+		};
+
+		// A full implementation would require a rope data structure or complex logic
+		// to apply deltas efficiently. We will log a warning and accept the new
+		// version number, but the content will be out of sync until the next full
+		// update.
+		log::warn!(
+			"Applying changes to {} by version bump only (delta application is a stub).",
+			self.URI
+		);
+
+		self.Version = NewVersion;
+		self.IsDirty = true;
+		Ok(())
+	}
+}