feat(code-index): add Semble as a local on-the-fly embedding provider

packages/types/src/codebase-index.ts

@@ -31,6 +31,7 @@ export const codebaseIndexConfigSchema = z.object({
 			"vercel-ai-gateway",
 			"bedrock",
 			"openrouter",
+			"semble",
 		])
 		.optional(),
 	codebaseIndexEmbedderBaseUrl: z.string().optional(),
@@ -67,6 +68,7 @@ export const codebaseIndexModelsSchema = z.object({
 	"vercel-ai-gateway": z.record(z.string(), z.object({ dimension: z.number() })).optional(),
 	openrouter: z.record(z.string(), z.object({ dimension: z.number() })).optional(),
 	bedrock: z.record(z.string(), z.object({ dimension: z.number() })).optional(),
+	semble: z.record(z.string(), z.object({ dimension: z.number() })).optional(),
 })
 
 export type CodebaseIndexModels = z.infer<typeof codebaseIndexModelsSchema>

packages/types/src/embedding.ts

@@ -6,7 +6,8 @@ export type EmbedderProvider =
 	| "mistral"
 	| "vercel-ai-gateway"
 	| "bedrock"
-	| "openrouter" // Add other providers as needed.
+	| "openrouter"
+	| "semble" // Local hybrid search via semble CLI — no API keys or Qdrant required.
 
 export interface EmbeddingModelProfile {
 	dimension: number

packages/types/src/vscode-extension-host.ts

@@ -375,6 +375,12 @@ export type ExtensionState = Pick<
 	deviceName?: string
 	debug?: boolean
 
+	/**
+	 * Platform info for conditional feature support (e.g. semble binary availability).
+	 */
+	platform?: string
+	arch?: string
+
 	/**
 	 * Monotonically increasing sequence number for clineMessages state pushes.
 	 * When present, the frontend should only apply clineMessages from a state push
@@ -660,6 +666,7 @@ export interface WebviewMessage {
 			| "vercel-ai-gateway"
 			| "bedrock"
 			| "openrouter"
+			| "semble"
 		codebaseIndexEmbedderBaseUrl?: string
 		codebaseIndexEmbedderModelId: string
 		codebaseIndexEmbedderModelDimension?: number // Generic dimension for all providers

src/core/webview/ClineProvider.ts

@@ -2283,6 +2283,8 @@ export class ClineProvider
 				}
 			})(),
 			...zooCodeState,
+			platform: process.platform,
+			arch: process.arch,
 			debug: vscode.workspace.getConfiguration(Package.name).get<boolean>("debug", false),
 		}
 	}

src/services/code-index/__tests__/config-manager.spec.ts

@@ -1127,6 +1127,86 @@ describe("CodeIndexConfigManager", () => {
 				expect(requiresRestart).toBe(true)
 			})
 		})
+
+		describe("semble provider configuration", () => {
+			it("should load semble provider configuration", async () => {
+				mockContextProxy.getGlobalState.mockReturnValue({
+					codebaseIndexEnabled: true,
+					codebaseIndexEmbedderProvider: "semble",
+				})
+				mockContextProxy.getSecret.mockReturnValue(undefined)
+
+				const result = await configManager.loadConfiguration()
+
+				expect(result.currentConfig.embedderProvider).toBe("semble")
+				expect(result.currentConfig.isConfigured).toBe(true)
+			})
+
+			it("should require restart when switching from openai to semble", async () => {
+				// Initial state with OpenAI
+				mockContextProxy.getGlobalState.mockReturnValue({
+					codebaseIndexEnabled: true,
+					codebaseIndexQdrantUrl: "http://qdrant.local",
+					codebaseIndexEmbedderProvider: "openai",
+					codebaseIndexEmbedderModelId: "text-embedding-3-small",
+				})
+				setupSecretMocks({
+					codeIndexOpenAiKey: "test-key",
+				})
+
+				await configManager.loadConfiguration()
+
+				// Switch to semble
+				mockContextProxy.getGlobalState.mockReturnValue({
+					codebaseIndexEnabled: true,
+					codebaseIndexEmbedderProvider: "semble",
+				})
+				mockContextProxy.getSecret.mockReturnValue(undefined)
+
+				const result = await configManager.loadConfiguration()
+				expect(result.requiresRestart).toBe(true)
+			})
+
+			it("should require restart when switching from semble to openai", async () => {
+				// Initial state with semble
+				mockContextProxy.getGlobalState.mockReturnValue({
+					codebaseIndexEnabled: true,
+					codebaseIndexEmbedderProvider: "semble",
+				})
+				mockContextProxy.getSecret.mockReturnValue(undefined)
+
+				await configManager.loadConfiguration()
+
+				// Switch to openai
+				mockContextProxy.getGlobalState.mockReturnValue({
+					codebaseIndexEnabled: true,
+					codebaseIndexQdrantUrl: "http://qdrant.local",
+					codebaseIndexEmbedderProvider: "openai",
+					codebaseIndexEmbedderModelId: "text-embedding-3-small",
+				})
+				setupSecretMocks({
+					codeIndexOpenAiKey: "test-key",
+				})
+
+				const result = await configManager.loadConfiguration()
+				expect(result.requiresRestart).toBe(true)
+			})
+
+			it("should not require restart when semble config stays the same", async () => {
+				// Initial state with semble
+				mockContextProxy.getGlobalState.mockReturnValue({
+					codebaseIndexEnabled: true,
+					codebaseIndexEmbedderProvider: "semble",
+				})
+				mockContextProxy.getSecret.mockReturnValue(undefined)
+
+				await configManager.loadConfiguration()
+
+				// Same semble config again
+				const result = await configManager.loadConfiguration()
+				expect(result.requiresRestart).toBe(false)
+			})
+		})
 	})
 
 	describe("isConfigured", () => {
@@ -1684,6 +1764,30 @@ describe("CodeIndexConfigManager", () => {
 			expect(configManager.isConfigured()).toBe(false)
 		})
 
+		it("should always return true for semble provider (no API keys or Qdrant needed)", () => {
+			mockContextProxy.getGlobalState.mockReturnValue({
+				codebaseIndexEnabled: true,
+				codebaseIndexEmbedderProvider: "semble",
+			})
+			mockContextProxy.getSecret.mockReturnValue(undefined)
+
+			configManager = new CodeIndexConfigManager(mockContextProxy)
+			expect(configManager.isConfigured()).toBe(true)
+		})
+
+		it("should return true for semble even without any other configuration", () => {
+			mockContextProxy.getGlobalState.mockReturnValue({
+				codebaseIndexEnabled: true,
+				codebaseIndexEmbedderProvider: "semble",
+				// No qdrant URL, no API keys
+			})
+			mockContextProxy.getSecret.mockReturnValue(undefined)
+
+			configManager = new CodeIndexConfigManager(mockContextProxy)
+			expect(configManager.isConfigured()).toBe(true)
+			expect(configManager.isFeatureConfigured).toBe(true)
+		})
+
 		describe("currentModelDimension", () => {
 			beforeEach(() => {
 				vi.clearAllMocks()

src/services/code-index/__tests__/service-factory.spec.ts

@@ -356,6 +356,17 @@ describe("CodeIndexServiceFactory", () => {
 			// Act & Assert
 			expect(() => factory.createEmbedder()).toThrow("serviceFactory.invalidEmbedderType")
 		})
+
+		it("should throw when provider is semble (semble handles its own embedding)", () => {
+			const testConfig = {
+				embedderProvider: "semble",
+			}
+			mockConfigManager.getConfig.mockReturnValue(testConfig as any)
+
+			expect(() => factory.createEmbedder()).toThrow(
+				"Semble provider handles its own embedding. Do not call createEmbedder() for semble",
+			)
+		})
 	})
 
 	describe("createVectorStore", () => {
@@ -678,6 +689,17 @@ describe("CodeIndexServiceFactory", () => {
 			// Act & Assert
 			expect(() => factory.createVectorStore()).toThrow("serviceFactory.qdrantUrlMissing")
 		})
+
+		it("should throw when provider is semble (semble handles its own vector storage)", () => {
+			const testConfig = {
+				embedderProvider: "semble",
+			}
+			mockConfigManager.getConfig.mockReturnValue(testConfig as any)
+
+			expect(() => factory.createVectorStore()).toThrow(
+				"Semble provider handles its own vector storage. Do not call createVectorStore() for semble",
+			)
+		})
 	})
 
 	describe("validateEmbedder", () => {

src/services/code-index/config-manager.ts

@@ -120,6 +120,8 @@ export class CodeIndexConfigManager {
 			this.embedderProvider = "bedrock"
 		} else if (codebaseIndexEmbedderProvider === "openrouter") {
 			this.embedderProvider = "openrouter"
+		} else if (codebaseIndexEmbedderProvider === "semble") {
+			this.embedderProvider = "semble"
 		} else {
 			this.embedderProvider = "openai"
 		}
@@ -231,6 +233,11 @@ export class CodeIndexConfigManager {
 	 * Checks if the service is properly configured based on the embedder type.
 	 */
 	public isConfigured(): boolean {
+		if (this.embedderProvider === "semble") {
+			// Semble requires no API keys or Qdrant — it's always configured
+			return true
+		}
+
 		if (this.embedderProvider === "openai") {
 			const openAiKey = this.openAiOptions?.openAiNativeApiKey
 			const qdrantUrl = this.qdrantUrl

src/services/code-index/interfaces/manager.ts

@@ -84,6 +84,7 @@ export type EmbedderProvider =
 	| "vercel-ai-gateway"
 	| "bedrock"
 	| "openrouter"
+	| "semble"
 
 export interface IndexProgressUpdate {
 	systemStatus: IndexingState