chore(Cocoon): Standardize naming conventions and casing across IPC and API components

- Rename all `Ipc` references to `IPC` for consistency with project acronym conventions
- Convert `Vscode` to `VSCode` in type names and variables to match official branding
- Normalize `Api` to `API` in service names and method calls (e.g. `ApiFactory` → `APIFactory`)
- Adjust `Workspace` to `WorkSpace` in alignment with VS Code's internal naming patterns
- Update ESLint configuration references from `Cocoon.js` to `Cocoon.ts`

These changes maintain functional equivalence while ensuring naming consistency across the Cocoon sidecar's codebase, particularly in components interfacing with Mountain via gRPC. The standardization supports clearer cross-component communication in Land's architecture and aligns with established TypeScript conventions in the VS Code ecosystem.

Author: NikolaRHristov

Source/Cocoon.ts

@@ -12,23 +12,23 @@
 
 import * as Path from "path";
 import { Barrier, Context, Effect, Layer, Scope } from "effect";
+import type { IExtensionHostInitData } from "vs/workbench/services/extensions/common/extensionHostProtocol.js";
 
 import { CoreServicesLayer } from "./Core.js";
 import { ExtensionHost } from "./Core/ExtensionHost.js";
 import { RequireInterceptor } from "./Core/RequireInterceptor.js";
-import { RunProcessPatches } from "./PatchProcess.js";
+import { RunProcessPatch } from "./PatchProcess.js";
 import { AllServicesLayer } from "./Service.js";
 import { InitDataLayer } from "./Service/InitData.js";
-import { IpcProvider, Live as LiveIpc } from "./Service/Ipc.js";
-import type { IExtensionHostInitData } from "./Type/vscode-proposed.js";
+import { IPCProvider, Live as LiveIPC } from "./Service/IPC.js";
 
 // --- Pre-initialization Steps ---
 // Add the bundled VS Code module path to Node's search paths. This allows
 // imports like `vs/base/common/uri.js` to resolve correctly.
-const VscodeOutDir =
+const VSCodeOutDir =
 	process.env["VSCODE_OUT_DIR"] ??
 	Path.resolve(__dirname, "../../../Dependency/VSCode/out");
-(module as any).paths.unshift(VscodeOutDir);
+(module as any).paths.unshift(VSCodeOutDir);
 
 // --- Application Logic ---
 
@@ -58,13 +58,13 @@ const Main = Effect.gen(function* (_) {
 	const InitBarrier = yield* _(Barrier.make());
 
 	// 1. Apply all low-level process patches (e.g., console piping, termination hooks).
-	yield* _(RunProcessPatches);
+	yield* _(RunProcessPatch);
 
 	// 2. Get the IPC provider.
-	const Ipc = yield* _(IpcProvider.Tag);
+	const IPC = yield* _(IPCProvider.Tag);
 
 	// 3. Register the handler that will be called by Mountain to kick off initialization.
-	Ipc.RegisterInvokeHandler(
+	IPC.RegisterInvokeHandler(
 		"initExtensionHost",
 		(InitData: IExtensionHostInitData) =>
 			Effect.gen(function* (_) {
@@ -90,7 +90,7 @@ const Main = Effect.gen(function* (_) {
 	);
 
 	// 4. Send the 'Ready' signal to Mountain, indicating we are ready for init data.
-	yield* _(Ipc.SendNotification("$initialHandshake", []));
+	yield* _(IPC.SendNotification("$initialHandshake", []));
 	yield* _(Effect.logInfo("Cocoon is ready. Sent handshake to Mountain."));
 
 	// 5. Wait for the `initExtensionHost` handler to open the barrier.
@@ -120,7 +120,7 @@ const AppConfig = {
  * The base Layer for the application, providing the IPC connection.
  * Other layers will be built on top of this.
  */
-const CocoonBaseLayer = LiveIpc(AppConfig);
+const CocoonBaseLayer = LiveIPC(AppConfig);
 
 // --- Run the Application ---
 

Source/Command/ProcessUserData/GetActiveTextEditor.ts

@@ -4,13 +4,13 @@
  */
 
 import { Effect, Option } from "effect";
-import * as Vscode from "vscode";
+import * as VSCode from "vscode";
 
 /**
  * An Effect that safely retrieves the active text editor.
- * @returns An `Effect` that resolves to an `Option<Vscode.TextEditor>`, which
+ * @returns An `Effect` that resolves to an `Option<VSCode.TextEditor>`, which
  * will be `None` if no editor is active, and `Some` otherwise.
  */
 export const GetActiveTextEditor = Effect.sync(() =>
-	Option.fromNullable(Vscode.window.activeTextEditor),
+	Option.fromNullable(VSCode.window.activeTextEditor),
 );

Source/Command/ProcessUserData/GetDocumentText.ts

@@ -4,13 +4,13 @@
  */
 
 import { Effect } from "effect";
-import type * as Vscode from "vscode";
+import type * as VSCode from "vscode";
 
 /**
  * An Effect that gets the full text content of a given document.
  * @param Document - The `vscode.TextDocument` to read from.
  * @returns An `Effect` that synchronously resolves to the document's text content.
  */
 export const GetDocumentText = (
-	Document: Vscode.TextDocument,
+	Document: VSCode.TextDocument,
 ): Effect.Effect<string> => Effect.sync(() => Document.getText());

Source/Configuration/ESBuild/Cocoon.js

@@ -34,7 +34,7 @@ export default {
         {
             name: "Target",
             // @ts-ignore
-            setup({ onStart, initialOptions: { outdir } }) {
+            setup({ onStart, initialOption: { outdir } }) {
                 switch (true) {
                     case Clean === true:
                         onStart(async () => {

Source/Configuration/ESBuild/Cocoon.ts

@@ -6,7 +6,7 @@
  * Export: Clean, On
  */
 
-import type { BuildOptions } from "esbuild";
+import type { BuildOption } from "esbuild";
 
 export const On =
 	process.env["NODE_ENV"] === "development" ||
@@ -40,7 +40,7 @@ export default {
 		{
 			name: "Target",
 			// @ts-ignore
-			setup({ onStart, initialOptions: { outdir } }) {
+			setup({ onStart, initialOption: { outdir } }) {
 				switch (true) {
 					case Clean === true:
 						onStart(async () => {
@@ -66,6 +66,6 @@ export default {
 		},
 	],
 	outbase: "Source/Configuration",
-} satisfies BuildOptions as BuildOptions;
+} satisfies BuildOption as BuildOption;
 
 export const { sep, posix } = await import("node:path");

Source/Configuration/ESBuild/Target.ts

@@ -33,7 +33,7 @@
 //
 //--------------------------------------------------------------------------------------------*/
 
-import type { BuildOptions } from "esbuild";
+import type { BuildOption } from "esbuild";
 
 // Import the global API function name constant from the compiled interceptor module.
 // This ensures the build configuration uses the exact same string that the interceptor expects.
@@ -53,10 +53,10 @@ export const On = (await import("./Cocoon.js")).On;
 /**
  * ESBuild configuration module.
  *
- * @param Current - The current BuildOptions, potentially passed from a preceding build step or CLI.
- * @returns A Promise resolving to the configured BuildOptions for esbuild.
+ * @param Current - The current BuildOption, potentially passed from a preceding build step or CLI.
+ * @returns A Promise resolving to the configured BuildOption for esbuild.
  */
-export default async (Current: BuildOptions): Promise<BuildOptions> => {
+export default async (Current: BuildOption): Promise<BuildOption> => {
 	// Asynchronously import dependencies for the configuration logic.
 	const [deepmergeMod, cocoonMod, ulidMod, playformBuildEntryMod] =
 		await Promise.all([
@@ -76,20 +76,20 @@ export default async (Current: BuildOptions): Promise<BuildOptions> => {
 	const { deepmerge } = deepmergeMod;
 
 	// Base configuration
-	const CocoonDefaultConfig = cocoonMod.default as BuildOptions;
+	const CocoonDefaultConfig = cocoonMod.default as BuildOption;
 
 	const { ulid } = ulidMod;
 
 	const getEntryPoints = playformBuildEntryMod.default as (
-		current: BuildOptions,
+		current: BuildOption,
 
 		patterns: string[],
 
 		// Type assertion for clarity
 	) => string[] | Record<string, string>;
 
 	// Merge the base configuration with specific overrides and additions.
-	return deepmerge<[BuildOptions, BuildOptions]>(CocoonDefaultConfig, {
+	return deepmerge<[BuildOption, BuildOption]>(CocoonDefaultConfig, {
 		// Specifies the output directory for compiled files.
 		outdir: "Target",
 

Source/Core.ts

@@ -2,10 +2,10 @@
 
 import { Layer } from "effect";
 
-import { Live as LiveApiFactory } from "./ApiFactory.js";
-import { Live as LiveExtensionHost } from "./ExtensionHost.js";
-import { Live as LiveExtensionPaths } from "./ExtensionPath.js";
-import { Live as LiveRequireInterceptor } from "./RequireInterceptor.js";
+import { Live as LiveAPIFactory } from "./Core/APIFactory.js";
+import { Live as LiveExtensionHost } from "./Core/ExtensionHost.js";
+import { Live as LiveExtensionPaths } from "./Core/ExtensionPath.js";
+import { Live as LiveRequireInterceptor } from "./Core/RequireInterceptor.js";
 
 /**
  * @module Core
@@ -16,17 +16,17 @@ import { Live as LiveRequireInterceptor } from "./RequireInterceptor.js";
 
 // --- Re-exporting the full public API (Tag, Interface, Live Layer) for each core service ---
 
-export * as ApiFactory from "./ApiFactory.js";
-export * as ExtensionHost from "./ExtensionHost.js";
-export * as ExtensionPaths from "./ExtensionPath.js";
-export * as RequireInterceptor from "./RequireInterceptor.js";
+export * as APIFactory from "./Core/APIFactory.js";
+export * as ExtensionHost from "./Core/ExtensionHost.js";
+export * as ExtensionPaths from "./Core/ExtensionPath.js";
+export * as RequireInterceptor from "./Core/RequireInterceptor.js";
 
 /**
  * A single, composed layer that provides all core services of the extension host.
  * This simplifies the process of building the final application layer in `Index.ts`.
  */
 export const CoreServicesLayer = Layer.mergeAll(
-	LiveApiFactory,
+	LiveAPIFactory,
 	LiveExtensionHost,
 	LiveExtensionPaths,
 	LiveRequireInterceptor,

Source/Core/APIFactory.ts

@@ -1,74 +1,74 @@
 /**
- * @module ApiFactory
- * @description The main module for the `ApiFactory` service, which is
+ * @module APIFactory
+ * @description The main module for the `APIFactory` service, which is
  * responsible for creating sandboxed `vscode` API objects for extensions.
  */
 
 import { Context, Effect, Layer } from "effect";
 import type { IExtensionDescription } from "vs/platform/extensions/common/extensions.js";
-import type * as Vscode from "vscode";
+import type * as VSCode from "vscode";
 
 import * as Service from "../../Service.js";
-import { CreateApiFactory } from "./CreateApiFactory.js";
+import { CreateAPIFactory } from "./CreateAPIFactory.js";
 
 /**
- * The interface for the `ApiFactory` service.
+ * The interface for the `APIFactory` service.
  */
 export interface Interface {
 	/**
 	 * Creates a new, sandboxed `vscode` API object for a specific extension.
 	 * @param Extension The full description of the extension requesting the API.
 	 * @returns A frozen `vscode` API object tailored for the extension.
 	 */
-	readonly Create: (Extension: IExtensionDescription) => typeof Vscode;
+	readonly Create: (Extension: IExtensionDescription) => typeof VSCode;
 }
 
 /**
- * The `Context.Tag` for the `ApiFactory` service.
+ * The `Context.Tag` for the `APIFactory` service.
  */
-export const Tag = Context.Tag<Interface>("ApiFactory");
+export const Tag = Context.Tag<Interface>("APIFactory");
 
 /**
- * The live implementation `Layer` for the `ApiFactory` service.
+ * The live implementation `Layer` for the `APIFactory` service.
  *
  * This layer has a comprehensive dependency graph, as it requires every
  * underlying service that contributes to the final `vscode` API object. It
- * injects all of these services into the `CreateApiFactory` function to
+ * injects all of these services into the `CreateAPIFactory` function to
  * construct the final service implementation.
  */
 export const Live = Layer.effect(
 	Tag,
 	Effect.gen(function* (_) {
 		// --- Inject all necessary services ---
 		const LogService = yield* _(Service.Log.Tag);
-		const ProposedApiService = yield* _(Service.ProposedApi.Tag);
-		const DeprecationService = yield* _(Service.ApiDeprecation.Tag);
-		const CommandsService = yield* _(Service.Commands.Tag);
-		const WorkspaceService = yield* _(Service.Workspace.Tag);
+		const ProposedAPIService = yield* _(Service.ProposedAPI.Tag);
+		const DeprecationService = yield* _(Service.APIDeprecation.Tag);
+		const CommandService = yield* _(Service.Command.Tag);
+		const WorkSpaceService = yield* _(Service.WorkSpace.Tag);
 		const WindowService = yield* _(Service.Window.Tag);
 		const LanguageFeaturesService = yield* _(Service.LanguageFeatures.Tag);
 		const DebugService = yield* _(Service.Debug.Tag);
 		const TasksService = yield* _(Service.Tasks.Tag);
 		const ExtensionService = yield* _(Service.Extension.Tag);
-		const WebviewPanelService = yield* _(Service.WebviewPanel.Tag);
+		const WebViewPanelService = yield* _(Service.WebViewPanel.Tag);
 		const CustomEditorService = yield* _(Service.CustomEditor.Tag);
 		const TreeViewService = yield* _(Service.TreeView.Tag);
 		const StatusBarService = yield* _(Service.StatusBar.Tag);
 		// Add other services here as they are implemented.
 
 		// --- Construct the factory with all its dependencies ---
-		return CreateApiFactory(
+		return CreateAPIFactory(
 			LogService,
-			ProposedApiService,
+			ProposedAPIService,
 			DeprecationService,
-			CommandsService,
-			WorkspaceService,
+			CommandService,
+			WorkSpaceService,
 			WindowService,
 			LanguageFeaturesService,
 			DebugService,
 			TasksService,
 			ExtensionService,
-			WebviewPanelService,
+			WebViewPanelService,
 			CustomEditorService,
 			TreeViewService,
 			StatusBarService,

Source/Core/ApiFactory/AsExtensionEvent.ts

@@ -4,7 +4,7 @@
  * to provide safe error handling for extension listeners.
  */
 
-import type * as Vscode from "vscode";
+import type * as VSCode from "vscode";
 
 import type { Log } from "../../Service.js";
 
@@ -23,10 +23,10 @@ import type { Log } from "../../Service.js";
  * @returns A new, safe `vscode.Event<T>` that can be exposed to extensions.
  */
 export const AsExtensionEvent = <T>(
-	ExtensionId: Vscode.ExtensionIdentifier,
+	ExtensionId: VSCode.ExtensionIdentifier,
 	LogService: Log.Interface,
-	ActualEvent: Vscode.Event<T>,
-): Vscode.Event<T> => {
+	ActualEvent: VSCode.Event<T>,
+): VSCode.Event<T> => {
 	// Return a new event subscription function.
 	return (Listener, ThisArgument, Disposables) => {
 		// Create a "safe" listener that wraps the original extension-provided listener.