feat: Add secret storage provider and event handling

- Introduces  to securely store and retrieve secrets using VS Code's secret storage.
- Implements  to listen for secret changes and trigger  event.
- Adds  and  events to  and .
- Modifies  to handle  events.
- Updates  to set code index in Memory.

Author: Olasunkanmi Oyinlola

src/agents/orchestrator.ts

@@ -31,10 +31,6 @@ export class Orchestrator extends BaseAiAgent implements vscode.Disposable {
     this.publish("onResponse", event.message);
   }
 
-  // public handleError(event: IEventPayload) {
-  //   console.log(`Error: ${event.message}`);
-  // }
-
   public dispose(): void {
     this.disposables.forEach((d) => d.dispose());
   }

src/emitter/agent-emitter.ts

@@ -9,6 +9,9 @@ export class EventEmitter extends BaseEmitter<Record<string, IEventPayload>> {
   onPromptGenerated: vscode.Event<IEventPayload> = this.createEvent("onQuery");
   onThinking: vscode.Event<IEventPayload> = this.createEvent("onThinking");
   onResponse: vscode.Event<IEventPayload> = this.createEvent("onResponse");
+  onSecretChange: vscode.Event<IEventPayload> =
+    this.createEvent("onSecretChange");
+  onBootstrap: vscode.Event<IEventPayload> = this.createEvent("onBootstrap");
 
   /**
    * Emits a generic event with specified status, message, and optional data.

src/emitter/interface.ts

@@ -18,6 +18,8 @@ export interface IAgentEventMap {
   onQuery: IEventPayload;
   onResponse: IEventPayload;
   onThinking: IEventPayload;
+  onSecretChange: IEventPayload;
+  onBootstrap: IEventPayload;
 }
 
 export interface IEventPayload {

src/extension.ts

@@ -24,12 +24,11 @@ import { AnthropicWebViewProvider } from "./providers/anthropic";
 import { CodeActionsProvider } from "./providers/code-actions";
 import { GeminiWebViewProvider } from "./providers/gemini";
 import { GroqWebViewProvider } from "./providers/groq";
+import { CodeIndexingService } from "./services/code-indexing";
 import { FileUploader } from "./services/file-uploader";
 import { initializeGenerativeAiEnvironment } from "./services/generative-ai-model-manager";
 import { Credentials } from "./services/github-authentication";
 import { getConfigValue } from "./utils/utils";
-import { WebSearchService } from "./services/web-search-service";
-import { CodeIndexingService } from "./services/code-indexing";
 
 const {
   geminiKey,

src/providers/base.ts

@@ -30,6 +30,9 @@ export abstract class BaseWebViewProvider implements vscode.Disposable {
       this.orchestrator.onThinking(this.handleModelResponseEvent.bind(this)),
       this.orchestrator.onUpdate(this.handleModelResponseEvent.bind(this)),
       this.orchestrator.onError(this.handleModelResponseEvent.bind(this)),
+      this.orchestrator.onSecretChange(
+        this.handleModelResponseEvent.bind(this),
+      ),
     );
   }
 

src/providers/secret-storage-provider.ts

@@ -0,0 +1,64 @@
+import * as vscode from "vscode";
+import { Logger } from "../infrastructure/logger/logger";
+import { Orchestrator } from "./../agents/orchestrator";
+
+export class VSCodeSecretStorage {
+  private readonly context: vscode.ExtensionContext;
+  private readonly logger: Logger;
+  private readonly orchestrator: Orchestrator;
+  private static instance: VSCodeSecretStorage;
+
+  constructor(context: vscode.ExtensionContext) {
+    this.context = context;
+    this.logger = new Logger("VSCodeSecretStorage");
+    this.orchestrator = Orchestrator.getInstance();
+  }
+
+  static getInstance(context: vscode.ExtensionContext) {
+    if (!VSCodeSecretStorage.instance) {
+      VSCodeSecretStorage.instance = new VSCodeSecretStorage(context);
+    }
+    return VSCodeSecretStorage.instance;
+  }
+
+  async get(key: string): Promise<string | undefined> {
+    try {
+      return await this.context.secrets.get(key);
+    } catch (error) {
+      this.logger.error(`Error retrieving secret for key: ${key}`, error);
+      return undefined;
+    }
+  }
+
+  async store(key: string, value: string): Promise<void> {
+    try {
+      if (value?.length > 0) {
+        await this.context.secrets.store(key, value);
+      }
+    } catch (error) {
+      this.logger.error(`Error storing secret for key: ${key}`, error);
+      throw error;
+    }
+  }
+
+  async delete(key: string): Promise<void> {
+    try {
+      await this.context.secrets.delete(key);
+    } catch (error) {
+      this.logger.error(`Error deleting secret for key: ${key}`, error);
+      throw error;
+    }
+  }
+
+  onDidChange(): vscode.Disposable {
+    return this.context.secrets.onDidChange((event) => {
+      if (event.key.length > 0) {
+        this.orchestrator.handleStatus({
+          type: "onSecretChange",
+          data: event.key,
+          timestamp: new Date().toISOString(),
+        });
+      }
+    });
+  }
+}

src/services/typescript-ats.service.ts

@@ -1,6 +1,7 @@
 import * as path from "path";
 import * as ts from "typescript";
 import * as vscode from "vscode";
+import { Orchestrator } from "../agents/orchestrator";
 import { FSPROPS } from "../application/constant";
 import {
   DeclarationFunctionNode,
@@ -17,14 +18,17 @@ import {
 import { ITypeScriptCodeMapper } from "../application/interfaces/ts.code.mapper.interface";
 import { handleError } from "../utils/utils";
 import { FileService } from "./file-system";
+import { Memory } from "../memory/base";
 
 export class TypeScriptAtsMapper implements ITypeScriptCodeMapper {
   private program: ts.Program | undefined;
   private typeChecker: ts.TypeChecker | undefined;
   private readonly fsService: FileService;
   private static instance: TypeScriptAtsMapper;
+  protected readonly orchestrator: Orchestrator;
   constructor() {
     this.fsService = FileService.getInstance();
+    this.orchestrator = Orchestrator.getInstance();
   }
 
   public async init() {
@@ -571,7 +575,7 @@ export class TypeScriptAtsMapper implements ITypeScriptCodeMapper {
           codebaseMap[repoNames].modules[moduleRalativePath] = moduleInfo;
         });
       });
-      //For Code Indexing return codebaseMap
+      Memory.set("codeIndex", filesMap);
       return filesMap;
     } catch (error) {
       handleError(error, "Error fetching the files");