fix: refresh codebase index on config change

shssoichiro · shssoichiro · commit 06237050cf75 · 2025-06-15T15:23:39.000-04:00
diff --git a/core/indexing/CodebaseIndexer.test.ts b/core/indexing/CodebaseIndexer.test.ts
@@ -1,3 +1,5 @@
+/* eslint-disable max-lines-per-function */
+/* lint is not useful for test classes */
 import { jest } from "@jest/globals";
 import { execSync } from "node:child_process";
 import fs from "node:fs";
@@ -14,6 +16,9 @@ import {
 } from "../test/testDir.js";
 import { getIndexSqlitePath } from "../util/paths.js";
 
+import { ConfigResult } from "@continuedev/config-yaml";
+import CodebaseContextProvider from "../context/providers/CodebaseContextProvider.js";
+import { ContinueConfig } from "../index.js";
 import { localPathToUri } from "../util/pathToUri.js";
 import { CodebaseIndexer, PauseToken } from "./CodebaseIndexer.js";
 import { getComputeDeleteAddRemove } from "./refreshIndex.js";
@@ -57,6 +62,17 @@ class TestCodebaseIndexer extends CodebaseIndexer {
   protected async getIndexesToBuild(): Promise<CodebaseIndex[]> {
     return [new TestCodebaseIndex()];
   }
+
+  // Add public methods to test private methods
+  public testHasCodebaseContextProvider() {
+    return (this as any).hasCodebaseContextProvider();
+  }
+
+  public async testHandleConfigUpdate(
+    configResult: ConfigResult<ContinueConfig>,
+  ) {
+    return (this as any).handleConfigUpdate({ config: configResult.config });
+  }
 }
 
 // Create a mock messenger type that doesn't require actual protocol imports
@@ -411,4 +427,270 @@ describe("CodebaseIndexer", () => {
       expect(codebaseIndexer.currentIndexingState).toEqual(testState);
     });
   });
+
+  // New describe block for testing handleConfigUpdate functionality
+  describe("handleConfigUpdate functionality", () => {
+    let testIndexer: TestCodebaseIndexer;
+    let mockRefreshCodebaseIndex: jest.MockedFunction<any>;
+    let mockGetWorkspaceDirs: jest.MockedFunction<any>;
+
+    beforeEach(() => {
+      testIndexer = new TestCodebaseIndexer(
+        testConfigHandler,
+        testIde,
+        mockMessenger as any,
+        false,
+      );
+
+      // Mock the refreshCodebaseIndex method to avoid actual indexing
+      mockRefreshCodebaseIndex = jest
+        .spyOn(testIndexer, "refreshCodebaseIndex")
+        .mockImplementation(async () => {});
+
+      // Mock getWorkspaceDirs to return test directories
+      mockGetWorkspaceDirs = jest
+        .spyOn(testIde, "getWorkspaceDirs")
+        .mockResolvedValue(["/test/workspace"]);
+    });
+
+    afterEach(() => {
+      jest.clearAllMocks();
+    });
+
+    describe("hasCodebaseContextProvider", () => {
+      test("should return true when codebase context provider is present", () => {
+        // Set up config with codebase context provider
+        (testIndexer as any).config = {
+          contextProviders: [
+            {
+              description: {
+                title: CodebaseContextProvider.description.title,
+              },
+            },
+          ],
+        };
+
+        const result = testIndexer.testHasCodebaseContextProvider();
+        expect(result).toBe(true);
+      });
+
+      test("should return false when no context providers are configured", () => {
+        (testIndexer as any).config = {
+          contextProviders: undefined,
+        };
+
+        const result = testIndexer.testHasCodebaseContextProvider();
+        expect(result).toBe(false);
+      });
+
+      test("should return false when context providers exist but no codebase provider", () => {
+        (testIndexer as any).config = {
+          contextProviders: [
+            {
+              description: {
+                title: "SomeOtherProvider",
+              },
+            },
+          ],
+        };
+
+        const result = testIndexer.testHasCodebaseContextProvider();
+        expect(result).toBe(false);
+      });
+
+      test("should return false when context providers is empty array", () => {
+        (testIndexer as any).config = {
+          contextProviders: [],
+        };
+
+        const result = testIndexer.testHasCodebaseContextProvider();
+        expect(result).toBe(false);
+      });
+    });
+
+    describe("handleConfigUpdate", () => {
+      test("should return early when newConfig is null", async () => {
+        const configResult: ConfigResult<ContinueConfig> = {
+          config: null as any,
+          errors: [],
+          configLoadInterrupted: false,
+        };
+
+        await testIndexer.testHandleConfigUpdate(configResult);
+
+        // These get called once on init, so we want them to not get called again
+        expect(mockRefreshCodebaseIndex).toHaveBeenCalledTimes(1);
+        expect(mockGetWorkspaceDirs).toHaveBeenCalledTimes(1);
+      });
+
+      test("should return early when newConfig is undefined", async () => {
+        const configResult: ConfigResult<ContinueConfig> = {
+          config: undefined as any,
+          errors: [],
+          configLoadInterrupted: false,
+        };
+
+        await testIndexer.testHandleConfigUpdate(configResult);
+
+        // These get called once on init, so we want them to not get called again
+        expect(mockRefreshCodebaseIndex).toHaveBeenCalledTimes(1);
+        expect(mockGetWorkspaceDirs).toHaveBeenCalledTimes(1);
+      });
+
+      test("should return early when no codebase context provider is present", async () => {
+        const configResult: ConfigResult<ContinueConfig> = {
+          config: {
+            contextProviders: [
+              {
+                description: {
+                  title: "SomeOtherProvider",
+                },
+              },
+            ],
+            selectedModelByRole: {
+              embed: {
+                model: "test-model",
+                provider: "test-provider",
+              },
+            },
+          } as unknown as ContinueConfig,
+          errors: [],
+          configLoadInterrupted: false,
+        };
+
+        await testIndexer.testHandleConfigUpdate(configResult);
+
+        // These get called once on init, so we want them to not get called again
+        expect(mockRefreshCodebaseIndex).toHaveBeenCalledTimes(1);
+        expect(mockGetWorkspaceDirs).toHaveBeenCalledTimes(1);
+      });
+
+      test("should return early when no embed model is configured", async () => {
+        const configResult: ConfigResult<ContinueConfig> = {
+          config: {
+            contextProviders: [
+              {
+                description: {
+                  title: CodebaseContextProvider.description.title,
+                },
+              },
+            ],
+            selectedModelByRole: {
+              embed: undefined,
+            },
+          } as unknown as ContinueConfig,
+          errors: [],
+          configLoadInterrupted: false,
+        };
+
+        await testIndexer.testHandleConfigUpdate(configResult);
+
+        // These get called once on init, so we want them to not get called again
+        expect(mockRefreshCodebaseIndex).toHaveBeenCalledTimes(1);
+        expect(mockGetWorkspaceDirs).toHaveBeenCalledTimes(1);
+      });
+
+      test("should call refreshCodebaseIndex when all conditions are met", async () => {
+        const configResult: ConfigResult<ContinueConfig> = {
+          config: {
+            contextProviders: [
+              {
+                description: {
+                  title: CodebaseContextProvider.description.title,
+                },
+              },
+            ],
+            selectedModelByRole: {
+              embed: {
+                model: "test-model",
+                provider: "test-provider",
+              },
+            },
+          } as unknown as ContinueConfig,
+          errors: [],
+          configLoadInterrupted: false,
+        };
+
+        await testIndexer.testHandleConfigUpdate(configResult);
+
+        // These get called once on init, and we want them to get called again
+        expect(mockGetWorkspaceDirs).toHaveBeenCalledTimes(2);
+        expect(mockRefreshCodebaseIndex).toHaveBeenCalledTimes(2);
+        expect(mockRefreshCodebaseIndex).toHaveBeenCalledWith([
+          "/test/workspace",
+        ]);
+      });
+
+      test("should set config property before checking conditions", async () => {
+        const testConfig = {
+          contextProviders: [
+            {
+              description: {
+                title: CodebaseContextProvider.description.title,
+              },
+            },
+          ],
+          selectedModelByRole: {
+            embed: {
+              model: "test-model",
+              provider: "test-provider",
+            },
+          },
+        } as unknown as ContinueConfig;
+
+        const configResult: ConfigResult<ContinueConfig> = {
+          config: testConfig,
+          errors: [],
+          configLoadInterrupted: false,
+        };
+
+        await testIndexer.testHandleConfigUpdate(configResult);
+
+        // Verify that the config was set
+        expect((testIndexer as any).config).toBe(testConfig);
+        // These get called once on init, and we want them to get called again
+        expect(mockRefreshCodebaseIndex).toHaveBeenCalledTimes(2);
+      });
+
+      test("should handle multiple context providers correctly", async () => {
+        const configResult: ConfigResult<ContinueConfig> = {
+          config: {
+            contextProviders: [
+              {
+                description: {
+                  title: "SomeOtherProvider",
+                },
+              },
+              {
+                description: {
+                  title: CodebaseContextProvider.description.title,
+                },
+              },
+              {
+                description: {
+                  title: "AnotherProvider",
+                },
+              },
+            ],
+            selectedModelByRole: {
+              embed: {
+                model: "test-model",
+                provider: "test-provider",
+              },
+            },
+          } as unknown as ContinueConfig,
+          errors: [],
+          configLoadInterrupted: false,
+        };
+
+        await testIndexer.testHandleConfigUpdate(configResult);
+
+        // These get called once on init, and we want them to get called again
+        expect(mockRefreshCodebaseIndex).toHaveBeenCalledTimes(2);
+        expect(mockRefreshCodebaseIndex).toHaveBeenCalledWith([
+          "/test/workspace",
+        ]);
+      });
+    });
+  });
 });
diff --git a/core/indexing/CodebaseIndexer.ts b/core/indexing/CodebaseIndexer.ts
@@ -1,14 +1,21 @@
 import * as fs from "fs/promises";
 
 import { ConfigHandler } from "../config/ConfigHandler.js";
-import { IDE, IndexingProgressUpdate, IndexTag } from "../index.js";
+import {
+  ContinueConfig,
+  IDE,
+  IndexingProgressUpdate,
+  IndexTag,
+} from "../index.js";
 import type { FromCoreProtocol, ToCoreProtocol } from "../protocol";
 import type { IMessenger } from "../protocol/messenger";
 import { extractMinimalStackTraceInfo } from "../util/extractMinimalStackTraceInfo.js";
 import { getIndexSqlitePath, getLanceDbPath } from "../util/paths.js";
 import { Telemetry } from "../util/posthog.js";
 import { findUriInDirs, getUriPathBasename } from "../util/uri.js";
 
+import { ConfigResult } from "@continuedev/config-yaml";
+import CodebaseContextProvider from "../context/providers/CodebaseContextProvider.js";
 import { ContinueServerClient } from "../continueServer/stubs/client";
 import { LLMError } from "../llm/index.js";
 import { getRootCause } from "../util/errors.js";
@@ -44,6 +51,8 @@ export class CodebaseIndexer {
    * - To make as few requests as possible to the embeddings providers
    */
   filesPerBatch = 500;
+  public isInitialized: Promise<void>;
+  private config!: ContinueConfig;
   private indexingCancellationController: AbortController | undefined;
   private codebaseIndexingState: IndexingProgressUpdate;
   private readonly pauseToken: PauseToken;
@@ -73,6 +82,17 @@ export class CodebaseIndexer {
 
     // Initialize pause token
     this.pauseToken = new PauseToken(initialPaused);
+
+    this.isInitialized = this.init(configHandler);
+  }
+
+  // Initialization - load config and attach config listener
+  private async init(configHandler: ConfigHandler) {
+    const result = await configHandler.loadConfig();
+    await this.handleConfigUpdate(result);
+    configHandler.onConfigUpdate(
+      this.handleConfigUpdate.bind(this) as (arg: any) => void,
+    );
   }
 
   /**
@@ -652,4 +672,35 @@ export class CodebaseIndexer {
   public get currentIndexingState(): IndexingProgressUpdate {
     return this.codebaseIndexingState;
   }
+
+  private hasCodebaseContextProvider() {
+    return !!this.config.contextProviders?.some(
+      (provider) =>
+        provider.description.title ===
+        CodebaseContextProvider.description.title,
+    );
+  }
+
+  private async handleConfigUpdate({
+    config: newConfig,
+  }: ConfigResult<ContinueConfig>) {
+    if (newConfig) {
+      this.config = newConfig; // IMPORTANT - need to set up top, other methods below use this without passing it in
+
+      // No point in indexing if no codebase context provider
+      const hasCodebaseContextProvider = this.hasCodebaseContextProvider();
+      if (!hasCodebaseContextProvider) {
+        return;
+      }
+
+      // Skip codebase indexing if not supported
+      // No warning message here because would show on ANY config update
+      if (!this.config.selectedModelByRole.embed) {
+        return;
+      }
+
+      const dirs = await this.ide.getWorkspaceDirs();
+      await this.refreshCodebaseIndex(dirs);
+    }
+  }
 }
