"refactor: implement dependency injection with tsyringe and restructure core components"

Author: bramburn

.vscode/settings.json

@@ -9,5 +9,6 @@
 		"dist": true // set this to false to include "dist" folder in search results
 	},
 	// Turn off tsc task auto detection since we have the necessary tasks as npm scripts
-	"typescript.tsc.autoDetect": "off"
+	"typescript.tsc.autoDetect": "off",
+	"python.languageServer": "None"
 }

src/activate/registerCommands.ts

@@ -61,7 +61,7 @@ export const registerCommands = (options: RegisterCommandOptions): void => {
 const getCommandsMap = ({ context, outputChannel, provider }: RegisterCommandOptions) => {
 	return {
 		"roo-cline.plusButtonClicked": async () => {
-			await provider.removeClineFromStack()
+			await provider.clineStackManager.removeClineFromStack()
 			await provider.postStateToWebview()
 			await provider.postMessageToWebview({ type: "action", action: "chatButtonClicked" })
 		},

src/container.ts

@@ -0,0 +1,13 @@
+import "reflect-metadata"
+import { container } from "tsyringe"
+import { ExtensionContext } from "vscode"
+import { ContextHolder, IExtensionContext } from "./core/contextHolder"
+
+// Register VS Code-specific dependencies
+export function configureContainer(context: ExtensionContext) {
+	container.register(ExtensionContext, { useValue: context })
+	container.registerSingleton(ContextHolder, ContextHolder)
+
+	return container
+}
+//todo: remove this so that we can build it properly after building the singletons

src/core/config/CustomModesManager.ts

@@ -9,7 +9,7 @@ import { logger } from "../../utils/logging"
 import { GlobalFileNames } from "../../shared/globalFileNames"
 
 const ROOMODES_FILENAME = ".roomodes"
-
+// TODO: Decouple this code
 export class CustomModesManager {
 	private disposables: vscode.Disposable[] = []
 	private isWriting = false

src/core/contextHolder.ts

@@ -0,0 +1,108 @@
+import * as vscode from "vscode"
+/**
+ * Interface for the vscode.ExtensionContext
+ */
+export interface IExtensionContext {
+	/**
+	 * The absolute file path of the extension's directory.
+	 */
+	readonly extensionPath: string
+	/**
+	 * The absolute file path of the extension's folder.
+	 */
+	readonly extensionUri: vscode.Uri
+	/**
+	 * The storage path for the extension.
+	 */
+	readonly storagePath?: string | undefined
+	/**
+	 * The global state of the extension.
+	 */
+	readonly globalState: vscode.Memento
+	/**
+	 * The workspace state of the extension.
+	 */
+	readonly workspaceState: vscode.Memento
+	/**
+	 * Logs a message at the 'log' level.
+	 * @param message The message to log.
+	 */
+	log(message: string): void
+	/**
+	 * Logs an error message at the 'error' level.
+	 * @param message The message to log.
+	 */
+	error(message: string): void
+	/**
+	 * Logs a warning message at the 'warn' level.
+	 * @param message The message to log.
+	 */
+	warn(message: string): void
+	/**
+	 * Subscribe to a specific event.
+	 * @param event The event to subscribe to.
+	 * @param listener The callback function to be called when the event occurs.
+	 */
+	subscribe<T>(event: string, listener: (data: T) => void): vscode.Disposable
+}
+
+export interface IContextHolder {
+	getContext(): vscode.ExtensionContext
+}
+
+/**
+ * This class is a singleton that holds the vscode.ExtensionContext.
+ * It can be obtained with ContextHolder.getInstance(context)
+ *
+ * Example of usage:
+ * const contextHolder = ContextHolder.getInstance(context)
+ * const extensionContext = contextHolder.getContext()
+ *
+ * OR
+ * const contextHolder = ContextHolder.getInstanceWithoutArgs()
+ * const extensionContext = contextHolder.getContext()
+ */
+export class ContextHolder implements IContextHolder {
+	/**
+	 * A singleton class that holds the vscode.ExtensionContext.
+	 * It can be obtained with ContextHolder.getInstance(context)
+	 *
+	 * Example of usage:
+	 * const contextHolder = ContextHolder.getInstance(context)
+	 * const extensionContext = contextHolder.getContext()
+	 */
+	private static instance: ContextHolder | undefined
+	private constructor(private readonly context: vscode.ExtensionContext) {}
+
+	/**
+	 * Gets the ContextHolder instance.
+	 * @param context The vscode.ExtensionContext.
+	 * @returns The ContextHolder instance.
+	 */
+	public static getInstance(context: vscode.ExtensionContext): ContextHolder {
+		if (!ContextHolder.instance) {
+			ContextHolder.instance = new ContextHolder(context)
+		}
+		return ContextHolder.instance
+	}
+
+	/**
+	 * Gets the ContextHolder instance without passing the context.
+	 * @returns The ContextHolder instance.
+	 * @throws {Error} If the ContextHolder has not been initialized. Call getInstance() first.
+	 */
+	public static getInstanceWithoutArgs(): ContextHolder {
+		if (!ContextHolder.instance) {
+			throw new Error("ContextHolder has not been initialized. Call getInstance() first.")
+		}
+		return ContextHolder.instance
+	}
+
+	/**
+	 * Gets the vscode.ExtensionContext.
+	 * @returns The vscode.ExtensionContext.
+	 */
+	public getContext(): vscode.ExtensionContext {
+		return this.context
+	}
+}

src/core/contextProxy.ts

@@ -13,26 +13,63 @@ import {
 	isPassThroughStateKey,
 } from "../shared/globalState"
 import { API_CONFIG_KEYS, ApiConfiguration } from "../shared/api"
+import { ContextHolder } from "./contextHolder"
+
+/*
+ * This class provides a proxy for the vscode.ExtensionContext.
+ * It caches global state and secrets in memory for faster access.
+ * It also provides a method to reset all state and secrets.
+ */
+
+export interface ContextProxyInstance {
+	get isInitialized(): boolean
+	get extensionUri(): vscode.Uri
+	get extensionPath(): string
+	get globalStorageUri(): vscode.Uri
+	get logUri(): vscode.Uri
+	get extension(): vscode.Extension<any>
+	get extensionMode(): vscode.ExtensionMode
+	getGlobalState<T>(key: GlobalStateKey): T | undefined
+	getGlobalState<T>(key: GlobalStateKey, defaultValue: T): T
+	getGlobalState<T>(key: GlobalStateKey, defaultValue?: T): T | undefined
+	updateGlobalState<T>(key: GlobalStateKey, value: T): any
+	getSecret(key: SecretKey): string | undefined
+	storeSecret(key: SecretKey, value?: string): Thenable<void>
+	setValue(key: ConfigurationKey, value: any): Thenable<void>
+	setValues(values: Partial<ConfigurationValues>): Thenable<void>
+	setApiConfiguration(apiConfiguration: ApiConfiguration): Thenable<void>
+	resetAllState(): Thenable<void>
+}
+
+export class ContextProxy implements ContextProxyInstance {
+	private static instance: ContextProxy
 
-export class ContextProxy {
 	private readonly originalContext: vscode.ExtensionContext
 
 	private stateCache: Map<GlobalStateKey, any>
 	private secretCache: Map<SecretKey, string | undefined>
 	private _isInitialized = false
 
-	constructor(context: vscode.ExtensionContext) {
-		this.originalContext = context
+	private constructor() {
+		this.originalContext = ContextHolder.getInstanceWithoutArgs().getContext()
 		this.stateCache = new Map()
 		this.secretCache = new Map()
-		this._isInitialized = false
+		this.initialize() // Initialize immediately
 	}
 
-	public get isInitialized() {
-		return this._isInitialized
+	public static getInstance(): ContextProxy {
+		if (!ContextProxy.instance) {
+			ContextProxy.instance = new ContextProxy()
+		}
+		return ContextProxy.instance
 	}
 
-	public async initialize() {
+	/**
+	 * Initialize the context proxy by loading global state and secrets.
+	 * This method is called automatically when the instance is created.
+	 */
+	private async initialize() {
+		if (this._isInitialized) return
 		for (const key of GLOBAL_STATE_KEYS) {
 			try {
 				this.stateCache.set(key, this.originalContext.globalState.get(key))
@@ -54,6 +91,10 @@ export class ContextProxy {
 		this._isInitialized = true
 	}
 
+	public get isInitialized() {
+		return this._isInitialized
+	}
+
 	get extensionUri() {
 		return this.originalContext.extensionUri
 	}
@@ -97,11 +138,23 @@ export class ContextProxy {
 		return this.originalContext.globalState.update(key, value)
 	}
 
+	/**
+	 * Retrieve a secret from the cache.
+	 * @param key The secret key to retrieve
+	 * @returns The cached secret value or undefined if not found
+	 */
 	getSecret(key: SecretKey) {
 		return this.secretCache.get(key)
 	}
 
-	storeSecret(key: SecretKey, value?: string) {
+	/**
+	 * Store a secret in the cache and write it to the context.
+	 * If the value is undefined, the secret will be deleted from the context.
+	 * @param key The secret key to store
+	 * @param value The secret value to store
+	 * @returns A promise that resolves when the operation completes
+	 */
+	storeSecret(key: SecretKey, value?: string): Thenable<void> {
 		// Update cache.
 		this.secretCache.set(key, value)
 
@@ -119,7 +172,7 @@ export class ContextProxy {
 	 * @param value The value to set
 	 * @returns A promise that resolves when the operation completes
 	 */
-	setValue(key: ConfigurationKey, value: any) {
+	setValue(key: ConfigurationKey, value: any): Thenable<void> {
 		if (isSecretKey(key)) {
 			return this.storeSecret(key, value)
 		}

src/core/interfaces/IOutputChannelManager.ts

@@ -0,0 +1,25 @@
+import * as vscode from "vscode"
+
+export interface IOutputChannelManager {
+	/**
+	 * Get the initialized output channel
+	 * @returns vscode.OutputChannel
+	 */
+	getOutputChannel(): vscode.OutputChannel
+
+	/**
+	 * Append a line to the output channel
+	 * @param message The message to append
+	 */
+	appendLine(message: string): void
+
+	/**
+	 * Show the output channel
+	 */
+	show(): void
+
+	/**
+	 * Clear the output channel
+	 */
+	clear(): void
+}

src/core/outputChannelManager.ts

@@ -0,0 +1,53 @@
+import * as vscode from "vscode"
+import { IOutputChannelManager } from "./interfaces/IOutputChannelManager"
+
+export class OutputChannelManager implements IOutputChannelManager {
+	private static instance: OutputChannelManager
+	private outputChannel: vscode.OutputChannel
+
+	private constructor() {
+		this.outputChannel = vscode.window.createOutputChannel("Roo-Code")
+	}
+
+	/**
+	 * Get the singleton instance of OutputChannelManager
+	 * @returns OutputChannelManager
+	 */
+	public static getInstance(): OutputChannelManager {
+		if (!OutputChannelManager.instance) {
+			OutputChannelManager.instance = new OutputChannelManager()
+		}
+		return OutputChannelManager.instance
+	}
+
+	/**
+	 * Get the initialized output channel
+	 * @returns vscode.OutputChannel
+	 */
+	public getOutputChannel(): vscode.OutputChannel {
+		return this.outputChannel
+	}
+
+	/**
+	 * Append a line to the output channel
+	 * TODO: Refactor and use this rather than using outputchannel
+	 * @param message The message to append
+	 */
+	public appendLine(message: string): void {
+		this.outputChannel.appendLine(message)
+	}
+
+	/**
+	 * Show the output channel
+	 */
+	public show(): void {
+		this.outputChannel.show()
+	}
+
+	/**
+	 * Clear the output channel
+	 */
+	public clear(): void {
+		this.outputChannel.clear()
+	}
+}