refactor(Cocoon/Service): Fully adopt Effect-TS patterns in service layer and type conversions

- Implement centralized `Dispatcher` service with Layer-based dependencies to handle RPC routing between `Mountain` and Cocoon's internal handlers
- Convert `FileSystem` service methods to return structured `Effect` instances instead of raw promises, enabling proper error propagation (VSCodeFileSystemError)
- Align `TypeConverter` method naming with project conventions (`fromAPI` → `FromAPI`) and standardize variable names for consistency
- Streamline IPC server setup by consolidating `Dispatcher` module references and strengthening gRPC method type assertions
- Update `WorkspaceEdit` converters to handle versioning through `IVersionInformationProvider` interface, ensuring compatibility with `Mountain`'s document state management

This refactoring completes the transition of Cocoon's core services to pure Effect-TS patterns, critical for maintaining strict effect tracking across the VS Code API boundary. The changes directly support the 'Opening Files' and 'Saving Files' workflows by ensuring all filesystem operations are properly managed through Mountain's gRPC API.

Author: NikolaRHristov

Source/Service/Dispatcher.ts

@@ -0,0 +1,23 @@
+/**
+ * @module Dispatcher (IPC)
+ * @description Provides the Dispatcher service, which routes all incoming RPC
+ * messages from the Mountain host to the appropriate handlers within Cocoon.
+ */
+
+import { Layer } from "effect";
+
+import { Live as LiveCancellation } from "./Cancellation.js";
+import { Definition } from "./IPC/Dispatcher/Definition.js";
+import { Tag, type Interface } from "./IPC/Dispatcher/Service.js";
+import { Live as LiveProtocolAdapter } from "./IPC/ProtocolAdapter.js";
+
+export { Tag, type Interface };
+
+/**
+ * The live implementation Layer for the Dispatcher service.
+ * It depends on the ProtocolAdapter (for the underlying transport) and the
+ * Cancellation service (for handling cancellation signals).
+ */
+export const Live = Layer.effect(Tag, Definition).pipe(
+	Layer.provide(Layer.merge(LiveProtocolAdapter, LiveCancellation)),
+);

Source/Service/FileSystem/CreateStatEffect.ts

@@ -4,16 +4,23 @@
  */
 
 import { Effect } from "effect";
-import type { FileStat, FileType, Uri } from "vscode";
+import {
+	FileSystemError as VscFileSystemError,
+	type FileStat,
+	type FileType,
+	type Uri,
+} from "vscode";
 
 import * as TypeConverter from "../../TypeConverter.js";
 import { IPC } from "../IPC.js";
 import { FileSystemError, MapToVSCodeError } from "./Error.js";
 
-export function CreateStatEffect(URI: Uri) {
+export function CreateStatEffect(
+	URI: Uri,
+): Effect.Effect<FileStat, VscFileSystemError, IPC.Interface> {
 	return Effect.gen(function* (_) {
 		const IPCService = yield* _(IPC.Tag);
-		const UriDTO = TypeConverter.URIConverter.FromAPI(URI);
+		const UriDTO = TypeConverter.URI.fromAPI(URI);
 		const RawStat = yield* _(
 			IPCService.SendRequest<any>("$stat", [UriDTO]),
 		);

Source/Service/FileSystem/Definition.ts

@@ -4,37 +4,49 @@
  */
 
 import { Effect } from "effect";
+import { FileSystemError as VscFileSystemError } from "vscode";
 
 import { FileSystemInformation } from "../FileSystemInformation.js";
 import { CreateStatEffect } from "./CreateStatEffect.js";
 import type { Interface } from "./Service.js";
 
-// Other effect creators would be imported here
-// import { CreateReadFileEffect } from "./CreateReadFileEffect.js";
-// import { CreateWriteFileEffect } from "./CreateWriteFileEffect.js";
-// import { CreateDeleteEffect } from "./CreateDeleteEffect.js";
-// etc.
-
 export const Definition = Effect.gen(function* (_) {
 	const FsInfo = yield* _(FileSystemInformation.Tag);
 
 	const ServiceImplementation: Interface = {
-		// Each method builds and runs the corresponding Effect.
-		stat: (uri) => Effect.runPromise(CreateStatEffect(uri)),
+		stat: (uri) => CreateStatEffect(uri),
 		readDirectory: (uri) =>
-			Promise.reject(new Error("readDirectory not implemented")),
+			Effect.fail(
+				new VscFileSystemError(
+					`readDirectory not implemented for ${uri}`,
+				),
+			),
 		createDirectory: (uri) =>
-			Promise.reject(new Error("createDirectory not implemented")),
+			Effect.fail(
+				new VscFileSystemError(
+					`createDirectory not implemented for ${uri}`,
+				),
+			),
 		readFile: (uri) =>
-			Promise.reject(new Error("readFile not implemented")),
+			Effect.fail(
+				new VscFileSystemError(`readFile not implemented for ${uri}`),
+			),
 		writeFile: (uri, content) =>
-			Promise.reject(new Error("writeFile not implemented")),
+			Effect.fail(
+				new VscFileSystemError(`writeFile not implemented for ${uri}`),
+			),
 		delete: (uri, options) =>
-			Promise.reject(new Error("delete not implemented")),
+			Effect.fail(
+				new VscFileSystemError(`delete not implemented for ${uri}`),
+			),
 		rename: (source, target, options) =>
-			Promise.reject(new Error("rename not implemented")),
+			Effect.fail(
+				new VscFileSystemError(`rename not implemented for ${source}`),
+			),
 		copy: (source, target, options) =>
-			Promise.reject(new Error("copy not implemented")),
+			Effect.fail(
+				new VscFileSystemError(`copy not implemented for ${source}`),
+			),
 		isWritableFileSystem: FsInfo.isWritableFileSystem,
 		onDidChangeFile: FsInfo.onDidChangeFile,
 	};

Source/Service/IPC/Client/Acquire.ts

@@ -16,12 +16,11 @@ import { Effect } from "effect";
 
 import { Configuration as ConfigurationService } from "../Configuration.js";
 import { gRPCConnectionError } from "../Error.js";
-import { Release } from "./Release.js";
 import type { Interface as ClientService } from "./Service.js";
+import { Release } from "./Release.js";
 
 /**
  * An `Effect` that loads the gRPC `.proto` file definition from disk.
- * @param ProtoPath The absolute path to the `vine.proto` file.
  */
 function LoadProtoDefinition(
 	ProtoPath: string,
@@ -44,8 +43,6 @@ function LoadProtoDefinition(
 /**
  * An `Effect` that creates an insecure gRPC client instance from a loaded
  * package definition.
- * @param PackageDefinition The loaded gRPC package definition.
- * @param ServerAddress The address of the `Mountain` gRPC server.
  */
 function CreateClientInstance(
 	PackageDefinition: GrpcObject,
@@ -72,9 +69,7 @@ function CreateClientInstance(
 }
 
 /**
- * An `Effect` that waits for the gRPC client to establish a ready connection
- * with the server, with a 10-second timeout.
- * @param Client The gRPC client instance.
+ * An `Effect` that waits for the gRPC client to establish a ready connection.
  */
 function WaitForClientReady(
 	Client: ClientService,

Source/Service/IPC/Server.ts

@@ -7,7 +7,7 @@
 import { Layer } from "effect";
 
 import type { Configuration } from "./Configuration.js";
-import { Dispatcher } from "./Dispatcher/Service.js";
+import { Live as LiveDispatcher } from "./Dispatcher.js";
 import type { gRPCConnectionError } from "./Error.js";
 import { Acquire } from "./Server/Acquire.js";
 import { Tag, type Interface as ServerService } from "./Server/Service.js";
@@ -19,4 +19,4 @@ export const Live: Layer.Layer<
 	ServerService,
 	gRPCConnectionError,
 	Configuration | Dispatcher.Interface
-> = Layer.scoped(Tag, Acquire).pipe(Layer.provide(Dispatcher));
+> = Layer.scoped(Tag, Acquire).pipe(Layer.provide(LiveDispatcher));

Source/Service/IPC/Server/Acquire.ts

@@ -14,7 +14,7 @@ import {
 import { Effect } from "effect";
 
 import { Configuration as ConfigurationService } from "../Configuration.js";
-import { Dispatcher } from "../Dispatcher/Service.js";
+import { Dispatcher } from "../Dispatcher.js";
 import { gRPCConnectionError } from "../Error.js";
 import { CreateServiceImplementation } from "./CreateServiceImplementation.js";
 import { Release } from "./Release.js";

Source/Service/IPC/Server/CreateServiceImplementation.ts

@@ -76,16 +76,16 @@ export function CreateServiceImplementation(
 			callback: gRPC.sendUnaryData<Empty>,
 		) => {
 			const Notification = call.request;
-
-			const ProcessEffect = DecodeValue(Notification.getParams()).pipe(
+			const ProcessEffect = DecodeValue(
+				(Notification as any).getParams(),
+			).pipe(
 				Effect.flatMap((DecodedParameter) =>
 					DispatcherService.DispatchNotification(
-						Notification.getMethod(),
+						(Notification as any).getMethod(),
 						DecodedParameter,
 					),
 				),
 			);
-
 			Effect.runFork(ProcessEffect);
 			callback(null, new Empty());
 		},

Source/TypeConverter/Command/Definition.ts

@@ -33,45 +33,45 @@ export class Definition implements Interface {
 		);
 	}
 
-	private ExecuteDelegatedCommand(ID: string, ...Arguments: any[]): any {
-		const command = this.DelegatedCommands.get(ID);
-		if (!command) {
+	private ExecuteDelegatedCommand(ID: string, ...ArgumentArray: any[]): any {
+		const Command = this.DelegatedCommands.get(ID);
+		if (!Command) {
 			throw new Error(`Unknown delegated command: ${ID}`);
 		}
 		return this.CommandService.ExecuteCommand(
-			command.command,
-			...(command.arguments ?? []),
+			Command.command,
+			...(Command.arguments ?? []),
 		);
 	}
 
 	public ToInternal(
 		Command: VSCode.Command,
-		Disposables: IDisposable[],
+		DisposableArray: IDisposable[],
 	): ICommand {
 		if (!Command) {
 			return undefined as any;
 		}
 
 		const APICommand = this.LookupAPICommand(Command.command);
 		if (APICommand) {
-			const ConvertedArguments =
-				Command.arguments?.map((argument, i) =>
-					APICommand.Arguments[i].Convert(argument),
+			const ConvertedArgumentArray =
+				Command.arguments?.map((Argument, i) =>
+					APICommand.Arguments[i].Convert(Argument),
 				) ?? [];
 			return {
 				id: APICommand.InternalID,
 				title: APICommand.ID,
-				arguments: ConvertedArguments,
+				arguments: ConvertedArgumentArray,
 			};
 		}
 
 		if (
 			Array.isArray(Command.arguments) &&
-			Command.arguments.some((argument) => typeof argument === "function")
+			Command.arguments.some((Argument) => typeof Argument === "function")
 		) {
 			const ID = generateUuid();
 			this.DelegatedCommands.set(ID, Command);
-			Disposables.push({
+			DisposableArray.push({
 				dispose: () => this.DelegatedCommands.delete(ID),
 			});
 			return {

Source/TypeConverter/WorkSpaceEdit.ts

@@ -34,74 +34,74 @@ export interface IVersionInformationProvider {
 }
 
 export namespace WorkSpaceEdit {
-	export function fromAPI(
+	export function FromAPI(
 		Edit: VSCode.WorkspaceEdit,
 		VersionProvider?: IVersionInformationProvider,
 	): IWorkspaceEdit {
-		const result: IWorkspaceEdit = { edits: [] };
+		const Result: IWorkspaceEdit = { edits: [] };
 
-		for (const [uri, edits] of Edit.entries()) {
-			if (edits[0] instanceof ExtHostTypes.TextEdit) {
-				const resource = URIConverter.fromAPI(uri);
-				const versionId = VersionProvider?.GetTextDocumentVersion(uri);
-				for (const edit of edits as VSCode.TextEdit[]) {
-					result.edits.push({
-						resource,
-						textEdit: TextEditConverter.fromAPI(edit),
-						versionId,
+		for (const [URI, URIEditArray] of Edit.entries()) {
+			if (URIEditArray[0] instanceof ExtHostTypes.TextEdit) {
+				const Resource = URIConverter.FromAPI(URI);
+				const VersionId = VersionProvider?.GetTextDocumentVersion(URI);
+				for (const SingleEdit of URIEditArray as VSCode.TextEdit[]) {
+					Result.edits.push({
+						resource: Resource,
+						textEdit: TextEditConverter.FromAPI(SingleEdit),
+						versionId: VersionId,
 					} as IWorkspaceTextEdit);
 				}
 			} else {
-				for (const edit of edits as any[]) {
-					result.edits.push({
-						oldResource: edit.oldUri
-							? URIConverter.fromAPI(edit.oldUri)
+				for (const FileEdit of URIEditArray as any[]) {
+					Result.edits.push({
+						oldResource: FileEdit.oldUri
+							? URIConverter.FromAPI(FileEdit.oldUri)
 							: undefined,
-						newResource: edit.newUri
-							? URIConverter.fromAPI(edit.newUri)
+						newResource: FileEdit.newUri
+							? URIConverter.FromAPI(FileEdit.newUri)
 							: undefined,
-						options: edit.options,
-						metadata: edit.metadata,
+						options: FileEdit.options,
+						metadata: FileEdit.metadata,
 					} as IWorkspaceFileEdit);
 				}
 			}
 		}
-		return result;
+		return Result;
 	}
 
 	export function ToAPI(DTO: IWorkspaceEdit): VSCode.WorkspaceEdit {
-		const result = new ExtHostTypes.WorkspaceEdit();
-		for (const edit of DTO.edits) {
-			if ("textEdit" in edit) {
-				const workspaceTextEdit = edit as IWorkspaceTextEdit;
-				const uri = URIConverter.ToAPI(
-					workspaceTextEdit.resource as any,
+		const Result = new ExtHostTypes.WorkspaceEdit();
+		for (const Edit of DTO.edits) {
+			if ("textEdit" in Edit) {
+				const WorkspaceTextEdit = Edit as IWorkspaceTextEdit;
+				const URI = URIConverter.ToAPI(
+					WorkspaceTextEdit.resource as any,
 				);
-				const textEdits = [
-					TextEditConverter.ToAPI(workspaceTextEdit.textEdit as any),
+				const TextEditArray = [
+					TextEditConverter.ToAPI(WorkspaceTextEdit.textEdit as any),
 				];
-				result.set(uri, textEdits);
+				Result.set(URI, TextEditArray);
 			} else {
-				const fileEdit = edit as IWorkspaceFileEdit;
-				if (fileEdit.oldResource && fileEdit.newResource) {
-					result.renameFile(
-						URIConverter.ToAPI(fileEdit.oldResource as any),
-						URIConverter.ToAPI(fileEdit.newResource as any),
-						fileEdit.options,
+				const FileEdit = Edit as IWorkspaceFileEdit;
+				if (FileEdit.oldResource && FileEdit.newResource) {
+					Result.renameFile(
+						URIConverter.ToAPI(FileEdit.oldResource as any),
+						URIConverter.ToAPI(FileEdit.newResource as any),
+						FileEdit.options,
 					);
-				} else if (fileEdit.newResource) {
-					result.createFile(
-						URIConverter.ToAPI(fileEdit.newResource as any),
-						fileEdit.options,
+				} else if (FileEdit.newResource) {
+					Result.createFile(
+						URIConverter.ToAPI(FileEdit.newResource as any),
+						FileEdit.options,
 					);
-				} else if (fileEdit.oldResource) {
-					result.deleteFile(
-						URIConverter.ToAPI(fileEdit.oldResource as any),
-						fileEdit.options,
+				} else if (FileEdit.oldResource) {
+					Result.deleteFile(
+						URIConverter.ToAPI(FileEdit.oldResource as any),
+						FileEdit.options,
 					);
 				}
 			}
 		}
-		return result;
+		return Result;
 	}
 }