Merge pull request #3925 from Kilo-Org/ss-chunker

Ss chunker

Author: jrf0110

.changeset/forty-bananas-fall.md

@@ -0,0 +1,5 @@
+---
+"kilo-code": patch
+---
+
+Improve organization/managed indexing performance

cli/src/host/VSCode.ts

@@ -1258,6 +1258,41 @@ export class WorkspaceAPI {
 		this.fs = new FileSystemAPI()
 	}
 
+	asRelativePath(pathOrUri: string | Uri, includeWorkspaceFolder?: boolean): string {
+		const fsPath = typeof pathOrUri === "string" ? pathOrUri : pathOrUri.fsPath
+
+		// If no workspace folders, return the original path
+		if (!this.workspaceFolders || this.workspaceFolders.length === 0) {
+			return fsPath
+		}
+
+		// Try to find a workspace folder that contains this path
+		for (const folder of this.workspaceFolders) {
+			const workspacePath = folder.uri.fsPath
+
+			// Normalize paths for comparison (handle different path separators)
+			const normalizedFsPath = path.normalize(fsPath)
+			const normalizedWorkspacePath = path.normalize(workspacePath)
+
+			// Check if the path is within this workspace folder
+			if (normalizedFsPath.startsWith(normalizedWorkspacePath)) {
+				// Get the relative path
+				let relativePath = path.relative(normalizedWorkspacePath, normalizedFsPath)
+
+				// If includeWorkspaceFolder is true and there are multiple workspace folders,
+				// prepend the workspace folder name
+				if (includeWorkspaceFolder && this.workspaceFolders.length > 1) {
+					relativePath = path.join(folder.name, relativePath)
+				}
+
+				return relativePath
+			}
+		}
+
+		// If not within any workspace folder, return the original path
+		return fsPath
+	}
+
 	onDidChangeWorkspaceFolders(listener: (event: WorkspaceFoldersChangeEvent) => void): Disposable {
 		return this._onDidChangeWorkspaceFolders.event(listener)
 	}

pnpm-lock.yaml

@@ -1,5 +1,6 @@
 import * as vscode from "vscode"
 import { ZodError } from "zod"
+import { EventEmitter } from "events"
 
 import {
 	PROVIDER_SETTINGS_KEYS,
@@ -20,6 +21,14 @@ import { TelemetryService } from "@roo-code/telemetry"
 
 import { logger } from "../../utils/logging"
 
+// kilocode_change start: Configuration change event types
+export interface ManagedIndexerConfig {
+	kilocodeToken: string | null
+	kilocodeOrganizationId: string | null
+	kilocodeTesterWarningsDisabledUntil: number | null
+}
+// kilocode_change end
+
 type GlobalStateKey = keyof GlobalState
 type SecretStateKey = keyof SecretState
 type RooCodeSettingsKey = keyof RooCodeSettings
@@ -40,6 +49,9 @@ export class ContextProxy {
 	private stateCache: GlobalState
 	private secretCache: SecretState
 	private _isInitialized = false
+	// kilocode_change start: Event emitter for configuration changes
+	private readonly configEmitter = new EventEmitter()
+	// kilocode_change end
 
 	constructor(context: vscode.ExtensionContext) {
 		this.originalContext = context
@@ -295,6 +307,12 @@ export class ContextProxy {
 	}
 
 	public async setProviderSettings(values: ProviderSettings) {
+		// kilocode_change start: Capture old values for change detection
+		const oldToken = this.secretCache.kilocodeToken
+		const oldOrgId = this.stateCache.kilocodeOrganizationId
+		const oldTesterWarnings = this.stateCache.kilocodeTesterWarningsDisabledUntil
+		// kilocode_change end
+
 		// Explicitly clear out any old API configuration values before that
 		// might not be present in the new configuration.
 		// If a value is not present in the new configuration, then it is assumed
@@ -316,6 +334,20 @@ export class ContextProxy {
 				.reduce((acc, key) => ({ ...acc, [key]: undefined }), {} as ProviderSettings),
 			...values,
 		})
+
+		// kilocode_change start: Emit event if managed indexer config changed
+		const newToken = this.secretCache.kilocodeToken
+		const newOrgId = this.stateCache.kilocodeOrganizationId
+		const newTesterWarnings = this.stateCache.kilocodeTesterWarningsDisabledUntil
+
+		if (oldToken !== newToken || oldOrgId !== newOrgId || oldTesterWarnings !== newTesterWarnings) {
+			this.configEmitter.emit("managed-indexer-config-changed", {
+				kilocodeToken: newToken ?? null,
+				kilocodeOrganizationId: newOrgId ?? null,
+				kilocodeTesterWarningsDisabledUntil: newTesterWarnings ?? null,
+			} as ManagedIndexerConfig)
+		}
+		// kilocode_change end
 	}
 
 	/**
@@ -387,6 +419,20 @@ export class ContextProxy {
 		await this.initialize()
 	}
 
+	// kilocode_change start: Public API for managed indexer configuration changes
+	/**
+	 * Subscribe to managed indexer configuration changes
+	 * @param listener Callback function that receives the new configuration
+	 * @returns Disposable to unsubscribe from the event
+	 */
+	public onManagedIndexerConfigChange(listener: (config: ManagedIndexerConfig) => void): vscode.Disposable {
+		this.configEmitter.on("managed-indexer-config-changed", listener)
+		return {
+			dispose: () => this.configEmitter.off("managed-indexer-config-changed", listener),
+		}
+	}
+	// kilocode_change end
+
 	private static _instance: ContextProxy | null = null
 
 	static get instance() {

src/core/config/ContextProxy.ts

@@ -118,6 +118,16 @@ __setMockImplementation(
 	},
 )
 
+// Mock ManagedIndexer before importing anything that uses it
+vi.mock("../../../services/code-index/managed/ManagedIndexer", () => ({
+	ManagedIndexer: {
+		getInstance: vi.fn().mockReturnValue({
+			isEnabled: vi.fn().mockResolvedValue(false),
+			organization: null,
+		}),
+	},
+}))
+
 // Mock vscode language
 vi.mock("vscode", () => ({
 	env: {

src/core/prompts/__tests__/add-custom-instructions.spec.ts

@@ -1,4 +1,14 @@
 // Mocks must come first, before imports
+// Mock ManagedIndexer before importing anything that uses it
+vi.mock("../../../services/code-index/managed/ManagedIndexer", () => ({
+	ManagedIndexer: {
+		getInstance: vi.fn().mockReturnValue({
+			isEnabled: vi.fn().mockResolvedValue(false),
+			organization: null,
+		}),
+	},
+}))
+
 vi.mock("vscode", () => ({
 	env: {
 		language: "en",

src/core/prompts/__tests__/custom-system-prompt.spec.ts

@@ -1,6 +1,16 @@
 // kilocode_change: file added
 // npx vitest core/prompts/__tests__/system-prompt.spec.ts
 
+// Mock ManagedIndexer before importing anything that uses it
+vi.mock("../../../../services/code-index/managed/ManagedIndexer", () => ({
+	ManagedIndexer: {
+		getInstance: vi.fn().mockReturnValue({
+			isEnabled: vi.fn().mockResolvedValue(false),
+			organization: null,
+		}),
+	},
+}))
+
 vi.mock("os", () => ({
 	default: {
 		homedir: () => "/home/user",

src/core/prompts/__tests__/kilocode/system-prompt-morph.spec.ts

@@ -1,5 +1,15 @@
 // npx vitest core/prompts/__tests__/system-prompt.spec.ts
 
+// Mock ManagedIndexer before importing anything that uses it
+vi.mock("../../../services/code-index/managed/ManagedIndexer", () => ({
+	ManagedIndexer: {
+		getInstance: vi.fn().mockReturnValue({
+			isEnabled: vi.fn().mockResolvedValue(false),
+			organization: null,
+		}),
+	},
+}))
+
 vi.mock("os", () => ({
 	default: {
 		homedir: () => "/home/user",

src/core/prompts/__tests__/system-prompt.spec.ts

@@ -7,6 +7,7 @@ import { formatResponse } from "../prompts/responses"
 import { VectorStoreSearchResult } from "../../services/code-index/interfaces"
 import { AskApproval, HandleError, PushToolResult, RemoveClosingTag, ToolUse } from "../../shared/tools"
 import path from "path"
+import { ManagedIndexer } from "../../services/code-index/managed/ManagedIndexer"
 
 export async function codebaseSearchTool(
 	cline: Task,
@@ -62,6 +63,12 @@ export async function codebaseSearchTool(
 
 	cline.consecutiveMistakeCount = 0
 
+	// kilode_change start - First try mnaaged indexing
+	if (await tryManagedSearch(cline, pushToolResult, query, directoryPrefix)) {
+		return
+	}
+	// kilode_change end - First try mnaaged indexing
+
 	// --- Core Logic ---
 	try {
 		const context = cline.providerRef.deref()?.context
@@ -75,16 +82,12 @@ export async function codebaseSearchTool(
 			throw new Error("CodeIndexManager is not available.")
 		}
 
-		// kilcode_change start
-		if (!manager.isManagedIndexingAvailable) {
-			if (!manager.isFeatureEnabled) {
-				throw new Error("Code Indexing is disabled in the settings.")
-			}
-			if (!manager.isFeatureConfigured) {
-				throw new Error("Code Indexing is not configured (Missing OpenAI Key or Qdrant URL).")
-			}
+		if (!manager.isFeatureEnabled) {
+			throw new Error("Code Indexing is disabled in the settings.")
+		}
+		if (!manager.isFeatureConfigured) {
+			throw new Error("Code Indexing is not configured (Missing OpenAI Key or Qdrant URL).")
 		}
-		// kilcode_change end
 
 		// kilocode_change start
 		const status = manager.getCurrentStatus()
@@ -198,3 +201,77 @@ ${result.codeChunk ? `Code Chunk: ${result.codeChunk}\n` : ""}`, // kilocode_cha
 		await handleError(toolName, error) // Use the standard error handler
 	}
 }
+
+// kilocode_change start - Add managed search block
+async function tryManagedSearch(
+	cline: Task,
+	pushToolResult: PushToolResult,
+	query: string,
+	directoryPrefix?: string,
+): Promise<boolean> {
+	try {
+		const managed = ManagedIndexer.getInstance()
+		if (!(await managed.isEnabled())) {
+			return false
+		}
+		const searchResults = await managed.search(query, directoryPrefix)
+		// 3. Format and push results
+		if (!searchResults || searchResults.length === 0) {
+			pushToolResult(`No relevant code snippets found for the query: "${query}"`) // Use simple string for no results
+			return true
+		}
+
+		const jsonResult = {
+			query,
+			results: [],
+		} as {
+			query: string
+			results: Array<{
+				filePath: string
+				score: number
+				startLine: number
+				endLine: number
+				codeChunk: string
+			}>
+		}
+
+		searchResults.forEach((result) => {
+			if (!result.payload) return
+			if (!("filePath" in result.payload)) return
+
+			const relativePath = vscode.workspace.asRelativePath(result.payload.filePath, false)
+
+			jsonResult.results.push({
+				filePath: relativePath,
+				score: result.score,
+				startLine: result.payload.startLine,
+				endLine: result.payload.endLine,
+				codeChunk: result.payload.codeChunk.trim(),
+			})
+		})
+
+		// Send results to UI
+		const payload = { tool: "codebaseSearch", content: jsonResult }
+		await cline.say("codebase_search_result", JSON.stringify(payload))
+
+		// Push results to AI
+		const output = `Query: ${query}
+Results:
+
+${jsonResult.results
+	.map(
+		(result) => `File path: ${result.filePath}
+Score: ${result.score}
+Lines: ${result.startLine}-${result.endLine}
+${result.codeChunk ? `Code Chunk: ${result.codeChunk}\n` : ""}`, // kilocode_change - don't include code chunk managed indexing
+	)
+	.join("\n")}`
+
+		pushToolResult(output)
+		return true
+	} catch (e) {
+		console.log(`[codebaseSearchTool]: Managed search failed with error: ${e}`)
+		return false
+	}
+}
+// kilocode_change end - Add managed search block