-
+
-
+
): void {
+ const type = msg.type as string
+
+ if (type === "webviewReady") {
+ this.post({
+ type: "ready",
+ vscodeLanguage: vscode.env.language,
+ languageOverride: vscode.workspace.getConfiguration("kilo-code.new").get("language"),
+ workspaceDirectory: getWorkspaceRoot(),
+ })
+ this.pushData()
+ return
+ }
+
+ if (type === "diffVirtual.close") {
+ this.panel?.dispose()
+ }
+ }
+
+ private pushData(): void {
+ if (!this.pending) return
+ this.post({ type: "diffVirtual.data", diff: this.pending })
+ }
+
+ private post(message: Record): void {
+ if (this.panel?.webview) void this.panel.webview.postMessage(message)
+ }
+
+ private getHtml(webview: vscode.Webview): string {
+ return buildWebviewHtml(webview, {
+ scriptUri: webview.asWebviewUri(vscode.Uri.joinPath(this.extensionUri, "dist", "diff-virtual.js")),
+ styleUri: webview.asWebviewUri(vscode.Uri.joinPath(this.extensionUri, "dist", "diff-virtual.css")),
+ iconsBaseUri: webview.asWebviewUri(vscode.Uri.joinPath(this.extensionUri, "assets", "icons")),
+ title: "Diff Virtual",
+ extraStyles: "#root { display: flex; flex-direction: column; height: 100%; }",
+ })
+ }
+
+ public dispose(): void {
+ this.panel?.dispose()
+ this.outputChannel.dispose()
+ }
+}
diff --git a/packages/kilo-vscode/src/KiloProvider.ts b/packages/kilo-vscode/src/KiloProvider.ts
index a337470209b..fa9a9b812da 100644
--- a/packages/kilo-vscode/src/KiloProvider.ts
+++ b/packages/kilo-vscode/src/KiloProvider.ts
@@ -36,11 +36,13 @@ import { GitOps } from "./agent-manager/GitOps"
import { GitStatsPoller, type LocalStats } from "./agent-manager/GitStatsPoller"
import { getWorkspaceRoot } from "./review-utils"
import { MarketplaceService, type MarketplaceItem, type RemoveResult } from "./services/marketplace"
+import type { RemoteStatusService } from "./services/RemoteStatusService"
import { resolveProjectDirectory } from "./project-directory"
import { getBusySessionCount, seedSessionStatuses } from "./session-status"
import { retry } from "./services/cli-backend/retry"
import { slimPart, slimParts } from "./kilo-provider/slim-metadata"
import { matchFollowup, recordFollowup, type Followup } from "./kilo-provider/followup-session"
+import { childID } from "./kilo-provider/task-session"
import { retryable, backoff, MAX_RETRIES } from "./util/retry"
// legacy-migration start
import {
@@ -112,6 +114,7 @@ const mapAgent = (a: Agent) => ({
export class KiloProvider implements vscode.WebviewViewProvider, TelemetryPropertiesProvider {
public static readonly viewType = "kilo-code.SidebarProvider"
+ private readonly instanceId = crypto.randomUUID()
private webview: vscode.Webview | null = null
private currentSession: Session | null = null
@@ -145,6 +148,8 @@ export class KiloProvider implements vscode.WebviewViewProvider, TelemetryProper
private cachedNotificationsMessage: unknown = null
private pendingReviewComments: { comments: unknown[]; autoSend: boolean }[] = []
private readyResolvers: (() => void)[] = []
+ private promptRecoveryQueued = false
+ private promptRecovery: Promise | null = null
private trackedSessionIds: Set = new Set()
private syncedChildSessions: Set = new Set()
/** Tracks the latest status for each session, used to warn before destructive config operations. */
@@ -173,6 +178,8 @@ export class KiloProvider implements vscode.WebviewViewProvider, TelemetryProper
private unsubscribeDirectoryProvider: (() => void) | null = null
private initConnectionPromise: Promise | null = null
private webviewMessageDisposable: vscode.Disposable | null = null
+ private viewStateDisposable: vscode.Disposable | null = null
+ private visibilityDisposable: vscode.Disposable | null = null
/** Lazily initialized ignore controller for .kilocodeignore filtering */
private ignoreController: FileIgnoreController | null = null
@@ -197,6 +204,10 @@ export class KiloProvider implements vscode.WebviewViewProvider, TelemetryProper
| ((sessionId: string, progress: (status: string, detail?: string, error?: string) => void) => Promise)
| null = null
+ private diffVirtualProvider: import("./DiffVirtualProvider").DiffVirtualProvider | undefined
+ private remoteService: RemoteStatusService | null = null
+ private unsubscribeRemote: (() => void) | null = null
+
constructor(
private readonly extensionUri: vscode.Uri,
private readonly connectionService: KiloConnectionService,
@@ -209,12 +220,29 @@ export class KiloProvider implements vscode.WebviewViewProvider, TelemetryProper
TelemetryProxy.getInstance().setProvider(this)
}
+ setRemoteService(service: RemoteStatusService): void {
+ this.remoteService = service
+ this.unsubscribeRemote = service.onChange(() => this.sendRemoteStatus())
+ }
+ private sendRemoteStatus(): void {
+ const s = this.remoteService?.getState()
+ if (s) this.postMessage({ type: "remoteStatus", enabled: s.enabled, connected: s.connected })
+ }
+ private focusSession(id?: string): void {
+ if (id) this.connectionService.registerFocused(this.instanceId, id)
+ else this.connectionService.unregisterFocused(this.instanceId)
+ }
+
public setProjectDirectory(directory: string | null): void {
if (this.projectDirectory === directory) return
this.projectDirectory = directory
this.postMessage({ type: "workspaceDirectoryChanged", directory: directory ?? "" })
}
+ public setDiffVirtualProvider(provider: import("./DiffVirtualProvider").DiffVirtualProvider): void {
+ this.diffVirtualProvider = provider
+ }
+
getTelemetryProperties(): Record {
return {
appName: "kilo-code",
@@ -318,6 +346,8 @@ export class KiloProvider implements vscode.WebviewViewProvider, TelemetryProper
// authoritative and reconciliation risks race-resetting busy sessions.
const reconcile = this.sessionStatusMap.size === 0
void this.seedSessionStatusMap(reconcile)
+
+ this.sendRemoteStatus()
}
// legacy-migration start
@@ -348,20 +378,16 @@ export class KiloProvider implements vscode.WebviewViewProvider, TelemetryProper
localResourceRoots: [this.extensionUri],
}
- // Set HTML content
webviewView.webview.html = this._getHtmlForWebview(webviewView.webview)
-
- // Handle messages from webview (shared handler)
this.setupWebviewMessageHandler(webviewView.webview)
- // Track sidebar visibility for keybinding when-clauses and stats polling
vscode.commands.executeCommand("setContext", "kilo-code.new.sidebarVisible", webviewView.visible)
- webviewView.onDidChangeVisibility(() => {
+ this.visibilityDisposable?.dispose()
+ this.visibilityDisposable = webviewView.onDidChangeVisibility(() => {
vscode.commands.executeCommand("setContext", "kilo-code.new.sidebarVisible", webviewView.visible)
this.statsPoller?.setEnabled(webviewView.visible)
+ this.focusSession(webviewView.visible ? this.currentSession?.id : undefined)
})
-
- // Initialize connection to CLI backend
this.initializeConnection()
}
@@ -380,9 +406,11 @@ export class KiloProvider implements vscode.WebviewViewProvider, TelemetryProper
panel.webview.html = this._getHtmlForWebview(panel.webview)
- // Handle messages from webview (shared handler)
this.setupWebviewMessageHandler(panel.webview)
-
+ this.viewStateDisposable?.dispose()
+ this.viewStateDisposable = panel.onDidChangeViewState(() =>
+ this.focusSession(panel.active ? this.currentSession?.id : undefined),
+ )
this.initializeConnection()
}
@@ -438,6 +466,30 @@ export class KiloProvider implements vscode.WebviewViewProvider, TelemetryProper
void this.handleLoadSessions()
}
+ /** Recover permission/question prompts after sessions and directories are tracked. */
+ public recoverPendingPrompts(): void {
+ this.promptRecoveryQueued = true
+ if (!this.isWebviewReady) return
+ if (!this.client) return
+ if (this.promptRecovery) return
+
+ this.promptRecovery = this.flushPendingPrompts().finally(() => {
+ this.promptRecovery = null
+ if (this.promptRecoveryQueued && this.isWebviewReady && this.client) this.recoverPendingPrompts()
+ })
+ }
+
+ private async flushPendingPrompts(): Promise {
+ while (this.promptRecoveryQueued && this.isWebviewReady) {
+ if (!this.client) return
+ this.promptRecoveryQueued = false
+ await Promise.all([
+ fetchAndSendPendingPermissions(this.permissionCtx),
+ fetchAndSendPendingQuestions(this.questionCtx),
+ ])
+ }
+ }
+
public openCloudSession(sessionId: string): void {
this.postMessage({ type: "openCloudSession", sessionId })
}
@@ -493,6 +545,7 @@ export class KiloProvider implements vscode.WebviewViewProvider, TelemetryProper
this.isWebviewReady = true
await this.syncWebviewState("webviewReady")
this.flushPendingReviewComments()
+ this.recoverPendingPrompts()
this.readyResolvers.splice(0).forEach((r) => r())
break
case "sendMessage": {
@@ -576,6 +629,7 @@ export class KiloProvider implements vscode.WebviewViewProvider, TelemetryProper
case "clearSession":
this.contextSessionID = this.currentSession?.id ?? this.contextSessionID
this.currentSession = null
+ this.focusSession()
break
case "loadMessages":
// Don't await: allow parallel loads so rapid session switching
@@ -627,6 +681,11 @@ export class KiloProvider implements vscode.WebviewViewProvider, TelemetryProper
case "openChanges":
vscode.commands.executeCommand("kilo-code.new.showChanges")
break
+ case "openDiffVirtual":
+ if (this.diffVirtualProvider && message.diff) {
+ this.diffVirtualProvider.open(message.diff)
+ }
+ break
case "continueInWorktree":
if (message.sessionId && this.continueInWorktreeHandler) {
this.continueInWorktreeHandler(message.sessionId, (status: string, detail?: string, error?: string) => {
@@ -806,6 +865,16 @@ export class KiloProvider implements vscode.WebviewViewProvider, TelemetryProper
case "renameSession":
await this.handleRenameSession(message.sessionID, message.title)
break
+ case "toggleRemote":
+ case "setRemoteEnabled":
+ case "requestRemoteStatus":
+ this.remoteService
+ ?.handleMessage(message.type, message.enabled)
+ .then((s) => {
+ if (s) this.sendRemoteStatus()
+ })
+ .catch((err) => console.error("[Kilo New] remote message failed:", err))
+ break
case "updateSetting":
await this.handleUpdateSetting(message.key, message.value)
break
@@ -1037,6 +1106,8 @@ export class KiloProvider implements vscode.WebviewViewProvider, TelemetryProper
// Subscribe to SSE events for this webview (filtered by tracked sessions)
this.unsubscribeEvent = this.connectionService.onEventFiltered(
(event) => {
+ // Remote status events are global and should always pass through
+ if (event.type === "kilo-sessions.remote-status-changed") return true
const sessionId = this.connectionService.resolveEventSessionId(event)
// message.part.updated and message.part.delta are always session-scoped; drop if session unknown.
@@ -1079,8 +1150,7 @@ export class KiloProvider implements vscode.WebviewViewProvider, TelemetryProper
}
await this.syncWebviewState("sse-connected")
await this.flushPendingSessionRefresh("sse-connected")
- await fetchAndSendPendingPermissions(this.permissionCtx)
- await fetchAndSendPendingQuestions(this.questionCtx)
+ this.recoverPendingPrompts()
} catch (error) {
console.error("[Kilo New] KiloProvider: ❌ Failed during connected state handling:", error)
this.postMessage({
@@ -1155,6 +1225,7 @@ export class KiloProvider implements vscode.WebviewViewProvider, TelemetryProper
await this.syncWebviewState("initializeConnection")
await this.flushPendingSessionRefresh("initializeConnection")
+ this.recoverPendingPrompts()
// Fetch providers, agents, skills, config, notifications, and session statuses in parallel
await Promise.all([
@@ -1233,6 +1304,7 @@ export class KiloProvider implements vscode.WebviewViewProvider, TelemetryProper
private async handleLoadMessages(sessionID: string): Promise {
// Track the session so we receive its SSE events
this.trackedSessionIds.add(sessionID)
+ this.focusSession(sessionID)
this.contextSessionID = sessionID
if (!this.client) {
@@ -1318,9 +1390,8 @@ export class KiloProvider implements vscode.WebviewViewProvider, TelemetryProper
messages,
})
- // Recover any permission.asked events that were missed while the webview
- // was loading or during an SSE reconnection (fire-and-forget).
- void fetchAndSendPendingPermissions(this.permissionCtx)
+ // Recover any prompts missed while the webview was loading or during an SSE reconnection.
+ this.recoverPendingPrompts()
} catch (error) {
// Silently ignore aborted requests — the user switched to a different session
if (abort.signal.aborted) return
@@ -1377,11 +1448,8 @@ export class KiloProvider implements vscode.WebviewViewProvider, TelemetryProper
messages,
})
- // Recover any missed permission/question prompts emitted by the child before
- // we started tracking it. Both run fire-and-forget after messagesLoaded so
- // the webview isn't blocked.
- void fetchAndSendPendingPermissions(this.permissionCtx)
- void fetchAndSendPendingQuestions(this.questionCtx)
+ // Recover any prompts emitted by the child before we started tracking it.
+ this.recoverPendingPrompts()
} catch (err) {
this.syncedChildSessions.delete(sessionID)
console.error("[Kilo New] KiloProvider: Failed to sync child session:", err)
@@ -2811,6 +2879,11 @@ export class KiloProvider implements vscode.WebviewViewProvider, TelemetryProper
* Filters events by project ID and tracked session IDs so each webview only sees its own sessions.
*/
private handleEvent(event: Event): void {
+ if (event.type === "kilo-sessions.remote-status-changed") {
+ this.remoteService?.updateFromEvent({ enabled: event.properties.enabled, connected: event.properties.connected })
+ return
+ }
+
// Drop session events from other projects before any tracking logic.
// This must come first: the trackedSessionIds guard below would otherwise
// let a foreign session through if it was accidentally tracked.
@@ -2888,9 +2961,10 @@ export class KiloProvider implements vscode.WebviewViewProvider, TelemetryProper
type?: string
tool?: string
metadata?: { sessionId?: string }
+ state?: { metadata?: { sessionId?: string } }
sessionID?: string
}
- const childId = part.type === "tool" && part.tool === "task" ? part.metadata?.sessionId : undefined
+ const childId = childID(part)
if (childId && !this.trackedSessionIds.has(childId)) {
console.log("[Kilo New] KiloProvider: 🔗 Auto-adopting child session from task tool", { childId })
void this.handleSyncSession(childId, part.sessionID ?? sessionID)
@@ -3222,6 +3296,8 @@ export class KiloProvider implements vscode.WebviewViewProvider, TelemetryProper
* Does NOT kill the server — that's the connection service's job.
*/
dispose(): void {
+ this.unsubscribeRemote?.()
+ this.focusSession()
this.statsPoller?.stop()
this.statsGitOps?.dispose()
this.unsubscribeEvent?.()
@@ -3233,7 +3309,11 @@ export class KiloProvider implements vscode.WebviewViewProvider, TelemetryProper
this.unsubscribeMigrationComplete?.()
this.unsubscribeClearPendingPrompts?.()
this.unsubscribeDirectoryProvider?.()
+ this.viewStateDisposable?.dispose()
+ this.visibilityDisposable?.dispose()
this.webviewMessageDisposable?.dispose()
+ this.isWebviewReady = false
+ this.promptRecoveryQueued = false
this.trackedSessionIds.clear()
this.syncedChildSessions.clear()
this.sessionDirectories.clear()
diff --git a/packages/kilo-vscode/src/SettingsEditorProvider.ts b/packages/kilo-vscode/src/SettingsEditorProvider.ts
index 922754e319f..493a6fd519b 100644
--- a/packages/kilo-vscode/src/SettingsEditorProvider.ts
+++ b/packages/kilo-vscode/src/SettingsEditorProvider.ts
@@ -2,6 +2,7 @@ import * as vscode from "vscode"
import { KiloProvider } from "./KiloProvider"
import { resolvePanelProjectDirectory } from "./project-directory"
import type { KiloConnectionService } from "./services/cli-backend"
+import type { RemoteStatusService } from "./services/RemoteStatusService"
type PanelView = "settings" | "profile" | "marketplace"
@@ -26,6 +27,7 @@ export class SettingsEditorProvider implements vscode.Disposable {
private panels = new Map()
private providers = new Map()
private tabs = new Map()
+ private remoteService: RemoteStatusService | null = null
constructor(
private readonly extensionUri: vscode.Uri,
@@ -101,6 +103,9 @@ export class SettingsEditorProvider implements vscode.Disposable {
const provider = new KiloProvider(this.extensionUri, this.connectionService, this.context, {
projectDirectory,
})
+ if (this.remoteService) {
+ provider.setRemoteService(this.remoteService)
+ }
provider.resolveWebviewPanel(panel)
// Listen for closePanel from the webview (back button in panel mode)
@@ -144,6 +149,14 @@ export class SettingsEditorProvider implements vscode.Disposable {
})
}
+ setRemoteService(service: RemoteStatusService): void {
+ this.remoteService = service
+ // Apply to any existing providers
+ for (const [, provider] of this.providers) {
+ provider.setRemoteService(service)
+ }
+ }
+
dispose(): void {
for (const [, panel] of this.panels) {
panel.dispose()
diff --git a/packages/kilo-vscode/src/agent-manager/AgentManagerProvider.ts b/packages/kilo-vscode/src/agent-manager/AgentManagerProvider.ts
index bebd61406a2..60c2383dbab 100644
--- a/packages/kilo-vscode/src/agent-manager/AgentManagerProvider.ts
+++ b/packages/kilo-vscode/src/agent-manager/AgentManagerProvider.ts
@@ -25,6 +25,7 @@ import { continueInWorktree } from "./continue-in-worktree"
import { shouldStopDiffPolling } from "./delete-worktree"
import { buildKeybindingMap } from "./format-keybinding"
import { resolveVersionModels, buildInitialMessages, type CreatedVersion } from "./multi-version"
+import { Semaphore } from "./semaphore"
import { PLATFORM } from "./constants"
import type { AgentManagerOutMessage, AgentManagerInMessage } from "./types"
import { hashFileDiffs, resolveLocalDiffTarget } from "../review-utils"
@@ -76,11 +77,13 @@ export class AgentManagerProvider implements Disposable {
(msg) => this.outputChannel.appendLine(`[SessionTerminal] ${msg}`),
createTerminalHost(),
)
- this.gitOps = new GitOps({ log: (...args) => this.log(...args) })
+ const semaphore = new Semaphore(3)
+ this.gitOps = new GitOps({ log: (...args) => this.log(...args), semaphore })
this.statsPoller = new GitStatsPoller({
getWorktrees: () => this.state?.getWorktrees() ?? [],
getWorkspaceRoot: () => this.getRoot(),
getClient: () => this.connectionService.getClient(),
+ semaphore,
onStats: (stats) => {
const msg = { type: "agentManager.worktreeStats" as const, stats }
this.cachedWorktreeStats = msg
@@ -105,6 +108,7 @@ export class AgentManagerProvider implements Disposable {
hasPersistedPR: (id: string) => !!this.state?.getWorktree(id)?.prNumber,
openExternal: (u) => this.host.openExternal(u),
log: (...a) => this.log(...a),
+ semaphore,
})
}
@@ -197,24 +201,25 @@ export class AgentManagerProvider implements Disposable {
this.host.refreshGit()
}
- // Do not auto-remove stale worktrees on load.
- // Presence checks run in the shared poller and require explicit user cleanup.
-
- // Register all worktree sessions with the session provider
- for (const worktree of state.getWorktrees()) {
- for (const session of state.getSessions(worktree.id)) {
- this.panel?.sessions.setSessionDirectory(session.id, worktree.path)
- this.panel?.sessions.trackSession(session.id)
+ for (const wt of state.getWorktrees()) {
+ for (const s of state.getSessions(wt.id)) {
+ this.panel?.sessions.setSessionDirectory(s.id, wt.path)
+ this.panel?.sessions.trackSession(s.id)
}
}
-
- // Push full state to webview
+ for (const s of state.getSessions()) if (!s.worktreeId) this.panel?.sessions.trackSession(s.id)
this.pushState()
// Refresh sessions so worktree sessions appear in the list
if (state.getSessions().length > 0) {
this.panel?.sessions.refreshSessions()
}
+
+ // Recover any pending permission/question prompts that were missed during
+ // panel recreation or SSE reconnection. Must run after all worktree sessions
+ // are registered with their directory overrides so the recovery queries the
+ // correct CLI backend Instances.
+ this.panel?.sessions.recoverPendingPrompts()
}
// ---------------------------------------------------------------------------
@@ -232,8 +237,12 @@ export class AgentManagerProvider implements Disposable {
if (m.type === "agentManager.removeStaleWorktree") return this.onRemoveStaleWorktree(m.worktreeId)
if (m.type === "agentManager.promoteSession") return this.onPromoteSession(m.sessionId)
if (m.type === "agentManager.openLocally") {
- if (!this.panel) return null
- this.panel.sessions.clearSessionDirectory(m.sessionId)
+ this.panel?.sessions.clearSessionDirectory(m.sessionId)
+ const st = this.getStateManager()
+ if (st?.getSession(m.sessionId)) {
+ st.moveSession(m.sessionId, null)
+ this.pushState()
+ }
return null
}
if (m.type === "continueInWorktree") {
@@ -245,6 +254,15 @@ export class AgentManagerProvider implements Disposable {
if (m.type === "agentManager.addSessionToWorktree") return this.onAddSessionToWorktree(m.worktreeId)
if (m.type === "agentManager.forkSession") return this.onForkSession(m.sessionId, m.worktreeId)
if (m.type === "agentManager.closeSession") return this.onCloseSession(m.sessionId)
+ if (m.type === "agentManager.persistSession" || m.type === "agentManager.forgetSession") {
+ const persist = m.type === "agentManager.persistSession"
+ void this.stateReady?.then(() => {
+ const st = this.getStateManager()
+ if (st)
+ persist ? !st.getSession(m.sessionId) && st.addSession(m.sessionId, null) : st.removeSession(m.sessionId)
+ })
+ return null
+ }
if ((m.type === "sendMessage" || m.type === "sendCommand") && m.draftID && !m.sessionID) {
this.activeSessionId = m.draftID
}
@@ -392,10 +410,18 @@ export class AgentManagerProvider implements Disposable {
void this.onApplyWorktreeDiff(m.worktreeId, selectedFiles)
return null
}
+ if (m.type === "agentManager.revertWorktreeFile") {
+ void this.onRevertWorktreeFile(m.sessionId, m.file)
+ return null
+ }
if (m.type === "agentManager.startDiffWatch") {
this.startDiffPolling(m.sessionId)
return null
}
+ if (m.type === "agentManager.openSessions") {
+ this.connectionService.registerOpen("agent-manager", m.sessionIDs)
+ return null
+ }
if (m.type === "agentManager.stopDiffWatch") {
this.stopDiffPolling()
return null
@@ -423,6 +449,7 @@ export class AgentManagerProvider implements Disposable {
// uses the correct session even before the session provider's async session.get completes.
if (m.type === "loadMessages") {
this.activeSessionId = m.sessionID
+ this.connectionService.registerFocused("agent-manager", m.sessionID)
this.terminalManager.syncOnSessionSwitch(m.sessionID)
this.prBridge.poller.setActiveWorktreeId(this.state?.getSession(m.sessionID)?.worktreeId ?? undefined)
}
@@ -430,6 +457,7 @@ export class AgentManagerProvider implements Disposable {
// After clearSession, clear active tracking and re-register worktree sessions
if (m.type === "clearSession") {
this.activeSessionId = undefined
+ this.connectionService.unregisterFocused("agent-manager")
void Promise.resolve().then(() => {
if (!this.panel || !this.state) return
for (const id of this.state.worktreeSessionIds()) {
@@ -907,9 +935,9 @@ export class AgentManagerProvider implements Disposable {
continue
}
- await this.runSetupScriptForWorktree(wt.result.path, wt.result.branch)
+ await this.runSetupScriptForWorktree(wt.result.path, wt.result.branch, wt.worktree.id)
- const session = await this.createSessionInWorktree(wt.result.path, wt.result.branch)
+ const session = await this.createSessionInWorktree(wt.result.path, wt.result.branch, wt.worktree.id)
if (!session) {
const state = this.getStateManager()
const manager = this.getWorktreeManager()
@@ -922,7 +950,7 @@ export class AgentManagerProvider implements Disposable {
const state = this.getStateManager()!
state.addSession(session.id, wt.worktree.id)
this.registerWorktreeSession(session.id, wt.result.path)
- this.notifyWorktreeReady(session.id, wt.result)
+ this.notifyWorktreeReady(session.id, wt.result, wt.worktree.id)
// Set the per-version model immediately so the UI selector reflects
// the correct model as soon as the worktree appears, before Phase 2.
@@ -1400,6 +1428,7 @@ export class AgentManagerProvider implements Disposable {
status: "error",
message: `Setup script failed: ${msg}`,
branch,
+ worktreeId,
})
}
}
@@ -1428,6 +1457,10 @@ export class AgentManagerProvider implements Disposable {
if (!this.panel) return
this.panel.sessions.setSessionDirectory(sessionId, directory)
this.panel.sessions.trackSession(sessionId)
+ // Recover any permission/question prompts that arrived before the session
+ // was tracked. The CLI backend may have emitted permission.asked between
+ // session.create() returning and this registration completing.
+ this.panel.sessions.recoverPendingPrompts()
}
private onWorktreePresence(result: WorktreePresenceResult): void {
@@ -1641,6 +1674,66 @@ export class AgentManagerProvider implements Disposable {
}
}
+ /** Revert a single file in a worktree back to the merge-base state. */
+ private async onRevertWorktreeFile(sessionId: string, file: string): Promise {
+ if (!file) return
+ if (this.stateReady) {
+ await this.stateReady.catch((err) => this.log("stateReady rejected, continuing revert resolve:", err))
+ }
+
+ const target =
+ this.cachedDiffTarget?.sessionId === sessionId ? this.cachedDiffTarget : await this.resolveDiffTarget(sessionId)
+ if (!target) {
+ this.postToWebview({
+ type: "agentManager.revertWorktreeFileResult",
+ sessionId,
+ file,
+ status: "error",
+ message: "Could not resolve diff target",
+ })
+ return
+ }
+
+ // Look up the file status from the cached diffs so we know if it's added/modified/deleted
+ let status: "added" | "deleted" | "modified" | undefined
+ try {
+ const client = this.connectionService.getClient()
+ const { data } = await client.worktree.diffFile(
+ { directory: target.directory, base: target.baseBranch, file },
+ { throwOnError: true },
+ )
+ status = data?.status
+ } catch (err) {
+ this.log("Failed to look up file status for revert:", err)
+ }
+
+ try {
+ const result = await this.gitOps.revertFile(target.directory, target.baseBranch, file, status)
+ this.postToWebview({
+ type: "agentManager.revertWorktreeFileResult",
+ sessionId,
+ file,
+ status: result.ok ? "success" : "error",
+ message: result.message,
+ })
+
+ // After successful revert, trigger a diff refresh so the UI updates
+ if (result.ok) {
+ void this.onRequestWorktreeDiff(sessionId)
+ }
+ } catch (err) {
+ const message = err instanceof Error ? err.message : String(err)
+ this.log("Failed to revert worktree file:", message)
+ this.postToWebview({
+ type: "agentManager.revertWorktreeFileResult",
+ sessionId,
+ file,
+ status: "error",
+ message,
+ })
+ }
+ }
+
// ---------------------------------------------------------------------------
// Diff polling
// ---------------------------------------------------------------------------
@@ -1923,6 +2016,8 @@ export class AgentManagerProvider implements Disposable {
}
public dispose(): void {
+ this.connectionService.unregisterFocused("agent-manager")
+ this.connectionService.registerOpen("agent-manager", [])
this.stopDiffPolling()
this.statsPoller.stop()
this.gitOps.dispose()
diff --git a/packages/kilo-vscode/src/agent-manager/GitOps.ts b/packages/kilo-vscode/src/agent-manager/GitOps.ts
index 6c43f64d1e4..3f36edb587e 100644
--- a/packages/kilo-vscode/src/agent-manager/GitOps.ts
+++ b/packages/kilo-vscode/src/agent-manager/GitOps.ts
@@ -4,11 +4,14 @@ import * as fs from "fs/promises"
import { spawn } from "../util/process"
import simpleGit from "simple-git"
import { parseWorktreeList, normalizePath } from "./git-import"
+import type { Semaphore } from "./semaphore"
interface GitOpsOptions {
log: (...args: unknown[]) => void
/** Override git command execution for testing. */
runGit?: (args: string[], cwd: string) => Promise
+ /** Shared concurrency gate for child process spawning. */
+ semaphore?: Semaphore
}
export interface ApplyConflict {
@@ -63,6 +66,7 @@ export class GitOps {
private readonly log: (...args: unknown[]) => void
private readonly runGit: (args: string[], cwd: string) => Promise
private readonly controller = new AbortController()
+ private readonly semaphore: Semaphore | undefined
get disposed(): boolean {
return this.controller.signal.aborted
@@ -70,6 +74,7 @@ export class GitOps {
constructor(options: GitOpsOptions) {
this.log = options.log
+ this.semaphore = options.semaphore
this.runGit =
options.runGit ??
((args, cwd) =>
@@ -87,20 +92,22 @@ export class GitOps {
private raw(args: string[], cwd: string): Promise {
const signal = this.controller.signal
if (signal.aborted) return Promise.reject(new Error("GitOps disposed"))
- return new Promise((resolve, reject) => {
- const onAbort = () => reject(new Error("GitOps disposed"))
- signal.addEventListener("abort", onAbort, { once: true })
- this.runGit(args, cwd).then(
- (value) => {
- signal.removeEventListener("abort", onAbort)
- resolve(value)
- },
- (err) => {
- signal.removeEventListener("abort", onAbort)
- reject(err)
- },
- )
- })
+ const invoke = () =>
+ new Promise((resolve, reject) => {
+ const onAbort = () => reject(new Error("GitOps disposed"))
+ signal.addEventListener("abort", onAbort, { once: true })
+ this.runGit(args, cwd).then(
+ (value) => {
+ signal.removeEventListener("abort", onAbort)
+ resolve(value)
+ },
+ (err) => {
+ signal.removeEventListener("abort", onAbort)
+ reject(err)
+ },
+ )
+ })
+ return this.semaphore ? this.semaphore.run(invoke) : invoke()
}
/** Return the name of the currently checked-out branch, or `"HEAD"` if detached. */
@@ -286,6 +293,55 @@ export class GitOps {
}
}
+ /**
+ * Revert a single file in a worktree back to the merge-base state.
+ * For modified/deleted files: restores the file from the merge-base commit.
+ * For added (new) files: removes the file from the worktree.
+ */
+ async revertFile(
+ cwd: string,
+ baseBranch: string,
+ file: string,
+ status?: "added" | "deleted" | "modified",
+ ): Promise<{ ok: boolean; message: string }> {
+ // Validate path: no absolute paths, no ".." traversal
+ if (nodePath.isAbsolute(file) || file.split(/[\\/]/).includes("..")) {
+ return { ok: false, message: "Invalid file path" }
+ }
+
+ const base = (await this.raw(["merge-base", "HEAD", baseBranch], cwd).catch(() => "")).trim()
+ if (!base) {
+ return { ok: false, message: "Could not resolve merge-base" }
+ }
+
+ if (status === "added") {
+ // New file — remove it from disk and unstage
+ const full = nodePath.resolve(cwd, file)
+ const root = await fs.realpath(cwd)
+ const resolved = await fs.realpath(full).catch(() => full)
+ if (resolved !== root && !resolved.startsWith(root + nodePath.sep)) {
+ return { ok: false, message: "File path outside worktree" }
+ }
+ await fs.rm(full, { force: true })
+ // Also remove from git index in case it was staged
+ await this.raw(["rm", "--cached", "--force", "--ignore-unmatch", "--", file], cwd).catch(() => "")
+ return { ok: true, message: "Removed added file" }
+ }
+
+ // Modified or deleted file — restore from merge-base
+ const result = await this.exec(["checkout", base, "--", file], cwd)
+ if (result.code !== 0) {
+ return { ok: false, message: result.stderr.trim() || "Failed to revert file" }
+ }
+ // Only unstage for modified files. For deleted files the checkout already
+ // restored the file into the index correctly — resetting to HEAD would drop
+ // it from the index and make it appear as a new untracked file.
+ if (status === "modified") {
+ await this.raw(["reset", "HEAD", "--", file], cwd).catch(() => "")
+ }
+ return { ok: true, message: "Reverted file to base" }
+ }
+
async checkApplyPatch(targetPath: string, patch: string): Promise {
if (!patch.trim()) {
return { ok: true, conflicts: [], message: "No changes to apply" }
@@ -364,37 +420,39 @@ export class GitOps {
if (this.controller.signal.aborted) {
return Promise.resolve({ code: 1, stdout: "", stderr: "GitOps disposed" })
}
- return new Promise((resolve) => {
- const child = spawn("git", args, {
- cwd,
- env: options?.env,
- signal: this.controller.signal,
- stdio: ["pipe", "pipe", "pipe"],
- })
+ const invoke = () =>
+ new Promise((resolve) => {
+ const child = spawn("git", args, {
+ cwd,
+ env: options?.env,
+ signal: this.controller.signal,
+ stdio: ["pipe", "pipe", "pipe"],
+ })
- if (options?.stdin !== undefined) {
- if (!child.stdin) {
- resolve({ code: 1, stdout: "", stderr: "stdin not available for git process" })
- return
+ if (options?.stdin !== undefined) {
+ if (!child.stdin) {
+ resolve({ code: 1, stdout: "", stderr: "stdin not available for git process" })
+ return
+ }
+ child.stdin.end(options.stdin)
}
- child.stdin.end(options.stdin)
- }
- const out: Buffer[] = []
- const err: Buffer[] = []
- child.stdout?.on("data", (chunk: Buffer) => out.push(chunk))
- child.stderr?.on("data", (chunk: Buffer) => err.push(chunk))
+ const out: Buffer[] = []
+ const err: Buffer[] = []
+ child.stdout?.on("data", (chunk: Buffer) => out.push(chunk))
+ child.stderr?.on("data", (chunk: Buffer) => err.push(chunk))
- child.on("error", (error) => {
- resolve({ code: 1, stdout: "", stderr: error.message })
- })
- child.on("close", (code) => {
- resolve({
- code: code ?? 1,
- stdout: Buffer.concat(out).toString("utf8"),
- stderr: Buffer.concat(err).toString("utf8"),
+ child.on("error", (error) => {
+ resolve({ code: 1, stdout: "", stderr: error.message })
+ })
+ child.on("close", (code) => {
+ resolve({
+ code: code ?? 1,
+ stdout: Buffer.concat(out).toString("utf8"),
+ stderr: Buffer.concat(err).toString("utf8"),
+ })
})
})
- })
+ return this.semaphore ? this.semaphore.run(invoke) : invoke()
}
}
diff --git a/packages/kilo-vscode/src/agent-manager/GitStatsPoller.ts b/packages/kilo-vscode/src/agent-manager/GitStatsPoller.ts
index 301261d137e..2cde458d432 100644
--- a/packages/kilo-vscode/src/agent-manager/GitStatsPoller.ts
+++ b/packages/kilo-vscode/src/agent-manager/GitStatsPoller.ts
@@ -3,6 +3,7 @@ import * as path from "path"
import type { KiloClient, FileDiff } from "@kilocode/sdk/v2/client"
import { remoteRef, type Worktree } from "./WorktreeStateManager"
import type { GitOps } from "./GitOps"
+import type { Semaphore } from "./semaphore"
import { normalizePath } from "./git-import"
export interface WorktreeStats {
@@ -45,6 +46,8 @@ interface GitStatsPollerOptions {
onWorktreePresence?: (result: WorktreePresenceResult) => void
log: (...args: unknown[]) => void
intervalMs?: number
+ /** Shared concurrency gate for child process spawning. */
+ semaphore?: Semaphore
}
export class GitStatsPoller {
@@ -154,15 +157,20 @@ export class GitStatsPoller {
return
}
+ // Gate the HTTP diffSummary call through the semaphore but NOT the
+ // aheadBehind call — that goes through GitOps.raw() which already
+ // acquires the same semaphore. Wrapping both would deadlock.
+ const gate = this.options.semaphore
+ const diff = (dir: string, base: string) => {
+ const invoke = () => client.worktree.diffSummary({ directory: dir, base }, { throwOnError: true })
+ return gate ? gate.run(invoke) : invoke()
+ }
const stats = (
await Promise.all(
active.map(async (wt) => {
try {
const base = remoteRef(wt)
- const [{ data: diffs }, ab] = await Promise.all([
- client.worktree.diffSummary({ directory: wt.path, base }, { throwOnError: true }),
- this.git.aheadBehind(wt.path, base),
- ])
+ const [{ data: diffs }, ab] = await Promise.all([diff(wt.path, base), this.git.aheadBehind(wt.path, base)])
const files = diffs.length
const additions = diffs.reduce((sum: number, diff: FileDiff) => sum + diff.additions, 0)
const deletions = diffs.reduce((sum: number, diff: FileDiff) => sum + diff.deletions, 0)
@@ -260,8 +268,10 @@ export class GitStatsPoller {
try {
if (base && client) {
this.options.log(`Local stats: using HTTP client with base=${base}`)
+ const gate = this.options.semaphore
+ const invoke = () => client.worktree.diffSummary({ directory: root, base }, { throwOnError: true })
const [{ data: diffs }, ab] = await Promise.all([
- client.worktree.diffSummary({ directory: root, base }, { throwOnError: true }),
+ gate ? gate.run(invoke) : invoke(),
this.git.aheadBehind(root, base),
])
files = diffs.length
diff --git a/packages/kilo-vscode/src/agent-manager/PRStatusPoller.ts b/packages/kilo-vscode/src/agent-manager/PRStatusPoller.ts
index 1b91b952904..f655616b96e 100644
--- a/packages/kilo-vscode/src/agent-manager/PRStatusPoller.ts
+++ b/packages/kilo-vscode/src/agent-manager/PRStatusPoller.ts
@@ -1,7 +1,9 @@
+import type { ExecFileOptionsWithStringEncoding } from "child_process"
import type { Worktree } from "./WorktreeStateManager"
import type { PRStatus, PRCheck, PRComment, CheckStatus, AggregateCheckStatus, PRState, ReviewDecision } from "./types"
import { execWithShellEnv } from "./shell-env"
import { classifyPRError } from "./git-import"
+import type { Semaphore } from "./semaphore"
interface PRStatusPollerOptions {
getWorktrees: () => Worktree[]
@@ -9,12 +11,16 @@ interface PRStatusPollerOptions {
onStatus: (worktreeId: string, pr: PRStatus | null, error?: "gh_missing" | "gh_auth" | "fetch_failed") => void
log: (...args: unknown[]) => void
intervalMs?: number
+ /** Shared concurrency gate for child process spawning. */
+ semaphore?: Semaphore
}
const GH_PROBE_TTL = 300_000 // 5 minutes — gh installation state rarely changes at runtime
const MAX_BACKOFF = 120_000 // 2 minutes — cap for exponential backoff on repeated errors
const BACKOFF_MULTIPLIER = 2
const PR_LOOKUP_TTL = 10_000 // 10 seconds — short TTL; only the active worktree polls so this stays cheap
+const FULL_SYNC_INTERVAL = 120_000 // 2 minutes — periodic sync of ALL worktrees (badges stay fresh)
+const FULL_SYNC_CONCURRENCY = 3 // max parallel gh processes during a full sync (caps the burst)
export class PRStatusPoller {
private timer: ReturnType | undefined
@@ -29,10 +35,23 @@ export class PRStatusPoller {
private activeWorktreeId: string | undefined
private cachedRepo: { owner: string; name: string; cwd: string } | undefined
private prCache = new Map()
+ private lastFullSync = 0 // timestamp of last full (all-worktree) sync
private readonly intervalMs: number
+ private readonly semaphore: Semaphore | undefined
constructor(private readonly options: PRStatusPollerOptions) {
this.intervalMs = options.intervalMs ?? 15_000
+ this.semaphore = options.semaphore
+ }
+
+ /** Run a command through the shared concurrency gate (when configured). */
+ private shell(
+ cmd: string,
+ args: string[],
+ options?: Omit,
+ ): Promise<{ stdout: string; stderr: string }> {
+ const invoke = () => execWithShellEnv(cmd, args, options)
+ return this.semaphore ? this.semaphore.run(invoke) : invoke()
}
setEnabled(enabled: boolean): void {
@@ -56,6 +75,7 @@ export class PRStatusPoller {
this.timer = undefined
this.prCache.clear()
this.lastHash.clear()
+ this.lastFullSync = 0
void this.poll()
return
}
@@ -80,6 +100,7 @@ export class PRStatusPoller {
this.ghProbeTime = 0
this.cachedRepo = undefined
this.prCache.clear()
+ this.lastFullSync = 0
}
/** Force-refresh a specific worktree immediately, bypassing the PR cache. */
@@ -135,7 +156,7 @@ export class PRStatusPoller {
return this.ghAvailable
}
try {
- await execWithShellEnv("gh", ["--version"], { timeout: 5_000 })
+ await this.shell("gh", ["--version"], { timeout: 5_000 })
this.ghAvailable = true
} catch {
this.ghAvailable = false
@@ -159,19 +180,26 @@ export class PRStatusPoller {
this.lastError = undefined
- // Only poll the active worktree on each timer tick. Inactive worktrees
- // refresh when selected (setActiveWorktreeId) or manually (refresh()).
- // On first poll (lastHash empty) fetch all worktrees once to populate badges.
+ // Most ticks only poll the active worktree for fast feedback. Every
+ // FULL_SYNC_INTERVAL we poll ALL worktrees so badges stay current even
+ // for sessions that aren't selected (e.g. CI results changing).
+ // The very first poll (lastHash empty) also fetches everything.
const worktrees = this.options.getWorktrees()
+ const now = Date.now()
const initial = this.lastHash.size === 0
- const targets = initial ? worktrees : worktrees.filter((wt) => wt.id === this.activeWorktreeId)
+ const full = initial || now - this.lastFullSync >= FULL_SYNC_INTERVAL
+ const targets = full ? worktrees : worktrees.filter((wt) => wt.id === this.activeWorktreeId)
+ if (full) this.lastFullSync = now
if (targets.length === 0) {
this.failures = 0
return
}
- const results = await Promise.allSettled(targets.map((wt) => this.fetchOne(wt.id)))
+ const thunks = targets.map((wt) => () => this.fetchOne(wt.id))
+ const results = full
+ ? await settled(thunks, FULL_SYNC_CONCURRENCY)
+ : await Promise.allSettled(thunks.map((fn) => fn()))
const ok = results.every((r) => r.status === "fulfilled")
if (ok) {
this.failures = 0
@@ -267,7 +295,7 @@ export class PRStatusPoller {
if (branch) args.push(branch)
args.push("--json", PRStatusPoller.PR_JSON_FIELDS)
- const { stdout } = await execWithShellEnv("gh", args, { cwd, timeout: 15_000 })
+ const { stdout } = await this.shell("gh", args, { cwd, timeout: 15_000 })
return parsePRResult(stdout)
} catch (err) {
const msg = err instanceof Error ? err.message : String(err)
@@ -279,11 +307,11 @@ export class PRStatusPoller {
/** Search for PRs containing the current HEAD SHA. Finds PRs when branch name/tracking ref don't match. */
private async ghPRListBySHA(cwd: string): Promise {
try {
- const { stdout: sha } = await execWithShellEnv("git", ["rev-parse", "HEAD"], { cwd, timeout: 5_000 })
+ const { stdout: sha } = await this.shell("git", ["rev-parse", "HEAD"], { cwd, timeout: 5_000 })
const head = sha.trim()
if (!head) return null
- const { stdout } = await execWithShellEnv(
+ const { stdout } = await this.shell(
"gh",
[
"pr",
@@ -325,7 +353,7 @@ export class PRStatusPoller {
items: PRCheck[]
}> {
try {
- const { stdout } = await execWithShellEnv(
+ const { stdout } = await this.shell(
"gh",
["pr", "checks", String(prNumber), "--json", "name,state,link,startedAt,completedAt"],
{ cwd, timeout: 15_000 },
@@ -363,7 +391,7 @@ export class PRStatusPoller {
if (this.cachedRepo && this.cachedRepo.cwd === cwd) {
return this.cachedRepo
}
- const { stdout } = await execWithShellEnv("gh", ["repo", "view", "--json", "owner,name"], {
+ const { stdout } = await this.shell("gh", ["repo", "view", "--json", "owner,name"], {
cwd,
timeout: 10_000,
})
@@ -403,7 +431,7 @@ export class PRStatusPoller {
}
}`
- const { stdout } = await execWithShellEnv(
+ const { stdout } = await this.shell(
"gh",
[
"api",
@@ -519,3 +547,22 @@ function formatCheckDuration(startedAt?: string, completedAt?: string): string |
const secs = Math.round((new Date(completedAt).getTime() - new Date(startedAt).getTime()) / 1000)
return secs < 60 ? `${secs}s` : `${Math.floor(secs / 60)}m ${secs % 60}s`
}
+
+/** Run async thunks with bounded concurrency, returning settled results. */
+async function settled(thunks: (() => Promise)[], concurrency: number): Promise[]> {
+ const results: PromiseSettledResult[] = new Array(thunks.length)
+ let idx = 0
+ async function run(): Promise {
+ while (idx < thunks.length) {
+ const i = idx++
+ const fn = thunks[i]!
+ try {
+ results[i] = { status: "fulfilled", value: await fn() }
+ } catch (reason) {
+ results[i] = { status: "rejected", reason }
+ }
+ }
+ }
+ await Promise.all(Array.from({ length: Math.min(concurrency, thunks.length) }, () => run()))
+ return results
+}
diff --git a/packages/kilo-vscode/src/agent-manager/WorktreeManager.ts b/packages/kilo-vscode/src/agent-manager/WorktreeManager.ts
index 932e35e5604..5d6c92edf9a 100644
--- a/packages/kilo-vscode/src/agent-manager/WorktreeManager.ts
+++ b/packages/kilo-vscode/src/agent-manager/WorktreeManager.ts
@@ -858,6 +858,15 @@ export class WorktreeManager {
this.log(`defaultBranch: branchLocal failed: ${e}`)
}
+ // Check if this is an empty repo with no commits (unborn branch).
+ // rev-parse --verify HEAD exits non-zero only when HEAD has no target
+ // commit, which is the definitive test for an unborn branch.
+ try {
+ await this.git.raw(["rev-parse", "--verify", "HEAD"])
+ } catch {
+ throw new Error("This repository has no commits yet. Create an initial commit before using worktrees.")
+ }
+
throw new Error("Could not determine default branch")
}
diff --git a/packages/kilo-vscode/src/agent-manager/WorktreeStateManager.ts b/packages/kilo-vscode/src/agent-manager/WorktreeStateManager.ts
index 3765785d96f..3b051b3680d 100644
--- a/packages/kilo-vscode/src/agent-manager/WorktreeStateManager.ts
+++ b/packages/kilo-vscode/src/agent-manager/WorktreeStateManager.ts
@@ -247,12 +247,12 @@ export class WorktreeStateManager {
return session
}
- /** Move an existing session to a worktree (promotion). */
- moveSession(sessionId: string, worktreeId: string): void {
+ /** Move an existing session to a worktree (or back to local when null). */
+ moveSession(sessionId: string, worktreeId: string | null): void {
const session = this.sessions.get(sessionId)
if (!session) return
session.worktreeId = worktreeId
- this.log(`Moved session ${sessionId} to worktree ${worktreeId}`)
+ this.log(`Moved session ${sessionId} to ${worktreeId ?? "local"}`)
void this.save()
}
@@ -304,6 +304,11 @@ export class WorktreeStateManager {
if (!wt.sectionId) top.add(wt.id)
}
this.worktreeOrder = order.filter((id) => top.has(id))
+ // Append any sections/ungrouped worktrees missing from the incoming order
+ const present = new Set(this.worktreeOrder)
+ for (const id of top) {
+ if (!present.has(id)) this.worktreeOrder.push(id)
+ }
void this.save()
}
@@ -380,6 +385,11 @@ export class WorktreeStateManager {
}
moveSection(id: string, dir: -1 | 1): void {
+ // Ensure the section is in worktreeOrder (it may be missing if drag-and-drop
+ // overwrote the order before this section was tracked)
+ if (this.sections.has(id) && !this.worktreeOrder.includes(id)) {
+ this.worktreeOrder.push(id)
+ }
const top = this.worktreeOrder.filter((item) => {
if (this.sections.has(item)) return true
const wt = this.worktrees.get(item)
diff --git a/packages/kilo-vscode/src/agent-manager/git-import.ts b/packages/kilo-vscode/src/agent-manager/git-import.ts
index 342a0448efd..ae3f2c37a73 100644
--- a/packages/kilo-vscode/src/agent-manager/git-import.ts
+++ b/packages/kilo-vscode/src/agent-manager/git-import.ts
@@ -29,7 +29,7 @@ interface WorktreeEntry {
type PRErrorKind = "not_found" | "gh_missing" | "gh_auth" | "unknown"
-export type WorktreeSetupErrorCode = "git_not_found" | "not_git_repo" | "lfs_missing"
+export type WorktreeSetupErrorCode = "git_not_found" | "not_git_repo" | "lfs_missing" | "no_commits"
export function parsePRUrl(url: string): PRUrlParts | null {
let normalized = url.trim()
@@ -158,5 +158,6 @@ export function classifyWorktreeError(msg: string): WorktreeSetupErrorCode | und
if (msg.includes("ENOENT") || msg.includes("not found in PATH")) return "git_not_found"
if (msg.includes("not a git repository")) return "not_git_repo"
if (msg.includes("Git LFS") && msg.includes("not found")) return "lfs_missing"
+ if (msg.includes("no commits yet")) return "no_commits"
return undefined
}
diff --git a/packages/kilo-vscode/src/agent-manager/host.ts b/packages/kilo-vscode/src/agent-manager/host.ts
index 596e32cf88c..6dc5e658280 100644
--- a/packages/kilo-vscode/src/agent-manager/host.ts
+++ b/packages/kilo-vscode/src/agent-manager/host.ts
@@ -38,6 +38,8 @@ export interface SessionProvider {
trackSession(id: string): void
refreshSessions(): void
registerSession(session: Session): void
+ /** Recover any pending permission/question prompts for tracked sessions. */
+ recoverPendingPrompts(): void
dispose(): void
}
diff --git a/packages/kilo-vscode/src/agent-manager/pr-status-bridge.ts b/packages/kilo-vscode/src/agent-manager/pr-status-bridge.ts
index 15d5d754d7e..03146dc49a6 100644
--- a/packages/kilo-vscode/src/agent-manager/pr-status-bridge.ts
+++ b/packages/kilo-vscode/src/agent-manager/pr-status-bridge.ts
@@ -7,6 +7,7 @@
import type { Worktree } from "./WorktreeStateManager"
import type { AgentManagerOutMessage, PRStatus } from "./types"
import type { Disposable } from "./host"
+import type { Semaphore } from "./semaphore"
import { PRStatusPoller } from "./PRStatusPoller"
interface PRBridgeHost {
@@ -17,6 +18,7 @@ interface PRBridgeHost {
hasPersistedPR(id: string): boolean
openExternal(url: string): void
log(...args: unknown[]): void
+ semaphore?: Semaphore
}
/** Minimal panel surface needed by the bridge (subset of PanelContext). */
@@ -43,6 +45,7 @@ export class PRStatusBridge {
hasPersistedPR: (id: string) => boolean
openExternal: (url: string) => void
log: (...args: unknown[]) => void
+ semaphore?: Semaphore
}): PRStatusBridge {
return new PRStatusBridge(opts)
}
@@ -85,6 +88,7 @@ function bridgePollerOpts(bridge: PRStatusBridge, host: PRBridgeHost) {
return {
getWorktrees: () => host.getWorktrees(),
getWorkspaceRoot: () => host.getWorkspaceRoot(),
+ semaphore: host.semaphore,
onStatus: (id: string, pr: PRStatus | null, err?: "gh_missing" | "gh_auth" | "fetch_failed") => {
if (err) {
// Don't forward errors to the webview when we have prior PR data
diff --git a/packages/kilo-vscode/src/agent-manager/semaphore.ts b/packages/kilo-vscode/src/agent-manager/semaphore.ts
new file mode 100644
index 00000000000..37f3ab9cdd2
--- /dev/null
+++ b/packages/kilo-vscode/src/agent-manager/semaphore.ts
@@ -0,0 +1,41 @@
+/**
+ * Bounded-concurrency gate for git/gh child processes.
+ *
+ * Shared across GitOps and PRStatusPoller so that all polling loops
+ * (GitStatsPoller, PRStatusPoller, diff watcher) compete for the same
+ * slots. Prevents process storms when many worktrees are active.
+ */
+export class Semaphore {
+ private running = 0
+ private readonly pending: (() => void)[] = []
+
+ constructor(private readonly limit: number) {}
+
+ async run(fn: () => Promise): Promise {
+ await this.acquire()
+ try {
+ return await fn()
+ } finally {
+ this.release()
+ }
+ }
+
+ private acquire(): Promise {
+ if (this.running < this.limit) {
+ this.running++
+ return Promise.resolve()
+ }
+ return new Promise((resolve) => {
+ this.pending.push(() => {
+ this.running++
+ resolve()
+ })
+ })
+ }
+
+ private release(): void {
+ this.running--
+ const next = this.pending.shift()
+ if (next) next()
+ }
+}
diff --git a/packages/kilo-vscode/src/agent-manager/task-runner.ts b/packages/kilo-vscode/src/agent-manager/task-runner.ts
index 0c9e7fa7c46..1329939e274 100644
--- a/packages/kilo-vscode/src/agent-manager/task-runner.ts
+++ b/packages/kilo-vscode/src/agent-manager/task-runner.ts
@@ -28,7 +28,16 @@ export async function executeVscodeTask(config: SetupTaskConfig): Promise {
let done = false
diff --git a/packages/kilo-vscode/src/agent-manager/types.ts b/packages/kilo-vscode/src/agent-manager/types.ts
index 264f1f46107..2dc76cc6a01 100644
--- a/packages/kilo-vscode/src/agent-manager/types.ts
+++ b/packages/kilo-vscode/src/agent-manager/types.ts
@@ -228,6 +228,14 @@ interface WorktreeDiffFileMessage {
diff: WorktreeDiffEntry | null
}
+interface RevertWorktreeFileResultMessage {
+ type: "agentManager.revertWorktreeFileResult"
+ sessionId: string
+ file: string
+ status: "success" | "error"
+ message: string
+}
+
interface PRStatusOutMessage {
type: "agentManager.prStatus"
worktreeId: string
@@ -262,6 +270,7 @@ export type AgentManagerOutMessage =
| WorktreeDiffLoadingMessage
| WorktreeDiffMessage
| WorktreeDiffFileMessage
+ | RevertWorktreeFileResultMessage
| PRStatusOutMessage
| ActionOutMessage
@@ -305,6 +314,18 @@ interface CloseSessionIn {
sessionId: string
}
+/** Persist a non-worktree session to agent-manager.json (worktreeId = null). */
+interface PersistSessionIn {
+ type: "agentManager.persistSession"
+ sessionId: string
+}
+
+/** Remove a non-worktree session from agent-manager.json. */
+interface ForgetSessionIn {
+ type: "agentManager.forgetSession"
+ sessionId: string
+}
+
interface ConfigureSetupScriptIn {
type: "agentManager.configureSetupScript"
}
@@ -440,6 +461,12 @@ interface StopDiffWatchIn {
type: "agentManager.stopDiffWatch"
}
+interface RevertWorktreeFileIn {
+ type: "agentManager.revertWorktreeFile"
+ sessionId: string
+ file: string
+}
+
interface RefreshPRIn {
type: "agentManager.refreshPR"
worktreeId: string
@@ -450,6 +477,11 @@ interface OpenPRIn {
worktreeId: string
}
+interface OpenSessionsIn {
+ type: "agentManager.openSessions"
+ sessionIDs: string[]
+}
+
interface OpenFileIn {
type: "agentManager.openFile"
sessionId: string
@@ -574,6 +606,8 @@ export type AgentManagerInMessage =
| OpenLocallyIn
| AddSessionToWorktreeIn
| CloseSessionIn
+ | PersistSessionIn
+ | ForgetSessionIn
| ForkSessionIn
| ConfigureSetupScriptIn
| ShowTerminalIn
@@ -601,8 +635,10 @@ export type AgentManagerInMessage =
| ApplyWorktreeDiffIn
| StartDiffWatchIn
| StopDiffWatchIn
+ | RevertWorktreeFileIn
| RefreshPRIn
| OpenPRIn
+ | OpenSessionsIn
| OpenFileIn
| GenericOpenFileIn
| PreviewImageIn
diff --git a/packages/kilo-vscode/src/agent-manager/vscode-host.ts b/packages/kilo-vscode/src/agent-manager/vscode-host.ts
index 7ea4403cbc0..9a539ccf0ba 100644
--- a/packages/kilo-vscode/src/agent-manager/vscode-host.ts
+++ b/packages/kilo-vscode/src/agent-manager/vscode-host.ts
@@ -9,17 +9,24 @@ import * as vscode from "vscode"
import type { Host, PanelContext, OutputHandle, SessionProvider, Disposable } from "./host"
import type { KiloConnectionService } from "../services/cli-backend"
import { KiloProvider } from "../KiloProvider"
+import { DiffVirtualProvider } from "../DiffVirtualProvider"
import { buildWebviewHtml } from "../utils"
import { openFileInEditor, getWorkspaceRoot } from "../review-utils"
import { TelemetryProxy, type TelemetryEventName } from "../services/telemetry"
export class VscodeHost implements Host {
+ private diffVirtual: DiffVirtualProvider | undefined
+
constructor(
private readonly extensionUri: vscode.Uri,
private readonly connectionService: KiloConnectionService,
private readonly context: vscode.ExtensionContext,
) {}
+ setDiffVirtualProvider(provider: DiffVirtualProvider): void {
+ this.diffVirtual = provider
+ }
+
openPanel(opts: {
onBeforeMessage: (msg: Record) => Promise | null>
}): PanelContext {
@@ -74,6 +81,9 @@ export class VscodeHost implements Host {
const provider = new KiloProvider(this.extensionUri, this.connectionService, this.context, {
slimEditMetadata: true,
})
+ if (this.diffVirtual) {
+ provider.setDiffVirtualProvider(this.diffVirtual)
+ }
provider.attachToWebview(panel.webview, {
onBeforeMessage: opts.onBeforeMessage,
})
@@ -85,6 +95,7 @@ export class VscodeHost implements Host {
trackSession: (id) => provider.trackSession(id),
refreshSessions: () => provider.refreshSessions(),
registerSession: (s) => provider.registerSession(s),
+ recoverPendingPrompts: () => provider.recoverPendingPrompts(),
dispose: () => provider.dispose(),
}
diff --git a/packages/kilo-vscode/src/extension.ts b/packages/kilo-vscode/src/extension.ts
index 438b26c3a9c..60b30ecc877 100644
--- a/packages/kilo-vscode/src/extension.ts
+++ b/packages/kilo-vscode/src/extension.ts
@@ -3,6 +3,7 @@ import { KiloProvider } from "./KiloProvider"
import { AgentManagerProvider } from "./agent-manager/AgentManagerProvider"
import { VscodeHost } from "./agent-manager/vscode-host"
import { DiffViewerProvider } from "./DiffViewerProvider"
+import { DiffVirtualProvider } from "./DiffVirtualProvider"
import { SettingsEditorProvider } from "./SettingsEditorProvider"
import { SubAgentViewerProvider } from "./SubAgentViewerProvider"
import { EXTENSION_DISPLAY_NAME } from "./constants"
@@ -15,6 +16,7 @@ import { TelemetryProxy } from "./services/telemetry"
import { registerCommitMessageService } from "./services/commit-message"
import { registerCodeActions, registerTerminalActions, KiloCodeActionProvider } from "./services/code-actions"
import { registerToggleAutoApprove } from "./commands/toggle-auto-approve"
+import { RemoteStatusService } from "./services/RemoteStatusService"
// Activated via "onStartupFinished" (package.json) so that commands, code actions, keybindings,
// autocomplete, commit-message generation, and URI deep links all work immediately — without
@@ -32,8 +34,13 @@ export function activate(context: vscode.ExtensionContext) {
const browserAutomationService = new BrowserAutomationService(connectionService)
browserAutomationService.syncWithSettings()
+ // Create remote status service (one status bar item for all webviews)
+ const remoteService = new RemoteStatusService()
+ context.subscriptions.push(remoteService)
+ connectionService.setRemoteService(remoteService)
+
// Re-register browser automation MCP server on CLI backend reconnect, configure telemetry,
- // and reload autocomplete so it picks up the now-available backend connection.
+ // set remote service client, and reload autocomplete so it picks up the now-available backend connection.
const unsubscribeStateChange = connectionService.onStateChange((state) => {
if (state === "connected") {
browserAutomationService.reregisterIfEnabled()
@@ -41,7 +48,17 @@ export function activate(context: vscode.ExtensionContext) {
if (config) {
telemetry.configure(config.baseUrl, config.password)
}
+ try {
+ remoteService.setClient(connectionService.getClient())
+ console.log("[Kilo New] CLI connected, calling remoteService.refresh()")
+ remoteService.refresh().catch((err) => console.warn("[Kilo New] initial remote refresh failed:", err))
+ } catch {
+ remoteService.setClient(null)
+ }
AutocompleteServiceManager.getInstance()?.load()
+ } else {
+ remoteService.clearState()
+ remoteService.setClient(null)
}
})
@@ -59,6 +76,7 @@ export function activate(context: vscode.ExtensionContext) {
// Create the provider with shared service
const provider = new KiloProvider(context.extensionUri, connectionService, context)
+ provider.setRemoteService(remoteService)
// Register the webview view provider for the sidebar.
// retainContextWhenHidden keeps the webview alive when switching to other sidebar panels.
@@ -102,9 +120,11 @@ export function activate(context: vscode.ExtensionContext) {
vscode.window.registerWebviewPanelSerializer("kilo-code.new.TabPanel", {
deserializeWebviewPanel(panel: vscode.WebviewPanel) {
const tabProvider = new KiloProvider(context.extensionUri, connectionService, context)
+ tabProvider.setRemoteService(remoteService)
tabProvider.setContinueInWorktreeHandler((sessionId, progress) =>
agentManagerProvider.continueFromSidebar(sessionId, progress),
)
+ tabProvider.setDiffVirtualProvider(diffVirtualProvider)
tabProvider.resolveWebviewPanel(panel)
tabPanels.set(panel, tabProvider)
panel.onDidDispose(
@@ -128,8 +148,15 @@ export function activate(context: vscode.ExtensionContext) {
})
context.subscriptions.push(diffViewerProvider)
+ // Create diff virtual provider (lightweight single-file diff for permission approval)
+ const diffVirtualProvider = new DiffVirtualProvider(context.extensionUri)
+ provider.setDiffVirtualProvider(diffVirtualProvider)
+ agentManagerHost.setDiffVirtualProvider(diffVirtualProvider)
+ context.subscriptions.push(diffVirtualProvider)
+
// Create settings/profile editor provider (opens in editor area, not sidebar)
const settingsEditorProvider = new SettingsEditorProvider(context.extensionUri, connectionService, context)
+ settingsEditorProvider.setRemoteService(remoteService)
context.subscriptions.push(settingsEditorProvider)
// Create sub-agent viewer provider (read-only editor panel for sub-agent sessions)
@@ -220,8 +247,18 @@ export function activate(context: vscode.ExtensionContext) {
await provider.waitForReady()
provider.postMessage({ type: "triggerTask", text: `Generate a terminal command: ${input}` })
}),
+ vscode.commands.registerCommand("kilo-code.new.toggleRemote", () => {
+ remoteService.toggle().catch((err) => console.error("[Kilo New] toggleRemote command failed:", err))
+ }),
vscode.commands.registerCommand("kilo-code.new.openInTab", () => {
- return openKiloInNewTab(context, connectionService, agentManagerProvider, tabPanels)
+ return openKiloInNewTab(
+ context,
+ connectionService,
+ agentManagerProvider,
+ tabPanels,
+ diffVirtualProvider,
+ remoteService,
+ )
}),
vscode.commands.registerCommand("kilo-code.new.showChanges", () => {
diffViewerProvider.openPanel()
@@ -353,6 +390,8 @@ async function openKiloInNewTab(
connectionService: KiloConnectionService,
agentManagerProvider: AgentManagerProvider,
tabPanels: Map,
+ diffVirtualProvider: DiffVirtualProvider,
+ remoteService: RemoteStatusService,
) {
const lastCol = Math.max(...vscode.window.visibleTextEditors.map((e) => e.viewColumn || 0), 0)
const hasVisibleEditors = vscode.window.visibleTextEditors.length > 0
@@ -375,9 +414,11 @@ async function openKiloInNewTab(
}
const tabProvider = new KiloProvider(context.extensionUri, connectionService, context)
+ tabProvider.setRemoteService(remoteService)
tabProvider.setContinueInWorktreeHandler((sessionId, progress) =>
agentManagerProvider.continueFromSidebar(sessionId, progress),
)
+ tabProvider.setDiffVirtualProvider(diffVirtualProvider)
tabProvider.resolveWebviewPanel(panel)
tabPanels.set(panel, tabProvider)
diff --git a/packages/kilo-vscode/src/kilo-provider/slim-metadata.ts b/packages/kilo-vscode/src/kilo-provider/slim-metadata.ts
index 3ec760d7c4a..a7748b5d004 100644
--- a/packages/kilo-vscode/src/kilo-provider/slim-metadata.ts
+++ b/packages/kilo-vscode/src/kilo-provider/slim-metadata.ts
@@ -112,13 +112,29 @@ function slimMultiedit(state: Record): Record
return next
}
-/** write: strip input.content (entire file). Keep filePath + diagnostics. */
+/** write: strip input.content, raw diff text, and filediff.before/after. Keep filepath + exists + diagnostics. */
function slimWrite(state: Record): Record {
const next = { ...state }
const input = state.input
if (isObj(input) && typeof input.content === "string") {
next.input = { ...input, content: undefined }
}
+ const meta = state.metadata
+ if (isObj(meta)) {
+ const slim: Record = {}
+ if (meta.filepath) slim.filepath = meta.filepath
+ if (meta.exists !== undefined) slim.exists = meta.exists
+ if (meta.diagnostics) slim.diagnostics = meta.diagnostics
+ const fd = meta.filediff
+ if (isObj(fd)) {
+ slim.filediff = {
+ ...(typeof fd.file === "string" ? { file: fd.file } : {}),
+ additions: typeof fd.additions === "number" ? fd.additions : 0,
+ deletions: typeof fd.deletions === "number" ? fd.deletions : 0,
+ }
+ }
+ next.metadata = slim
+ }
return next
}
diff --git a/packages/kilo-vscode/src/kilo-provider/task-session.ts b/packages/kilo-vscode/src/kilo-provider/task-session.ts
new file mode 100644
index 00000000000..cff8f6661d7
--- /dev/null
+++ b/packages/kilo-vscode/src/kilo-provider/task-session.ts
@@ -0,0 +1,17 @@
+type Meta = { sessionId?: string }
+
+type State = {
+ metadata?: Meta
+}
+
+type Part = {
+ type?: string
+ tool?: string
+ metadata?: Meta
+ state?: State
+}
+
+export function childID(part: Part): string | undefined {
+ if (part.type !== "tool" || part.tool !== "task") return undefined
+ return part.metadata?.sessionId ?? part.state?.metadata?.sessionId
+}
diff --git a/packages/kilo-vscode/src/services/RemoteStatusService.ts b/packages/kilo-vscode/src/services/RemoteStatusService.ts
new file mode 100644
index 00000000000..14181005063
--- /dev/null
+++ b/packages/kilo-vscode/src/services/RemoteStatusService.ts
@@ -0,0 +1,129 @@
+import * as vscode from "vscode"
+import type { KiloClient } from "@kilocode/sdk/v2/client"
+import { t } from "./cli-backend/i18n"
+
+export type RemoteState = { enabled: boolean; connected: boolean }
+
+type Listener = (state: RemoteState) => void
+
+/**
+ * Singleton service that owns all remote-control state and the VS Code status bar item.
+ * Replaces the per-webview polling in RemoteIndicator.tsx and ExperimentalTab.tsx
+ * with a push-based model: one status bar item, zero recurring cost for non-remote users.
+ */
+export class RemoteStatusService implements vscode.Disposable {
+ private state: RemoteState = { enabled: false, connected: false }
+ private bar: vscode.StatusBarItem
+ private listeners = new Set()
+ private client: KiloClient | null = null
+
+ constructor() {
+ this.bar = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Right, 99)
+ this.bar.command = "kilo-code.new.toggleRemote"
+ this.sync()
+ }
+
+ setClient(c: KiloClient | null): void {
+ this.client = c
+ }
+
+ /** Get current state synchronously. */
+ getState(): RemoteState {
+ return this.state
+ }
+
+ updateFromEvent(state: RemoteState): void {
+ this.update(state)
+ }
+
+ /** Subscribe to state changes. Returns an unsubscribe function. */
+ onChange(cb: Listener): () => void {
+ this.listeners.add(cb)
+ return () => this.listeners.delete(cb)
+ }
+
+ clearState(): void {
+ this.update({ enabled: false, connected: false })
+ }
+
+ /** One-shot status fetch — broadcasts via onChange if state changed. */
+ async refresh(): Promise {
+ if (!this.client) return
+ const res = await this.client.remote.status().catch((err: unknown) => {
+ console.warn("[Kilo] remote status refresh failed:", err)
+ return undefined
+ })
+ if (!res?.data) return
+ this.update({ enabled: res.data.enabled, connected: res.data.connected })
+ }
+
+ /** Toggle remote on/off based on current state. */
+ async toggle(): Promise {
+ if (!this.client) return
+ const { data } = await this.client.remote.status(undefined, { throwOnError: true })
+ await this.setEnabled(!data.enabled)
+ }
+
+ /** Enable or disable remote. State updates are pushed via events. */
+ async setEnabled(enabled: boolean): Promise {
+ if (!this.client) return
+ if (enabled) {
+ await this.client.remote.enable(undefined, { throwOnError: true })
+ } else {
+ await this.client.remote.disable(undefined, { throwOnError: true })
+ }
+ this.update({ enabled, connected: false })
+ }
+
+ /**
+ * Handle a remote-related webview message.
+ * Returns a response message to post back to the webview, or null.
+ */
+ async handleMessage(type: string, enabled?: boolean): Promise {
+ switch (type) {
+ case "toggleRemote":
+ await this.toggle()
+ return null
+ case "setRemoteEnabled":
+ if (enabled === undefined) return null
+ await this.setEnabled(enabled)
+ return null
+ case "requestRemoteStatus":
+ void this.refresh()
+ return this.state
+ }
+ return null
+ }
+
+ dispose(): void {
+ this.listeners.clear()
+ this.bar.dispose()
+ }
+
+ // -- internal ---------------------------------------------------------------
+
+ private update(next: RemoteState): void {
+ if (this.state.enabled === next.enabled && this.state.connected === next.connected) return
+ this.state = next
+ this.sync()
+ for (const cb of this.listeners) cb(next)
+ }
+
+ /** Sync status bar appearance to current state. */
+ private sync(): void {
+ if (!this.state.enabled) {
+ this.bar.hide()
+ return
+ }
+ if (this.state.connected) {
+ this.bar.text = "$(radio-tower) Kilo Remote"
+ this.bar.tooltip = t("remote.connected")
+ this.bar.color = new vscode.ThemeColor("testing.iconPassed")
+ } else {
+ this.bar.text = "$(radio-tower) Kilo Remote \u2026"
+ this.bar.tooltip = t("remote.connecting")
+ this.bar.color = new vscode.ThemeColor("editorWarning.foreground")
+ }
+ this.bar.show()
+ }
+}
diff --git a/packages/kilo-vscode/src/services/autocomplete/chat-autocomplete/ChatTextAreaAutocomplete.ts b/packages/kilo-vscode/src/services/autocomplete/chat-autocomplete/ChatTextAreaAutocomplete.ts
index 690f0e1261a..bb4e52f000d 100644
--- a/packages/kilo-vscode/src/services/autocomplete/chat-autocomplete/ChatTextAreaAutocomplete.ts
+++ b/packages/kilo-vscode/src/services/autocomplete/chat-autocomplete/ChatTextAreaAutocomplete.ts
@@ -1,15 +1,24 @@
import * as vscode from "vscode"
import { AutocompleteModel } from "../AutocompleteModel"
-import { AutocompleteContext, VisibleCodeContext } from "../types"
+import type { AutocompleteContext, VisibleCodeContext } from "../types"
import { removePrefixOverlap } from "../continuedev/core/autocomplete/postprocessing/removePrefixOverlap.js"
import { AutocompleteTelemetry } from "../classic-auto-complete/AutocompleteTelemetry"
import { postprocessAutocompleteSuggestion } from "../classic-auto-complete/uselessSuggestionFilter"
import { VisibleCodeTracker } from "../context/VisibleCodeTracker"
import { FileIgnoreController } from "../shims/FileIgnoreController"
import type { KiloConnectionService } from "../../cli-backend"
-import type { ChatCompletionRequestMessage, ChatCompletionResponseSender } from "./handleChatCompletionRequest"
import { finalizeChatSuggestion, buildChatPrefix } from "./chat-autocomplete-utils"
+interface ChatCompletionRequestMessage {
+ type: "requestChatCompletion"
+ text: string
+ requestId: string
+}
+
+interface ChatCompletionResponseSender {
+ postMessage(message: { type: "chatCompletionResult"; text: string; requestId: string }): void
+}
+
/**
* Chat textarea autocomplete with cached per-request objects.
*
diff --git a/packages/kilo-vscode/src/services/autocomplete/chat-autocomplete/handleChatCompletionAccepted.ts b/packages/kilo-vscode/src/services/autocomplete/chat-autocomplete/handleChatCompletionAccepted.ts
deleted file mode 100644
index 9bb9a153bd1..00000000000
--- a/packages/kilo-vscode/src/services/autocomplete/chat-autocomplete/handleChatCompletionAccepted.ts
+++ /dev/null
@@ -1,29 +0,0 @@
-import { AutocompleteTelemetry } from "../classic-auto-complete/AutocompleteTelemetry"
-
-export interface ChatCompletionAcceptedMessage {
- type: "chatCompletionAccepted"
- suggestionLength?: number
-}
-
-// Singleton telemetry instance for chat-textarea autocomplete
-// This ensures we use the same instance across requests and acceptance events
-let telemetryInstance: AutocompleteTelemetry | null = null
-
-/**
- * Get or create the telemetry instance for chat-textarea autocomplete
- */
-export function getChatAutocompleteTelemetry(): AutocompleteTelemetry {
- if (!telemetryInstance) {
- telemetryInstance = new AutocompleteTelemetry("chat-textarea")
- }
- return telemetryInstance
-}
-
-/**
- * Handles a chat completion accepted event from the webview.
- * Captures telemetry when the user accepts a suggestion via Tab or ArrowRight.
- */
-export function handleChatCompletionAccepted(message: ChatCompletionAcceptedMessage): void {
- const telemetry = getChatAutocompleteTelemetry()
- telemetry.captureAcceptSuggestion(message.suggestionLength)
-}
diff --git a/packages/kilo-vscode/src/services/autocomplete/chat-autocomplete/handleChatCompletionRequest.ts b/packages/kilo-vscode/src/services/autocomplete/chat-autocomplete/handleChatCompletionRequest.ts
deleted file mode 100644
index eeac049683e..00000000000
--- a/packages/kilo-vscode/src/services/autocomplete/chat-autocomplete/handleChatCompletionRequest.ts
+++ /dev/null
@@ -1,43 +0,0 @@
-import * as vscode from "vscode"
-import { VisibleCodeTracker } from "../context/VisibleCodeTracker"
-import { FileIgnoreController } from "../shims/FileIgnoreController"
-import { ChatTextAreaAutocomplete } from "./ChatTextAreaAutocomplete"
-import type { KiloConnectionService } from "../../cli-backend"
-
-export interface ChatCompletionRequestMessage {
- type: "requestChatCompletion"
- text?: string
- requestId?: string
-}
-
-export interface ChatCompletionResponseSender {
- postMessage(message: { type: "chatCompletionResult"; text: string; requestId: string }): void
-}
-
-/**
- * Handles a chat completion request from the webview.
- * Captures visible code context and generates an autocomplete suggestion.
- */
-export async function handleChatCompletionRequest(
- message: ChatCompletionRequestMessage,
- responseSender: ChatCompletionResponseSender,
- connectionService: KiloConnectionService,
-): Promise {
- const userText = message.text || ""
- const requestId = message.requestId || ""
-
- const workspacePath = vscode.workspace.workspaceFolders?.[0]?.uri.fsPath ?? ""
-
- const ignoreController = new FileIgnoreController(workspacePath)
- await ignoreController.initialize()
-
- const tracker = new VisibleCodeTracker(workspacePath, ignoreController)
- const visibleContext = await tracker.captureVisibleCode()
-
- const autocomplete = new ChatTextAreaAutocomplete(connectionService)
- const { suggestion } = await autocomplete.getCompletion(userText, visibleContext)
-
- responseSender.postMessage({ type: "chatCompletionResult", text: suggestion, requestId })
-
- ignoreController.dispose()
-}
diff --git a/packages/kilo-vscode/src/services/autocomplete/continuedev/API_REFERENCE.md b/packages/kilo-vscode/src/services/autocomplete/continuedev/API_REFERENCE.md
deleted file mode 100644
index 216538b0c7f..00000000000
--- a/packages/kilo-vscode/src/services/autocomplete/continuedev/API_REFERENCE.md
+++ /dev/null
@@ -1,807 +0,0 @@
-# API Reference
-
-Complete API documentation for the Autocomplete & NextEdit library.
-
-## Table of Contents
-
-- [CompletionProvider](#completionprovider)
-- [NextEditProvider](#nexteditprovider)
-- [MinimalConfigProvider](#minimalconfigprovider)
-- [Core Interfaces](#core-interfaces)
-- [LLM Adapters](#llm-adapters)
-- [Types and Interfaces](#types-and-interfaces)
-
----
-
-## CompletionProvider
-
-The main class for providing AI-powered code autocompletion.
-
-**Location**: [`core/autocomplete/CompletionProvider.ts`](core/autocomplete/CompletionProvider.ts)
-
-### Constructor
-
-```typescript
-constructor(
- configHandler: MinimalConfigProvider,
- ide: IDE,
- _injectedGetLlm: () => Promise,
- _onError: (e: any) => void,
- getDefinitionsFromLsp: GetLspDefinitionsFunction
-)
-```
-
-**Parameters**:
-
-- `configHandler`: Configuration provider for autocomplete options
-- `ide`: IDE interface implementation for file I/O and editor operations
-- `_injectedGetLlm`: Async function that returns the LLM to use for completions
-- `_onError`: Error callback function for handling autocomplete errors
-- `getDefinitionsFromLsp`: Function to retrieve LSP definitions for enhanced context
-
-### Methods
-
-#### `provideInlineCompletionItems()`
-
-Generates an autocomplete completion for the given input.
-
-```typescript
-async provideInlineCompletionItems(
- input: AutocompleteInput,
- token: AbortSignal | undefined,
- force?: boolean
-): Promise
-```
-
-**Parameters**:
-
-- `input`: Autocomplete context including file path, cursor position, recent edits
-- `token`: AbortSignal to cancel the request
-- `force`: If true, bypasses debouncing
-
-**Returns**: `AutocompleteOutcome` containing the completion text and metadata, or `undefined` if no completion
-
-**Example**:
-
-```typescript
-const outcome = await completionProvider.provideInlineCompletionItems(
- {
- filepath: "/path/to/file.ts",
- pos: { line: 10, character: 5 },
- completionId: "unique-completion-id",
- recentlyEditedRanges: [],
- recentlyEditedFiles: new Map(),
- clipboardText: "",
- },
- abortController.signal,
-)
-```
-
-#### `accept()`
-
-Marks a completion as accepted by the user.
-
-```typescript
-accept(completionId: string): void
-```
-
-**Parameters**:
-
-- `completionId`: Unique identifier for the accepted completion
-
-**Side Effects**: Updates bracket matching service and completion cache
-
-#### `markDisplayed()`
-
-Marks a completion as having been displayed to the user.
-
-```typescript
-markDisplayed(completionId: string, outcome: AutocompleteOutcome): void
-```
-
-**Parameters**:
-
-- `completionId`: Unique identifier for the completion
-- `outcome`: The autocomplete outcome that was displayed
-
-#### `cancel()`
-
-Cancels any in-progress autocomplete requests.
-
-```typescript
-cancel(): void
-```
-
-### Configuration Options
-
-See [`MinimalConfigProvider`](#minimalconfigprovider) for configuration options.
-
----
-
-## NextEditProvider
-
-The main class for providing predictive multi-location code edits.
-
-**Location**: [`core/nextEdit/NextEditProvider.ts`](core/nextEdit/NextEditProvider.ts)
-
-### Constructor
-
-```typescript
-constructor(
- configHandler: MinimalConfigProvider,
- ide: IDE,
- _injectedGetLlm: () => Promise,
- _onError: (e: any) => void
-)
-```
-
-**Parameters**:
-
-- `configHandler`: Configuration provider
-- `ide`: IDE interface implementation
-- `_injectedGetLlm`: Function returning the LLM for edit predictions
-- `_onError`: Error callback
-
-### Methods
-
-#### `getNextEditPrediction()`
-
-Generates predicted edits based on context and recent changes.
-
-```typescript
-async getNextEditPrediction(
- context: ModelSpecificContext,
- signal?: AbortSignal,
- usingFullFileDiff?: boolean
-): Promise
-```
-
-**Parameters**:
-
-- `context`: Context including file contents, cursor position, recent edits
-- `signal`: Optional AbortSignal to cancel the request
-- `usingFullFileDiff`: If true, generates full-file diffs; if false, only edits within a region
-
-**Returns**: `NextEditOutcome` containing predicted edits and final cursor position
-
-**Example**:
-
-```typescript
-const outcome = await nextEditProvider.getNextEditPrediction(
- {
- filepath: "/path/to/file.ts",
- pos: { line: 15, character: 0 },
- fileContents: currentFileContents,
- userEdits: recentDiff,
- // ... other context
- },
- abortController.signal,
- false, // Use partial file diff
-)
-
-if (outcome) {
- console.log("Edit regions:", outcome.editableRegions)
- console.log("Diff lines:", outcome.diffLines)
- console.log("New cursor:", outcome.finalCursorPosition)
-}
-```
-
----
-
-## MinimalConfigProvider
-
-Simple configuration provider that replaces the complex Continue config system.
-
-**Location**: [`core/autocomplete/MinimalConfig.ts`](core/autocomplete/MinimalConfig.ts)
-
-### Constructor
-
-```typescript
-constructor(config?: Partial)
-```
-
-**Parameters**:
-
-- `config`: Optional partial configuration to override defaults
-
-**Example**:
-
-```typescript
-const configProvider = new MinimalConfigProvider({
- tabAutocompleteOptions: {
- debounceDelay: 200,
- maxPromptTokens: 2048,
- prefixPercentage: 0.5,
- suffixPercentage: 0.3,
- useCache: true,
- onlyMyCode: false,
- },
- experimental: {
- enableStaticContextualization: true,
- },
-})
-```
-
-### Methods
-
-#### `loadConfig()`
-
-Returns the configuration object.
-
-```typescript
-async loadConfig(): Promise<{ config: MinimalConfig }>
-```
-
-**Returns**: Promise resolving to an object containing the config
-
-#### `getAutocompleteOptions()`
-
-Gets autocomplete-specific options.
-
-```typescript
-getAutocompleteOptions(): TabAutocompleteOptions
-```
-
-**Returns**: Autocomplete configuration options
-
-#### `isStaticContextualizationEnabled()`
-
-Checks if static contextualization is enabled.
-
-```typescript
-isStaticContextualizationEnabled(): boolean
-```
-
-**Returns**: True if enabled, false otherwise
-
-### Configuration Interface
-
-```typescript
-interface MinimalConfig {
- tabAutocompleteOptions?: TabAutocompleteOptions
- experimental?: {
- enableStaticContextualization?: boolean
- }
- modelsByRole?: {
- autocomplete?: ILLM[]
- }
- selectedModelByRole?: {
- autocomplete?: ILLM
- }
-}
-```
-
-### TabAutocompleteOptions
-
-```typescript
-interface TabAutocompleteOptions {
- debounceDelay?: number // Debounce delay in ms (default: 150)
- maxPromptTokens?: number // Max tokens for prompt (default: 1024)
- prefixPercentage?: number // Percentage of tokens for prefix (default: 0.5)
- suffixPercentage?: number // Percentage of tokens for suffix (default: 0.3)
- maxSuffixPercentage?: number // Max suffix tokens percentage (default: 0.5)
- useCache?: boolean // Enable completion caching (default: true)
- onlyMyCode?: boolean // Only use workspace files for context (default: false)
- template?: string // Custom prompt template
- useFileSuffix?: boolean // Include file suffix in context (default: true)
- multilineCompletions?: "always" | "never" | "auto" // Multiline behavior (default: 'auto')
- slidingWindowPrefixPercentage?: number // Sliding window prefix % (default: 0.75)
- slidingWindowSize?: number // Sliding window size (default: 500)
- maxSnippetPercentage?: number // Max tokens for snippets (default: 0.6)
- recentlyEditedSimilarityThreshold?: number // Similarity threshold (default: 0.3)
- useOtherFiles?: boolean // Use other files for context (default: true)
- disableInFiles?: string[] // Glob patterns to disable autocomplete
- stopTokens?: string[] // Custom stop tokens
- tokensPerCompletion?: number // Tokens per completion (default: 256)
- transform?: boolean // Apply post-processing transforms (default: true)
-}
-```
-
----
-
-## Core Interfaces
-
-### IDE Interface
-
-The IDE interface abstracts editor operations. Implement this to integrate with your editor.
-
-**Location**: [`core/index.d.ts`](core/index.d.ts)
-
-```typescript
-interface IDE {
- // File Operations
- readFile(filepath: string): Promise
- writeFile(filepath: string, contents: string): Promise
-
- // Workspace
- getWorkspaceDirs(): Promise
- listWorkspaceContents(directory?: string): Promise
-
- // Editor State
- getCurrentFile(): Promise
- getCursorPosition(): Promise
- getVisibleFiles(): Promise
-
- // Code Navigation
- getDefinition(filepath: string, position: Position): Promise
- getReferences(filepath: string, position: Position): Promise
- getSymbols(filepath: string): Promise
-
- // File Information
- readRangeInFile(filepath: string, range: Range): Promise
- getStats(filepath: string): Promise
-
- // Edits
- applyEdits(edits: FileEdit[]): Promise
-
- // Diff/SCM
- getDiff(includeUnstaged: boolean): Promise
- getRepoName(dir: string): Promise
- getBranch(dir: string): Promise
-
- // UI
- showMessage(message: string, severity?: "info" | "warning" | "error"): Promise
- showToast(type: "info" | "warning" | "error", message: string, ...actions: string[]): Promise
-
- // Terminal
- runCommand(command: string, options?: TerminalOptions): Promise
-
- // Clipboard
- getClipboardContent(): Promise<{ text: string; copiedAt: number } | undefined>
-
- // Search
- getSearchResults(query: string): Promise
- subprocess(command: string, cwd?: string): Promise<[string, string]>
-
- // Other
- getIdeInfo(): Promise
- getIdeSettings(): Promise
- isTelemetryEnabled(): Promise
- getUniqueId(): Promise
-}
-```
-
-**Key Methods to Implement**:
-
-- `readFile()`, `writeFile()`: Essential for file I/O
-- `getWorkspaceDirs()`: Returns workspace root directories
-- `getCurrentFile()`, `getCursorPosition()`: Current editor state
-- `applyEdits()`: Apply code changes
-- `getDefinition()`: LSP-like functionality for context gathering
-
-### ILLM Interface
-
-The ILLM (Language Model) interface abstracts LLM providers.
-
-**Location**: [`core/index.d.ts`](core/index.d.ts)
-
-```typescript
-interface ILLM {
- // Required properties
- uniqueId: string
- model: string
- contextLength: number
- completionOptions: CompletionOptions
-
- // Provider info
- get providerName(): string
- get underlyingProviderName(): string
-
- // Optional
- apiKey?: string
- apiBase?: string
- autocompleteOptions?: Partial
- promptTemplates?: PromptTemplates
-
- // Completion methods
- complete(prompt: string, signal: AbortSignal, options?: LLMFullCompletionOptions): Promise
-
- streamComplete(
- prompt: string,
- signal: AbortSignal,
- options?: LLMFullCompletionOptions,
- ): AsyncGenerator
-
- streamFim(
- prefix: string,
- suffix: string,
- signal: AbortSignal,
- options?: LLMFullCompletionOptions,
- ): AsyncGenerator
-
- // Chat methods
- chat(messages: ChatMessage[], signal: AbortSignal, options?: LLMFullCompletionOptions): Promise
-
- streamChat(
- messages: ChatMessage[],
- signal: AbortSignal,
- options?: LLMFullCompletionOptions,
- ): AsyncGenerator
-
- // Utility methods
- countTokens(text: string): number
- supportsImages(): boolean
- supportsCompletions(): boolean
- supportsFim(): boolean
- listModels(): Promise
-}
-```
-
----
-
-## LLM Adapters
-
-### OpenAI
-
-Pre-built adapter for OpenAI and OpenAI-compatible APIs.
-
-**Location**: [`core/llm/llms/OpenAI.ts`](core/llm/llms/OpenAI.ts)
-
-```typescript
-import OpenAI from "@continuedev/core/llm/llms/OpenAI"
-
-const llm = new OpenAI({
- model: "gpt-4",
- apiKey: process.env.OPENAI_API_KEY,
- apiBase: "https://api.openai.com/v1", // Optional custom base URL
- completionOptions: {
- temperature: 0.1,
- maxTokens: 1000,
- },
-})
-```
-
-**Constructor Options**:
-
-```typescript
-interface OpenAIOptions {
- model: string
- apiKey: string
- apiBase?: string
- completionOptions?: CompletionOptions
- contextLength?: number
- autocompleteOptions?: Partial
-}
-```
-
-### Creating Custom LLM Adapters
-
-To create a custom LLM adapter, implement the `ILLM` interface:
-
-```typescript
-import { ILLM, CompletionOptions } from "@continuedev/core"
-
-class CustomLLM implements ILLM {
- uniqueId = "custom-llm"
- model: string
- contextLength: number
- completionOptions: CompletionOptions
-
- get providerName() {
- return "custom"
- }
- get underlyingProviderName() {
- return "custom"
- }
-
- constructor(options: { model: string }) {
- this.model = options.model
- this.contextLength = 4096
- this.completionOptions = {
- model: options.model,
- temperature: 0.1,
- }
- }
-
- async complete(prompt: string, signal: AbortSignal): Promise {
- // Call your LLM API
- const response = await fetch("your-api-endpoint", {
- method: "POST",
- body: JSON.stringify({ prompt }),
- signal,
- })
- return await response.text()
- }
-
- async *streamComplete(prompt: string, signal: AbortSignal) {
- // Stream from your LLM API
- for await (const chunk of streamFromAPI(prompt, signal)) {
- yield chunk
- }
- return { modelTitle: this.model, prompt, completion: "" }
- }
-
- // Implement other required methods...
- countTokens(text: string): number {
- return text.length / 4 // Rough estimate
- }
-
- supportsImages() {
- return false
- }
- supportsCompletions() {
- return true
- }
- supportsFim() {
- return false
- }
-
- // ... other methods
-}
-```
-
----
-
-## Types and Interfaces
-
-### AutocompleteInput
-
-Input for autocomplete requests.
-
-```typescript
-interface AutocompleteInput {
- filepath: string // Path to the file being edited
- pos: Position // Cursor position
- completionId: string // Unique ID for this completion request
- recentlyEditedRanges: Range[] // Recently edited ranges in this file
- recentlyEditedFiles: Map // Recently edited files
- clipboardText: string // Current clipboard content
- manuallyPassFileContext?: RangeInFile[] // Manually provided context
-}
-```
-
-### AutocompleteOutcome
-
-Result of an autocomplete request.
-
-```typescript
-interface AutocompleteOutcome {
- completion: string // The completion text
- completionId: string // Unique ID for this completion
- filepath: string // File path
- prefix: string // Code prefix (before cursor)
- suffix: string // Code suffix (after cursor)
- prompt: string // Full prompt sent to LLM
- modelTitle: string // Model used
- modelProvider: string // Provider used
- completionOptions: CompletionOptions // Options used
- cacheHit: boolean // Whether cached
- latency: number // Response latency in ms
-}
-```
-
-### NextEditOutcome
-
-Result of a NextEdit prediction.
-
-```typescript
-interface NextEditOutcome {
- edits: string // The predicted edit text
- diffLines: DiffLine[] // Diff representation
- editableRegions: Range[] // Regions that were edited
- finalCursorPosition: Position // Predicted cursor position after edits
- filepath: string // File path
- prompt: string // Prompt sent to LLM
- modelTitle: string // Model used
- latency: number // Response latency in ms
-}
-```
-
-### Position
-
-Position in a text document.
-
-```typescript
-interface Position {
- line: number // 0-based line number
- character: number // 0-based character offset
-}
-```
-
-### Range
-
-Range in a text document.
-
-```typescript
-interface Range {
- start: Position // Start position (inclusive)
- end: Position // End position (exclusive)
-}
-```
-
-### RangeInFile
-
-Range in a specific file.
-
-```typescript
-interface RangeInFile {
- filepath: string // File path
- range: Range // Range within the file
-}
-```
-
-### DiffLine
-
-A single line in a diff.
-
-```typescript
-interface DiffLine {
- type: "same" | "new" | "old" // Type of change
- line: string // Line content
- lineNumber: number // Line number in file
-}
-```
-
-### FileEdit
-
-An edit to apply to a file.
-
-```typescript
-interface FileEdit {
- filepath: string // File to edit
- range: Range // Range to replace
- replacement: string // New content
-}
-```
-
----
-
-## Usage Examples
-
-### Complete Example: Autocomplete with Custom IDE
-
-```typescript
-import { CompletionProvider, MinimalConfigProvider } from "@continuedev/core/autocomplete"
-import { IDE, ILLM, Position } from "@continuedev/core"
-import OpenAI from "@continuedev/core/llm/llms/OpenAI"
-
-// 1. Implement IDE interface
-class MyIDE implements IDE {
- async readFile(filepath: string): Promise {
- return fs.readFileSync(filepath, "utf-8")
- }
-
- async getWorkspaceDirs(): Promise {
- return ["/path/to/workspace"]
- }
-
- async getCurrentFile() {
- return {
- filepath: this.currentFilePath,
- contents: await this.readFile(this.currentFilePath),
- }
- }
-
- async getCursorPosition(): Promise {
- return this.cursorPosition
- }
-
- // ... implement other methods
-}
-
-// 2. Set up configuration
-const config = new MinimalConfigProvider({
- tabAutocompleteOptions: {
- debounceDelay: 150,
- maxPromptTokens: 1024,
- useCache: true,
- },
-})
-
-// 3. Set up LLM
-const getLlm = async (): Promise => {
- return new OpenAI({
- apiKey: process.env.OPENAI_API_KEY,
- model: "gpt-4",
- })
-}
-
-// 4. Create completion provider
-const ide = new MyIDE()
-const provider = new CompletionProvider(
- config,
- ide,
- getLlm,
- (error) => console.error(error),
- async () => [], // LSP definitions function
-)
-
-// 5. Request completion
-const outcome = await provider.provideInlineCompletionItems(
- {
- filepath: "/path/to/file.ts",
- pos: { line: 10, character: 5 },
- completionId: "completion-1",
- recentlyEditedRanges: [],
- recentlyEditedFiles: new Map(),
- clipboardText: "",
- },
- new AbortController().signal,
-)
-
-if (outcome) {
- console.log("Completion:", outcome.completion)
- provider.markDisplayed("completion-1", outcome)
-}
-```
-
----
-
-## Error Handling
-
-Both `CompletionProvider` and `NextEditProvider` accept an error callback:
-
-```typescript
-const onError = (error: any) => {
- if (error instanceof Error) {
- console.error("Error:", error.message)
- // Show user notification
- showNotification(error.message)
- }
-}
-
-const provider = new CompletionProvider(
- config,
- ide,
- getLlm,
- onError, // Error callback
- getLspDefinitions,
-)
-```
-
-Common errors:
-
-- **LLM API errors**: Network failures, invalid API keys, rate limits
-- **File I/O errors**: Missing files, permission errors
-- **Timeout errors**: Long-running requests that are aborted
-
----
-
-## Performance Considerations
-
-### Caching
-
-Completions are automatically cached using an LRU cache. Configure caching:
-
-```typescript
-const config = new MinimalConfigProvider({
- tabAutocompleteOptions: {
- useCache: true, // Enable caching (default)
- },
-})
-```
-
-### Debouncing
-
-Prevent excessive LLM calls during rapid typing:
-
-```typescript
-const config = new MinimalConfigProvider({
- tabAutocompleteOptions: {
- debounceDelay: 150, // Wait 150ms before requesting (default)
- },
-})
-```
-
-### Abort Signals
-
-Always provide AbortSignals to cancel in-progress requests:
-
-```typescript
-const controller = new AbortController()
-
-// Start request
-const promise = provider.provideInlineCompletionItems(input, controller.signal)
-
-// Cancel if needed
-controller.abort()
-```
-
----
-
-## See Also
-
-- [README.md](README.md) - Project overview and quick start
-- [ARCHITECTURE.md](ARCHITECTURE.md) - Technical architecture details
-- [EXAMPLES.md](EXAMPLES.md) - More usage examples
-- [Core TypeScript Definitions](core/index.d.ts) - Full type definitions
diff --git a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/CompletionProvider.ts b/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/CompletionProvider.ts
deleted file mode 100644
index 8871fc5e0fb..00000000000
--- a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/CompletionProvider.ts
+++ /dev/null
@@ -1,272 +0,0 @@
-import { MinimalConfigProvider } from "./MinimalConfig.js"
-import { IDE, ILLM } from "../index.js"
-import { DEFAULT_AUTOCOMPLETE_OPTS } from "../util/parameters.js"
-import { shouldCompleteMultiline } from "./classification/shouldCompleteMultiline.js"
-import { ContextRetrievalService } from "./context/ContextRetrievalService.js"
-import { isSecurityConcern } from "../indexing/ignore.js"
-import { BracketMatchingService } from "./filtering/BracketMatchingService.js"
-import { CompletionStreamer } from "./generation/CompletionStreamer.js"
-import { postprocessCompletion } from "./postprocessing/index.js"
-import { shouldPrefilter } from "./prefiltering/index.js"
-import { getAllSnippetsWithoutRace } from "./snippets/index.js"
-import { renderPromptWithTokenLimit } from "./templating/index.js"
-import { GetLspDefinitionsFunction } from "./types.js"
-import { AutocompleteDebouncer } from "./util/AutocompleteDebouncer.js"
-import { AutocompleteLoggingService } from "./util/AutocompleteLoggingService.js"
-import { AutocompleteLruCacheInMem } from "./util/AutocompleteLruCacheInMem.js"
-import { HelperVars } from "./util/HelperVars.js"
-import { AutocompleteInput, AutocompleteOutcome } from "./util/types.js"
-
-// Errors that can be expected on occasion even during normal functioning should not be shown.
-// Not worth disrupting the user to tell them that a single autocomplete request didn't go through
-const ERRORS_TO_IGNORE = [
- // From Ollama
- "unexpected server status",
- "operation was aborted",
-]
-
-export class CompletionProvider {
- private autocompleteCache = AutocompleteLruCacheInMem.get()
- public errorsShown: Set = new Set()
- private bracketMatchingService = new BracketMatchingService()
- private debouncer = new AutocompleteDebouncer()
- private completionStreamer: CompletionStreamer
- private loggingService = new AutocompleteLoggingService()
- private contextRetrievalService: ContextRetrievalService
-
- constructor(
- private readonly configHandler: MinimalConfigProvider,
- private readonly ide: IDE,
- private readonly _injectedGetLlm: () => Promise,
- private readonly _onError: (e: unknown) => void,
- private readonly getDefinitionsFromLsp: GetLspDefinitionsFunction,
- ) {
- this.completionStreamer = new CompletionStreamer(this.onError.bind(this))
- this.contextRetrievalService = new ContextRetrievalService(this.ide)
- }
-
- private async _prepareLlm(): Promise {
- const llm = await this._injectedGetLlm()
-
- if (!llm) {
- return undefined
- }
-
- // Temporary fix for JetBrains autocomplete bug as described in https://github.com/continuedev/continue/pull/3022
- if (llm.model === undefined && llm.completionOptions?.model !== undefined) {
- llm.model = llm.completionOptions.model
- }
-
- // Ignore empty API keys for Mistral since we currently write
- // a template provider without one during onboarding
- if (llm.providerName === "mistral" && llm.apiKey === "") {
- return undefined
- }
-
- // Set temperature (but don't override)
- if (llm.completionOptions.temperature === undefined) {
- llm.completionOptions.temperature = 0.01
- }
-
- return llm
- }
-
- private onError(e: unknown) {
- if (
- ERRORS_TO_IGNORE.some((err) => (typeof e === "string" ? e.includes(err) : (e as Error)?.message?.includes(err)))
- ) {
- return
- }
-
- console.warn("Error generating autocompletion: ", e)
- const errorMessage = e instanceof Error ? e.message : String(e)
- if (!this.errorsShown.has(errorMessage)) {
- this.errorsShown.add(errorMessage)
- this._onError(e)
- }
- }
-
- public cancel() {
- this.loggingService.cancel()
- }
-
- public accept(completionId: string) {
- const outcome = this.loggingService.accept(completionId)
- if (!outcome) {
- return
- }
- this.bracketMatchingService.handleAcceptedCompletion(outcome.completion, outcome.filepath)
- }
-
- public markDisplayed(completionId: string, outcome: AutocompleteOutcome) {
- this.loggingService.markDisplayed(completionId, outcome)
- }
-
- private async _getAutocompleteOptions(llm: ILLM) {
- const { config } = await this.configHandler.loadConfig()
- const options = {
- ...DEFAULT_AUTOCOMPLETE_OPTS,
- ...config?.tabAutocompleteOptions,
- ...llm.autocompleteOptions,
- }
-
- // Enable static contextualization if defined.
- if (config?.experimental?.enableStaticContextualization) {
- options.experimental_enableStaticContextualization = false
- }
-
- return options
- }
-
- public async provideInlineCompletionItems(
- input: AutocompleteInput,
- token: AbortSignal | undefined,
- force?: boolean,
- ): Promise {
- try {
- // Create abort signal if not given
- if (!token) {
- const controller = this.loggingService.createAbortController(input.completionId)
- token = controller.signal
- }
- const startTime = Date.now()
-
- const llm = await this._prepareLlm()
- if (!llm) {
- return undefined
- }
-
- if (isSecurityConcern(input.filepath)) {
- return undefined
- }
-
- const options = await this._getAutocompleteOptions(llm)
-
- // Debounce
- if (!force) {
- if (await this.debouncer.delayAndShouldDebounce(options.debounceDelay)) {
- return undefined
- }
- }
-
- const helper = await HelperVars.create(input, options, llm.model, this.ide)
-
- if (await shouldPrefilter(helper, await this.ide.getWorkspaceDirs())) {
- return undefined
- }
-
- const [snippetPayload, workspaceDirs] = await Promise.all([
- getAllSnippetsWithoutRace({
- helper,
- ide: this.ide,
- getDefinitionsFromLsp: this.getDefinitionsFromLsp,
- contextRetrievalService: this.contextRetrievalService,
- }),
- this.ide.getWorkspaceDirs(),
- ])
-
- const { prompt, prefix, suffix, completionOptions } = renderPromptWithTokenLimit({
- snippetPayload,
- workspaceDirs,
- helper,
- llm,
- })
-
- // Completion
- let completion: string | undefined = ""
-
- const cache = await this.autocompleteCache
- const cachedCompletion = helper.options.useCache ? await cache.get(helper.prunedPrefix) : undefined
- let cacheHit = false
- if (cachedCompletion) {
- // Cache
- cacheHit = true
- completion = cachedCompletion
- } else {
- const multiline = !helper.options.transform || shouldCompleteMultiline(helper)
-
- const completionStream = this.completionStreamer.streamCompletionWithFilters(
- token,
- llm,
- prefix,
- suffix,
- prompt,
- multiline,
- completionOptions,
- helper,
- )
-
- for await (const update of completionStream) {
- completion += update
- }
-
- // Don't postprocess if aborted
- if (token.aborted) {
- return undefined
- }
-
- const processedCompletion = helper.options.transform
- ? postprocessCompletion({
- completion,
- prefix: helper.prunedPrefix,
- suffix: helper.prunedSuffix,
- llm,
- })
- : completion
-
- completion = processedCompletion
- }
-
- if (!completion) {
- return undefined
- }
-
- const outcome: AutocompleteOutcome = {
- time: Date.now() - startTime,
- completion,
- prefix,
- suffix,
- prompt,
- modelProvider: llm.underlyingProviderName,
- modelName: llm.model,
- completionOptions,
- cacheHit,
- filepath: helper.filepath,
- numLines: completion.split("\n").length,
- completionId: helper.input.completionId,
- gitRepo: "fake-placeholder", //MINIMAL_REPO - came from git
- uniqueId: await this.ide.getUniqueId(),
- timestamp: new Date().toISOString(),
- profileType: this.configHandler.currentProfile?.profileDescription.profileType,
- ...helper.options,
- }
-
- if (options.experimental_enableStaticContextualization) {
- outcome.enabledStaticContextualization = true
- }
-
- //////////
- // Save to cache
- if (!outcome.cacheHit && helper.options.useCache) {
- ;(await this.autocompleteCache)
- .put(outcome.prefix, outcome.completion)
- .catch((e) => console.warn(`Failed to save to cache: ${e.message}`))
- }
-
- // When using the JetBrains extension, Mark as displayed
- const ideType = (await this.ide.getIdeInfo()).ideType
- if (ideType === "jetbrains") {
- this.markDisplayed(input.completionId, outcome)
- }
-
- return outcome
- } catch (e: unknown) {
- this.onError(e)
- return undefined
- } finally {
- this.loggingService.deleteAbortController(input.completionId)
- }
- }
-}
-
-export default CompletionProvider
diff --git a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/MinimalConfig.ts b/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/MinimalConfig.ts
deleted file mode 100644
index c834949ff15..00000000000
--- a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/MinimalConfig.ts
+++ /dev/null
@@ -1,126 +0,0 @@
-/**
- * Minimal configuration for autocomplete features.
- * This replaces the complex ConfigHandler system with simple hardcoded defaults.
- *
- * Analysis of ConfigHandler usage:
- * - CompletionProvider needs: config.tabAutocompleteOptions, config.experimental.enableStaticContextualization, currentProfile.profileType
- *
- * The profileType is only used for logging/telemetry, so we can set it to undefined for a minimal extraction.
- */
-
-import { ILLM, TabAutocompleteOptions } from "../index.js"
-import { DEFAULT_AUTOCOMPLETE_OPTS } from "../util/parameters.js"
-
-interface MinimalConfig {
- tabAutocompleteOptions?: TabAutocompleteOptions
- experimental?: {
- enableStaticContextualization?: boolean
- }
- // Minimal model selection support for NextEdit context fetching
- modelsByRole?: {
- autocomplete?: ILLM[]
- }
- selectedModelByRole?: {
- autocomplete?: ILLM
- edit?: ILLM
- chat?: ILLM
- rerank?: ILLM
- }
- rules?: unknown[]
-}
-
-interface MinimalProfile {
- profileDescription: {
- profileType?: "control-plane" | "local" | "platform"
- }
-}
-
-/**
- * Default configuration with hardcoded values suitable for autocomplete/NextEdit.
- * Uses the same defaults from DEFAULT_AUTOCOMPLETE_OPTS.
- */
-const DEFAULT_MINIMAL_CONFIG: MinimalConfig = {
- tabAutocompleteOptions: {
- ...DEFAULT_AUTOCOMPLETE_OPTS,
- },
- experimental: {
- enableStaticContextualization: false,
- },
- modelsByRole: {
- autocomplete: [],
- },
- selectedModelByRole: {
- autocomplete: undefined,
- },
-}
-
-/**
- * Simple config provider that replaces ConfigHandler for autocomplete/NextEdit.
- * Returns hardcoded configuration without dependencies on control-plane.
- */
-export class MinimalConfigProvider {
- private config: MinimalConfig
- public currentProfile: MinimalProfile | undefined
-
- constructor(config?: Partial) {
- this.config = {
- ...DEFAULT_MINIMAL_CONFIG,
- ...config,
- tabAutocompleteOptions: {
- ...DEFAULT_AUTOCOMPLETE_OPTS,
- ...config?.tabAutocompleteOptions,
- } as TabAutocompleteOptions,
- experimental: {
- ...DEFAULT_MINIMAL_CONFIG.experimental,
- ...config?.experimental,
- },
- }
-
- // Set a minimal profile for logging purposes
- // In a minimal extraction, we don't have a control-plane profile
- this.currentProfile = undefined
- }
-
- /**
- * Returns the config in the same shape as ConfigHandler.loadConfig()
- * This maintains API compatibility with existing code.
- */
- async loadConfig(): Promise<{ config: MinimalConfig }> {
- return { config: this.config }
- }
-
- /**
- * Get autocomplete options directly
- */
- getAutocompleteOptions(): TabAutocompleteOptions {
- return this.config.tabAutocompleteOptions || DEFAULT_AUTOCOMPLETE_OPTS
- }
-
- /**
- * Check if static contextualization is enabled
- */
- isStaticContextualizationEnabled(): boolean {
- return this.config.experimental?.enableStaticContextualization ?? false
- }
-
- /**
- * Reload config (stub for compatibility)
- */
- async reloadConfig(..._args: unknown[]): Promise {
- // No-op for minimal config
- }
-
- /**
- * Register config update handler (stub for compatibility)
- */
- onConfigUpdate(_handler: (event: { config: MinimalConfig; configLoadInterrupted: boolean }) => void): void {
- // No-op for minimal config
- }
-
- /**
- * Register custom context provider (stub for compatibility)
- */
- registerCustomContextProvider(_provider: unknown): void {
- // No-op for minimal config
- }
-}
diff --git a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/classification/shouldCompleteMultiline.ts b/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/classification/shouldCompleteMultiline.ts
deleted file mode 100644
index e24b7008402..00000000000
--- a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/classification/shouldCompleteMultiline.ts
+++ /dev/null
@@ -1,37 +0,0 @@
-import { AutocompleteLanguageInfo } from "../constants/AutocompleteLanguageInfo"
-import { HelperVars } from "../util/HelperVars"
-
-function shouldCompleteMultilineBasedOnLanguage(language: AutocompleteLanguageInfo, prefix: string, suffix: string) {
- return language.useMultiline?.({ prefix, suffix }) ?? true
-}
-
-export function shouldCompleteMultiline(helper: HelperVars) {
- switch (helper.options.multilineCompletions) {
- case "always":
- return true
- case "never":
- return false
- default:
- break
- }
-
- // Always single-line if an intellisense option is selected
- if (helper.input.selectedCompletionInfo) {
- return true
- }
-
- // // Don't complete multi-line if you are mid-line
- // if (isMidlineCompletion(helper.fullPrefix, helper.fullSuffix)) {
- // return false;
- // }
-
- // Don't complete multi-line for single-line comments
- if (
- helper.lang.singleLineComment &&
- helper.fullPrefix.split("\n").slice(-1)[0]?.trimStart().startsWith(helper.lang.singleLineComment)
- ) {
- return false
- }
-
- return shouldCompleteMultilineBasedOnLanguage(helper.lang, helper.prunedPrefix, helper.prunedSuffix)
-}
diff --git a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/context/root-path-context/__fixtures__/files/typescript/arrowFunctions.ts b/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/context/root-path-context/__fixtures__/files/typescript/arrowFunctions.ts
deleted file mode 100644
index cb853ef39b6..00000000000
--- a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/context/root-path-context/__fixtures__/files/typescript/arrowFunctions.ts
+++ /dev/null
@@ -1,29 +0,0 @@
-// @ts-nocheck
-
-const getAddress = (person: Person): Address => {
- // TODO
-}
-
-const logPerson = (person: Person) => {
- // TODO
-}
-
-const getHardcodedAddress = (): Address => {
- // TODO
-}
-
-const getAddresses = (people: Person[]): Address[] => {
- // TODO
-}
-
-const logPersonWithAddres = (person: Person): Person => {
- // TODO
-}
-
-const logPersonOrAddress = (person: Person | Address): Person | Address => {
- // TODO
-}
-
-const logPersonAndAddress = (person: Person, address: Address) => {
- // TODO
-}
diff --git a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/context/root-path-context/__fixtures__/files/typescript/classMethods.ts b/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/context/root-path-context/__fixtures__/files/typescript/classMethods.ts
deleted file mode 100644
index 08f7506a70e..00000000000
--- a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/context/root-path-context/__fixtures__/files/typescript/classMethods.ts
+++ /dev/null
@@ -1,35 +0,0 @@
-// @ts-nocheck
-
-class Group {
- getPersonAddress(person: Person): Address {
- // TODO
- }
-
- getHardcodedAddress(): Address {
- // TODO
- }
-
- addPerson(person: Person) {
- // TODO
- }
-
- addPeople(people: Person[]) {
- // TODO
- }
-
- getAddresses(people: Person[]): Address[] {
- // TODO
- }
-
- logPersonWithAddress(person: Person): Person {
- // TODO
- }
-
- logPersonOrAddress(person: Person | Address): Person | Address {
- // TODO
- }
-
- logPersonAndAddress(person: Person, address: Address) {
- // TODO
- }
-}
diff --git a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/context/root-path-context/__fixtures__/files/typescript/classes.ts b/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/context/root-path-context/__fixtures__/files/typescript/classes.ts
deleted file mode 100644
index 8bb8299868e..00000000000
--- a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/context/root-path-context/__fixtures__/files/typescript/classes.ts
+++ /dev/null
@@ -1,9 +0,0 @@
-// @ts-nocheck
-
-class Group extends BaseClass {}
-
-class Group implements FirstInterface {}
-
-class Group extends BaseClass implements FirstInterface, SecondInterface {}
-
-class Group extends BaseClass implements FirstInterface {}
diff --git a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/context/root-path-context/__fixtures__/files/typescript/functions.ts b/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/context/root-path-context/__fixtures__/files/typescript/functions.ts
deleted file mode 100644
index bb9d39c85d9..00000000000
--- a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/context/root-path-context/__fixtures__/files/typescript/functions.ts
+++ /dev/null
@@ -1,33 +0,0 @@
-// @ts-nocheck
-
-function getAddress(person: Person): Address {
- // TODO
-}
-
-function getFirstAddress(people: Person[]): Address {
- // TODO
-}
-
-function logPerson(person: Person) {
- // TODO
-}
-
-function getHardcodedAddress(): Address {
- // TODO
-}
-
-function getAddresses(people: Person[]): Address[] {
- // TODO
-}
-
-function logPersonWithAddress(person: Person): Person {
- // TODO
-}
-
-function logPersonOrAddress(person: Person | Address): Person | Address {
- // TODO
-}
-
-function logPersonAndAddress(person: Person, address: Address) {
- // TODO
-}
diff --git a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/context/root-path-context/__fixtures__/files/typescript/generators.ts b/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/context/root-path-context/__fixtures__/files/typescript/generators.ts
deleted file mode 100644
index 79811b47873..00000000000
--- a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/context/root-path-context/__fixtures__/files/typescript/generators.ts
+++ /dev/null
@@ -1,33 +0,0 @@
-// @ts-nocheck
-
-function* getAddress(person: Person): Address {
- // TODO
-}
-
-function* getFirstAddress(people: Person[]): Address {
- // TODO
-}
-
-function* logPerson(person: Person) {
- // TODO
-}
-
-function* getHardcodedAddress(): Address {
- // TODO
-}
-
-function* getAddresses(people: Person[]): Address[] {
- // TODO
-}
-
-function* logPersonWithAddress(person: Person): Person {
- // TODO
-}
-
-function* logPersonOrAddress(person: Person | Address): Person | Address {
- // TODO
-}
-
-function* logPersonAndAddress(person: Person, address: Address) {
- // TODO
-}
diff --git a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/context/root-path-context/__test-cases__/python.ts b/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/context/root-path-context/__test-cases__/python.ts
index 68a29efbfa1..cb1c48318c1 100644
--- a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/context/root-path-context/__test-cases__/python.ts
+++ b/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/context/root-path-context/__test-cases__/python.ts
@@ -1,98 +1,3 @@
-export const FUNCTIONS = [
- {
- nodeType: "function_definition with argument and return type",
- fileName: "python/functions.py",
- language: "Python",
- cursorPosition: { line: 15, character: 8 },
- definitionPositions: [
- { row: 14, column: 30 }, // Person
- { row: 14, column: 42 }, // Address
- ],
- },
- {
- nodeType: "function_definition with generic argument and generic return type",
- fileName: "python/functions.py",
- language: "Python",
- cursorPosition: { line: 18, character: 8 },
- definitionPositions: [
- { row: 17, column: 35 }, // Group
- { row: 17, column: 42 }, // Person
- { row: 17, column: 53 }, // Group
- { row: 17, column: 61 }, // Address
- ],
- },
- {
- nodeType: "function_definition with single argument and None return type",
- fileName: "python/functions.py",
- language: "Python",
- cursorPosition: { line: 21, character: 8 },
- definitionPositions: [
- { row: 20, column: 29 }, // Person
- ],
- },
- {
- nodeType: "function_definition with no arguments and single return type",
- fileName: "python/functions.py",
- language: "Python",
- cursorPosition: { line: 24, character: 8 },
- definitionPositions: [
- { row: 23, column: 38 }, // Address
- ],
- },
- {
- nodeType: "function_definition with Union arguments and Union return type",
- fileName: "python/functions.py",
- language: "Python",
- cursorPosition: { line: 27, character: 8 },
- definitionPositions: [
- { row: 26, column: 45 }, // Person
- { row: 26, column: 54 }, // Address
- { row: 26, column: 72 }, // Person
- { row: 26, column: 81 }, // Address
- ],
- },
- {
- nodeType: "function_definition with multiple arguments and None return type",
- fileName: "python/functions.py",
- language: "Python",
- cursorPosition: { line: 30, character: 8 },
- definitionPositions: [
- { row: 29, column: 41 }, // Person
- { row: 29, column: 59 }, // Address
- ],
- },
- {
- nodeType: "function_definition with one argument and Generator return type",
- fileName: "python/functions.py",
- language: "Python",
- cursorPosition: { line: 33, character: 9 },
- definitionPositions: [
- { row: 32, column: 40 }, // Person
- { row: 32, column: 62 }, // Address
- ],
- },
- {
- nodeType: "function_definition inside a class",
- fileName: "python/functions.py",
- language: "Python",
- cursorPosition: { line: 38, character: 12 },
- definitionPositions: [
- { row: 37, column: 51 }, // Person
- { row: 37, column: 69 }, // Address
- ],
- },
- {
- nodeType: "function_definition of an async function",
- fileName: "python/functions.py",
- language: "Python",
- cursorPosition: { line: 41, character: 8 },
- definitionPositions: [
- { row: 40, column: 37 }, // Address
- { row: 40, column: 48 }, // Person
- ],
- },
-]
-
export const CLASSES = [
{
nodeType: "class_definition with multiple superclasses",
diff --git a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/filtering/streamTransforms/StreamTransformPipeline.ts b/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/filtering/streamTransforms/StreamTransformPipeline.ts
deleted file mode 100644
index 28bedc73429..00000000000
--- a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/filtering/streamTransforms/StreamTransformPipeline.ts
+++ /dev/null
@@ -1,82 +0,0 @@
-import { streamLines } from "../../../diff/util"
-import { HelperVars } from "../../util/HelperVars"
-
-import { stopAtStartOf, stopAtStopTokens } from "./charStream"
-import {
- avoidEmptyComments,
- avoidPathLine,
- noDoubleNewLine,
- showWhateverWeHaveAtXMs,
- skipPrefixes,
- stopAtLines,
- stopAtLinesExact,
- stopAtRepeatingLines,
- stopAtSimilarLine,
- streamWithNewLines,
-} from "./lineStream"
-
-const STOP_AT_PATTERNS = ["diff --git"]
-
-export class StreamTransformPipeline {
- async *transform(
- generator: AsyncGenerator,
- prefix: string,
- suffix: string,
- multiline: boolean,
- stopTokens: string[],
- fullStop: () => void,
- helper: HelperVars,
- ): AsyncGenerator {
- let charGenerator = generator
-
- charGenerator = stopAtStopTokens(generator, [...stopTokens, ...STOP_AT_PATTERNS])
- charGenerator = stopAtStartOf(charGenerator, suffix)
- for (const charFilter of helper.lang.charFilters ?? []) {
- charGenerator = charFilter({
- chars: charGenerator,
- prefix,
- suffix,
- filepath: helper.filepath,
- multiline,
- })
- }
-
- let lineGenerator = streamLines(charGenerator)
-
- lineGenerator = stopAtLines(lineGenerator, fullStop)
- const lineBelowCursor = this.getLineBelowCursor(helper)
- if (lineBelowCursor.trim() !== "") {
- lineGenerator = stopAtLinesExact(lineGenerator, fullStop, [lineBelowCursor])
- }
- lineGenerator = stopAtRepeatingLines(lineGenerator, fullStop)
- lineGenerator = avoidEmptyComments(lineGenerator, helper.lang.singleLineComment)
- lineGenerator = avoidPathLine(lineGenerator, helper.lang.singleLineComment)
- lineGenerator = skipPrefixes(lineGenerator)
- lineGenerator = noDoubleNewLine(lineGenerator)
-
- for (const lineFilter of helper.lang.lineFilters ?? []) {
- lineGenerator = lineFilter({ lines: lineGenerator, fullStop })
- }
-
- lineGenerator = stopAtSimilarLine(lineGenerator, this.getLineBelowCursor(helper), fullStop)
-
- const timeoutValue = helper.options.modelTimeout
-
- lineGenerator = showWhateverWeHaveAtXMs(lineGenerator, timeoutValue!)
-
- const finalGenerator = streamWithNewLines(lineGenerator)
- for await (const update of finalGenerator) {
- yield update
- }
- }
-
- private getLineBelowCursor(helper: HelperVars): string {
- let lineBelowCursor = ""
- let i = 1
- while (lineBelowCursor.trim() === "" && helper.pos.line + i <= helper.fileLines.length - 1) {
- lineBelowCursor = helper.fileLines[Math.min(helper.pos.line + i, helper.fileLines.length - 1)]
- i++
- }
- return lineBelowCursor
- }
-}
diff --git a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/filtering/streamTransforms/charStream.test.ts b/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/filtering/streamTransforms/charStream.test.ts
deleted file mode 100644
index 488798b60f8..00000000000
--- a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/filtering/streamTransforms/charStream.test.ts
+++ /dev/null
@@ -1,192 +0,0 @@
-import { describe, expect, it } from "vitest"
-import { stopAtStartOf, stopAtStopTokens } from "./charStream"
-
-async function* createMockStream(chunks: string[]): AsyncGenerator {
- for (const chunk of chunks) {
- yield chunk
- }
-}
-
-async function streamToString(stream: AsyncGenerator): Promise {
- let result = ""
- for await (const chunk of stream) {
- result += chunk
- }
- return result
-}
-
-describe("stopAtStopTokens", () => {
- it("should yield characters until a stop token is encountered", async () => {
- const mockStream = createMockStream(["Hello", " world", "! Stop", "here"])
- const stopTokens = ["Stop"]
- const result = stopAtStopTokens(mockStream, stopTokens)
-
- const output = []
- for await (const char of result) {
- output.push(char)
- }
-
- expect(output.join("")).toBe("Hello world! ")
- })
-
- it("should handle multiple stop tokens", async () => {
- const mockStream = createMockStream(["This", " is a ", "test. END", " of stream"])
- const stopTokens = ["END", "STOP", "HALT"]
- const result = stopAtStopTokens(mockStream, stopTokens)
-
- expect(await streamToString(result)).toBe("This is a test. ")
- })
-
- it("should handle stop tokens split across chunks", async () => {
- const mockStream = createMockStream(["Hello", " wo", "r", "ld! ST", "OP now"])
- const stopTokens = ["STOP"]
- const result = stopAtStopTokens(mockStream, stopTokens)
-
- const output = []
- for await (const char of result) {
- output.push(char)
- }
-
- expect(output.join("")).toBe("Hello world! ")
- })
-
- it("should yield all characters if no stop token is encountered", async () => {
- const mockStream = createMockStream(["This", " is ", "a complete", " stream"])
- const stopTokens = ["END"]
- const result = stopAtStopTokens(mockStream, stopTokens)
-
- expect(await streamToString(result)).toBe("This is a complete stream")
- })
-
- it("should handle empty chunks", async () => {
- const mockStream = createMockStream(["Hello", "", " world", "", "! STOP"])
- const stopTokens = ["STOP"]
- const result = stopAtStopTokens(mockStream, stopTokens)
-
- expect(await streamToString(result)).toBe("Hello world! ")
- })
-
- it("should handle stop token at the beginning of the stream", async () => {
- const mockStream = createMockStream(["STOP", "Hello world"])
- const stopTokens = ["STOP"]
- const result = stopAtStopTokens(mockStream, stopTokens)
-
- const output = []
- for await (const char of result) {
- output.push(char)
- }
-
- expect(output.join("")).toBe("")
- })
-
- it("should handle stop token at the end of the stream", async () => {
- const mockStream = createMockStream(["Hello world", "STOP"])
- const stopTokens = ["STOP"]
- const result = stopAtStopTokens(mockStream, stopTokens)
-
- expect(await streamToString(result)).toBe("Hello world")
- })
-
- it("should handle multiple stop tokens of different lengths", async () => {
- const mockStream = createMockStream(["This is a ", "test with ", "multiple STOP", " tokens END"])
- const stopTokens = ["STOP", "END", "HALT"]
- const result = stopAtStopTokens(mockStream, stopTokens)
-
- expect(await streamToString(result)).toBe("This is a test with multiple ")
- })
-
- it("should handle an empty stream", async () => {
- const mockStream = createMockStream([])
- const stopTokens = ["STOP"]
- const result = stopAtStopTokens(mockStream, stopTokens)
-
- expect(await streamToString(result)).toBe("")
- })
-
- it("should handle an empty stop tokens array", async () => {
- const mockStream = createMockStream(["Hello", " world!"])
- const stopTokens: string[] = []
- const result = stopAtStopTokens(mockStream, stopTokens)
-
- const output = []
- for await (const char of result) {
- output.push(char)
- }
-
- expect(output.join("")).toBe("Hello world!")
- })
-
- it("should handle stop token when remaining buffer is smaller than maximum stop token length", async () => {
- const mockStream = createMockStream(["Hello world!STOP"])
- const stopTokens: string[] = ["STOP", "STOP_TOKEN_THAT_IS_LARGER_THAN_BUFFER"]
- const result = stopAtStopTokens(mockStream, stopTokens)
-
- expect(await streamToString(result)).toBe("Hello world!")
- })
-})
-
-describe("stopAtStartOf", () => {
- const sampleCode = ` {
- method: "GET",
- headers: {
- "Content-Type": "application/json",
- Authorization: \`Bearer \${this.workOsAccessToken}\`,
- },
- },
- );
- const data = await response.json();
- return data.items;
- }
-
- async getContextItems(
- query: string,
- extras: ContextProviderExtras,
- ): Promise {
- const response = await extras.fetch(
- new URL(
- \`/proxy/context/\${this.options.id}/retrieve\`,
- controlPlaneEnv.CONTROL_PLANE_URL,
- ),
-`
-
- /* Some LLMs, such as Codestral, repeat the suffix of the query. To test our filtering, we cut the sample code at random positions, remove a part of the input
-and construct a response, containing the removed part and the suffix. The goal of the stopAtStartOf() method is to detect the start of the suffix in the response */
- it("should stop if the start of the suffix is reached", async () => {
- const suffix = `
- const data = await response.json();
- return data.items;
-}`
- const mockStream = createMockStream(sampleCode.split(/(?! )/g))
- const result = stopAtStartOf(mockStream, suffix)
-
- const resultStr = await streamToString(result)
- expect(resultStr).toBe(` {
- method: "GET",
- headers: {
- "Content-Type": "application/json",
- Authorization: \`Bearer \${this.workOsAccessToken}\`,
- },
- },
- );
- `)
- })
- it("should stop if the start of the suffix is reached, even if the suffix has a prefix", async () => {
- const suffix = `
- xxxconst data = await response.json();
- return data.items;
-}`
- const mockStream = createMockStream(sampleCode.split(/(?! )/g))
- const result = stopAtStartOf(mockStream, suffix)
-
- const resultStr = await streamToString(result)
- expect(resultStr).toBe(` {
- method: "GET",
- headers: {
- "Content-Type": "application/json",
- Authorization: \`Bearer \${this.workOsAccessToken}\`,
- },
- },
- );
- `)
- })
-})
diff --git a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/filtering/streamTransforms/charStream.ts b/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/filtering/streamTransforms/charStream.ts
deleted file mode 100644
index d19bed609ca..00000000000
--- a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/filtering/streamTransforms/charStream.ts
+++ /dev/null
@@ -1,96 +0,0 @@
-/**
- * Asynchronously yields characters from the input stream, stopping if a stop token is encountered.
- *
- * @param {AsyncGenerator} stream - The input stream of characters.
- * @param {string[]} stopTokens - Array of tokens that signal when to stop yielding.
- * @yields {string} Characters from the input stream.
- * @returns {AsyncGenerator} An async generator that yields characters until a stop condition is met.
- * @description
- * 1. If no stop tokens are provided, yields all characters from the stream.
- * 2. Otherwise, buffers incoming chunks and checks for stop tokens.
- * 3. Yields characters one by one if no stop token is found at the start of the buffer.
- * 4. Stops yielding and returns if a stop token is encountered.
- * 5. After the stream ends, filters encountered stop tokens in remaining buffer.
- * 6. Yields any remaining buffered characters.
- */
-export async function* stopAtStopTokens(stream: AsyncGenerator, stopTokens: string[]): AsyncGenerator {
- if (stopTokens.length === 0) {
- for await (const char of stream) {
- yield char
- }
- return
- }
-
- const maxStopTokenLength = Math.max(...stopTokens.map((token) => token.length))
- let buffer = ""
-
- for await (const chunk of stream) {
- buffer += chunk
-
- while (buffer.length >= maxStopTokenLength) {
- let found = false
- for (const stopToken of stopTokens) {
- if (buffer.startsWith(stopToken)) {
- found = true
- return
- }
- }
-
- if (!found) {
- yield buffer[0]
- buffer = buffer.slice(1)
- }
- }
- }
- // Filter out the possible stop tokens from remaining buffer
- stopTokens.forEach((token) => {
- buffer = buffer.replace(token, "")
- })
-
- // Yield any remaining characters in the buffer
- for (const char of buffer) {
- yield char
- }
-}
-
-/**
- * Asynchronously yields characters from the input stream.
- * Stops if the beginning of the suffix is detected in the stream.
- */
-export async function* stopAtStartOf(
- stream: AsyncGenerator,
- suffix: string,
- sequenceLength: number = 20,
-): AsyncGenerator {
- if (suffix.length < sequenceLength) {
- for await (const chunk of stream) {
- yield chunk
- }
- return
- }
- // We use sequenceLength * 1.5 as a heuristic to make sure we don't miss the sequence if the
- // stream is not perfectly aligned with the sequence (small whitespace differences etc).
- const targetPart = suffix.trimStart().slice(0, Math.floor(sequenceLength * 1.5))
-
- let buffer = ""
-
- for await (const chunk of stream) {
- buffer += chunk
-
- // Check if the targetPart contains contains the buffer at any point
- if (buffer.length >= sequenceLength && targetPart.includes(buffer)) {
- return // Stop processing when the sequence is found
- }
-
- // Yield chunk by chunk, ensuring not to exceed sequenceLength in the buffer
- while (buffer.length > sequenceLength) {
- yield buffer[0]
- buffer = buffer.slice(1)
- }
- }
-
- // Yield the remaining buffer if it is not contained in the `targetPart`
- if (buffer.length > 0) {
- yield buffer
- }
-}
diff --git a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/filtering/streamTransforms/lineStream.ts b/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/filtering/streamTransforms/lineStream.ts
index 2a0be704a67..a4cc5e15265 100644
--- a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/filtering/streamTransforms/lineStream.ts
+++ b/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/filtering/streamTransforms/lineStream.ts
@@ -1,4 +1,4 @@
-import { LineStream } from "../../../diff/util"
+import type { LineStream } from "../../../diff/util"
import { lineIsRepeated } from "../../util/textSimilarity"
export { lineIsRepeated }
@@ -177,19 +177,6 @@ export async function* stopAtLines(
}
}
-/**
- * Yield until an exact stop line is encountered, then call fullStop.
- */
-export async function* stopAtLinesExact(stream: LineStream, fullStop: () => void, linesToStopAt: string[]): LineStream {
- for await (const line of stream) {
- if (linesToStopAt.some((stopAt) => line === stopAt)) {
- fullStop()
- break
- }
- yield line
- }
-}
-
/**
* On the first line only, strip any configured prefix (e.g. "").
*/
@@ -230,41 +217,3 @@ export async function* stopAtRepeatingLines(lines: LineStream, fullStop: () => v
previousLine = line
}
}
-
-/**
- * Pass through lines, but if the stream takes longer than ms after we have at least one non-empty line, stop early.
- */
-export async function* showWhateverWeHaveAtXMs(lines: LineStream, ms: number): LineStream {
- const startTime = Date.now()
- let firstNonWhitespaceLineYielded = false
-
- for await (const line of lines) {
- yield line
-
- if (!firstNonWhitespaceLineYielded && line.trim() !== "") {
- firstNonWhitespaceLineYielded = true
- }
-
- const isTakingTooLong = Date.now() - startTime > ms
- if (isTakingTooLong && firstNonWhitespaceLineYielded) {
- break
- }
- }
-}
-
-/**
- * Yield lines until the first blank line after some content; then stop.
- */
-export async function* noDoubleNewLine(lines: LineStream): LineStream {
- let isFirstLine = true
-
- for await (const line of lines) {
- if (line.trim() === "" && !isFirstLine) {
- return
- }
-
- isFirstLine = false
-
- yield line
- }
-}
diff --git a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/filtering/test/NEGATIVE_TEST_CASES/QWEN_JSON.txt b/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/filtering/test/NEGATIVE_TEST_CASES/QWEN_JSON.txt
deleted file mode 100644
index ff0ba3cb39a..00000000000
--- a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/filtering/test/NEGATIVE_TEST_CASES/QWEN_JSON.txt
+++ /dev/null
@@ -1,60 +0,0 @@
-##### Prompt #####
-{
- "active": true,
- "department": "Product Development",
- "location": {
- "country": "USA",
- "state": "California",
- "city": "San BERNARDINO",
- "coordinates": {
-
- }
- },
- "employees": [
- {
- "name": "John Doe",
- "age": 30,
- "position": "Developer",
- "skills": ["JavaScript", "React", "Node.js"],
- "remote": false,
- "salary": {
- "currency": "USD",
- "amount": 95000
- }
- },
- {
- "name": "Jane Smith",
- "age": 25,
- "position": "Designer",
- "skills": ["Photoshop", "Illustrator"],
- "remote": true,
- "salary": {
- "currency": "USD",
- "amount": 70000
- }
- },
- {
- "name": "Emily Johnson",
- "age": 35,
- "position": "Manager",
- "teamSize": 8,
- "remote": true,
- "skills": ["Leadership", "Project Management"],==========================================================================
-==========================================================================
-Completion:
-
- "latitude": 34.10834,
- "longitude": -117.28977
- }
- },
- "employeeCount": 2,
- "averageAge": 30,
- "remoteFriendly": true,
- "salaryRange": {
- "min": 70000,
- "max": 95000,
- "currency": "USD"
- },
- "skills": {
- "required": ["JavaScript", "React", "Node.js", "Leadership", "Project Management"],
- "optional": ["Photoshop", "Illustrator"]
\ No newline at end of file
diff --git a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/filtering/test/NEGATIVE_TEST_CASES/QWEN_TYPESCRIPT.txt b/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/filtering/test/NEGATIVE_TEST_CASES/QWEN_TYPESCRIPT.txt
deleted file mode 100644
index 241d141f28b..00000000000
--- a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/filtering/test/NEGATIVE_TEST_CASES/QWEN_TYPESCRIPT.txt
+++ /dev/null
@@ -1,128 +0,0 @@
-##### Prompt #####
- }`,
- },
- {
- description: "Should autocomplete Vue computed property",
- filename: "UserComponent.vue",
- input: `
-
-
-
-
-
-`,
- llmOutput: `this.completed`,
- expectedCompletion: `this.completed`,
- },
- {
- description: "Should autocomplete Svelte reactive statement",
- filename: "Counter.svelte",
- input: `
-
-
-
-`,
- llmOutput: `doubledCount = count * 2`,
- expectedCompletion: `doubledCount = count * 2`,
- },
-
- {
- description: "Should autocomplete Svelte component inside HTML",
- filename: "NestedComponent.svelte",
- input: `
-
-
-
- />
-
-`,
- llmOutput: `name="World"`,
- expectedCompletion: `name="World"`,
- },
-
- {
- description: "Should handle autocomplete in Svelte each block",
- filename: "List.svelte",
- input: `
-
-
-
-];
-==========================================================================
-==========================================================================
-Completion:
-
-
-
-export default {
- components: {
- ChildComponent,
- },
\ No newline at end of file
diff --git a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/filtering/test/NEGATIVE_TEST_CASES/STARCODER_JSON.txt b/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/filtering/test/NEGATIVE_TEST_CASES/STARCODER_JSON.txt
deleted file mode 100644
index a50bd2fb4c1..00000000000
--- a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/filtering/test/NEGATIVE_TEST_CASES/STARCODER_JSON.txt
+++ /dev/null
@@ -1,20 +0,0 @@
-##### Prompt #####
-{
- "employees": [
- { "name": "John Doe", "age": 30, "position": "Developer" },
- { "name": "Jane Smith", "age": 25, "position": "Designer" },
- { "name": "Emily Johnson", "age": 35, "position": "Manager" }
- ],
- "active": true
-}
-==========================================================================
-==========================================================================
-Completion:
-
-
-}
-
-{
- "employees": [
- { "name": "John Doe", "age": 30 },
- { "name": "Jane Smith", "age": 25 }
\ No newline at end of file
diff --git a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/filtering/test/NEGATIVE_TEST_CASES/STARCODER_PYTHON.TXT b/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/filtering/test/NEGATIVE_TEST_CASES/STARCODER_PYTHON.TXT
deleted file mode 100644
index c4aaf43ec1f..00000000000
--- a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/filtering/test/NEGATIVE_TEST_CASES/STARCODER_PYTHON.TXT
+++ /dev/null
@@ -1,29 +0,0 @@
-##### Prompt #####
-class Calculator:
- def __init__(self):
- self.result = 0
-
- def add(self, number):
- self.result += number
- return self
-
- def divid
-
- def subtract(self, number):
- self.result -= number
- return self
-
- def reset(self):
- self.result = 0
- return self
-
- def get_result(self):
- return self.result
-
-
-==========================================================================
-==========================================================================
-Completion:
-
-self.result /= number
- return self
\ No newline at end of file
diff --git a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/filtering/test/NEGATIVE_TEST_CASES/STARCODER_RUBY.TXT b/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/filtering/test/NEGATIVE_TEST_CASES/STARCODER_RUBY.TXT
deleted file mode 100644
index df8c2011fba..00000000000
--- a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/filtering/test/NEGATIVE_TEST_CASES/STARCODER_RUBY.TXT
+++ /dev/null
@@ -1,41 +0,0 @@
-##### Prompt #####
-class Calculator
- attr_accessor :result
-
- def initialize
- @result = 0
- end
-
- def add(number)
- @result += number
- self
- end
-
- def subtract(number)
- @result -= number
- self
- end
-
- def power(ne
-
- def get_result
- @result
- end
-
- def reset
- @result = 0
- self
- end
-end
-
-calc = Calculator.new
-calc.add(5).subtract(3)
-puts "Result: #{calc.get_result}"
-==========================================================================
-==========================================================================
-Completion:
-
-
- @result ** number
- self
- end
\ No newline at end of file
diff --git a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/filtering/test/NEGATIVE_TEST_CASES/STARCODER_RUST.TXT b/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/filtering/test/NEGATIVE_TEST_CASES/STARCODER_RUST.TXT
deleted file mode 100644
index 582ae5f364d..00000000000
--- a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/filtering/test/NEGATIVE_TEST_CASES/STARCODER_RUST.TXT
+++ /dev/null
@@ -1,73 +0,0 @@
-##### Prompt #####
-use std::io;
-
-fn main() {
- println!("Welcome to the Calculator!");
-
- loop {
- println!("Please enter an operator (+, -, *, /) or 'q' to quit:");
- let operator = read_input();
-
- if operator == "q" {
- break;
- }
-
- println!("Please enter the first number:");
- let num1 = read_input().parse::().unwrap();
-
- println!("Please enter the second number:");
- let num2 = read_input().parse::().unwrap();
-
- let result = match operator.as_str() {
- "+" => num1 + num2,
- "-" => num1 - num2,
- "*" => num1 * num2,
- "/" => num1 / num2,
-
- _ => {
- println!("Invalid operator. Please try again.");
- continue;
- }
- };
-
- println!("Result: {}", result);
- }
-}
-
-fn read_input() -> String {
- let mut input = String::new();
- io::stdin()
- .read_line(&mut input)
- .expect("Failed to read input");
- input.trim().to_string()
-}
-==========================================================================
-==========================================================================
-Completion:
-
- => {
- println!("Invalid operator. Please try again.");
- continue;
- }
- };
-
- println!("Result: {}", result);
- }
-
- println!("Goodbye!");
-}
-
-
-fn main2() {
- println!("Welcome to the Calculator!");
-
- loop {
- println!("Please enter an operator (+, -, *, /) or 'q' to quit:");
- let operator = read_input();
-
- if operator == "q" {
- break;
- }
-
- match operator.as_str() {
- "+" | "-" | "*" | "/" => (),
\ No newline at end of file
diff --git a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/filtering/test/filter.test.ts b/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/filtering/test/filter.test.ts
deleted file mode 100644
index 9f3a1d68e9a..00000000000
--- a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/filtering/test/filter.test.ts
+++ /dev/null
@@ -1,37 +0,0 @@
-import { afterAll, beforeAll, describe, it } from "vitest"
-import { addToTestDir, setUpTestDir, tearDownTestDir } from "../../../test/testDir"
-
-import { TEST_CASES_WITH_DIFF, TEST_CASES_WITHOUT_DIFF } from "./testCases"
-import { AutocompleteFileringTestInput, testAutocompleteFiltering } from "./util"
-
-const filterTestCases = (tests: AutocompleteFileringTestInput[]) => {
- if (tests.some((test) => test.options?.only)) {
- return tests.filter((test) => test.options?.only)
- }
-
- return tests
-}
-
-describe("Autocomplete filtering tests", () => {
- beforeAll(async () => {
- tearDownTestDir()
- setUpTestDir()
- addToTestDir([".continueignore"])
- })
-
- afterAll(async () => {
- tearDownTestDir()
- })
-
- describe("Should return unmodified LLM output", () => {
- it.each(filterTestCases(TEST_CASES_WITHOUT_DIFF))("$description", async (testCase) => {
- await testAutocompleteFiltering(testCase)
- })
- })
-
- describe("Should return modified LLM output", () => {
- it.each(filterTestCases(TEST_CASES_WITH_DIFF))("$description", async (testCase) => {
- await testAutocompleteFiltering(testCase)
- })
- })
-})
diff --git a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/filtering/test/testCases.ts b/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/filtering/test/testCases.ts
deleted file mode 100644
index 909cb0a2b03..00000000000
--- a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/filtering/test/testCases.ts
+++ /dev/null
@@ -1,2175 +0,0 @@
-import { dedent } from "../../../util"
-
-import { AutocompleteFileringTestInput } from "./util"
-
-export const TEST_CASES_WITH_DIFF: AutocompleteFileringTestInput[] = [
- {
- description: "Should handle python multi-line string",
- filename: "test.py",
- input: `def create_greeting(name):
- greeting = """Hello, """ + name + """!
-Welcome to our community. We hope you have a great time here.
-If you have any questions, feel free to reach out."""
- return greeting
-
-message = create_greeting("Alice")
-print(message)
-
-multi_line_message = """<|fim|>
-print(multi_line_message)
-`,
- llmOutput: `This is a multi-line message.
-It continues across multiple lines,
-which allows for easy reading and formatting.
-"""
-`,
- expectedCompletion: `This is a multi-line message.
-It continues across multiple lines,
-which allows for easy reading and formatting.
-"""`,
- },
- {
- description: "Should autocomplete Rust match arms",
- filename: "main.rs",
- input: `
-fn get_status_code_description(code: u16) -> &'static str {
- match code {
- 200 => "OK",
- 404 => "Not Found",
- 500 => "Internal Server Error",
- <|fim|>
- }
-}
-`,
- llmOutput: `403 => "Forbidden",
- 401 => "Unauthorized",
- _ => "Unknown Status",
-`,
- expectedCompletion: `403 => "Forbidden",
- 401 => "Unauthorized",
- _ => "Unknown Status",`,
- },
- {
- description: "Should complete a Markdown code block",
- filename: "test.md",
- input: `
-Here is a sample JavaScript function:
-
-\`\`\`javascript
-function sayHello() {
- console.log("Hello, <|fim|>
-}
-\`\`\`
-`,
- llmOutput: `world!");
-`,
- expectedCompletion: 'world!");',
- },
- {
- description: "Should autocomplete Java when inside a block",
- filename: "Main.java",
- input: `
-public class Main {
- public static void main(String[] args) {
- for (int i = 0; i < 10; i++) {
- if (i % 2 == 0) {
- System.out.println("Even: " + i);
- } else {
-<|fim|>
- }
- }
- }
-}`,
- llmOutput: `
- System.out.println("Odd: " + i);
-`,
- expectedCompletion: `
- System.out.println("Odd: " + i);`,
- },
- {
- description: "Should autocomplete a Markdown heading and preserve formatting",
- filename: "test.md",
- input: `# My Document
-
-## Introduction
-This is a sample document for testing.
-
-## <|fim|>
-### Conclusion
-Thank you for reading.
-`,
- llmOutput: `Features
-Here is a list of features:
-- Feature 1
-- Feature 2
-`,
- expectedCompletion: `Features
-Here is a list of features:
-- Feature 1
-- Feature 2`,
- },
- {
- // options: { only: true },
- description: "Should autocomplete a Java method within a class",
- filename: "Calculator.java",
- input: `
-public class Calculator {
- private double result;
-
- public Calculator() {
- this.result = 0.0;
- }
-
- public void add(double number) {
- result += number;
-<|fim|>`,
- llmOutput: `
- }
-
- public void subtract(double number) {
- result -= number;
- }
-`,
- expectedCompletion: `
- }`,
- },
- {
- description: "Should filter out consecutive, repeated YAML keys",
- filename: "test.yaml",
- input: `
- version: '3'
- services:
- db:
- image: postgres
- environment:
- POSTGRES_USER: user
- POSTGRES_PASSWORD: pass<|fim|>
- `,
- llmOutput: `
- POSTGRES_DB: mydb
- POSTGRES_DB: mydb
- `,
- expectedCompletion: `
- POSTGRES_DB: mydb`,
- },
- {
- description: "Should enforce bracket matching in JSON files",
- filename: "test.json",
- input: `{
- "active": true,
- "department": "Product Development",
- "location": {
- "country": "USA",
- "state": "California",
- "city": "San BERNARDINO",
- "coordinates": {
- <|fim|>
- }
- },
- "employees": [
- {
- "name": "John Doe",
- "age": 30,
- "position": "Developer",
- "skills": ["JavaScript", "React", "Node.js"],
- "remote": false,
- "salary": {
- "currency": "USD",
- "amount": 95000
- }
- },
- {
- "name": "Jane Smith",
- "age": 25,
- "position": "Designer",
- "skills": ["Photoshop", "Illustrator"],
- "remote": true,
- "salary": {
- "currency": "USD",
- "amount": 70000
- }
- },
- {
- "name": "Emily Johnson",
- "age": 35,
- "position": "Manager",
- "teamSize": 8,
- "remote": true,
- "skills": ["Leadership", "Project Management"],`,
- llmOutput: `"latitude": 34.10834,
- "longitude": -117.28977
- }
- },
- "employeeCount": 2,
- "averageAge": 30,
- "remoteFriendly": true,
- "salaryRange": {
- "min": 70000,
- "max": 95000,
- "currency": "USD"
- },
- "skills": {
- "required": ["JavaScript", "React", "Node.js", "Leadership", "Project Management"],
- "optional": ["Photoshop", "Illustrator"]`,
- expectedCompletion: `"latitude": 34.10834,
- "longitude": -117.28977`,
- },
- {
- description: "Should return nothing when output is duplicated lines in TypeScript",
- filename: "file.ts",
- input: `
-async getContextForPath(
- filepath: string,
- astPath: AstPatt,
- language: LanguageName,
- options: ContextOptions = {},
-<|fim|>
- ): Promise {
- const snippets: AutocompleteCodeSnippet[] = [];
- let parentKey = filepath;
-`,
- llmOutput: ` ): Promise {
- const snippets: AutocompleteCodeSnippet[] = [];
- `,
- expectedCompletion: undefined,
- },
- {
- description: "Should return partial result when output is duplicated lines in TypeScript",
- filename: "file.ts",
- input: `
-async getContextForPath(
- filepath: string,
- astPath: AstPatt,
- language: LanguageName,
- options: ContextOptions = {},
-<|fim|>
- ): Promise {
- const snippets: AutocompleteCodeSnippet[] = [];
- let parentKey = filepath;
-`,
- llmOutput: `console.log('TEST');
- ): Promise {
- const snippets: AutocompleteCodeSnippet[] = [];
- `,
- expectedCompletion: `console.log('TEST');`,
- },
- {
- description: "Should autocomplete React effect hook",
- input: `import React, { useState, useEffect } from "react";
-
-export const Timer = () => {
- const [seconds, setSeconds] = useState(0);
-
- useEffect(() => {
- const interval = setInterval(() => {
- setSeconds(seconds + 1);
- }, 1000);
-
- <|fim|>;
-
- return () => clearInterval(interval);
- }, [seconds]);
-
- return (
- Document
-
-
-
-
-int add(int a, int b) {
- return a + b;
-}
-
-int multiply(int a, int b) {
- return a * b;
-}
-
-int subtract(int a, int b) {
- <|fim|>
-}
-
-int main() {
- printf("Result: %d", add(2, 3));
- return 0;
-}`,
- llmOutput: "return a - b;",
- expectedCompletion: "return a - b;",
- },
-
- {
- description: "Should handle C struct with missing field initialization",
- filename: "person.c",
- input: `#include
-
-typedef struct {
- char name[50];
- int age;
- float height;
-} Person;
-
-int main() {
- Person alice = {"Alice", 30, <|fim|>};
- printf("Name: %s, Age: %d, Height: %.2f", alice.name, alice.age, alice.height);
- return 0;
-}`,
- llmOutput: "5.5",
- expectedCompletion: "5.5",
- },
-
- {
- description: "Should autocomplete C function with missing body bracket",
- filename: "area.c",
- input: `#include
-
-double calculateCircleArea(double radius) {
- const double pi = 3.14159;
- return pi * radius * radius;<|fim|>
-
-double calculateRectangleArea(double length, double width) {
- return length * width;
-}
-
-int main() {
- printf("Circle Area: %.2f", calculateCircleArea(5.0));
- printf("Rectangle Area: %.2f", calculateRectangleArea(4.0, 6.0));
- return 0;
-}`,
- llmOutput: `
-}`,
- expectedCompletion: `
-}`,
- },
- {
- description: "Should autocomplete a simple Kotlin function declaration",
- filename: "simpleFunction.kt",
- input: `
-fun main() {
- println("Hello, World!")
-}
-
-fun calculateArea(length: Double, width: Double): Double <|fim|>`,
- llmOutput: `{
- return length * width
-}`,
- expectedCompletion: `{
- return length * width
-}`,
- },
- {
- description: "Should handle autocomplete inside a Kotlin data class",
- filename: "dataClass.kt",
- input: `
-data class User(
- val id: Int,
- val name: String,
- val email: String,
- <|fim|>
-)`,
- llmOutput: "val age: Int",
- expectedCompletion: "val age: Int",
- },
- {
- description: "Should complete Kotlin if-else structure with missing brackets",
- filename: "controlStructure.kt",
- input: `
-fun getMax(a: Int, b: Int): Int {
- if (a > b<|fim|>
- } else {
- return b
- }
-}`,
- llmOutput: `) {
- return a`,
- expectedCompletion: `) {
- return a`,
- },
- {
- description: "Should autocomplete Solidity function definition",
- filename: "SimpleStorage.sol",
- input: `
-pragma solidity ^0.8.0;
-
-contract SimpleStorage {
- uint private data;
-
- function set(uint x) public {
- data = x;
- }
-
- function get() public view returns (uint) {
- <|fim|>
- }
-}
- `,
- llmOutput: "return data;",
- expectedCompletion: "return data;",
- },
-
- {
- description: "Should autocomplete Solidity event with parameters",
- filename: "EventExample.sol",
- input: `
-pragma solidity ^0.8.0;
-
-contract EventExample {
- event DataStored(uint indexed id, string content);
-
- function storeData(uint id, string memory content) public {
- emit DataStored(<|fim|>);
- }
-}
- `,
- llmOutput: "id, content",
- expectedCompletion: "id, content",
- },
-
- {
- description: "Should handle Solidity struct definition completion",
- filename: "StructDefinition.sol",
- input: `
-pragma solidity ^0.8.0;
-
-contract StructExample {
- struct Person {
- string name;
- uint age;
- address wallet;
- }
-
- Person[] private people;
-
- function addPerson(string memory name, uint age, address wallet) public {
- people.push(Person(name, age, wallet));
- }
-
- function getFirstPerson<|fim|>
-}
- `,
- llmOutput: `() public view returns (string memory, uint, address) {
- if (people.length > 0) {
- Person storage person = people[0];
- return (person.name, person.age, person.wallet);
- }
- return ("", 0, address(0));
- }`,
- expectedCompletion: `() public view returns (string memory, uint, address) {
- if (people.length > 0) {
- Person storage person = people[0];
- return (person.name, person.age, person.wallet);
- }
- return ("", 0, address(0));
- }`,
- },
- {
- description: "Should autocomplete TypeScript interface properties",
- filename: "User.ts",
- input: `
-interface User {
- id: number;
- name: string;
- e<|fim|>
-}
-`,
- llmOutput: `mail: string;
- age: number;
-}`,
- expectedCompletion: `mail: string;
- age: number;`,
- },
- {
- description: "Should autocomplete TypeScript interface declarations",
- filename: "autocomplete.ts",
- input: `interface AutocompleteDiffSnippet extends BaseAutocompleteSnippet {}
-
-interface AutocompleteCodeSnippet`,
- llmOutput: ` extends BaseAutocompleteSnippet {
- filepath: string;
-}`,
- expectedCompletion: ` extends BaseAutocompleteSnippet {
- filepath: string;
-}`,
- },
- {
- description: "Should autocomplete a TypeScript arrow function inside a variable assignment",
- filename: "mathOperations.ts",
- input: `
-const addNumbers = (a: number, b: number): number => {
- return a + b;
-};
-
-const multiplyNumbers = (a: number, b: number): number => {
- re<|fim|>
-}
-
-console.log(multiplyNumbers(2, 3));
-`,
- llmOutput: "turn a * b;",
- expectedCompletion: "turn a * b;",
- },
-
- // TODO
- // {
- // description:
- // "Should handle autocomplete inside a nested TypeScript class method",
- // filename: "Account.ts",
- // input: `
- // class Account {
- // private balance: number = 0;
-
- // deposit(amount: number) {
- // this.balance += amount;
- // return this.balance;
- // }
-
- // withdraw(amount: number) {
- // if (amount > this.balance) {
- // throw new Error("Insufficient funds");
- // }
- // this.balance -= amount;
- // return thi<|fim|>
- // }
- // }
- // `,
- // llmOutput: `s.balance;`,
- // expectedCompletion: `s.balance;`,
- // },
-
- // TODO
- // {
- // description: "Should autocomplete a TypeScript generic function",
- // filename: "GenericFunction.ts",
- // input: `
- // function identity(arg: T): T {
- // return ar<|fim|>
- // }
-
- // console.log(identity(5));
- // `,
- // llmOutput: `g;`,
- // expectedCompletion: `g;`,
- // },
-
- // TODO
- // {
- // description:
- // "Should autocomplete a TypeScript promise within an asynchronous function",
- // filename: "asyncFunction.ts",
- // input: `
- // async function fetchData(url: string): Promise {
- // const response = await fetch(url);
- // <|fim|>
- // return data;
- // }
-
- // fetchData('https://api.example.com/data');
- // `,
- // llmOutput: `const data = await response.json();`,
- // expectedCompletion: `const data = await response.json();`,
- // },
-
- {
- description: "Should autocomplete a C# class with a constructor and property",
- filename: "Person.cs",
- input: `using System;
-
-public class Person
-{
- public string Name { get; set; }
- public int Age { get; set; }
-
- public Person(string name, int <|fim|>
-}`,
- llmOutput: `age)
- {
- Name = name;
- Age = age;
- }`,
- expectedCompletion: `age)
- {
- Name = name;
- Age = age;
- }`,
- },
- {
- description: "Should autocomplete a C# interface method",
- filename: "IGreetable.cs",
- input: `public interface IGreetable
-{
- void <|fim|>
-}`,
- llmOutput: "Greet();",
- expectedCompletion: "Greet();",
- },
- {
- description: "Should autocomplete inside C# method with if condition",
- filename: "Calculator.cs",
- input: `using System;
-
-public class Calculator
-{
- public int Add(int a, int b)
- {
- if(<|fim|>)
- {
- return a + b;
- }
- return 0;
- }
-}`,
- llmOutput: "a > 0 && b > 0",
- expectedCompletion: "a > 0 && b > 0",
- },
- {
- description: "Should complete a simple Julia function",
- filename: "simpleFunction.jl",
- input: `function calculate_area(length, width)
- <|fim|>
-end
-`,
- llmOutput: "return length * width",
- expectedCompletion: "return length * width",
- },
- {
- description: "Should autocomplete Julia for loop",
- filename: "loop.jl",
- input: `numbers = [1, 2, 3, 4, 5]
-squared_numbers = []
-
-for num in numbers
- <|fim|>
-end
-
-println(squared_numbers)
-`,
- llmOutput: "push!(squared_numbers, num^2)",
- expectedCompletion: "push!(squared_numbers, num^2)",
- },
- {
- description: "Should complete a Julia struct definition",
- filename: "structDefinition.jl",
- input: `struct Person
- first_name::String
- last_name::String
- age::Int
- address::Address
-end
-
-struct Address
- street::String
- city::String
- <|fim|>
-end
-`,
- llmOutput: `state::String
- zip_code::String`,
- expectedCompletion: `state::String
- zip_code::String`,
- },
- {
- description: "Should complete a Julia dictionary access",
- filename: "dictionary.jl",
- input: `grades = Dict("Alice" => 90, "Bob" => 85, "Eve" => 88)
-
-function get_grade(student_name)
- return grades[<|fim|>]
-end
-
-println(get_grade("Alice")) # Should print 90
-`,
- llmOutput: "student_name",
- expectedCompletion: "student_name",
- },
- {
- description: "Should complete a Julia module declaration",
- filename: "moduleDeclaration.jl",
- input: `module MathOperations
-
-export add, subtract
-
-function add(a, b)
- return a + b
-end
-
-function subtract(a, b)
- return a - b
-end
-
-<|fim|>
-`,
- llmOutput: "end",
- expectedCompletion: "end",
- },
- {
- description: "Should complete F# let-binding with function definition",
- filename: "mathModule.fs",
- input: `module MathModule
-
-let calculateArea length width =
- <|fim|>`,
- llmOutput: "length * width",
- expectedCompletion: "length * width",
- },
-
- {
- description: "Should complete incomplete F# type definition",
- filename: "personType.fs",
- input: `type Person = {
- FirstName: string
- LastName: string
- Age: int<|fim|>
-}
-
-let john = { FirstName = "John"; LastName = "Doe"; Age = 30 }`,
- llmOutput: `
- Address: string
-}`,
- expectedCompletion: `
- Address: string`,
- },
-
- {
- description: "Should complete F# pattern matching expression",
- filename: "patternMatching.fs",
- input: `let describeNumber number =
- match number with
- | 0 -> "Zero"
- | 1 -> "One"
- | <|fim|>`,
- llmOutput: `2 -> "Two"
- | _ -> "Other"`,
- expectedCompletion: `2 -> "Two"
- | _ -> "Other"`,
- },
-
- {
- description: "Should complete F# list comprehension expression",
- filename: "listComprehension.fs",
- input: `let squares = [ for x in 1..10 -> x * x ]
-let evenSquares = [ for x in squares do if x % 2 = 0 then yield x ]
-let oddSquares = [<|fim|>]`,
- llmOutput: " for x in squares do if x % 2 <> 0 then yield x ]",
- expectedCompletion: " for x in squares do if x % 2 <> 0 then yield x ]",
- },
- {
- description: "Should complete an F# recursive function",
- filename: "recursiveFunctions.fs",
- input: `let rec factorial n =
- if n <= 1 then 1
- else n <|fim|> factorial (n - 1)`,
- llmOutput: "*",
- expectedCompletion: "*",
- },
- {
- description: "Should complete F# member method inside a class type",
- filename: "bankAccount.fs",
- input: `type BankAccount(owner: string, initialBalance: float) =
- let mutable balance = initialBalance
-
- member this.Deposit amount =
- balance <- balance + amount
- this
- <|fim|>`,
- llmOutput: `
- member this.Withdraw amount =
- if amount > balance then
- failwith "Insufficient funds"
- balance <- balance - amount
- this`,
- expectedCompletion: `
- member this.Withdraw amount =
- if amount > balance then
- failwith "Insufficient funds"
- balance <- balance - amount
- this`,
- },
-
- {
- description: "Should complete F# async workflow function",
- filename: "asyncWorkflow.fs",
- input: `let fetchDataAsync url =
- async {
- use client = new System.Net.Http.HttpClient()
- <|fim|>
- }`,
- llmOutput: `let! response = client.GetStringAsync(url)
- return response`,
- expectedCompletion: `let! response = client.GetStringAsync(url)
- return response`,
- },
- {
- description: "Should autocomplete SCSS nested class starting inside a rule",
- filename: "styles.scss",
- input: `nav {
- display: flex;
- justify-content: space-between;
- .logo {
- font-size: 1.5rem;
- color: #333;
-
- .brand<|fim|>
- }
-
- ul {
- list-style: none;
- display: flex;
- gap: 1rem;
- }
-}`,
- llmOutput: `-name {
- font-weight: bold;
- text-transform: uppercase;
-}`,
- expectedCompletion: `-name {
- font-weight: bold;
- text-transform: uppercase;
-}`,
- },
-
- {
- description: "Should handle SCSS mixin within a class",
- filename: "styles.scss",
- input: `.card {
- border: 1px solid #ccc;
- padding: 10px;
-
- @include<|fim|>
-
- &:hover {
- box-shadow: 0 4px 8px rgba(0, 0, 0, 0.1);
- }
-}`,
- llmOutput: " transition(all 0.3s ease);",
- expectedCompletion: " transition(all 0.3s ease);",
- },
-
- {
- description: "Should autocomplete SCSS variable in the middle of a statement",
- filename: "styles.scss",
- input: `$primary-color: #007bff;
-$secondary-color: #6c757d;
-
-.button {
- background-color: <|fim|> color;
- padding: 10px 15px;
- border: none;
- color: #fff;
- border-radius: 4px;
-}`,
- llmOutput: "$primary-",
- expectedCompletion: "$primary-",
- },
- {
- description: "Should autocomplete Vue component method",
- filename: "MyComponent.vue",
- input: `
-
-
-
-
-
-`,
- llmOutput: "this.completed",
- expectedCompletion: "this.completed",
- },
- {
- description: "Should autocomplete Svelte reactive statement",
- filename: "Counter.svelte",
- input: `
-
-
-
-`,
- llmOutput: "doubledCount = count * 2",
- expectedCompletion: "doubledCount = count * 2",
- },
-
- {
- description: "Should autocomplete Svelte component inside HTML",
- filename: "NestedComponent.svelte",
- input: `
-
-
-
- />
-
-`,
- llmOutput: 'name="World"',
- expectedCompletion: 'name="World"',
- },
-
- {
- description: "Should handle autocomplete in Svelte each block",
- filename: "List.svelte",
- input: `
-
-
- {
- return (await this.client.exists(this._getKey(tableName, key))) > 0;
- }
-
- public async keys(tableName: string): Promise {
- const keys = await this.client.keys(this._getTableKey(tableName));
- return keys.map((key) => key.split("::")[1]);
- }
-
- public async put(
- tableName: string,
- key: string,
- value: string,
- ): Promise {
- await this.client.set(this._getKey(tableName, key), value);
- }
-
- public async get(
- tableName: string,
- key: string,
- ): Promise {
- const value = await this.client.get(this._getKey(tableName, key));
- return value ?? undefined;
- }
-
- public async deleteAll(tableName: string): Promise {
- await this.client.del(this._getTableKey(tableName));
- }
-
-<|fim|>
-
-
- public async remove(tableName: string, key: string): Promise {
- const result = await this.client.del(this._getKey(tableName, key));
- return result > 0;
- }
-}
-`,
- llmOutput: ` public async delete(tableName: string, key: string): Promise {
- await this.client.del(this._getKey(tableName, key));
- }`,
- expectedCompletion: ` public async delete(tableName: string, key: string): Promise {
- await this.client.del(this._getKey(tableName, key));
- }`,
- },
-]
diff --git a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/filtering/test/util.ts b/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/filtering/test/util.ts
deleted file mode 100644
index e07a53cd125..00000000000
--- a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/filtering/test/util.ts
+++ /dev/null
@@ -1,81 +0,0 @@
-import { expect } from "vitest"
-import { MockLLM } from "../../../llm/llms/Mock"
-import { testMinimalConfigProvider, testIde } from "../../../test/fixtures"
-import { joinPathsToUri } from "../../../util/uri"
-import { CompletionProvider } from "../../CompletionProvider"
-import { AutocompleteInput } from "../../util/types"
-
-const FIM_DELIMITER = "<|fim|>"
-
-function parseFimExample(text: string): { prefix: string; suffix: string } {
- const [prefix, suffix] = text.split(FIM_DELIMITER)
- return { prefix, suffix }
-}
-
-export interface AutocompleteFileringTestInput {
- description: string
- filename: string
- input: string
- llmOutput: string
- expectedCompletion: string | null | undefined
- options?: {
- only?: boolean
- }
-}
-
-export async function testAutocompleteFiltering(test: AutocompleteFileringTestInput) {
- // Normalize line endings to LF for cross-platform compatibility (Windows Git may check out CRLF)
- const normalizedInput = test.input.replace(/\r\n/g, "\n")
- const normalizedLlmOutput = test.llmOutput.replace(/\r\n/g, "\n")
-
- const { prefix } = parseFimExample(normalizedInput)
-
- // Setup necessary objects
- const llm = new MockLLM({
- model: "mock",
- })
- llm.completion = normalizedLlmOutput
- const ide = testIde
- const configHandler = testMinimalConfigProvider
-
- // Create a real file
- const [workspaceDir] = await ide.getWorkspaceDirs()
- const fileUri = joinPathsToUri(workspaceDir, test.filename)
- await ide.writeFile(fileUri, normalizedInput.replace(FIM_DELIMITER, ""))
-
- // Prepare completion input and provider
- const completionProvider = new CompletionProvider(
- configHandler,
- ide,
- async () => llm,
- () => {},
- async () => [],
- )
-
- const line = prefix.split("\n").length - 1
- const character = prefix.split("\n")[line].length
- const autocompleteInput: AutocompleteInput = {
- isUntitledFile: false,
- completionId: "test-completion-id",
- filepath: fileUri,
- pos: {
- line,
- character,
- },
- recentlyEditedRanges: [],
- recentlyVisitedRanges: [],
- }
-
- // Generate a completion
- const result = await completionProvider.provideInlineCompletionItems(
- autocompleteInput,
- undefined,
- true, // force=true to skip debounce in tests
- )
-
- // Ensure that we return the text that is wanted to be displayed
- // Normalize line endings for cross-platform compatibility
- const normalizeLineEndings = (str: string | null | undefined) => str?.replace(/\r\n/g, "\n")
-
- expect(normalizeLineEndings(result?.completion)).toEqual(normalizeLineEndings(test.expectedCompletion))
-}
diff --git a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/generation/CompletionStreamer.ts b/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/generation/CompletionStreamer.ts
deleted file mode 100644
index 6ceedf7f291..00000000000
--- a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/generation/CompletionStreamer.ts
+++ /dev/null
@@ -1,79 +0,0 @@
-import { CompletionOptions, ILLM } from "../.."
-import { StreamTransformPipeline } from "../filtering/streamTransforms/StreamTransformPipeline"
-import { HelperVars } from "../util/HelperVars"
-
-import { GeneratorReuseManager } from "./GeneratorReuseManager"
-import { stopAfterMaxProcessingTime } from "./utils"
-
-export class CompletionStreamer {
- private streamTransformPipeline = new StreamTransformPipeline()
- private generatorReuseManager: GeneratorReuseManager
-
- constructor(onError: (err: unknown) => void) {
- this.generatorReuseManager = new GeneratorReuseManager(onError)
- }
-
- async *streamCompletionWithFilters(
- token: AbortSignal,
- llm: ILLM,
- prefix: string,
- suffix: string,
- prompt: string,
- multiline: boolean,
- completionOptions: Partial | undefined,
- helper: HelperVars,
- ) {
- // Full stop means to stop the LLM's generation, instead of just truncating the displayed completion
- const fullStop = () => this.generatorReuseManager.currentGenerator?.cancel()
-
- // Try to reuse pending requests if what the user typed matches start of completion
- const generator = this.generatorReuseManager.getGenerator(
- prefix,
- (abortSignal: AbortSignal) => {
- const generator = llm.supportsFim()
- ? llm.streamFim(prefix, suffix, abortSignal, completionOptions)
- : llm.streamComplete(prompt, abortSignal, {
- ...completionOptions,
- raw: true,
- })
-
- /**
- * This transformer applies even on reused generator. We are deliberately
- * not using streamTransformPipeline because we want to capture and stop
- * the request even if the generator is being reused.
- */
- return helper.options.transform
- ? stopAfterMaxProcessingTime(generator, helper.options.modelTimeout * 2.5, fullStop)
- : generator
- },
- multiline,
- )
-
- // LLM
- const generatorWithCancellation = async function* () {
- for await (const update of generator) {
- if (token.aborted) {
- return
- }
- yield update
- }
- }
-
- const initialGenerator = generatorWithCancellation()
- const transformedGenerator = helper.options.transform
- ? this.streamTransformPipeline.transform(
- initialGenerator,
- prefix,
- suffix,
- multiline,
- completionOptions?.stop || [],
- fullStop,
- helper,
- )
- : initialGenerator
-
- for await (const update of transformedGenerator) {
- yield update
- }
- }
-}
diff --git a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/generation/GeneratorReuseManager.test.ts b/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/generation/GeneratorReuseManager.test.ts
deleted file mode 100644
index a30399957dd..00000000000
--- a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/generation/GeneratorReuseManager.test.ts
+++ /dev/null
@@ -1,208 +0,0 @@
-import { afterEach, beforeEach, describe, expect, Mock, test, vi } from "vitest"
-import { GeneratorReuseManager } from "./GeneratorReuseManager"
-
-function createMockGenerator(data: string[], delay: number = 0): (abortSignal: AbortSignal) => AsyncGenerator {
- const mockGenerator = async function* () {
- for (const chunk of data) {
- yield chunk
-
- if (delay > 0) {
- await new Promise((resolve) => setTimeout(resolve, delay))
- }
- }
- }
- const newGenerator = vi.fn<() => AsyncGenerator>().mockReturnValue(mockGenerator())
-
- return newGenerator
-}
-
-describe("GeneratorReuseManager", () => {
- let reuseManager: GeneratorReuseManager
- let onErrorMock: Mock
-
- beforeEach(() => {
- onErrorMock = vi.fn()
- reuseManager = new GeneratorReuseManager(onErrorMock)
- })
-
- afterEach(() => {
- vi.clearAllMocks()
- })
-
- test("creates new generator when there is no current generator", async () => {
- const data = ["hello ", "world"]
- const newGenerator = createMockGenerator(data)
-
- const prefix = ""
-
- const generator = reuseManager.getGenerator(prefix, newGenerator, true)
-
- const output: string[] = []
- for await (const chunk of generator) {
- output.push(chunk)
- }
-
- expect(output).toEqual(data)
- expect(newGenerator).toHaveBeenCalledTimes(1)
- })
-
- test("reuses generator when prefix matches pending completion", async () => {
- const newGenerator = createMockGenerator(["llo ", "world"])
-
- // First call with initial prefix
- const prefix1 = "he"
- const generator1 = reuseManager.getGenerator(prefix1, newGenerator, true)
-
- const output1: string[] = []
- for await (const chunk of generator1) {
- output1.push(chunk)
- }
-
- expect(output1).toEqual(["llo ", "world"])
-
- // Second call with extended prefix that matches pending completion
- const prefix2 = "hello "
- const generator2 = reuseManager.getGenerator(prefix2, newGenerator, true)
-
- const output2: string[] = []
- for await (const chunk of generator2) {
- output2.push(chunk)
- }
-
- expect(output2).toEqual(["world"])
-
- // Ensure generator was reused (newGenerator should be called only once)
- expect(newGenerator).toHaveBeenCalledTimes(1)
- })
-
- test("creates new generator when prefix does not match pending completion", async () => {
- const data = ["goodbye ", "world"]
- const newGenerator = createMockGenerator(data)
-
- // Initial generator with different prefix
- reuseManager.pendingGeneratorPrefix = "hello "
- reuseManager.pendingCompletion = "world"
-
- const prefix = "good"
- const generator = reuseManager.getGenerator(prefix, newGenerator, true)
-
- const output: string[] = []
- for await (const chunk of generator) {
- output.push(chunk)
- }
-
- expect(output).toEqual(data)
- // Ensure a new generator was created
- expect(newGenerator).toHaveBeenCalledTimes(1)
- })
-
- test("handles multiline=false by stopping at newline", async () => {
- const data = ["first line\n", "second line"]
- const newGenerator = createMockGenerator(data)
-
- const prefix = ""
- const generator = reuseManager.getGenerator(prefix, newGenerator, false)
-
- const output: string[] = []
- for await (const chunk of generator) {
- output.push(chunk)
- }
-
- expect(output).toEqual(["first line"])
- // Ensure it stops after the first newline
- })
-
- test("handles multiline=true by not stopping at newline", async () => {
- const data = ["first line\n", "second line"]
- const newGenerator = createMockGenerator(data)
-
- const prefix = ""
- const generator = reuseManager.getGenerator(prefix, newGenerator, true)
-
- const output: string[] = []
- for await (const chunk of generator) {
- output.push(chunk)
- }
-
- expect(output).toEqual(data)
- })
-
- test("cancels previous generator when creating a new one", async () => {
- const data1 = ["data from generator 1", "not generated"]
- const data2 = ["data from generator 2"]
-
- const newGenerator1 = createMockGenerator(data1, 1000) // Delay so we have the chance to cancel it
- const newGenerator2 = createMockGenerator(data2)
-
- const prefix1 = "prefix1"
- const prefix2 = "prefix2"
-
- // First generator
- const generator1 = reuseManager.getGenerator(prefix1, newGenerator1, true)
- const output1: string[] = []
- for await (const chunk of generator1) {
- output1.push(chunk)
- // Simulate the generator being canceled before completing
- reuseManager.currentGenerator?.cancel()
- }
-
- expect(output1.length).toEqual(1)
- expect(output1[0]).toEqual(data1[0])
-
- // Second generator
- const generator2 = reuseManager.getGenerator(prefix2, newGenerator2, true)
- const output2: string[] = []
- for await (const chunk of generator2) {
- output2.push(chunk)
- }
-
- expect(output2).toEqual(data2)
- })
-
- test("calls onError when generator throws an error", async () => {
- const error = new Error("Generator error")
- const mockGenerator = async function* () {
- throw error
- }
- const newGenerator = vi.fn<() => AsyncGenerator>().mockReturnValue(mockGenerator())
-
- const prefix = ""
- const generator = reuseManager.getGenerator(prefix, newGenerator, true)
-
- const output: string[] = []
- await expect(async () => {
- for await (const chunk of generator) {
- output.push(chunk)
- }
- }).not.toThrow() // getGenerator handles errors internally
-
- expect(onErrorMock).toHaveBeenCalledWith(error)
- expect(output).toEqual([])
- })
-
- test("handles backspacing by creating new generator when prefix is shorter", async () => {
- const data = ["hello world"]
- const newGenerator1 = createMockGenerator(data)
- const newGenerator2 = createMockGenerator(data)
-
- // First prefix
- const prefix1 = "hello world"
- const generator1 = reuseManager.getGenerator(prefix1, newGenerator1, true)
- const output1: string[] = []
- for await (const chunk of generator1) {
- output1.push(chunk)
- }
-
- // Simulate backspace (prefix is shorter)
- const prefix2 = "hello worl"
- const generator2 = reuseManager.getGenerator(prefix2, newGenerator2, true)
- const output2: string[] = []
- for await (const chunk of generator2) {
- output2.push(chunk)
- }
-
- // Ensure a new generator was created
- expect(newGenerator1).toHaveBeenCalledTimes(1)
- expect(newGenerator2).toHaveBeenCalledTimes(1)
- })
-})
diff --git a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/generation/GeneratorReuseManager.ts b/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/generation/GeneratorReuseManager.ts
deleted file mode 100644
index 37d29f6e0c3..00000000000
--- a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/generation/GeneratorReuseManager.ts
+++ /dev/null
@@ -1,70 +0,0 @@
-import { ListenableGenerator } from "./ListenableGenerator"
-
-export class GeneratorReuseManager {
- currentGenerator: ListenableGenerator | undefined
- pendingGeneratorPrefix: string | undefined
- pendingCompletion = ""
-
- constructor(private readonly onError: (err: unknown) => void) {}
-
- private _createListenableGenerator(abortController: AbortController, gen: AsyncGenerator, prefix: string) {
- this.currentGenerator?.cancel()
-
- const listenableGen = new ListenableGenerator(gen, this.onError, abortController)
- listenableGen.listen((chunk) => (this.pendingCompletion += chunk ?? ""))
-
- this.pendingGeneratorPrefix = prefix
- this.pendingCompletion = ""
- this.currentGenerator = listenableGen
- }
-
- private shouldReuseExistingGenerator(prefix: string): boolean {
- return (
- !!this.currentGenerator &&
- !!this.pendingGeneratorPrefix &&
- (this.pendingGeneratorPrefix + this.pendingCompletion).startsWith(prefix) &&
- // for e.g. backspace
- this.pendingGeneratorPrefix?.length <= prefix?.length
- )
- }
-
- async *getGenerator(
- prefix: string,
- newGenerator: (abortSignal: AbortSignal) => AsyncGenerator,
- multiline: boolean,
- ): AsyncGenerator {
- // If we can't reuse, then create a new generator
- if (!this.shouldReuseExistingGenerator(prefix)) {
- // Create a wrapper over the current generator to fix the prompt
- const abortController = new AbortController()
- this._createListenableGenerator(abortController, newGenerator(abortController.signal), prefix)
- }
-
- // Already typed characters are those that are new in the prefix from the old generator
- let typedSinceLastGenerator = prefix.slice(this.pendingGeneratorPrefix?.length) || ""
- for await (let chunk of this.currentGenerator?.tee() ?? []) {
- if (!chunk) {
- continue
- }
-
- // Ignore already typed characters in the completion
- while (chunk.length && typedSinceLastGenerator.length) {
- if (chunk[0] === typedSinceLastGenerator[0]) {
- typedSinceLastGenerator = typedSinceLastGenerator.slice(1)
- chunk = chunk.slice(1)
- } else {
- break
- }
- }
-
- // Break at newline unless we are in multiline mode
- const newLineIndex = chunk.indexOf("\n")
- if (newLineIndex >= 0 && !multiline) {
- yield chunk.slice(0, newLineIndex)
- break
- } else if (chunk !== "") {
- yield chunk
- }
- }
- }
-}
diff --git a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/generation/ListenableGenerator.test.ts b/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/generation/ListenableGenerator.test.ts
deleted file mode 100644
index 35cdc207a1e..00000000000
--- a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/generation/ListenableGenerator.test.ts
+++ /dev/null
@@ -1,148 +0,0 @@
-import { describe, expect, it, vi } from "vitest"
-
-import { ListenableGenerator } from "./ListenableGenerator"
-
-describe("ListenableGenerator", () => {
- // Helper function to create an async generator
- async function* asyncGenerator(values: T[]) {
- for (const value of values) {
- // Yield on next event loop iteration to ensure async behavior
- await new Promise(setImmediate)
- yield value
- }
- }
-
- it("should yield values from the source generator via tee()", async () => {
- const values = [1, 2, 3]
- const source = asyncGenerator(values)
- const onError = vi.fn()
-
- const lg = new ListenableGenerator(source, onError, new AbortController())
-
- const result: number[] = []
- for await (const value of lg.tee()) {
- result.push(value)
- }
-
- expect(result).toEqual(values)
- expect(onError).not.toHaveBeenCalled()
- })
-
- it("should allow listeners to receive values", async () => {
- const values = [1, 2, 3]
- const source = asyncGenerator(values)
- const onError = vi.fn()
-
- const lg = new ListenableGenerator(source, onError, new AbortController())
-
- const listener = vi.fn()
-
- // Add listener after yielding starts (next event loop iteration)
- await new Promise(setImmediate)
- lg.listen(listener)
-
- // Wait for generator to actually finish
- await lg.waitForCompletion()
-
- expect(listener).toHaveBeenCalledWith(1)
- expect(listener).toHaveBeenCalledWith(2)
- expect(listener).toHaveBeenCalledWith(3)
- // Listener should receive null at the end
- expect(listener).toHaveBeenCalledWith(null)
- })
-
- it("should buffer values for listeners added after some values have been yielded", async () => {
- const values = [1, 2, 3]
- const source = asyncGenerator(values)
- const onError = vi.fn()
-
- const lg = new ListenableGenerator(source, onError, new AbortController())
-
- const initialListener = vi.fn()
-
- lg.listen(initialListener)
-
- // Wait for the first value to be yielded (next event loop iteration)
- await new Promise(setImmediate)
-
- // Add a second listener after first value has been yielded
- const newListener = vi.fn()
- lg.listen(newListener)
-
- // Wait for generator to actually finish
- await lg.waitForCompletion()
-
- // Both listeners should have received all values
- ;[initialListener, newListener].forEach((listener) => {
- expect(listener).toHaveBeenCalledWith(1)
- expect(listener).toHaveBeenCalledWith(2)
- expect(listener).toHaveBeenCalledWith(3)
- expect(listener).toHaveBeenCalledWith(null)
- })
- })
-
- it("should handle cancellation", async () => {
- const values = [1, 2, 3, 4, 5]
- const source = asyncGenerator(values)
- const onError = vi.fn()
-
- const lg = new ListenableGenerator(source, onError, new AbortController())
-
- const result: number[] = []
- const teeIterator = lg.tee()
-
- const consume = async () => {
- for await (const value of teeIterator) {
- result.push(value)
- if (value === 3) {
- lg.cancel()
- }
- }
- }
-
- await consume()
-
- expect(result).toEqual([1, 2, 3])
- expect(lg["_isEnded"]).toBe(true)
- })
-
- it("should call onError when the source generator throws an error", async () => {
- async function* errorGenerator() {
- yield 1
- throw new Error("Test error")
- }
-
- const source = errorGenerator()
- const onError = vi.fn()
-
- const lg = new ListenableGenerator(source, onError, new AbortController())
-
- const result: number[] = []
- for await (const value of lg.tee()) {
- result.push(value)
- }
-
- expect(result).toEqual([1])
- expect(onError).toHaveBeenCalledTimes(1)
- expect(onError).toHaveBeenCalledWith(new Error("Test error"))
- })
-
- it("should notify listeners when the generator ends", async () => {
- const values = [1, 2, 3]
- const source = asyncGenerator(values)
- const onError = vi.fn()
-
- const lg = new ListenableGenerator(source, onError, new AbortController())
-
- const listener = vi.fn()
- lg.listen(listener)
-
- // Wait for the generator to actually finish
- await lg.waitForCompletion()
-
- expect(listener).toHaveBeenCalledWith(1)
- expect(listener).toHaveBeenCalledWith(2)
- expect(listener).toHaveBeenCalledWith(3)
- expect(listener).toHaveBeenCalledWith(null)
- })
-})
diff --git a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/generation/ListenableGenerator.ts b/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/generation/ListenableGenerator.ts
deleted file mode 100644
index 4005b13023a..00000000000
--- a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/generation/ListenableGenerator.ts
+++ /dev/null
@@ -1,84 +0,0 @@
-export class ListenableGenerator {
- private _source: AsyncGenerator
- private _buffer: T[] = []
- private _listeners: Set<(value: T) => void> = new Set()
- private _isEnded = false
- private _abortController: AbortController
- private _completionPromise: Promise
-
- constructor(
- source: AsyncGenerator,
- private readonly onError: (e: unknown) => void,
- abortController: AbortController,
- ) {
- this._source = source
- this._abortController = abortController
- this._completionPromise = this._start().catch((e) => console.log(`Listenable generator failed: ${e.message}`))
- }
-
- public cancel() {
- this._abortController.abort()
- this._isEnded = true
- }
-
- public waitForCompletion(): Promise {
- return this._completionPromise
- }
-
- private async _start() {
- try {
- for await (const value of this._source) {
- if (this._isEnded) {
- break
- }
- this._buffer.push(value)
- for (const listener of this._listeners) {
- listener(value)
- }
- }
- } catch (e) {
- this.onError(e)
- } finally {
- this._isEnded = true
- for (const listener of this._listeners) {
- listener(null as any)
- }
- }
- }
-
- listen(listener: (value: T) => void) {
- this._listeners.add(listener)
- for (const value of this._buffer) {
- listener(value)
- }
- if (this._isEnded) {
- listener(null as any)
- }
- }
-
- async *tee(): AsyncGenerator {
- try {
- let i = 0
- while (i < this._buffer.length) {
- yield this._buffer[i++]
- }
- while (!this._isEnded) {
- let resolve: (value: T) => void
- const promise = new Promise((res) => {
- resolve = res
- this._listeners.add(resolve!)
- })
- await promise
- this._listeners.delete(resolve!)
-
- // Possible timing caused something to slip in between
- // timers so we iterate over the buffer
- while (i < this._buffer.length) {
- yield this._buffer[i++]
- }
- }
- } finally {
- // this._listeners.delete(resolve!);
- }
- }
-}
diff --git a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/generation/utils.test.ts b/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/generation/utils.test.ts
deleted file mode 100644
index 87dba5f97db..00000000000
--- a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/generation/utils.test.ts
+++ /dev/null
@@ -1,126 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"
-import { stopAfterMaxProcessingTime } from "./utils"
-
-describe("stopAfterMaxProcessingTime", () => {
- beforeEach(() => {
- vi.useFakeTimers()
- })
-
- afterEach(() => {
- vi.useRealTimers()
- })
-
- async function* createMockStream(chunks: string[]): AsyncGenerator {
- for (const chunk of chunks) {
- yield chunk
- }
- }
-
- async function streamToString(stream: AsyncGenerator): Promise {
- let result = ""
- for await (const chunk of stream) {
- result += chunk
- }
- return result
- }
-
- it("should yield all chunks when maxTimeMs is not reached", async () => {
- const mockStream = createMockStream(["Hello", " world", "!"])
- const fullStop = vi.fn()
- const result = stopAfterMaxProcessingTime(mockStream, 1000, fullStop)
-
- const output = await streamToString(result)
-
- expect(output).toBe("Hello world!")
- expect(fullStop).not.toHaveBeenCalled()
- })
-
- it("should stop processing after max time is reached", async () => {
- // Mock implementation of Date.now
- let currentTime = 0
- const originalDateNow = Date.now
- Date.now = vi.fn(() => currentTime)
-
- // Create a generator that we can control
- async function* controlledGenerator(): AsyncGenerator {
- for (let i = 0; i < 100; i++) {
- // After yielding 10 chunks, simulate time passing beyond our limit
- if (i === 10) {
- currentTime = 1000 // This exceeds our 500ms limit
- }
- yield `chunk-${i}`
- }
- }
-
- const fullStop = vi.fn()
- const maxTimeMs = 500
-
- const transformedGenerator = stopAfterMaxProcessingTime(controlledGenerator(), maxTimeMs, fullStop)
-
- // Consume the generator and collect outputs
- const outputs: string[] = []
- for await (const chunk of transformedGenerator) {
- outputs.push(chunk)
- }
-
- // We expect:
- // 1. Not all chunks were processed (less than 100)
- // 2. fullStop was called
- // 3. We processed at least the chunks before time was exceeded
- expect(outputs.length).toBeLessThan(100)
- expect(outputs.length).toBeGreaterThanOrEqual(10) // We should get at least the first 10 chunks
- expect(fullStop).toHaveBeenCalled()
-
- // Restore Date.now
- Date.now = originalDateNow
- })
-
- it("should check time only periodically based on checkInterval", async () => {
- const chunks = Array(100).fill("x")
- const mockStream = createMockStream(chunks)
- const fullStop = vi.fn()
-
- // Spy on Date.now to count how many times it's called
- const dateSpy = vi.spyOn(Date, "now")
-
- // Stream should complete normally (not hitting the timeout)
- await streamToString(stopAfterMaxProcessingTime(mockStream, 10000, fullStop))
-
- // The first call is to set startTime, then once every checkInterval (10) chunks
- // So for 100 chunks, we expect startTime + ~10 checks = ~11 calls
- // We use a range because implementation details might vary slightly
- expect(dateSpy.mock.calls.length).toBeGreaterThanOrEqual(1)
- expect(dateSpy.mock.calls.length).toBeLessThanOrEqual(15)
-
- dateSpy.mockRestore()
- })
-
- it("should handle empty stream gracefully", async () => {
- const mockStream = createMockStream([])
- const fullStop = vi.fn()
- const result = stopAfterMaxProcessingTime(mockStream, 1000, fullStop)
-
- const output = await streamToString(result)
-
- expect(output).toBe("")
- expect(fullStop).not.toHaveBeenCalled()
- })
-
- it("should pass through all chunks if there's no timeout", async () => {
- const chunks = Array(100).fill("test chunk")
- const mockStream = createMockStream(chunks)
- const fullStop = vi.fn()
-
- // Use undefined as timeout to simulate no timeout
- const result = stopAfterMaxProcessingTime(mockStream, undefined as any, fullStop)
-
- // Process the stream
- const processedChunks = []
- for await (const chunk of result) {
- processedChunks.push(chunk)
- }
-
- expect(processedChunks.length).toBe(chunks.length)
- expect(fullStop).not.toHaveBeenCalled()
- })
-})
diff --git a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/generation/utils.ts b/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/generation/utils.ts
deleted file mode 100644
index 131a791b732..00000000000
--- a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/generation/utils.ts
+++ /dev/null
@@ -1,25 +0,0 @@
-export async function* stopAfterMaxProcessingTime(
- stream: AsyncGenerator,
- maxTimeMs: number,
- fullStop: () => void,
-): AsyncGenerator {
- const startTime = Date.now()
- /**
- * Check every 10 chunks to avoid performance overhead.
- */
- const checkInterval = 10
- let chunkCount = 0
-
- for await (const chunk of stream) {
- yield chunk
-
- chunkCount++
-
- if (chunkCount % checkInterval === 0) {
- if (Date.now() - startTime > maxTimeMs) {
- fullStop()
- return
- }
- }
- }
-}
diff --git a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/prefiltering/index.ts b/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/prefiltering/index.ts
deleted file mode 100644
index 02866d092b9..00000000000
--- a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/prefiltering/index.ts
+++ /dev/null
@@ -1,57 +0,0 @@
-import ignore from "ignore"
-import { getConfigJsonPath } from "../../util/paths"
-import { findUriInDirs } from "../../util/uri"
-import { HelperVars } from "../util/HelperVars"
-
-async function isDisabledForFile(
- currentFilepath: string,
- disableInFiles: string[] | undefined,
- workspaceDirs: string[],
-) {
- if (disableInFiles) {
- // Relative path needed for `ignore`
- const { relativePathOrBasename } = findUriInDirs(currentFilepath, workspaceDirs)
-
- const pattern = ignore().add(disableInFiles)
- if (pattern.ignores(relativePathOrBasename)) {
- return true
- }
- }
- return false
-}
-
-export async function shouldPrefilter(helper: HelperVars, workspaceDirs: string[]): Promise {
- // Allow disabling autocomplete from config.json
- if (helper.options.disable) {
- return true
- }
-
- // Check whether we're in the continue config.json file
- if (helper.filepath === getConfigJsonPath()) {
- return true
- }
-
- // Check whether autocomplete is disabled for this file
- const disableInFiles = [
- ...(helper.options.disableInFiles ?? []),
- "*.prompt",
- // "some-example-ignored-file", //MINIMAL_REPO - was configurable
- ]
- if (await isDisabledForFile(helper.filepath, disableInFiles, workspaceDirs)) {
- return true
- }
-
- // Don't offer completions when we have no information (untitled file and no file contents)
- if (helper.filepath.includes("Untitled") && helper.fileContents.trim() === "") {
- return true
- }
-
- // if (
- // helper.options.transform &&
- // (await shouldLanguageSpecificPrefilter(helper))
- // ) {
- // return true;
- // }
-
- return false
-}
diff --git a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/templating/__tests__/renderPrompt.test.ts b/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/templating/__tests__/renderPrompt.test.ts
deleted file mode 100644
index 8ef9281d8d1..00000000000
--- a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/templating/__tests__/renderPrompt.test.ts
+++ /dev/null
@@ -1,262 +0,0 @@
-import { afterEach, describe, expect, it, vi } from "vitest"
-
-// ---------- Module mocks ----------
-
-// Simple Handlebars mock that does naive placeholder substitution
-vi.mock("handlebars", () => {
- return {
- default: {
- compile: (template: string) => (ctx: Record) => {
- return template
- .replace(/{{prefix}}/g, ctx.prefix)
- .replace(/{{suffix}}/g, ctx.suffix)
- .replace(/{{filename}}/g, ctx.filename ?? "")
- .replace(/{{reponame}}/g, ctx.reponame ?? "")
- .replace(/{{language}}/g, ctx.language ?? "")
- },
- },
- }
-})
-
-// Token utilities – we map 1 char = 1 token for simplicity
-vi.mock("../../../llm/countTokens", () => {
- const countTokens = (str: string) => str.length
- const pruneLinesFromTop = (str: string, allowed: number) => str.slice(Math.max(0, str.length - allowed))
- const pruneLinesFromBottom = (str: string, allowed: number) => str.slice(0, allowed)
- const getTokenCountingBufferSafety = () => 0
-
- return {
- countTokens,
- pruneLinesFromTop,
- pruneLinesFromBottom,
- getTokenCountingBufferSafety,
- }
-})
-
-// Snippet selection – configurable via constant return value
-vi.mock("../filtering", () => ({
- getSnippets: () => [],
-}))
-
-// Snippet formatting
-const FORMATTED_SNIPPETS = "[FORMATTED_SNIPPETS]"
-vi.mock("../formatting", () => ({
- formatSnippets: () => FORMATTED_SNIPPETS,
-}))
-
-// Stop tokens helper – we expose a variable so each test can override it
-let stopTokenReturn: string[] = [""]
-vi.mock("../getStopTokens", () => ({
- getStopTokens: () => stopTokenReturn,
-}))
-
-// AutocompleteTemplate – provide overridable template + compiler + completionOptions
-let templateOverride: any = (prefix: string, suffix: string) => `${prefix}|${suffix}`
-let compileFnOverride: ((...args: any[]) => [string, string]) | undefined
-let completionOptionsOverride: Record | undefined
-vi.mock("../AutocompleteTemplate", () => ({
- getTemplateForModel: () => ({
- template: templateOverride,
- compilePrefixSuffix: compileFnOverride,
- completionOptions: completionOptionsOverride ?? {},
- }),
-}))
-
-// ---------- Imports after mocks ----------
-import { renderPrompt, renderPromptWithTokenLimit } from ".."
-import { AutocompleteLanguageInfo } from "../../constants/AutocompleteLanguageInfo"
-import { SnippetPayload } from "../../snippets"
-import { HelperVars } from "../../util/HelperVars"
-
-// ---------- Helper builders ----------
-
-const tsLang: AutocompleteLanguageInfo = {
- name: "TypeScript",
- topLevelKeywords: [],
- singleLineComment: "//",
- endOfLine: [";"],
-}
-
-const emptySnippetPayload: SnippetPayload = {
- rootPathSnippets: [],
- importDefinitionSnippets: [],
- ideSnippets: [],
- recentlyEditedRangeSnippets: [],
- recentlyVisitedRangesSnippets: [],
- diffSnippets: [],
- clipboardSnippets: [],
- recentlyOpenedFileSnippets: [],
- staticSnippet: [],
-}
-
-function makeHelper() {
- return {
- input: {
- filepath: "file:///test.ts",
- pos: { line: 0, character: 0 },
- recentlyEditedRanges: [],
- recentlyVisitedRanges: [],
- },
- prunedPrefix: "PRUNED_PREFIX",
- prunedSuffix: "PRUNED_SUFFIX",
- lang: tsLang,
- modelName: "test-model",
- filepath: "file:///test.ts",
- workspaceUris: [],
- options: {
- maxPromptTokens: 2048,
- prefixPercentage: 0.5,
- maxSuffixPercentage: 0.5,
- experimental_includeClipboard: false,
- useRecentlyOpened: false,
- experimental_includeRecentlyVisitedRanges: false,
- experimental_includeRecentlyEditedRanges: false,
- experimental_includeDiff: false,
- onlyMyCode: false,
- },
- } as unknown as HelperVars
-}
-
-afterEach(() => {
- // reset overridable mocks
- templateOverride = (prefix: string, suffix: string) => `${prefix}|${suffix}`
- compileFnOverride = undefined
- completionOptionsOverride = undefined
- stopTokenReturn = [""]
- vi.restoreAllMocks()
-})
-
-// ---------- Test suite ----------
-
-describe("renderPrompt prefix/suffix selection", () => {
- it("uses manuallyPassPrefix when provided", () => {
- const helper = makeHelper()
- helper.input.manuallyPassPrefix = "MANUAL"
- const { prefix, suffix } = renderPrompt({
- snippetPayload: emptySnippetPayload,
- workspaceDirs: ["file:///workspace"],
- helper,
- })
-
- expect(suffix).toBe("\n")
- expect(prefix.endsWith("MANUAL")).toBe(true)
- })
-
- it("falls back to prunedPrefix when no manual prefix", () => {
- const helper = makeHelper()
-
- const { prefix } = renderPrompt({
- snippetPayload: emptySnippetPayload,
- workspaceDirs: ["file:///workspace"],
- helper,
- })
-
- expect(prefix.includes("PRUNED_PREFIX")).toBe(true)
- })
-})
-
-describe("template rendering paths", () => {
- it("handles function template", () => {
- templateOverride = (p: string, s: string, _filepath: string, _reponame: string) => `FUNC:${p}|${s}`
-
- const helper = makeHelper()
-
- const { prompt } = renderPrompt({
- snippetPayload: emptySnippetPayload,
- workspaceDirs: ["file:///workspace"],
- helper,
- })
-
- expect(prompt.startsWith("FUNC:")).toBe(true)
- expect(prompt.includes("PRUNED_PREFIX")).toBe(true)
- })
-})
-
-describe("compilePrefixSuffix vs snippet formatting", () => {
- it("applies compilePrefixSuffix when provided", () => {
- compileFnOverride = (p: string, s: string) => [`COMP_${p}`, `COMP_${s}`]
- templateOverride = (prefix: string, suffix: string) => `${prefix}|${suffix}`
- const helper = makeHelper()
-
- const { prefix: compiledPrefix } = renderPrompt({
- snippetPayload: emptySnippetPayload,
- workspaceDirs: ["file:///workspace"],
- helper,
- })
-
- expect(compiledPrefix.startsWith("COMP_PRUNED_PREFIX")).toBe(true)
- })
-
- it("prepends formatted snippets when no compiler present", () => {
- const helper = makeHelper()
-
- const { prefix: compiledPrefix } = renderPrompt({
- snippetPayload: emptySnippetPayload,
- workspaceDirs: ["file:///workspace"],
- helper,
- })
-
- expect(compiledPrefix.startsWith(`${FORMATTED_SNIPPETS}\n`)).toBe(true)
- })
-})
-
-describe("renderPromptWithTokenLimit parity & pruning", () => {
- it("matches renderPrompt when llm is undefined", () => {
- const helper = makeHelper()
-
- const res1 = renderPrompt({
- snippetPayload: emptySnippetPayload,
- workspaceDirs: ["file:///workspace"],
- helper,
- })
-
- const res2 = renderPromptWithTokenLimit({
- snippetPayload: emptySnippetPayload,
- workspaceDirs: ["file:///workspace"],
- helper,
- llm: undefined,
- })
-
- expect(res2).toEqual(res1)
- })
-
- it("prunes prefix/suffix to respect small context length", () => {
- const longPrefix = "A".repeat(300)
-
- const helper = makeHelper()
- ;(helper as any).prunedPrefix = longPrefix
-
- const llmStub = {
- contextLength: 120,
- completionOptions: { maxTokens: 10 },
- model: "test-model",
- } as any
-
- const { prefix: compiledPrefix } = renderPromptWithTokenLimit({
- snippetPayload: emptySnippetPayload,
- workspaceDirs: ["file:///workspace"],
- helper,
- llm: llmStub,
- })
-
- expect(compiledPrefix.length).toBeLessThan(120)
- })
-})
-
-describe("stop-token merging", () => {
- it("returns stop tokens from getStopTokens", () => {
- stopTokenReturn = ["LANG_STOP", "TEMPLATE_STOP"]
- completionOptionsOverride = { stop: ["TEMPLATE_STOP"] }
- templateOverride = (prefix: string, suffix: string) => `${prefix}|${suffix}`
-
- const helper = makeHelper()
-
- const { completionOptions } = renderPrompt({
- snippetPayload: emptySnippetPayload,
- workspaceDirs: ["file:///workspace"],
- helper,
- })
-
- expect(completionOptions?.stop).toEqual(stopTokenReturn)
- })
-})
diff --git a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/templating/formatting.ts b/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/templating/formatting.ts
deleted file mode 100644
index 5aba7208e98..00000000000
--- a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/templating/formatting.ts
+++ /dev/null
@@ -1,90 +0,0 @@
-import { getLastNUriRelativePathParts } from "../../util/uri"
-import {
- AutocompleteClipboardSnippet,
- AutocompleteCodeSnippet,
- AutocompleteDiffSnippet,
- AutocompleteSnippet,
- AutocompleteSnippetType,
- AutocompleteStaticSnippet,
-} from "../types"
-import { HelperVars } from "../util/HelperVars"
-
-const getCommentMark = (helper: HelperVars) => {
- return helper.lang.singleLineComment
-}
-
-const addCommentMarks = (text: string, helper: HelperVars) => {
- const commentMark = getCommentMark(helper)
- return text
- .trim()
- .split("\n")
- .map((line) => `${commentMark} ${line}`)
- .join("\n")
-}
-
-const formatClipboardSnippet = (
- snippet: AutocompleteClipboardSnippet,
- workspaceDirs: string[],
-): AutocompleteCodeSnippet => {
- return formatCodeSnippet(
- {
- filepath: "file:///Untitled.txt",
- content: snippet.content,
- type: AutocompleteSnippetType.Code,
- },
- workspaceDirs,
- )
-}
-
-const formatCodeSnippet = (snippet: AutocompleteCodeSnippet, workspaceDirs: string[]): AutocompleteCodeSnippet => {
- return {
- ...snippet,
- content: `Path: ${getLastNUriRelativePathParts(workspaceDirs, snippet.filepath, 2)}\n${snippet.content}`,
- }
-}
-
-const formatDiffSnippet = (snippet: AutocompleteDiffSnippet): AutocompleteDiffSnippet => {
- return snippet
-}
-
-const formatStaticSnippet = (snippet: AutocompleteStaticSnippet): AutocompleteStaticSnippet => {
- return snippet
-}
-
-const commentifySnippet = (helper: HelperVars, snippet: AutocompleteSnippet): AutocompleteSnippet => {
- return {
- ...snippet,
- content: addCommentMarks(snippet.content, helper),
- }
-}
-
-export const formatSnippets = (
- helper: HelperVars,
- snippets: AutocompleteSnippet[],
- workspaceDirs: string[],
-): string => {
- const currentFilepathComment = addCommentMarks(
- getLastNUriRelativePathParts(workspaceDirs, helper.filepath, 2),
- helper,
- )
-
- return (
- snippets
- .map((snippet) => {
- switch (snippet.type) {
- case AutocompleteSnippetType.Code:
- return formatCodeSnippet(snippet, workspaceDirs)
- case AutocompleteSnippetType.Diff:
- return formatDiffSnippet(snippet)
- case AutocompleteSnippetType.Clipboard:
- return formatClipboardSnippet(snippet, workspaceDirs)
- case AutocompleteSnippetType.Static:
- return formatStaticSnippet(snippet)
- }
- })
- .map((item) => {
- return commentifySnippet(helper, item).content
- })
- .join("\n") + `\n${currentFilepathComment}`
- )
-}
diff --git a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/templating/getStopTokens.ts b/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/templating/getStopTokens.ts
deleted file mode 100644
index cbaa9f3d867..00000000000
--- a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/templating/getStopTokens.ts
+++ /dev/null
@@ -1,28 +0,0 @@
-import { CompletionOptions } from "../.."
-import { AutocompleteLanguageInfo } from "../constants/AutocompleteLanguageInfo"
-
-// TODO: Do we want to stop completions when reaching a `/src/` string?
-const SRC_DIRECTORY = "/src/"
-// Starcoder2 tends to output artifacts starting with the letter "t"
-const STARCODER2_T_ARTIFACTS = ["t.", "\nt", ""]
-const PYTHON_ENCODING = "#- coding: utf-8"
-const CODE_BLOCK_END = "```"
-
-// const multilineStops: string[] = [DOUBLE_NEWLINE, WINDOWS_DOUBLE_NEWLINE];
-const commonStops = [SRC_DIRECTORY, PYTHON_ENCODING, CODE_BLOCK_END]
-
-export function getStopTokens(
- completionOptions: Partial | undefined,
- _lang: AutocompleteLanguageInfo,
- model: string,
-): string[] {
- const stopTokens = [
- ...(completionOptions?.stop || []),
- // ...multilineStops,
- ...commonStops,
- ...(model.toLowerCase().includes("starcoder2") ? STARCODER2_T_ARTIFACTS : []),
- // ...lang.topLevelKeywords.map((word) => `\n${word}`),
- ]
-
- return stopTokens
-}
diff --git a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/templating/index.ts b/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/templating/index.ts
deleted file mode 100644
index 43516dfb9ed..00000000000
--- a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/templating/index.ts
+++ /dev/null
@@ -1,205 +0,0 @@
-import { CompletionOptions } from "../.."
-import { HelperVars } from "../util/HelperVars"
-
-import { ILLM } from "../../index.js"
-import { DEFAULT_MAX_TOKENS } from "../../llm/constants.js"
-import {
- countTokens,
- getTokenCountingBufferSafety,
- pruneLinesFromBottom,
- pruneLinesFromTop,
-} from "../../llm/countTokens"
-import { getUriPathBasename } from "../../util/uri"
-import { SnippetPayload } from "../snippets"
-import { AutocompleteSnippet } from "../types"
-import { AutocompleteTemplate, getTemplateForModel } from "./AutocompleteTemplate"
-import { getSnippets } from "./filtering"
-import { formatSnippets } from "./formatting"
-import { getStopTokens } from "./getStopTokens"
-
-function getTemplate(helper: HelperVars): AutocompleteTemplate {
- return getTemplateForModel(helper.modelName)
-}
-
-/** Consolidates shared setup between renderPrompt and renderPromptWithTokenLimit. */
-function preparePromptContext({
- snippetPayload,
- workspaceDirs,
- helper,
-}: {
- snippetPayload: SnippetPayload
- workspaceDirs: string[]
- helper: HelperVars
-}): {
- prefix: string
- suffix: string
- reponame: string
- template: AutocompleteTemplate["template"]
- compilePrefixSuffix: AutocompleteTemplate["compilePrefixSuffix"] | undefined
- completionOptions: Partial | undefined
- snippets: AutocompleteSnippet[]
-} {
- // Determine base prefix/suffix, accounting for any manually supplied prefix.
- const prefix = helper.input.manuallyPassPrefix || helper.prunedPrefix
- let suffix = helper.input.manuallyPassPrefix ? "" : helper.prunedSuffix
- if (suffix === "") {
- suffix = "\n"
- }
-
- const reponame = getUriPathBasename(workspaceDirs[0] ?? "myproject")
-
- const { template, compilePrefixSuffix, completionOptions } = getTemplate(helper)
-
- const snippets = getSnippets(helper, snippetPayload)
-
- return {
- prefix,
- suffix,
- reponame,
- template,
- compilePrefixSuffix,
- completionOptions,
- snippets,
- }
-}
-
-export function renderPrompt({
- snippetPayload,
- workspaceDirs,
- helper,
-}: {
- snippetPayload: SnippetPayload
- workspaceDirs: string[]
- helper: HelperVars
-}): {
- prompt: string
- prefix: string
- suffix: string
- completionOptions: Partial | undefined
-} {
- const { prefix, suffix, reponame, template, compilePrefixSuffix, completionOptions, snippets } = preparePromptContext(
- { snippetPayload, workspaceDirs, helper },
- )
-
- // Delegate prompt construction to buildPrompt to avoid duplication.
- const {
- prompt,
- prefix: compiledPrefix,
- suffix: compiledSuffix,
- } = buildPrompt(template, compilePrefixSuffix, prefix, suffix, helper, snippets, workspaceDirs, reponame)
-
- const stopTokens = getStopTokens(completionOptions, helper.lang, helper.modelName)
-
- return {
- prompt,
- prefix: compiledPrefix,
- suffix: compiledSuffix,
- completionOptions: {
- ...completionOptions,
- stop: stopTokens,
- },
- }
-}
-
-/** Builds the final prompt by applying prefix/suffix compilation or snippet formatting, then rendering the template. */
-function buildPrompt(
- template: AutocompleteTemplate["template"],
- compilePrefixSuffix: AutocompleteTemplate["compilePrefixSuffix"] | undefined,
- prefix: string,
- suffix: string,
- helper: HelperVars,
- snippets: AutocompleteSnippet[],
- workspaceDirs: string[],
- reponame: string,
-): { prompt: string; prefix: string; suffix: string } {
- if (compilePrefixSuffix) {
- ;[prefix, suffix] = compilePrefixSuffix(prefix, suffix, helper.filepath, reponame, snippets, helper.workspaceUris)
- } else {
- const formatted = formatSnippets(helper, snippets, workspaceDirs)
- prefix = [formatted, prefix].join("\n")
- }
- const prompt = template(prefix, suffix, helper.filepath, reponame, helper.lang.name, snippets, helper.workspaceUris)
- return { prompt, prefix, suffix }
-}
-
-function pruneLength(llm: ILLM, prompt: string): number {
- const contextLength = llm.contextLength
- const reservedTokens = llm.completionOptions.maxTokens ?? DEFAULT_MAX_TOKENS
- const safetyBuffer = getTokenCountingBufferSafety(contextLength)
- const maxAllowedPromptTokens = contextLength - reservedTokens - safetyBuffer
- const promptTokenCount = countTokens(prompt, llm.model)
- return promptTokenCount - maxAllowedPromptTokens
-}
-
-export function renderPromptWithTokenLimit({
- snippetPayload,
- workspaceDirs,
- helper,
- llm,
-}: {
- snippetPayload: SnippetPayload
- workspaceDirs: string[]
- helper: HelperVars
- llm: ILLM | undefined
-}): {
- prompt: string
- prefix: string
- suffix: string
- completionOptions: Partial | undefined
-} {
- const {
- prefix: initialPrefix,
- suffix: initialSuffix,
- reponame,
- template,
- compilePrefixSuffix,
- completionOptions,
- snippets,
- } = preparePromptContext({ snippetPayload, workspaceDirs, helper })
-
- // We'll mutate prefix/suffix during pruning, so copy them.
- let prefix = initialPrefix
- let suffix = initialSuffix
-
- let {
- prompt,
- prefix: compiledPrefix,
- suffix: compiledSuffix,
- } = buildPrompt(template, compilePrefixSuffix, prefix, suffix, helper, snippets, workspaceDirs, reponame)
-
- // Truncate prefix and suffix if prompt tokens exceed maxAllowedPromptTokens
- if (llm) {
- const prune = pruneLength(llm, prompt)
- if (prune > 0) {
- const tokensToDrop = prune
- const prefixTokenCount = countTokens(prefix, helper.modelName)
- const suffixTokenCount = countTokens(suffix, helper.modelName)
- const totalContextTokens = prefixTokenCount + suffixTokenCount
- if (totalContextTokens > 0) {
- const dropPrefix = Math.ceil(tokensToDrop * (prefixTokenCount / totalContextTokens))
- const dropSuffix = Math.ceil(tokensToDrop - dropPrefix)
- const allowedPrefixTokens = Math.max(0, prefixTokenCount - dropPrefix)
- const allowedSuffixTokens = Math.max(0, suffixTokenCount - dropSuffix)
- prefix = pruneLinesFromTop(prefix, allowedPrefixTokens, helper.modelName)
- suffix = pruneLinesFromBottom(suffix, allowedSuffixTokens, helper.modelName)
- }
- ;({
- prompt,
- prefix: compiledPrefix,
- suffix: compiledSuffix,
- } = buildPrompt(template, compilePrefixSuffix, prefix, suffix, helper, snippets, workspaceDirs, reponame))
- }
- }
-
- const stopTokens = getStopTokens(completionOptions, helper.lang, helper.modelName)
-
- return {
- prompt,
- prefix: compiledPrefix,
- suffix: compiledSuffix,
- completionOptions: {
- ...completionOptions,
- stop: stopTokens,
- },
- }
-}
diff --git a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/util/AutocompleteDebouncer.ts b/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/util/AutocompleteDebouncer.ts
deleted file mode 100644
index 6bfb8a654ad..00000000000
--- a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/util/AutocompleteDebouncer.ts
+++ /dev/null
@@ -1,32 +0,0 @@
-import { randomUUID } from "node:crypto"
-
-export class AutocompleteDebouncer {
- private debounceTimeout: NodeJS.Timeout | undefined = undefined
- private currentRequestId: string | undefined = undefined
-
- async delayAndShouldDebounce(debounceDelay: number): Promise {
- // Generate a unique ID for this request
- const requestId = randomUUID()
- this.currentRequestId = requestId
-
- // Clear any existing timeout
- if (this.debounceTimeout) {
- clearTimeout(this.debounceTimeout)
- }
-
- // Create a new promise that resolves after the debounce delay
- return new Promise((resolve) => {
- this.debounceTimeout = setTimeout(() => {
- // When the timeout completes, check if this is still the most recent request
- const shouldDebounce = this.currentRequestId !== requestId
-
- // If this is the most recent request, it shouldn't be debounced
- if (!shouldDebounce) {
- this.currentRequestId = undefined
- }
-
- resolve(shouldDebounce)
- }, debounceDelay)
- })
- }
-}
diff --git a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/util/AutocompleteLoggingService.ts b/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/util/AutocompleteLoggingService.ts
deleted file mode 100644
index 83a8cf43ee4..00000000000
--- a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/util/AutocompleteLoggingService.ts
+++ /dev/null
@@ -1,93 +0,0 @@
-import { COUNT_COMPLETION_REJECTED_AFTER } from "../../util/parameters"
-import { AutocompleteOutcome } from "./types"
-
-export class AutocompleteLoggingService {
- // Key is completionId
- private _abortControllers = new Map()
- private _logRejectionTimeouts = new Map()
- private _outcomes = new Map()
- _lastDisplayedCompletion: { id: string; displayedAt: number } | undefined = undefined
-
- public createAbortController(completionId: string): AbortController {
- const abortController = new AbortController()
- this._abortControllers.set(completionId, abortController)
- return abortController
- }
-
- public deleteAbortController(completionId: string) {
- this._abortControllers.delete(completionId)
- }
-
- public cancel() {
- this._abortControllers.forEach((abortController) => {
- abortController.abort()
- })
- this._abortControllers.clear()
- }
-
- public accept(completionId: string): AutocompleteOutcome | undefined {
- if (this._logRejectionTimeouts.has(completionId)) {
- clearTimeout(this._logRejectionTimeouts.get(completionId))
- this._logRejectionTimeouts.delete(completionId)
- }
-
- if (this._outcomes.has(completionId)) {
- const outcome = this._outcomes.get(completionId)!
- outcome.accepted = true
- this.logAutocompleteOutcome(outcome)
- this._outcomes.delete(completionId)
- return outcome
- }
- return undefined
- }
-
- public cancelRejectionTimeout(completionId: string) {
- if (this._logRejectionTimeouts.has(completionId)) {
- clearTimeout(this._logRejectionTimeouts.get(completionId)!)
- this._logRejectionTimeouts.delete(completionId)
- }
-
- if (this._outcomes.has(completionId)) {
- this._outcomes.delete(completionId)
- }
- }
-
- public markDisplayed(completionId: string, outcome: AutocompleteOutcome) {
- const logRejectionTimeout = setTimeout(() => {
- // Wait 10 seconds, then assume it wasn't accepted
- outcome.accepted = false
- this.logAutocompleteOutcome(outcome)
- this._logRejectionTimeouts.delete(completionId)
- }, COUNT_COMPLETION_REJECTED_AFTER)
- this._outcomes.set(completionId, outcome)
- this._logRejectionTimeouts.set(completionId, logRejectionTimeout)
-
- // If the previously displayed completion is still waiting for rejection,
- // and this one is a continuation of that (the outcome.completion is the same modulo prefix)
- // then we should cancel the rejection timeout
- const previous = this._lastDisplayedCompletion
- const now = Date.now()
- if (previous && this._logRejectionTimeouts.has(previous.id)) {
- const previousOutcome = this._outcomes.get(previous.id)
- const c1 = previousOutcome?.completion.split("\n")[0] ?? ""
- const c2 = outcome.completion.split("\n")[0]
- if (previousOutcome && (c1.endsWith(c2) || c2.endsWith(c1) || c1.startsWith(c2) || c2.startsWith(c1))) {
- this.cancelRejectionTimeout(previous.id)
- } else if (now - previous.displayedAt < 500) {
- // If a completion isn't shown for more than
- this.cancelRejectionTimeout(previous.id)
- }
- }
-
- this._lastDisplayedCompletion = {
- id: completionId,
- displayedAt: now,
- }
- }
-
- private logAutocompleteOutcome(outcome: AutocompleteOutcome) {
- if (!process.env.VITEST) {
- console.log(outcome)
- }
- }
-}
diff --git a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/util/AutocompleteLruCacheInMem.test.ts b/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/util/AutocompleteLruCacheInMem.test.ts
deleted file mode 100644
index 216a979749b..00000000000
--- a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/util/AutocompleteLruCacheInMem.test.ts
+++ /dev/null
@@ -1,247 +0,0 @@
-import { describe, it, expect, beforeEach } from "vitest"
-import { AutocompleteLruCacheInMem } from "./AutocompleteLruCacheInMem"
-
-describe("AutoCompleteLruCacheInMem", () => {
- let cache: AutocompleteLruCacheInMem
-
- beforeEach(async () => {
- cache = await AutocompleteLruCacheInMem.get()
- })
-
- describe("basic operations", () => {
- it("should store and retrieve a value", async () => {
- await cache.put("hello", "world")
- const result = await cache.get("hello")
- expect(result).toBe("world")
- })
-
- it("should return undefined for non-existent key", async () => {
- const result = await cache.get("nonexistent")
- expect(result).toBeUndefined()
- })
-
- it("should update existing value", async () => {
- await cache.put("key", "value1")
- await cache.put("key", "value2")
- const result = await cache.get("key")
- expect(result).toBe("value2")
- })
- })
-
- describe("exact key matching", () => {
- it("should match exact key and return value", async () => {
- await cache.put("hello", "world")
- const result = await cache.get("hello")
- expect(result).toBe("world")
- })
-
- it("should return undefined when key doesn't match exactly", async () => {
- await cache.put("hello", "world")
- const result = await cache.get("goodbye")
- expect(result).toBeUndefined()
- })
-
- it("should return undefined for partial key match", async () => {
- await cache.put("hello", "world")
- const result = await cache.get("hel")
- expect(result).toBeUndefined()
- })
-
- it("should be case sensitive", async () => {
- await cache.put("Hello", "World")
- const result1 = await cache.get("Hello")
- const result2 = await cache.get("hello")
- expect(result1).toBe("World")
- expect(result2).toBeUndefined()
- })
- })
-
- describe("fuzzy matching", () => {
- it("should return completion when prefix extends a cached key", async () => {
- // Cache "c" -> "ontinue"
- await cache.put("c", "ontinue")
- // Query "co" should return "ntinue" (completion minus what we already have)
- const result = await cache.get("co")
- expect(result).toBe("ntinue")
- })
-
- it("should prefer longest matching key", async () => {
- // Cache multiple overlapping keys
- await cache.put("h", "ello world")
- await cache.put("he", "llo world")
- await cache.put("hel", "lo world")
-
- // Query "hello" should match "hel" (longest key)
- // User typed "hello" = "hel" + "lo", cached completion is "lo world"
- // So return " world" (the part not yet typed)
- const result = await cache.get("hello")
- expect(result).toBe(" world")
- })
-
- it("should validate cached completion starts correctly", async () => {
- // Cache "c" -> "ontinue"
- await cache.put("c", "ontinue")
- // Query "cx" doesn't match the completion pattern, should return undefined
- const result = await cache.get("cx")
- expect(result).toBeUndefined()
- })
-
- it("should return exact match if available", async () => {
- // Cache both exact and partial keys
- await cache.put("co", "mplete")
- await cache.put("c", "ontinue")
-
- // Exact match should be preferred
- const result = await cache.get("co")
- expect(result).toBe("mplete")
- })
-
- it("should handle multiple partial matches correctly", async () => {
- // Cache overlapping prefixes
- await cache.put("fun", "ction")
- await cache.put("f", "unction")
-
- // Query "func" should match "fun" (longest) and return "ction"
- const result = await cache.get("func")
- expect(result).toBe("tion")
- })
-
- it("should return undefined when no fuzzy match exists", async () => {
- await cache.put("hello", "world")
- // "goodbye" doesn't start with "hello"
- const result = await cache.get("goodbye")
- expect(result).toBeUndefined()
- })
-
- it("should handle empty cache for fuzzy matching", async () => {
- const result = await cache.get("anyprefix")
- expect(result).toBeUndefined()
- })
- })
-
- describe("LRU eviction", () => {
- it("should evict oldest entry when capacity is reached", async () => {
- // Create a fresh cache for this test
- const testCache = await AutocompleteLruCacheInMem.get()
-
- // Fill cache to capacity (100 entries)
- for (let i = 0; i < 100; i++) {
- await testCache.put(`key${i}`, `value${i}`)
- }
-
- // Add one more entry to trigger eviction
- await testCache.put("newkey", "newvalue")
-
- // First entry should be evicted (oldest timestamp)
- const result = await testCache.get("key0")
- expect(result).toBeUndefined()
-
- // New entry should exist
- const newResult = await testCache.get("newkey")
- expect(newResult).toBe("newvalue")
- })
-
- it("should update timestamp on cache hit", async () => {
- // Create a fresh cache for this test
- const testCache = await AutocompleteLruCacheInMem.get()
-
- // Fill to capacity
- for (let i = 0; i < 100; i++) {
- await testCache.put(`key${i}`, `value${i}`)
- }
-
- // Access an early entry to refresh its timestamp
- const refreshedValue = await testCache.get("key5")
- expect(refreshedValue).toBe("value5")
-
- // Add new entries to trigger evictions
- await testCache.put("new1", "newvalue1")
- await testCache.put("new2", "newvalue2")
-
- // key5 should still exist (refreshed timestamp)
- const key5Result = await testCache.get("key5")
- expect(key5Result).toBe("value5")
-
- // key0 should be evicted (oldest timestamp, never accessed)
- const key0Result = await testCache.get("key0")
- expect(key0Result).toBeUndefined()
- })
- })
-
- describe("edge cases", () => {
- it("should handle empty strings", async () => {
- const testCache = await AutocompleteLruCacheInMem.get()
- await testCache.put("", "empty")
- const result = await testCache.get("")
- expect(result).toBe("empty")
- })
-
- it("should handle very long strings", async () => {
- const testCache = await AutocompleteLruCacheInMem.get()
- const longString = "a".repeat(10000)
- await testCache.put(longString, "completion")
- const result = await testCache.get(longString)
- expect(result).toBe("completion")
- })
-
- it("should handle special characters", async () => {
- await cache.put("const x = {", "foo: 'bar'}")
- const result = await cache.get("const x = {")
- expect(result).toBe("foo: 'bar'}")
- })
-
- it("should handle unicode characters", async () => {
- await cache.put("emoji 🚀", "rocket")
- const result = await cache.get("emoji 🚀")
- expect(result).toBe("rocket")
- })
- })
-
- describe("concurrent operations", () => {
- it("should handle concurrent put operations", async () => {
- const promises = []
- for (let i = 0; i < 10; i++) {
- promises.push(cache.put(`concurrent${i}`, `value${i}`))
- }
- await Promise.all(promises)
-
- // All values should be stored
- for (let i = 0; i < 10; i++) {
- const result = await cache.get(`concurrent${i}`)
- expect(result).toBe(`value${i}`)
- }
- })
-
- it("should handle concurrent get operations", async () => {
- await cache.put("shared", "value")
-
- const promises = []
- for (let i = 0; i < 10; i++) {
- promises.push(cache.get("shared"))
- }
- const results = await Promise.all(promises)
-
- // All gets should return the same value
- results.forEach((result) => {
- expect(result).toBe("value")
- })
- })
- })
-
- describe("multiple cache instances", () => {
- it("should create separate cache instances", async () => {
- const cache1 = await AutocompleteLruCacheInMem.get()
- const cache2 = await AutocompleteLruCacheInMem.get()
-
- await cache1.put("test", "value1")
- await cache2.put("test", "value2")
-
- const result1 = await cache1.get("test")
- const result2 = await cache2.get("test")
-
- // Each instance should have its own data
- expect(result1).toBe("value1")
- expect(result2).toBe("value2")
- })
- })
-})
diff --git a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/util/AutocompleteLruCacheInMem.ts b/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/util/AutocompleteLruCacheInMem.ts
deleted file mode 100644
index 3cad96a860a..00000000000
--- a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/util/AutocompleteLruCacheInMem.ts
+++ /dev/null
@@ -1,77 +0,0 @@
-import { LRUCache } from "lru-cache"
-
-const MAX_PREFIX_LENGTH = 50000
-
-function truncatePrefix(input: string, safety: number = 100): string {
- const maxBytes = MAX_PREFIX_LENGTH - safety
- let bytes = 0
- let startIndex = 0
-
- // Count bytes from the end, keeping the most recent typing
- for (let i = input.length - 1; i >= 0; i--) {
- bytes += new TextEncoder().encode(input[i]).length
- if (bytes > maxBytes) {
- startIndex = i + 1
- break
- }
- }
-
- return input.substring(startIndex)
-}
-
-export class AutocompleteLruCacheInMem {
- private static capacity = 100
- private cache: LRUCache
-
- private constructor() {
- this.cache = new LRUCache({
- max: AutocompleteLruCacheInMem.capacity,
- })
- }
-
- static async get(): Promise {
- return new AutocompleteLruCacheInMem()
- }
-
- async get(prefix: string): Promise {
- const truncated = truncatePrefix(prefix)
-
- // First try exact match (faster)
- const exactMatch = this.cache.get(truncated)
- if (exactMatch !== undefined) {
- return exactMatch
- }
-
- // Then try fuzzy matching - find keys where prefix starts with the key
- // If the query is "co" and we have "c" -> "ontinue" in the cache,
- // we should return "ntinue" as the completion.
- // Have to make sure we take the key with longest length for best match
- let bestMatch: { key: string; value: string } | null = null
- let longestKeyLength = 0
-
- for (const [key, value] of this.cache.entries()) {
- // Check if truncated prefix starts with this key
- if (truncated.startsWith(key) && key.length > longestKeyLength) {
- bestMatch = { key, value }
- longestKeyLength = key.length
- }
- }
-
- if (bestMatch) {
- // Validate that the cached completion is a valid completion for the prefix
- if (bestMatch.value.startsWith(truncated.slice(bestMatch.key.length))) {
- // Update LRU timestamp for the matched key by accessing it
- this.cache.get(bestMatch.key)
- // Return the portion of the value that extends beyond the current prefix
- return bestMatch.value.slice(truncated.length - bestMatch.key.length)
- }
- }
-
- return undefined
- }
-
- async put(prefix: string, completion: string) {
- const truncated = truncatePrefix(prefix)
- this.cache.set(truncated, completion)
- }
-}
diff --git a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/util/completionTestUtils.test.ts b/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/util/completionTestUtils.test.ts
deleted file mode 100644
index 045f3995b28..00000000000
--- a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/util/completionTestUtils.test.ts
+++ /dev/null
@@ -1,63 +0,0 @@
-import { describe, expect, it } from "vitest"
-import { processTestCase, type CompletionTestCase } from "./completionTestUtils"
-
-describe("processTestCase utility", () => {
- it("processes simple console.log completion", () => {
- const testCase: CompletionTestCase = {
- original: "console.log(|cur||till|)",
- completion: '"foo,", bar',
- }
-
- expect(processTestCase(testCase)).toEqual({
- input: {
- lastLineOfCompletionText: '"foo,", bar',
- currentText: ")",
- cursorPosition: "console.log(".length,
- },
- expectedResult: {
- completionText: '"foo,", bar',
- },
- })
- })
-
- it("processes simple console.log completion with overwriting", () => {
- const testCase: CompletionTestCase = {
- original: "console.log(|cur|)|till|",
- completion: '"foo,", bar);',
- }
-
- expect(processTestCase(testCase)).toEqual({
- input: {
- lastLineOfCompletionText: '"foo,", bar);',
- currentText: ")",
- cursorPosition: "console.log(".length,
- },
- expectedResult: {
- completionText: '"foo,", bar);',
- range: {
- start: "console.log(".length,
- end: "console.log()".length,
- },
- },
- })
- })
-
- it("partially applying completion", () => {
- const testCase: CompletionTestCase = {
- original: '|cur||till|fetch("https://example.com");',
- completion: 'await fetch("https://example.com");',
- appliedCompletion: "await ",
- }
-
- expect(processTestCase(testCase)).toEqual({
- input: {
- lastLineOfCompletionText: 'await fetch("https://example.com");',
- currentText: 'fetch("https://example.com");',
- cursorPosition: 0,
- },
- expectedResult: {
- completionText: "await ",
- },
- })
- })
-})
diff --git a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/util/completionTestUtils.ts b/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/util/completionTestUtils.ts
deleted file mode 100644
index 9dfbc6c63c5..00000000000
--- a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/util/completionTestUtils.ts
+++ /dev/null
@@ -1,94 +0,0 @@
-export interface CompletionTestCase {
- original: string // Text with |cur| and |till| markers
- completion: string // Text to insert/overwrite
- appliedCompletion?: string | null
- cursorMarker?: string
- tillMarker?: string
-}
-
-interface ProcessedTestCase {
- input: {
- lastLineOfCompletionText: string
- currentText: string
- cursorPosition: number
- }
- expectedResult: {
- completionText: string
- range?: {
- start: number
- end: number
- }
- }
-}
-
-/**
- * Transforms human-readable test case into input and expected results.
- *
- * - `original`: Your original text with |cur| marking where the cursor is before completion,
- * and |till| marking where the cursor should be after accepting completion (and this is
- * the end of the actual applied completion)
- * - `completion`: LLM completion output
- * - `appliedCompletion` (optional): part of the LLM completion output that is actually applied
- * (written between |cur| and |till| in the original)
- *
- * For example, you have this line:
- *
- * console.log("");
- *
- * and expect it to be completed this way:
- *
- * console.log("foo: ", bar);
- *
- * with your completion coming from LLM being: `'foo: ", bar);'`
- *
- * Your input to this function should be:
- * - original: `'console.log("|cur|"|till|);'`
- * - completion: `'foo: ", bar);'`
- * - appliedCompletion: `'foo: ", bar'`
- *
- * Output: input and expected output of {@link core/autocomplete/util/processSingleLineCompletion/processSingleLineCompletion|processSingleLineCompletion()}
- *
- */
-export function processTestCase({
- original,
- completion,
- appliedCompletion = null,
- cursorMarker = "|cur|",
- tillMarker = "|till|",
-}: CompletionTestCase): ProcessedTestCase {
- // Validate cursor marker
- if (!original.includes(cursorMarker)) {
- throw new Error("Cursor marker not found in original text")
- }
-
- const cursorPos = original.indexOf(cursorMarker)
- original = original.replace(cursorMarker, "")
-
- let tillPos = original.indexOf(tillMarker)
- if (tillPos < 0) {
- tillPos = cursorPos
- } else {
- original = original.replace(tillMarker, "")
- }
-
- // Calculate currentText based on what's between cursor and till marker
- const currentText = original.substring(cursorPos)
-
- return {
- input: {
- lastLineOfCompletionText: completion,
- currentText,
- cursorPosition: cursorPos,
- },
- expectedResult: {
- completionText: appliedCompletion || completion,
- range:
- cursorPos === tillPos
- ? undefined
- : {
- start: cursorPos,
- end: tillPos,
- },
- },
- }
-}
diff --git a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/util/processSingleLineCompletion.test.ts b/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/util/processSingleLineCompletion.test.ts
deleted file mode 100644
index df60fd5123a..00000000000
--- a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/util/processSingleLineCompletion.test.ts
+++ /dev/null
@@ -1,96 +0,0 @@
-import { describe, expect, it } from "vitest"
-import { processTestCase } from "./completionTestUtils"
-import { processSingleLineCompletion } from "./processSingleLineCompletion"
-
-describe("processSingleLineCompletion", () => {
- it("should handle simple end of line completion", () => {
- const testCase = processTestCase({
- original: "console.log(|cur|",
- completion: '"Hello, world!")',
- })
-
- const result = processSingleLineCompletion(
- testCase.input.lastLineOfCompletionText,
- testCase.input.currentText,
- testCase.input.cursorPosition,
- )
-
- expect(result).toEqual(testCase.expectedResult)
- })
-
- it("should handle midline insert repeating the end of line", () => {
- const testCase = processTestCase({
- original: "console.log(|cur|);|till|",
- completion: '"Hello, world!");',
- })
-
- const result = processSingleLineCompletion(
- testCase.input.lastLineOfCompletionText,
- testCase.input.currentText,
- testCase.input.cursorPosition,
- )
-
- expect(result).toEqual(testCase.expectedResult)
- })
-
- it("should handle midline insert repeating the end of line plus adding a semicolon", () => {
- const testCase = processTestCase({
- original: "console.log(|cur|)|till|",
- completion: '"Hello, world!");',
- })
-
- const result = processSingleLineCompletion(
- testCase.input.lastLineOfCompletionText,
- testCase.input.currentText,
- testCase.input.cursorPosition,
- )
-
- expect(result).toEqual(testCase.expectedResult)
- })
-
- it("should handle simple midline insert", () => {
- const testCase = processTestCase({
- original: "console.log(|cur|)",
- completion: '"Hello, world!"',
- })
-
- const result = processSingleLineCompletion(
- testCase.input.lastLineOfCompletionText,
- testCase.input.currentText,
- testCase.input.cursorPosition,
- )
-
- expect(result).toEqual(testCase.expectedResult)
- })
-
- it("should handle complex dif with addition in the beginning", () => {
- const testCase = processTestCase({
- original: 'console.log(|cur||till|, "param1", )', // TODO
- completion: '"Hello world!", "param1", param1);',
- appliedCompletion: '"Hello world!"',
- })
-
- const result = processSingleLineCompletion(
- testCase.input.lastLineOfCompletionText,
- testCase.input.currentText,
- testCase.input.cursorPosition,
- )
-
- expect(result).toEqual(testCase.expectedResult)
- })
-
- it("should handle simple insertion even with random equality", () => {
- const testCase = processTestCase({
- original: 'print(f"Foobar length: |cur||till|")',
- completion: "{len(foobar)}",
- })
-
- const result = processSingleLineCompletion(
- testCase.input.lastLineOfCompletionText,
- testCase.input.currentText,
- testCase.input.cursorPosition,
- )
-
- expect(result).toEqual(testCase.expectedResult)
- })
-})
diff --git a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/util/processSingleLineCompletion.ts b/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/util/processSingleLineCompletion.ts
deleted file mode 100644
index f4642295472..00000000000
--- a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/util/processSingleLineCompletion.ts
+++ /dev/null
@@ -1,80 +0,0 @@
-import * as Diff from "diff"
-
-interface SingleLineCompletionResult {
- completionText: string
- range?: {
- start: number
- end: number
- }
-}
-
-interface DiffType {
- count?: number
- added?: boolean
- removed?: boolean
- value: string
-}
-
-function diffPatternMatches(diffs: DiffType[], pattern: DiffPartType[]): boolean {
- if (diffs.length !== pattern.length) {
- return false
- }
-
- for (let i = 0; i < diffs.length; i++) {
- const diff = diffs[i]
- const diffPartType: DiffPartType = !diff.added && !diff.removed ? "=" : diff.added ? "+" : "-"
-
- if (diffPartType !== pattern[i]) {
- return false
- }
- }
-
- return true
-}
-
-type DiffPartType = "+" | "-" | "="
-
-export function processSingleLineCompletion(
- lastLineOfCompletionText: string,
- currentText: string,
- cursorPosition: number,
-): SingleLineCompletionResult | undefined {
- const diffs: DiffType[] = Diff.diffWords(currentText, lastLineOfCompletionText)
-
- if (diffPatternMatches(diffs, ["+"])) {
- // Just insert, we're already at the end of the line
- return {
- completionText: lastLineOfCompletionText,
- }
- }
-
- if (diffPatternMatches(diffs, ["+", "="]) || diffPatternMatches(diffs, ["+", "=", "+"])) {
- // The model repeated the text after the cursor to the end of the line
- return {
- completionText: lastLineOfCompletionText,
- range: {
- start: cursorPosition,
- end: currentText.length + cursorPosition,
- },
- }
- }
-
- if (diffPatternMatches(diffs, ["+", "-"]) || diffPatternMatches(diffs, ["-", "+"])) {
- // We are midline and the model just inserted without repeating to the end of the line
- return {
- completionText: lastLineOfCompletionText,
- }
- }
-
- // For any other diff pattern, just use the first added part if available
- if (diffs[0]?.added) {
- return {
- completionText: diffs[0].value,
- }
- }
-
- // Default case: treat as simple insertion
- return {
- completionText: lastLineOfCompletionText,
- }
-}
diff --git a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/util/types.ts b/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/util/types.ts
index 815bb4a66a6..1b11559f8a0 100644
--- a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/util/types.ts
+++ b/packages/kilo-vscode/src/services/autocomplete/continuedev/core/autocomplete/util/types.ts
@@ -1,5 +1,5 @@
-import { Position, Range, RangeInFile, TabAutocompleteOptions } from "../.."
-import { AutocompleteCodeSnippet } from "../types"
+import type { Position, Range, RangeInFile } from "../.."
+import type { AutocompleteCodeSnippet } from "../types"
export type RecentlyEditedRange = RangeInFile & {
timestamp: number
@@ -24,24 +24,3 @@ export interface AutocompleteInput {
}
injectDetails?: string
}
-
-export interface AutocompleteOutcome extends TabAutocompleteOptions {
- accepted?: boolean
- time: number
- prefix: string
- suffix: string
- prompt: string
- completion: string
- modelProvider: string
- modelName: string
- completionOptions: any
- cacheHit: boolean
- numLines: number
- filepath: string
- gitRepo?: string
- completionId: string
- uniqueId: string
- timestamp: string
- enabledStaticContextualization?: boolean
- profileType?: "local" | "platform" | "control-plane"
-}
diff --git a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/diff/myers.test.ts b/packages/kilo-vscode/src/services/autocomplete/continuedev/core/diff/myers.test.ts
deleted file mode 100644
index 40011c37992..00000000000
--- a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/diff/myers.test.ts
+++ /dev/null
@@ -1,634 +0,0 @@
-import { describe, expect, test } from "vitest"
-
-import { dedent } from "../util"
-
-import { myersCharDiff, myersDiff } from "./myers"
-
-describe("Test myers diff function", () => {
- test("should ...", () => {
- const linesA = dedent`
- A
- B
- C
- D
- E
- `
- const linesB = dedent`
- A
- B
- C'
- D'
- E
- `
- const diffLines = myersDiff(linesA, linesB)
- expect(diffLines).toEqual([
- { type: "same", line: "A" },
- { type: "same", line: "B" },
- { type: "old", line: "C" },
- { type: "old", line: "D" },
- { type: "new", line: "C'" },
- { type: "new", line: "D'" },
- { type: "same", line: "E" },
- ])
- })
-
- test("should ignore newline differences at end", () => {
- const linesA = "A\nB\nC\n"
- const linesB = "A\nB\nC"
-
- const diffLines = myersDiff(linesA, linesB)
- expect(diffLines).toEqual([
- { type: "same", line: "A" },
- { type: "same", line: "B" },
- { type: "same", line: "C" },
- ])
- })
-
- test("should ignore single-line whitespace-only differences", () => {
- const linesA = "A\n B\nC\n"
- const linesB = "A\nB\nC"
-
- const diffLines = myersDiff(linesA, linesB)
- expect(diffLines).toEqual([
- { type: "same", line: "A" },
- { type: "same", line: " B" },
- { type: "same", line: "C" },
- ])
- })
-})
-
-describe("Test myersCharDiff function on the same line", () => {
- test("should differentiate character changes", () => {
- const oldContent = "hello world"
- const newContent = "hello earth"
-
- const diffChars = myersCharDiff(oldContent, newContent)
- expect(diffChars).toEqual([
- {
- type: "same",
- char: "hello ",
- oldIndex: 0,
- newIndex: 0,
- oldCharIndexInLine: 0,
- newCharIndexInLine: 0,
- oldLineIndex: 0,
- newLineIndex: 0,
- },
- {
- type: "old",
- char: "wo",
- oldIndex: 6,
- oldCharIndexInLine: 6,
- oldLineIndex: 0,
- },
- {
- type: "new",
- char: "ea",
- newIndex: 6,
- newCharIndexInLine: 6,
- newLineIndex: 0,
- },
- {
- type: "same",
- char: "r",
- oldIndex: 8,
- newIndex: 8,
- oldCharIndexInLine: 8,
- newCharIndexInLine: 8,
- oldLineIndex: 0,
- newLineIndex: 0,
- },
- {
- type: "old",
- char: "ld",
- oldIndex: 9,
- oldCharIndexInLine: 9,
- oldLineIndex: 0,
- },
- {
- type: "new",
- char: "th",
- newIndex: 9,
- newCharIndexInLine: 9,
- newLineIndex: 0,
- },
- ])
- })
-
- test("should handle insertions", () => {
- const oldContent = "abc"
- const newContent = "abxyzc"
-
- const diffChars = myersCharDiff(oldContent, newContent)
- expect(diffChars).toEqual([
- {
- type: "same",
- char: "ab",
- oldIndex: 0,
- newIndex: 0,
- oldCharIndexInLine: 0,
- newCharIndexInLine: 0,
- oldLineIndex: 0,
- newLineIndex: 0,
- },
- {
- type: "new",
- char: "xyz",
- newIndex: 2,
- newCharIndexInLine: 2,
- newLineIndex: 0,
- },
- {
- type: "same",
- char: "c",
- oldIndex: 2,
- newIndex: 5,
- oldCharIndexInLine: 2,
- newCharIndexInLine: 5,
- oldLineIndex: 0,
- newLineIndex: 0,
- },
- ])
- })
-
- test("should handle deletions", () => {
- const oldContent = "abxyzc"
- const newContent = "abc"
-
- const diffChars = myersCharDiff(oldContent, newContent)
- expect(diffChars).toEqual([
- {
- type: "same",
- char: "ab",
- oldIndex: 0,
- newIndex: 0,
- oldCharIndexInLine: 0,
- newCharIndexInLine: 0,
- oldLineIndex: 0,
- newLineIndex: 0,
- },
- {
- type: "old",
- char: "xyz",
- oldIndex: 2,
- oldCharIndexInLine: 2,
- oldLineIndex: 0,
- },
- {
- type: "same",
- char: "c",
- oldIndex: 5,
- newIndex: 2,
- oldCharIndexInLine: 5,
- newCharIndexInLine: 2,
- oldLineIndex: 0,
- newLineIndex: 0,
- },
- ])
- })
-
- test("should handle empty strings", () => {
- const oldContent = ""
- const newContent = "abc"
-
- const diffChars = myersCharDiff(oldContent, newContent)
- expect(diffChars).toEqual([
- {
- type: "new",
- char: "abc",
- newIndex: 0,
- newCharIndexInLine: 0,
- newLineIndex: 0,
- },
- ])
- })
-
- test("should handle identical strings", () => {
- const content = "no changes here"
-
- const diffChars = myersCharDiff(content, content)
- expect(diffChars).toEqual([
- {
- type: "same",
- char: "no changes here",
- oldIndex: 0,
- newIndex: 0,
- oldCharIndexInLine: 0,
- newCharIndexInLine: 0,
- oldLineIndex: 0,
- newLineIndex: 0,
- },
- ])
- })
-
- test("should handle whitespace changes", () => {
- const oldContent = "hello world"
- const newContent = "hello world"
-
- const diffChars = myersCharDiff(oldContent, newContent)
- expect(diffChars).toEqual([
- {
- type: "same",
- char: "hello ",
- oldIndex: 0,
- newIndex: 0,
- oldCharIndexInLine: 0,
- newCharIndexInLine: 0,
- oldLineIndex: 0,
- newLineIndex: 0,
- },
- {
- type: "new",
- char: " ",
- newIndex: 6,
- newCharIndexInLine: 6,
- newLineIndex: 0,
- },
- {
- type: "same",
- char: "world",
- oldIndex: 6,
- newIndex: 7,
- oldCharIndexInLine: 6,
- newCharIndexInLine: 7,
- oldLineIndex: 0,
- newLineIndex: 0,
- },
- ])
- })
-
- test("should handle complex changes", () => {
- const oldContent = "The quick brown fox jumps over the lazy dog"
- const newContent = "The fast brown fox leaps over the sleeping dog"
-
- const diffChars = myersCharDiff(oldContent, newContent)
- expect(diffChars).toEqual([
- {
- type: "same",
- char: "The ",
- oldIndex: 0,
- newIndex: 0,
- oldCharIndexInLine: 0,
- newCharIndexInLine: 0,
- oldLineIndex: 0,
- newLineIndex: 0,
- },
- {
- type: "old",
- char: "quick",
- oldIndex: 4,
- oldCharIndexInLine: 4,
- oldLineIndex: 0,
- },
- {
- type: "new",
- char: "fast",
- newIndex: 4,
- newCharIndexInLine: 4,
- newLineIndex: 0,
- },
- {
- type: "same",
- char: " brown fox ",
- oldIndex: 9,
- newIndex: 8,
- oldCharIndexInLine: 9,
- newCharIndexInLine: 8,
- oldLineIndex: 0,
- newLineIndex: 0,
- },
- {
- type: "old",
- char: "jum",
- oldIndex: 20,
- oldCharIndexInLine: 20,
- oldLineIndex: 0,
- },
- {
- type: "new",
- char: "lea",
- newIndex: 19,
- newCharIndexInLine: 19,
- newLineIndex: 0,
- },
- {
- type: "same",
- char: "ps over the ",
- oldIndex: 23,
- newIndex: 22,
- oldCharIndexInLine: 23,
- newCharIndexInLine: 22,
- oldLineIndex: 0,
- newLineIndex: 0,
- },
- {
- type: "new",
- char: "s",
- newIndex: 34,
- newCharIndexInLine: 34,
- newLineIndex: 0,
- },
- {
- type: "same",
- char: "l",
- oldIndex: 35,
- newIndex: 35,
- oldCharIndexInLine: 35,
- newCharIndexInLine: 35,
- oldLineIndex: 0,
- newLineIndex: 0,
- },
- {
- type: "old",
- char: "azy",
- oldIndex: 36,
- oldCharIndexInLine: 36,
- oldLineIndex: 0,
- },
- {
- type: "new",
- char: "eeping",
- newIndex: 36,
- newCharIndexInLine: 36,
- newLineIndex: 0,
- },
- {
- type: "same",
- char: " dog",
- oldIndex: 39,
- newIndex: 42,
- oldCharIndexInLine: 39,
- newCharIndexInLine: 42,
- oldLineIndex: 0,
- newLineIndex: 0,
- },
- ])
- })
-})
-
-describe("Test myersCharDiff function on different lines", () => {
- test("should track line indices for multi-line changes", () => {
- const oldContent = ["Line one", "Line two", "Line three"].join("\n")
-
- const newContent = ["Line one", "Modified line", "Line three"].join("\n")
-
- const diffChars = myersCharDiff(oldContent, newContent)
- expect(diffChars).toEqual([
- {
- type: "same",
- char: "Line one",
- oldIndex: 0,
- newIndex: 0,
- oldCharIndexInLine: 0,
- newCharIndexInLine: 0,
- oldLineIndex: 0,
- newLineIndex: 0,
- },
- {
- type: "same",
- char: "\n",
- oldIndex: 8,
- newIndex: 8,
- oldCharIndexInLine: 8,
- newCharIndexInLine: 8,
- oldLineIndex: 0,
- newLineIndex: 0,
- },
- {
- type: "old",
- char: "L",
- oldIndex: 9,
- oldCharIndexInLine: 0,
- oldLineIndex: 1,
- },
- {
- type: "new",
- char: "Mod",
- newIndex: 9,
- newCharIndexInLine: 0,
- newLineIndex: 1,
- },
- {
- char: "i",
- newCharIndexInLine: 3,
- newIndex: 12,
- newLineIndex: 1,
- oldCharIndexInLine: 1,
- oldIndex: 10,
- oldLineIndex: 1,
- type: "same",
- },
- {
- char: "n",
- oldCharIndexInLine: 2,
- oldIndex: 11,
- oldLineIndex: 1,
- type: "old",
- },
- {
- char: "fi",
- newCharIndexInLine: 4,
- newIndex: 13,
- newLineIndex: 1,
- type: "new",
- },
- {
- char: "e",
- newCharIndexInLine: 6,
- newIndex: 15,
- newLineIndex: 1,
- oldCharIndexInLine: 3,
- oldIndex: 12,
- oldLineIndex: 1,
- type: "same",
- },
- {
- char: "d",
- newCharIndexInLine: 7,
- newIndex: 16,
- newLineIndex: 1,
- type: "new",
- },
- {
- char: " ",
- newCharIndexInLine: 8,
- newIndex: 17,
- newLineIndex: 1,
- oldCharIndexInLine: 4,
- oldIndex: 13,
- oldLineIndex: 1,
- type: "same",
- },
- {
- type: "old",
- char: "two",
- oldCharIndexInLine: 5,
- oldIndex: 14,
- oldLineIndex: 1,
- },
- {
- type: "new",
- char: "line",
- newCharIndexInLine: 9,
- newIndex: 18,
- newLineIndex: 1,
- },
- {
- type: "same",
- char: "\n",
- oldIndex: 17,
- oldCharIndexInLine: 8,
- oldLineIndex: 1,
- newIndex: 22,
- newCharIndexInLine: 13,
- newLineIndex: 1,
- },
- {
- type: "same",
- char: "Line three",
- oldIndex: 18,
- newIndex: 23,
- oldCharIndexInLine: 0,
- newCharIndexInLine: 0,
- oldLineIndex: 2,
- newLineIndex: 2,
- },
- ])
- })
-
- test("should track line indices when adding new lines", () => {
- const oldContent = ["First line", "Last line"].join("\n")
-
- const newContent = ["First line", "Middle line", "Another middle", "Last line"].join("\n")
-
- const diffChars = myersCharDiff(oldContent, newContent)
- expect(diffChars).toEqual([
- {
- type: "same",
- char: "First line",
- oldIndex: 0,
- newIndex: 0,
- oldCharIndexInLine: 0,
- newCharIndexInLine: 0,
- oldLineIndex: 0,
- newLineIndex: 0,
- },
- {
- type: "same",
- char: "\n",
- oldIndex: 10,
- newIndex: 10,
- oldCharIndexInLine: 10,
- newCharIndexInLine: 10,
- oldLineIndex: 0,
- newLineIndex: 0,
- },
- {
- type: "new",
- char: "Middle line",
- newIndex: 11,
- newCharIndexInLine: 0,
- newLineIndex: 1,
- },
- {
- type: "new",
- char: "\n",
- newIndex: 22,
- newCharIndexInLine: 11,
- newLineIndex: 1,
- },
- {
- type: "new",
- char: "Another middle",
- newCharIndexInLine: 0,
- newIndex: 23,
- newLineIndex: 2,
- },
- {
- type: "new",
- char: "\n",
- newCharIndexInLine: 14,
- newIndex: 37,
- newLineIndex: 2,
- },
- {
- type: "same",
- char: "Last line",
- oldIndex: 11,
- oldCharIndexInLine: 0,
- oldLineIndex: 1,
- newIndex: 38,
- newCharIndexInLine: 0,
- newLineIndex: 3,
- },
- ])
- })
-
- test("should track line indices when removing lines", () => {
- const oldContent = ["Start", "Line to remove", "Another to remove", "End"].join("\n")
-
- const newContent = ["Start", "End"].join("\n")
-
- const diffChars = myersCharDiff(oldContent, newContent)
- expect(diffChars).toEqual([
- {
- type: "same",
- char: "Start",
- oldIndex: 0,
- newIndex: 0,
- oldCharIndexInLine: 0,
- newCharIndexInLine: 0,
- oldLineIndex: 0,
- newLineIndex: 0,
- },
- {
- type: "same",
- char: "\n",
- oldIndex: 5,
- newIndex: 5,
- oldCharIndexInLine: 5,
- newCharIndexInLine: 5,
- oldLineIndex: 0,
- newLineIndex: 0,
- },
- {
- type: "old",
- char: "Line to remove",
- oldIndex: 6,
- oldCharIndexInLine: 0,
- oldLineIndex: 1,
- },
- {
- type: "old",
- char: "\n",
- oldCharIndexInLine: 14,
- oldIndex: 20,
- oldLineIndex: 1,
- },
- {
- type: "old",
- char: "Another to remove",
- oldCharIndexInLine: 0,
- oldIndex: 21,
- oldLineIndex: 2,
- },
- {
- type: "old",
- char: "\n",
- oldCharIndexInLine: 17,
- oldIndex: 38,
- oldLineIndex: 2,
- },
- {
- type: "same",
- char: "End",
- oldIndex: 39,
- newIndex: 6,
- oldCharIndexInLine: 0,
- newCharIndexInLine: 0,
- oldLineIndex: 3,
- newLineIndex: 1,
- },
- ])
- })
-})
diff --git a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/diff/myers.ts b/packages/kilo-vscode/src/services/autocomplete/continuedev/core/diff/myers.ts
deleted file mode 100644
index 1d61d26d769..00000000000
--- a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/diff/myers.ts
+++ /dev/null
@@ -1,204 +0,0 @@
-import { diffChars, diffLines, type Change } from "diff"
-
-import { DiffChar, DiffLine } from ".."
-
-function convertMyersChangeToDiffLines(change: Change): DiffLine[] {
- const type: DiffLine["type"] = change.added ? "new" : change.removed ? "old" : "same"
- const lines = change.value.split("\n")
-
- // Ignore the \n at the end of the final line, if there is one
- if (lines[lines.length - 1] === "") {
- lines.pop()
- }
-
- return lines.map((line) => ({ type, line }))
-}
-
-// The interpretation of lines in oldContent and newContent is the same as jsdiff
-// Lines are separated by \n, with the exception that a trailing \n does *not*
-// represent an empty line.
-//
-// The default for jsdiff is that "foo" and "foo\n" are *different* single-line
-// contents, but we can't represent that: to avoid a diff
-// [ { type: "old", line: "foo" }, { type: "new", line: "foo" } ], we
-// pass ignoreNewlineAtEof: true.
-export function myersDiff(oldContent: string, newContent: string): DiffLine[] {
- const theirFormat = diffLines(oldContent, newContent, {
- ignoreNewlineAtEof: true,
- })
- const ourFormat = theirFormat.flatMap(convertMyersChangeToDiffLines)
-
- // Combine consecutive old/new pairs that are identical after trimming
- for (let i = 0; i < ourFormat.length - 1; i++) {
- if (
- ourFormat[i]?.type === "old" &&
- ourFormat[i + 1]?.type === "new" &&
- ourFormat[i].line.trim() === ourFormat[i + 1].line.trim()
- ) {
- ourFormat[i] = { type: "same", line: ourFormat[i].line }
- ourFormat.splice(i + 1, 1)
- }
- }
-
- // Remove trailing empty old lines
- while (
- ourFormat.length > 0 &&
- ourFormat[ourFormat.length - 1].type === "old" &&
- ourFormat[ourFormat.length - 1].line === ""
- ) {
- ourFormat.pop()
- }
-
- return ourFormat
-}
-
-export function myersCharDiff(oldContent: string, newContent: string): DiffChar[] {
- // Process the content character by character.
- // We will handle newlines separately,
- // because diffChars does not have an option to ignore eol newlines.
- const theirFormat = diffChars(oldContent, newContent)
-
- // Track indices as we process the diff.
- let oldIndex = 0
- let newIndex = 0
- let oldLineIndex = 0
- let newLineIndex = 0
- let oldCharIndexInLine = 0
- let newCharIndexInLine = 0
-
- const result: DiffChar[] = []
-
- for (const change of theirFormat) {
- // Split the change value by newlines to handle them separately.
- if (change.value.includes("\n")) {
- const parts = change.value.split(/(\n)/g) // This keeps the newlines as separate entries.
-
- for (let i = 0; i < parts.length; i++) {
- const part = parts[i]
- if (part === "") continue
-
- if (part === "\n") {
- // Handle newline.
- if (change.added) {
- result.push({
- type: "new",
- char: part,
- newIndex: newIndex,
- newLineIndex: newLineIndex,
- newCharIndexInLine: newCharIndexInLine,
- })
- newIndex += part.length
- newLineIndex++
- newCharIndexInLine = 0 // Reset when moving to a new line.
- } else if (change.removed) {
- result.push({
- type: "old",
- char: part,
- oldIndex: oldIndex,
- oldLineIndex: oldLineIndex,
- oldCharIndexInLine: oldCharIndexInLine,
- })
- oldIndex += part.length
- oldLineIndex++
- oldCharIndexInLine = 0 // Reset when moving to a new line.
- } else {
- result.push({
- type: "same",
- char: part,
- oldIndex: oldIndex,
- newIndex: newIndex,
- oldLineIndex: oldLineIndex,
- newLineIndex: newLineIndex,
- oldCharIndexInLine: oldCharIndexInLine,
- newCharIndexInLine: newCharIndexInLine,
- })
- oldIndex += part.length
- newIndex += part.length
- oldLineIndex++
- newLineIndex++
- oldCharIndexInLine = 0
- newCharIndexInLine = 0
- }
- } else {
- // Handle regular text.
- if (change.added) {
- result.push({
- type: "new",
- char: part,
- newIndex: newIndex,
- newLineIndex: newLineIndex,
- newCharIndexInLine: newCharIndexInLine,
- })
- newIndex += part.length
- newCharIndexInLine += part.length
- } else if (change.removed) {
- result.push({
- type: "old",
- char: part,
- oldIndex: oldIndex,
- oldLineIndex: oldLineIndex,
- oldCharIndexInLine: oldCharIndexInLine,
- })
- oldIndex += part.length
- oldCharIndexInLine += part.length
- } else {
- result.push({
- type: "same",
- char: part,
- oldIndex: oldIndex,
- newIndex: newIndex,
- oldLineIndex: oldLineIndex,
- newLineIndex: newLineIndex,
- oldCharIndexInLine: oldCharIndexInLine,
- newCharIndexInLine: newCharIndexInLine,
- })
- oldIndex += part.length
- newIndex += part.length
- oldCharIndexInLine += part.length
- newCharIndexInLine += part.length
- }
- }
- }
- } else {
- // No newlines, handle as a simple change.
- if (change.added) {
- result.push({
- type: "new",
- char: change.value,
- newIndex: newIndex,
- newLineIndex: newLineIndex,
- newCharIndexInLine: newCharIndexInLine,
- })
- newIndex += change.value.length
- newCharIndexInLine += change.value.length
- } else if (change.removed) {
- result.push({
- type: "old",
- char: change.value,
- oldIndex: oldIndex,
- oldLineIndex: oldLineIndex,
- oldCharIndexInLine: oldCharIndexInLine,
- })
- oldIndex += change.value.length
- oldCharIndexInLine += change.value.length
- } else {
- result.push({
- type: "same",
- char: change.value,
- oldIndex: oldIndex,
- newIndex: newIndex,
- oldLineIndex: oldLineIndex,
- newLineIndex: newLineIndex,
- oldCharIndexInLine: oldCharIndexInLine,
- newCharIndexInLine: newCharIndexInLine,
- })
- oldIndex += change.value.length
- newIndex += change.value.length
- oldCharIndexInLine += change.value.length
- newCharIndexInLine += change.value.length
- }
- }
- }
-
- return result
-}
diff --git a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/diff/streamDiff.test.ts b/packages/kilo-vscode/src/services/autocomplete/continuedev/core/diff/streamDiff.test.ts
deleted file mode 100644
index c02e427472a..00000000000
--- a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/diff/streamDiff.test.ts
+++ /dev/null
@@ -1,317 +0,0 @@
-import fs from "node:fs"
-import path from "node:path"
-
-import { describe, expect, test } from "vitest"
-
-// @ts-expect-error no typings available
-import { changed, diff as myersDiff } from "myers-diff"
-import { streamDiff } from "../diff/streamDiff.js"
-import { DiffLine, DiffType } from "../index.js"
-import { generateLines } from "./util.js"
-
-// "modification" is an extra type used to represent an "old" + "new" diff line
-type MyersDiffTypes = Extract | "modification"
-
-const UNIFIED_DIFF_SYMBOLS = {
- same: "",
- new: "+",
- old: "-",
-}
-
-async function collectDiffs(
- oldLines: string[],
- newLines: string[],
-): Promise<{ streamDiffs: DiffLine[]; myersDiffs: any }> {
- const streamDiffs: DiffLine[] = []
-
- for await (const diffLine of streamDiff(oldLines, generateLines(newLines))) {
- streamDiffs.push(diffLine)
- }
-
- const myersDiffs = myersDiff(oldLines.join("\n"), newLines.join("\n"))
-
- return { streamDiffs, myersDiffs }
-}
-
-function getMyersDiffType(diff: any): MyersDiffTypes | undefined {
- if (changed(diff.rhs) && !changed(diff.lhs)) {
- return "new"
- }
-
- if (!changed(diff.rhs) && changed(diff.lhs)) {
- return "old"
- }
-
- if (changed(diff.rhs) && changed(diff.lhs)) {
- return "modification"
- }
-
- return undefined
-}
-
-function displayDiff(diff: DiffLine[]) {
- return diff.map(({ type, line }) => `${UNIFIED_DIFF_SYMBOLS[type]} ${line}`).join("\n")
-}
-
-async function expectDiff(file: string) {
- const testFilePath = path.join(__dirname, "test-examples", file + ".diff")
- const testFileContents = fs.readFileSync(testFilePath, "utf-8")
- const normalized = testFileContents.replace(/\r\n/g, "\n")
-
- const [oldText, newText, expectedDiff] = normalized.split("\n---\n").map((s) => s.replace(/^\n+/, "").trimEnd())
- const oldLines = oldText.split("\n")
- const newLines = newText.split("\n")
- const { streamDiffs } = await collectDiffs(oldLines, newLines)
- const displayedDiff = displayDiff(streamDiffs)
-
- if (!expectedDiff || expectedDiff.trim() === "") {
- console.log("Expected diff was empty. Writing computed diff to the test file")
- // Persist with LF to keep fixtures stable cross-platform
- fs.writeFileSync(testFilePath, `${oldText}\n\n---\n\n${newText}\n\n---\n\n${displayedDiff}`)
-
- throw new Error("Expected diff is empty")
- }
-
- expect(displayedDiff).toEqual(expectedDiff)
-}
-
-// We use a longer `)` string here to not get
-// caught by the fuzzy matcher
-describe("streamDiff(", () => {
- test("no changes", async () => {
- const oldLines = ["first item", "second arg", "third param"]
- const newLines = ["first item", "second arg", "third param"]
-
- const { streamDiffs, myersDiffs } = await collectDiffs(oldLines, newLines)
-
- expect(streamDiffs).toEqual([
- { type: "same", line: "first item" },
- { type: "same", line: "second arg" },
- { type: "same", line: "third param" },
- ])
-
- expect(myersDiffs).toEqual([])
- })
-
- test("add new line", async () => {
- const oldLines = ["first item", "second arg"]
- const newLines = ["first item", "second arg", "third param"]
-
- const { streamDiffs, myersDiffs } = await collectDiffs(oldLines, newLines)
-
- expect(streamDiffs).toEqual([
- { type: "same", line: "first item" },
- { type: "same", line: "second arg" },
- { type: "new", line: "third param" },
- ])
-
- expect(myersDiffs.length).toEqual(1)
- expect(getMyersDiffType(myersDiffs[0])).toBe("new")
- })
-
- test("remove line", async () => {
- const oldLines = ["first item", "second arg", "third param"]
- const newLines = ["first item", "third param"]
-
- const { streamDiffs, myersDiffs } = await collectDiffs(oldLines, newLines)
-
- expect(streamDiffs).toEqual([
- { type: "same", line: "first item" },
- { type: "old", line: "second arg" },
- { type: "same", line: "third param" },
- ])
-
- expect(myersDiffs.length).toEqual(1)
- expect(getMyersDiffType(myersDiffs[0])).toBe("old")
- })
-
- test("modify line", async () => {
- const oldLines = ["first item", "second arg", "third param"]
- const newLines = ["first item", "modified second arg", "third param"]
-
- const { streamDiffs, myersDiffs } = await collectDiffs(oldLines, newLines)
-
- expect(streamDiffs).toEqual([
- { type: "same", line: "first item" },
- { type: "old", line: "second arg" },
- { type: "new", line: "modified second arg" },
- { type: "same", line: "third param" },
- ])
-
- expect(myersDiffs.length).toEqual(1)
- expect(getMyersDiffType(myersDiffs[0])).toBe("modification")
- })
-
- test("add multiple lines", async () => {
- const oldLines = ["first item", "fourth val"]
- const newLines = ["first item", "second arg", "third param", "fourth val"]
-
- const { streamDiffs, myersDiffs } = await collectDiffs(oldLines, newLines)
-
- expect(streamDiffs).toEqual([
- { type: "same", line: "first item" },
- { type: "new", line: "second arg" },
- { type: "new", line: "third param" },
- { type: "same", line: "fourth val" },
- ])
-
- // Multi-line addition
- expect(myersDiffs[0].rhs.add).toEqual(2)
- expect(getMyersDiffType(myersDiffs[0])).toBe("new")
- })
-
- test("remove multiple lines", async () => {
- const oldLines = ["first item", "second arg", "third param", "fourth val"]
- const newLines = ["first item", "fourth val"]
-
- const { streamDiffs, myersDiffs } = await collectDiffs(oldLines, newLines)
-
- expect(streamDiffs).toEqual([
- { type: "same", line: "first item" },
- { type: "old", line: "second arg" },
- { type: "old", line: "third param" },
- { type: "same", line: "fourth val" },
- ])
-
- // Multi-line deletion
- expect(myersDiffs[0].lhs.del).toEqual(2)
- expect(getMyersDiffType(myersDiffs[0])).toBe("old")
- })
-
- test("empty old lines", async () => {
- const oldLines: string[] = []
- const newLines = ["first item", "second arg"]
-
- const { streamDiffs, myersDiffs } = await collectDiffs(oldLines, newLines)
-
- expect(streamDiffs).toEqual([
- { type: "new", line: "first item" },
- { type: "new", line: "second arg" },
- ])
-
- // Multi-line addition
- expect(myersDiffs[0].rhs.add).toEqual(2)
- expect(getMyersDiffType(myersDiffs[0])).toBe("new")
- })
-
- test("empty new lines", async () => {
- const oldLines = ["first item", "second arg"]
- const newLines: string[] = []
-
- const { streamDiffs, myersDiffs } = await collectDiffs(oldLines, newLines)
-
- expect(streamDiffs).toEqual([
- { type: "old", line: "first item" },
- { type: "old", line: "second arg" },
- ])
-
- // Multi-line deletion
- expect(myersDiffs[0].lhs.del).toEqual(2)
- expect(getMyersDiffType(myersDiffs[0])).toBe("old")
- })
-
- test("tabs vs. spaces differences are ignored", async () => {
- await expectDiff("fastapi-tabs-vs-spaces.py")
- })
-
- test("trailing whitespaces should match ", async () => {
- const oldLines = ["first item ", "second arg ", "third param "]
-
- const newLines = ["first item", "second arg", "third param "]
-
- const { streamDiffs } = await collectDiffs(oldLines, newLines)
-
- expect(streamDiffs).toEqual([
- { type: "same", line: "first item " },
- { type: "same", line: "second arg " },
- { type: "same", line: "third param " },
- ])
- })
-
- //indentation and whitespace handling
- test.each([false, true])(
- "ignores indentation changes for sufficiently long lines (trailingWhitespace: %s)",
- async (trailingWhitespace) => {
- let oldLines = [" short", " middle", " a long enough line", " short2", "indented line", "final line"]
-
- const newLines = ["short", "middle", "a long enough line", "short2", " indented line", "final line"]
-
- if (trailingWhitespace) {
- oldLines = oldLines.map((line) => line + " ")
- }
-
- const { streamDiffs } = await collectDiffs(oldLines, newLines)
- const expected = trailingWhitespace
- ? [
- { type: "old", line: " short " },
- { type: "new", line: "short" },
- { type: "old", line: " middle " },
- { type: "new", line: "middle" },
- { type: "same", line: " a long enough line " },
- { type: "same", line: " short2 " },
- { type: "same", line: "indented line " },
- { type: "same", line: "final line " },
- ]
- : [
- { type: "old", line: " short" },
- { type: "new", line: "short" },
- { type: "old", line: " middle" },
- { type: "new", line: "middle" },
- { type: "same", line: " a long enough line" },
- { type: "same", line: " short2" },
- { type: "same", line: "indented line" },
- { type: "same", line: "final line" },
- ]
-
- expect(streamDiffs).toEqual(expected)
- },
- )
-
- test("preserves original lines for minor reindentation in simple block", async () => {
- const oldLines = ["if (checkValueOf(x)) {", " doSomethingWith(x);", "}"]
- const newLines = ["if (checkValueOf(x)) {", " doSomethingWith(x);", "}"]
-
- const { streamDiffs } = await collectDiffs(oldLines, newLines)
-
- expect(streamDiffs).toEqual([
- { type: "same", line: "if (checkValueOf(x)) {" },
- { type: "same", line: " doSomethingWith(x);" },
- { type: "same", line: "}" },
- ])
- })
-
- test("uses new lines for nested reindentation changes", async () => {
- const oldLines = ["if (checkValueOf(x)) {", " doSomethingWith(x);", "}"]
- const newLines = [
- "if (checkValueOf(x)) {",
- " if (reallyCheckValueOf(x)) {",
- " doSomethingElseWith(x);",
- " }",
- "}",
- ]
-
- const { streamDiffs } = await collectDiffs(oldLines, newLines)
-
- expect(streamDiffs).toEqual([
- { type: "same", line: "if (checkValueOf(x)) {" },
- { type: "new", line: " if (reallyCheckValueOf(x)) {" },
- { type: "old", line: " doSomethingWith(x);" },
- { type: "new", line: " doSomethingElseWith(x);" },
- { type: "old", line: "}" },
- { type: "new", line: " }" },
- { type: "new", line: "}" },
- ])
- })
-
- test("FastAPI example", async () => {
- await expectDiff("fastapi.py")
- })
-
- test("FastAPI comments", async () => {
- await expectDiff("add-comments.py")
- })
-
- test("Mock LLM example", async () => {
- await expectDiff("mock-llm.ts")
- })
-})
diff --git a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/diff/streamDiff.ts b/packages/kilo-vscode/src/services/autocomplete/continuedev/core/diff/streamDiff.ts
deleted file mode 100644
index 8c3407de13c..00000000000
--- a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/diff/streamDiff.ts
+++ /dev/null
@@ -1,76 +0,0 @@
-import { DiffLine, DiffType } from "../index.js"
-
-import { LineStream, matchLine } from "./util.js"
-
-/**
- * https://blog.jcoglan.com/2017/02/12/the-myers-diff-algorithm-part-1/
- * Invariants:
- * - new + same = newLines.length
- * - old + same = oldLinesCopy.length
- * ^ (above two guarantee that all lines get represented)
- * - Lines are always output in order, at least among old and new separately
- * - Old lines in a hunk are always output before the new lines
- */
-export async function* streamDiff(oldLines: string[], newLines: LineStream): AsyncGenerator {
- const oldLinesCopy = [...oldLines]
-
- // If one indentation mistake is made, others are likely. So we are more permissive about matching
- let seenIndentationMistake = false
-
- let newLineResult = await newLines.next()
-
- while (oldLinesCopy.length > 0 && !newLineResult.done) {
- const { matchIndex, isPerfectMatch, newLine } = matchLine(newLineResult.value, oldLinesCopy, seenIndentationMistake)
-
- if (!seenIndentationMistake && newLineResult.value !== newLine) {
- seenIndentationMistake = true
- }
-
- let type: DiffType
-
- const isNewLine = matchIndex === -1
-
- if (isNewLine) {
- type = "new"
- } else {
- // Insert all deleted lines before match
- for (let i = 0; i < matchIndex; i++) {
- yield { type: "old", line: oldLinesCopy.shift()! }
- }
- type = isPerfectMatch ? "same" : "old"
- }
-
- switch (type) {
- case "new":
- yield { type, line: newLine }
- break
-
- case "same":
- yield { type, line: oldLinesCopy.shift()! }
- break
-
- case "old":
- yield { type, line: oldLinesCopy.shift()! }
- yield { type: "new", line: newLine }
- break
-
- default:
- console.error(`Error streaming diff, unrecognized diff type: ${type}`)
- }
- newLineResult = await newLines.next()
- }
-
- // Once at the edge, only one choice
- if (newLineResult.done && oldLinesCopy.length > 0) {
- for (const oldLine of oldLinesCopy) {
- yield { type: "old", line: oldLine }
- }
- }
-
- if (!newLineResult.done && oldLinesCopy.length === 0) {
- yield { type: "new", line: newLineResult.value }
- for await (const newLine of newLines) {
- yield { type: "new", line: newLine }
- }
- }
-}
diff --git a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/diff/util.ts b/packages/kilo-vscode/src/services/autocomplete/continuedev/core/diff/util.ts
index 90a5ced95a4..d5da1720c3c 100644
--- a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/diff/util.ts
+++ b/packages/kilo-vscode/src/services/autocomplete/continuedev/core/diff/util.ts
@@ -1,94 +1,8 @@
-import { distance } from "fastest-levenshtein"
-
-import { ChatMessage } from "../index.js"
+import type { ChatMessage } from "../index.js"
import { renderChatMessage } from "../util/messageContent.js"
export type LineStream = AsyncGenerator
-type MatchLineResult = {
- /**
- * -1 if it's a new line, otherwise the index of the first match
- * in the old lines.
- */
- matchIndex: number
- isPerfectMatch: boolean
- newLine: string
-}
-
-function linesMatchPerfectly(lineA: string, lineB: string): boolean {
- return lineA === lineB && lineA !== ""
-}
-
-const END_BRACKETS = ["}", "});", "})"]
-
-function linesMatch(lineA: string, lineB: string, linesBetween = 0): boolean {
- // Require a perfect (without padding) match for these lines
- // Otherwise they are edit distance 1 from empty lines and other single char lines (e.g. each other)
- if (["}", "*", "});", "})"].includes(lineA.trim())) {
- return lineA.trim() === lineB.trim()
- }
-
- const d = distance(lineA, lineB)
-
- return (
- // Should be more unlikely for lines to fuzzy match if they are further away
- (d / Math.max(lineA.length, lineB.length) <= Math.max(0, 0.48 - linesBetween * 0.06) ||
- lineA.trim() === lineB.trim()) &&
- lineA.trim() !== ""
- )
-}
-
-/**
- * Used to find a match for a new line in an array of old lines.
- *
- * Return the index of the first match and whether it is a perfect match
- * Also return a version of the line with correct indentation if needs fixing
- */
-export function matchLine(newLine: string, oldLines: string[], permissiveAboutIndentation = false): MatchLineResult {
- // Only match empty lines if it's the next one:
- if (newLine.trim() === "" && oldLines[0]?.trim() === "") {
- return {
- matchIndex: 0,
- isPerfectMatch: true,
- newLine: newLine.trim(),
- }
- }
-
- const isEndBracket = END_BRACKETS.includes(newLine.trim())
-
- for (let i = 0; i < oldLines.length; i++) {
- // trims trailing whitespaces from the lines before comparison
- //this ensures trailing spaces don't affect matching.
- const oldLineTrimmed = oldLines[i].trimEnd()
- const newLineTrimmed = newLine.trimEnd()
-
- // Don't match end bracket lines if too far away
- if (i > 4 && isEndBracket) {
- return { matchIndex: -1, isPerfectMatch: false, newLine }
- }
-
- if (linesMatchPerfectly(newLineTrimmed, oldLineTrimmed)) {
- return { matchIndex: i, isPerfectMatch: true, newLine }
- }
- if (linesMatch(newLineTrimmed, oldLineTrimmed, i)) {
- // This is a way to fix indentation, but only for sufficiently long lines to avoid matching whitespace or short lines
- if (
- newLineTrimmed.trimStart() === oldLineTrimmed.trimStart() &&
- (permissiveAboutIndentation || newLine.trim().length > 8)
- ) {
- return {
- matchIndex: i,
- isPerfectMatch: true,
- newLine: oldLines[i],
- }
- }
- return { matchIndex: i, isPerfectMatch: false, newLine }
- }
- }
-
- return { matchIndex: -1, isPerfectMatch: false, newLine }
-}
-
/**
* Convert a stream of arbitrary chunks to a stream of lines
*/
@@ -97,7 +11,6 @@ export async function* streamLines(
log: boolean = false,
): LineStream {
const allLines = []
-
let buffer = ""
try {
@@ -110,11 +23,6 @@ export async function* streamLines(
yield line
allLines.push(line)
}
-
- // if (buffer === "" && chunk.endsWith("\n")) {
- // yield "";
- // allLines.push("");
- // }
}
if (buffer.length > 0) {
yield buffer
@@ -130,6 +38,5 @@ export async function* streamLines(
export async function* generateLines(lines: T[]): AsyncGenerator {
for (const line of lines) {
yield line
- // await new Promise((resolve, reject) => setTimeout(() => resolve(null), 50));
}
}
diff --git a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/fetch/stream.ts b/packages/kilo-vscode/src/services/autocomplete/continuedev/core/fetch/stream.ts
deleted file mode 100644
index 74cace737ba..00000000000
--- a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/fetch/stream.ts
+++ /dev/null
@@ -1,138 +0,0 @@
-/**
- * Parses a single line from an SSE (Server-Sent Events) stream.
- */
-function parseSseLine(line: string): { done: boolean; data: unknown } {
- if (line.startsWith("data:[DONE]") || line.startsWith("data: [DONE]")) {
- return { done: true, data: undefined }
- }
- if (line.startsWith("data:")) {
- const jsonStr = line.slice(5).trim()
- try {
- return { done: false, data: JSON.parse(jsonStr) }
- } catch {
- return { done: false, data: undefined }
- }
- }
- if (line.startsWith(": ping")) {
- return { done: true, data: undefined }
- }
- return { done: false, data: undefined }
-}
-
-/**
- * Streams a Response body as UTF-8 text chunks.
- *
- * Modern implementation using native ReadableStream and TextDecoderStream APIs.
- * Requires Node.js 18+ or modern browsers.
- */
-export async function* streamResponse(response: Response): AsyncGenerator {
- // Handle client-side cancellation
- if (response.status === 499) {
- return
- }
-
- // Check for error responses
- if (response.status !== 200) {
- throw new Error(await response.text())
- }
-
- if (!response.body) {
- throw new Error("No response body returned.")
- }
-
- let chunks = 0
-
- try {
- // Modern API: Use TextDecoderStream to decode the response body
- const textStream = response.body.pipeThrough(new TextDecoderStream("utf-8"))
- const reader = textStream.getReader()
-
- try {
- while (true) {
- const { done, value } = await reader.read()
- if (done) break
- yield value
- chunks++
- }
- } finally {
- reader.releaseLock()
- }
- } catch (e) {
- if (e instanceof Error) {
- // Handle graceful cancellation
- if (e.name.startsWith("AbortError")) {
- return
- }
-
- // Handle premature close errors
- if (e.message.toLowerCase().includes("premature close")) {
- if (chunks === 0) {
- throw new Error("Stream was closed before any data was received. Try again. (Premature Close)")
- } else {
- throw new Error("The response was cancelled mid-stream. Try again. (Premature Close).")
- }
- }
- }
- throw e
- }
-}
-/**
- * Streams Server-Sent Events (SSE) from a Response.
- * Parses SSE format and yields parsed data objects.
- */
-export async function* streamSse(response: Response): AsyncGenerator {
- let buffer = ""
-
- for await (const value of streamResponse(response)) {
- buffer += value
-
- let position: number
- while ((position = buffer.indexOf("\n")) >= 0) {
- const line = buffer.slice(0, position)
- buffer = buffer.slice(position + 1)
-
- const { done, data } = parseSseLine(line)
- if (done) {
- break
- }
- if (data) {
- yield data
- }
- }
- }
-
- // Process any remaining buffered content
- if (buffer.length > 0) {
- const { done, data } = parseSseLine(buffer)
- if (!done && data) {
- yield data
- }
- }
-}
-
-/**
- * Streams newline-delimited JSON from a Response.
- * Each line should be a complete JSON object.
- */
-export async function* streamJSON(response: Response): AsyncGenerator {
- let buffer = ""
-
- for await (const value of streamResponse(response)) {
- buffer += value
-
- let position: number
- while ((position = buffer.indexOf("\n")) >= 0) {
- const line = buffer.slice(0, position)
- buffer = buffer.slice(position + 1)
-
- if (line.trim()) {
- try {
- const data = JSON.parse(line)
- yield data
- } catch {
- throw new Error(`Malformed JSON sent from server: ${line}`)
- }
- }
- }
- }
-}
diff --git a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/llm/constants.ts b/packages/kilo-vscode/src/services/autocomplete/continuedev/core/llm/constants.ts
deleted file mode 100644
index b0e2a8528ad..00000000000
--- a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/llm/constants.ts
+++ /dev/null
@@ -1,10 +0,0 @@
-const DEFAULT_MAX_TOKENS = 4096
-const DEFAULT_CONTEXT_LENGTH = 32_768
-const DEFAULT_PRUNING_LENGTH = 128000
-
-export enum NEXT_EDIT_MODELS {
- MERCURY_CODER = "mercury-coder",
- INSTINCT = "instinct",
-}
-
-export { DEFAULT_CONTEXT_LENGTH, DEFAULT_MAX_TOKENS, DEFAULT_PRUNING_LENGTH }
diff --git a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/llm/countTokens.ts b/packages/kilo-vscode/src/services/autocomplete/continuedev/core/llm/countTokens.ts
index f37012aaa3a..2bc58aad0de 100644
--- a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/llm/countTokens.ts
+++ b/packages/kilo-vscode/src/services/autocomplete/continuedev/core/llm/countTokens.ts
@@ -1,8 +1,7 @@
import { Tiktoken, encodingForModel as _encodingForModel } from "js-tiktoken"
-import { ChatMessage, CompiledMessagesResult, MessageContent } from "../index.js"
-import { addSpaceToAnyEmptyMessages, chatMessageIsEmpty } from "./messages.js"
-import { DEFAULT_PRUNING_LENGTH } from "./constants.js"
+import type { MessageContent } from "../index.js"
import { llamaTokenizer } from "./llamaTokenizer.js"
+
interface Encoding {
encode: Tiktoken["encode"]
decode: Tiktoken["decode"]
@@ -47,7 +46,7 @@ export function encodingForModel(modelName: string): Encoding {
return (gptEncoding ??= _encodingForModel("gpt-4"))
}
-function countTokens(
+export function countTokens(
content: MessageContent,
// defaults to llama2 because the tokenizer tends to produce more tokens
modelName = "llama2",
@@ -57,58 +56,21 @@ function countTokens(
return content.reduce((acc, part) => {
return acc + encoding.encode(part.text ?? "", "all", []).length
}, 0)
- } else {
- return encoding.encode(content ?? "", "all", []).length
}
+ return encoding.encode(content ?? "", "all", []).length
}
-function countChatMessageTokens(modelName: string, chatMessage: ChatMessage): number {
- // Doing simpler, safer version of what is here:
- // https://github.com/openai/openai-cookbook/blob/main/examples/How_to_count_tokens_with_tiktoken.ipynb
- // every message follows <|im_start|>{role/name}\n{content}<|end|>\n
- const BASE_TOKENS = 4
- let tokens = BASE_TOKENS
-
- if (chatMessage.content) {
- tokens += countTokens(chatMessage.content, modelName)
- }
-
- return tokens
-}
-
-/**
- * Extracts and validates the user message from the end of a message array.
- *
- * @param messages - Array of chat messages (will be modified by popping messages)
- * @returns Array of messages that form the tool sequence
- */
-function extractToolSequence(messages: ChatMessage[]): ChatMessage[] {
- const lastMsg = messages.pop()
- if (!lastMsg || lastMsg.role !== "user") {
- throw new Error("Error parsing chat history: no user message found")
- }
-
- const toolSequence: ChatMessage[] = [lastMsg]
-
- return toolSequence
-}
-
-function pruneLinesFromTop(prompt: string, maxTokens: number, modelName: string): string {
+export function pruneLinesFromTop(prompt: string, maxTokens: number, modelName: string): string {
const lines = prompt.split("\n")
- // Preprocess tokens for all lines and cache them.
const lineTokens = lines.map((line) => countTokens(line, modelName))
let totalTokens = lineTokens.reduce((sum, tokens) => sum + tokens, 0)
let start = 0
const currentLines = lines.length
- // Calculate initial token count including newlines
- totalTokens += Math.max(0, currentLines - 1) // Add tokens for joining newlines
+ totalTokens += Math.max(0, currentLines - 1)
- // Using indexes instead of array modifications.
- // Remove lines from the top until the token count is within the limit.
while (totalTokens > maxTokens && start < currentLines) {
- totalTokens -= lineTokens[start]
- // Decrement token count for the removed line and its preceding/joining newline (if not the last line)
+ totalTokens -= lineTokens[start] ?? 0
if (currentLines - start > 1) {
totalTokens--
}
@@ -118,21 +80,17 @@ function pruneLinesFromTop(prompt: string, maxTokens: number, modelName: string)
return lines.slice(start).join("\n")
}
-function pruneLinesFromBottom(prompt: string, maxTokens: number, modelName: string): string {
+export function pruneLinesFromBottom(prompt: string, maxTokens: number, modelName: string): string {
const lines = prompt.split("\n")
const lineTokens = lines.map((line) => countTokens(line, modelName))
let totalTokens = lineTokens.reduce((sum, tokens) => sum + tokens, 0)
let end = lines.length
- // Calculate initial token count including newlines
- totalTokens += Math.max(0, end - 1) // Add tokens for joining newlines
+ totalTokens += Math.max(0, end - 1)
- // Reverse traversal to avoid array modification
- // Remove lines from the bottom until the token count is within the limit.
while (totalTokens > maxTokens && end > 0) {
end--
- totalTokens -= lineTokens[end]
- // Decrement token count for the removed line and its following/joining newline (if not the first line)
+ totalTokens -= lineTokens[end] ?? 0
if (end > 0) {
totalTokens--
}
@@ -141,180 +99,11 @@ function pruneLinesFromBottom(prompt: string, maxTokens: number, modelName: stri
return lines.slice(0, end).join("\n")
}
-function pruneStringFromBottom(modelName: string, maxTokens: number, prompt: string): string {
+export function pruneStringFromBottom(modelName: string, maxTokens: number, prompt: string): string {
const encoding = encodingForModel(modelName)
-
const tokens = encoding.encode(prompt, "all", [])
if (tokens.length <= maxTokens) {
return prompt
}
-
return encoding.decode(tokens.slice(0, maxTokens))
}
-
-function pruneStringFromTop(modelName: string, maxTokens: number, prompt: string): string {
- const encoding = encodingForModel(modelName)
-
- const tokens = encoding.encode(prompt, "all", [])
- if (tokens.length <= maxTokens) {
- return prompt
- }
-
- return encoding.decode(tokens.slice(tokens.length - maxTokens))
-}
-
-const MAX_TOKEN_SAFETY_BUFFER = 1000
-const TOKEN_SAFETY_PROPORTION = 0.02
-export function getTokenCountingBufferSafety(contextLength: number) {
- return Math.min(MAX_TOKEN_SAFETY_BUFFER, contextLength * TOKEN_SAFETY_PROPORTION)
-}
-
-const MIN_RESPONSE_TOKENS = 1000
-
-function pruneRawPromptFromTop(
- modelName: string,
- contextLength: number,
- prompt: string,
- tokensForCompletion: number,
-): string {
- const maxTokens = contextLength - tokensForCompletion - getTokenCountingBufferSafety(contextLength)
- return pruneStringFromTop(modelName, maxTokens, prompt)
-}
-
-/**
- * Reconciles chat messages with available context length by intelligently pruning older messages
- * while preserving critical conversation elements.
- *
- * Core Guidelines:
- * - Always preserve the last user/tool message sequence (including any associated assistant message with tool calls)
- * - Always preserve the system message and tools
- * - Never allow orphaned tool responses without their corresponding tool calls
- * - Remove older messages first when pruning is necessary
- * - Maintain conversation coherence by flattening adjacent similar messages
- *
- * Process:
- * 1. Handle image content conversion for models that don't support images
- * 2. Extract and preserve system message
- * 3. Filter out empty messages and trailing non-user/tool messages
- * 4. Extract the complete tool sequence from the end (user message or assistant + tool responses)
- * 5. Calculate token requirements for non-negotiable elements (system, tools, last sequence)
- * 6. Prune older messages until within available token budget
- * 7. Reassemble with proper ordering and flatten adjacent similar messages
- *
- * @param params - Configuration object containing:
- * - modelName: LLM model name for token counting
- * - msgs: Array of chat messages to process
- * - contextLength: Maximum context length supported by the model
- * - maxTokens: Maximum tokens to reserve for the response
- * @returns Processed array of chat messages that fit within context constraints
- * @throws Error if non-negotiable elements exceed available context
- */
-function compileChatMessages({
- modelName,
- msgs,
- knownContextLength,
- maxTokens,
-}: {
- modelName: string
- msgs: ChatMessage[]
- knownContextLength: number | undefined
- maxTokens: number
-}): CompiledMessagesResult {
- let didPrune = false
-
- let msgsCopy: ChatMessage[] = msgs.map((m) => ({ ...m }))
-
- // Extract system message
- const systemMsg = msgsCopy.find((msg) => msg.role === "system")
- msgsCopy = msgsCopy.filter((msg) => msg.role !== "system")
-
- // Remove any empty messages or non-user/tool trailing messages
- msgsCopy = msgsCopy.filter((msg) => !chatMessageIsEmpty(msg))
-
- msgsCopy = addSpaceToAnyEmptyMessages(msgsCopy)
-
- // Extract the tool sequence from the end of the message array
- const toolSequence = extractToolSequence(msgsCopy)
-
- // Count tokens for all messages in the tool sequence
- let lastMessagesTokens = 0
- for (const msg of toolSequence) {
- lastMessagesTokens += countChatMessageTokens(modelName, msg)
- }
-
- // System message
- let systemMsgTokens = 0
- if (systemMsg) {
- systemMsgTokens = countChatMessageTokens(modelName, systemMsg)
- }
-
- const contextLength = knownContextLength ?? DEFAULT_PRUNING_LENGTH
- const countingSafetyBuffer = getTokenCountingBufferSafety(contextLength)
- const minOutputTokens = Math.min(MIN_RESPONSE_TOKENS, maxTokens)
-
- let inputTokensAvailable = contextLength
-
- // Leave space for output/safety
- inputTokensAvailable -= countingSafetyBuffer
- inputTokensAvailable -= minOutputTokens
-
- // Non-negotiable messages
- inputTokensAvailable -= systemMsgTokens
- inputTokensAvailable -= lastMessagesTokens
-
- // Make sure there's enough context for the non-excludable items
- if (knownContextLength !== undefined && inputTokensAvailable < 0) {
- throw new Error(
- `Not enough context available to include the system message, last user message, and tools.
- There must be at least ${minOutputTokens} tokens remaining for output.
- Request had the following token counts:
- - contextLength: ${knownContextLength}
- - counting safety buffer: ${countingSafetyBuffer}
- - system message: ~${systemMsgTokens}
- - max output tokens: ${maxTokens}`,
- )
- }
-
- // Now remove messages till we're under the limit
- let currentTotal = 0
- const historyWithTokens = msgsCopy.map((message) => {
- const tokens = countChatMessageTokens(modelName, message)
- currentTotal += tokens
- return {
- ...message,
- tokens,
- }
- })
-
- while (historyWithTokens.length > 0 && currentTotal > inputTokensAvailable) {
- const message = historyWithTokens.shift()!
- currentTotal -= message.tokens
- didPrune = true
- }
-
- // Now reassemble
- const reassembled: ChatMessage[] = []
- if (systemMsg) {
- reassembled.push(systemMsg)
- }
- reassembled.push(...historyWithTokens.map(({ tokens: _tokens, ...rest }) => rest))
- reassembled.push(...toolSequence)
-
- const inputTokens = currentTotal + systemMsgTokens + lastMessagesTokens
- const availableTokens = contextLength - countingSafetyBuffer - minOutputTokens
- const contextPercentage = inputTokens / availableTokens
- return {
- compiledChatMessages: reassembled,
- didPrune,
- contextPercentage,
- }
-}
-
-export {
- compileChatMessages,
- countTokens,
- pruneLinesFromBottom,
- pruneLinesFromTop,
- pruneRawPromptFromTop,
- pruneStringFromBottom,
-}
diff --git a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/llm/index.ts b/packages/kilo-vscode/src/services/autocomplete/continuedev/core/llm/index.ts
deleted file mode 100644
index 6d6fef85ba6..00000000000
--- a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/llm/index.ts
+++ /dev/null
@@ -1,664 +0,0 @@
-import { findLlmInfo } from "./model-info"
-import { ChatCompletionCreateParams } from "openai/resources/index"
-
-import {
- ChatMessage,
- Chunk,
- CompletionOptions,
- ILLM,
- LLMFullCompletionOptions,
- LLMOptions,
- MessageOption,
- ModelCapability,
- PromptLog,
- TabAutocompleteOptions,
- Usage,
-} from "../index.js"
-import type { CacheBehavior, ILLMInteractionLog, ILLMLogger } from "../index.js"
-import { mergeJson } from "../util/merge.js"
-import { renderChatMessage } from "../util/messageContent.js"
-import { TokensBatchingService } from "../util/TokensBatchingService.js"
-
-import { DEFAULT_CONTEXT_LENGTH, DEFAULT_MAX_TOKENS } from "./constants.js"
-import { compileChatMessages, countTokens, pruneRawPromptFromTop } from "./countTokens.js"
-import {
- fromChatCompletionChunk,
- fromChatResponse,
- LlmApiRequestType,
- toChatBody,
- toCompleteBody,
- toFimBody,
-} from "./openaiTypeConverters.js"
-
-type InteractionStatus = "in_progress" | "success" | "error" | "cancelled"
-
-export abstract class BaseLLM implements ILLM {
- static providerName: string
-
- get providerName(): string {
- return (this.constructor as typeof BaseLLM).providerName
- }
-
- /**
- * This exists because for the continue-proxy, sometimes we want to get the value of the underlying provider that is used on the server
- * For example, the underlying provider should always be sent with dev data
- */
- get underlyingProviderName(): string {
- return this.providerName
- }
-
- autocompleteOptions?: Partial
-
- supportsFim(): boolean {
- return false
- }
-
- supportsCompletions(): boolean {
- if (["openai", "azure"].includes(this.providerName)) {
- if (
- this.apiBase?.includes("api.groq.com") ||
- this.apiBase?.includes("api.mistral.ai") ||
- this.apiBase?.includes(":1337") ||
- this.apiBase?.includes("integrate.api.nvidia.com") ||
- this._llmOptions.useLegacyCompletionsEndpoint?.valueOf() === false
- ) {
- // Jan + Groq + Mistral don't support completions : (
- // Seems to be going out of style...
- return false
- }
- }
- if (["groq", "mistral", "deepseek"].includes(this.providerName)) {
- return false
- }
- return true
- }
-
- uniqueId: string
- model: string
-
- title?: string
- _contextLength: number | undefined
- maxStopWords?: number | undefined
- completionOptions: CompletionOptions
- templateMessages?: (messages: ChatMessage[]) => string
- logger?: ILLMLogger
- llmRequestHook?: (model: string, prompt: string) => any
- apiKey?: string
- apiBase?: string
- cacheBehavior?: CacheBehavior
- capabilities?: ModelCapability
-
- lastRequestId: string | undefined
-
- private _llmOptions: LLMOptions
-
- protected openaiAdapter?: any
-
- constructor(_options: LLMOptions) {
- this._llmOptions = _options
- this.lastRequestId = undefined
-
- // Set default options
- const options = {
- title: (this.constructor as typeof BaseLLM).providerName,
- ..._options,
- }
-
- this.model = options.model
- // Use ../llm-info package to autodetect certain parameters
- const modelSearchString =
- this.providerName === "continue-proxy" ? this.model?.split("/").pop() || this.model : this.model
- const llmInfo = findLlmInfo(modelSearchString, this.underlyingProviderName)
-
- this.title = options.title
- this.uniqueId = options.uniqueId ?? "None"
- this._contextLength = options.contextLength ?? llmInfo?.contextLength
- this.maxStopWords = options.maxStopWords ?? this.maxStopWords
- this.completionOptions = {
- ...options.completionOptions,
- model: options.model || "gpt-4",
- maxTokens:
- options.completionOptions?.maxTokens ??
- (llmInfo?.maxCompletionTokens
- ? Math.min(
- llmInfo.maxCompletionTokens,
- // Even if the model has a large maxTokens, we don't want to use that every time,
- // because it takes away from the context length
- this.contextLength / 4,
- )
- : DEFAULT_MAX_TOKENS),
- }
-
- this.apiKey = options.apiKey
- this.apiBase = options.apiBase
- if (this.apiBase && !this.apiBase.endsWith("/")) {
- this.apiBase = `${this.apiBase}/`
- }
- this.capabilities = options.capabilities
-
- this.autocompleteOptions = options.autocompleteOptions
- }
-
- get contextLength() {
- return this._contextLength ?? DEFAULT_CONTEXT_LENGTH
- }
-
- private _templatePromptLikeMessages(prompt: string): string {
- if (!this.templateMessages) {
- return prompt
- }
-
- // NOTE system message no longer supported here
-
- const msgs: ChatMessage[] = [{ role: "user", content: prompt }]
-
- return this.templateMessages(msgs)
- }
-
- private _logEnd(
- model: string,
- prompt: string,
- completion: string,
- interaction: ILLMInteractionLog | undefined,
- usage: Usage | undefined,
- error?: any,
- ): InteractionStatus {
- const promptTokens = this.countTokens(prompt)
- const generatedTokens = this.countTokens(completion)
-
- TokensBatchingService.getInstance().addTokens(model, this.providerName, promptTokens, generatedTokens)
-
- console.log("tokensGenerated", {
- model: model,
- provider: this.underlyingProviderName,
- promptTokens: promptTokens,
- generatedTokens: generatedTokens,
- })
-
- if (typeof error === "undefined") {
- interaction?.logItem({
- kind: "success",
- promptTokens,
- generatedTokens,
- usage,
- })
- return "success"
- } else {
- if (error === "cancel" || error?.name?.includes("AbortError")) {
- interaction?.logItem({
- kind: "cancel",
- promptTokens,
- generatedTokens,
- usage,
- })
- return "cancelled"
- } else {
- console.log(error)
- interaction?.logItem({
- kind: "error",
- name: error.name,
- message: error.message,
- promptTokens,
- generatedTokens,
- usage,
- })
- return "error"
- }
- }
- }
-
- private parseCompletionOptions(options: LLMFullCompletionOptions) {
- const log = options.log ?? true
- const raw = options.raw ?? false
- options.log = undefined
-
- const completionOptions: CompletionOptions = mergeJson(this.completionOptions, options)
-
- return { completionOptions, logEnabled: log, raw }
- }
-
- private formatChatMessages(messages: ChatMessage[]): string {
- const msgsCopy = messages ? messages.map((msg) => ({ ...msg })) : []
- let formatted = ""
- for (const msg of msgsCopy) {
- formatted += this._formatChatMessage(msg)
- }
- return formatted
- }
-
- private _formatChatMessage(msg: ChatMessage): string {
- let contentToShow = renderChatMessage(msg)
-
- return `<${msg.role}>\n${contentToShow}\n\n`
- }
-
- protected async *_streamFim(
- _prefix: string,
- _suffix: string,
- _signal: AbortSignal,
- _options: CompletionOptions,
- ): AsyncGenerator {
- throw new Error("Not implemented")
- }
-
- protected useOpenAIAdapterFor: (LlmApiRequestType | "*")[] = []
-
- private shouldUseOpenAIAdapter(requestType: LlmApiRequestType) {
- return this.useOpenAIAdapterFor.includes(requestType) || this.useOpenAIAdapterFor.includes("*")
- }
-
- async *streamFim(
- prefix: string,
- suffix: string,
- signal: AbortSignal,
- options: LLMFullCompletionOptions = {},
- ): AsyncGenerator {
- this.lastRequestId = undefined
- const { completionOptions, logEnabled } = this.parseCompletionOptions(options)
- const interaction = logEnabled ? this.logger?.createInteractionLog() : undefined
- let status: InteractionStatus = "in_progress"
-
- const fimLog = `Prefix: ${prefix}\nSuffix: ${suffix}`
- if (logEnabled) {
- interaction?.logItem({
- kind: "startFim",
- prefix,
- suffix,
- options: completionOptions,
- provider: this.providerName,
- })
- if (this.llmRequestHook) {
- this.llmRequestHook(completionOptions.model, fimLog)
- }
- }
-
- let completion = ""
- try {
- if (this.shouldUseOpenAIAdapter("streamFim") && this.openaiAdapter) {
- const stream = this.openaiAdapter.fimStream(toFimBody(prefix, suffix, completionOptions), signal)
- for await (const chunk of stream) {
- if (!this.lastRequestId && typeof (chunk as any).id === "string") {
- this.lastRequestId = (chunk as any).id
- }
- const result = fromChatCompletionChunk(chunk)
- if (result) {
- const content = renderChatMessage(result)
- const formattedContent = this._formatChatMessage(result)
- interaction?.logItem({
- kind: "chunk",
- chunk: formattedContent,
- })
-
- completion += formattedContent
- yield content
- }
- }
- } else {
- for await (const chunk of this._streamFim(prefix, suffix, signal, completionOptions)) {
- interaction?.logItem({
- kind: "chunk",
- chunk,
- })
-
- completion += chunk
- yield chunk
- }
- }
-
- status = this._logEnd(completionOptions.model, fimLog, completion, interaction, undefined)
- } catch (e) {
- console.error(e as Error, {
- context: "llm_stream_fim",
- model: completionOptions.model,
- provider: this.providerName,
- useOpenAIAdapter: this.shouldUseOpenAIAdapter("streamFim"),
- })
-
- status = this._logEnd(completionOptions.model, fimLog, completion, interaction, undefined, e)
- throw e
- } finally {
- if (status === "in_progress") {
- this._logEnd(completionOptions.model, fimLog, completion, interaction, undefined, "cancel")
- }
- }
-
- return {
- prompt: fimLog,
- completion,
- completionOptions,
- }
- }
-
- async *streamComplete(_prompt: string, signal: AbortSignal, options: LLMFullCompletionOptions = {}) {
- this.lastRequestId = undefined
- const { completionOptions, logEnabled, raw } = this.parseCompletionOptions(options)
- const interaction = logEnabled ? this.logger?.createInteractionLog() : undefined
- let status: InteractionStatus = "in_progress"
-
- let prompt = pruneRawPromptFromTop(
- completionOptions.model,
- this.contextLength,
- _prompt,
- completionOptions.maxTokens ?? DEFAULT_MAX_TOKENS,
- )
-
- if (!raw) {
- prompt = this._templatePromptLikeMessages(prompt)
- }
-
- if (logEnabled) {
- interaction?.logItem({
- kind: "startComplete",
- prompt,
- options: completionOptions,
- provider: this.providerName,
- })
- if (this.llmRequestHook) {
- this.llmRequestHook(completionOptions.model, prompt)
- }
- }
-
- let completion = ""
- try {
- if (this.shouldUseOpenAIAdapter("streamComplete") && this.openaiAdapter) {
- if (completionOptions.stream === false) {
- // Stream false
- const response = await this.openaiAdapter.completionNonStream(
- { ...toCompleteBody(prompt, completionOptions), stream: false },
- signal,
- )
- this.lastRequestId = response.id ?? this.lastRequestId
- completion = response.choices[0]?.text ?? ""
- yield completion
- } else {
- // Stream true
- for await (const chunk of this.openaiAdapter.completionStream(
- {
- ...toCompleteBody(prompt, completionOptions),
- stream: true,
- },
- signal,
- )) {
- if (!this.lastRequestId && typeof (chunk as any).id === "string") {
- this.lastRequestId = (chunk as any).id
- }
- const content = chunk.choices[0]?.text ?? ""
- completion += content
- interaction?.logItem({
- kind: "chunk",
- chunk: content,
- })
- yield content
- }
- }
- } else {
- for await (const chunk of this._streamComplete(prompt, signal, completionOptions)) {
- completion += chunk
- interaction?.logItem({
- kind: "chunk",
- chunk,
- })
- yield chunk
- }
- }
- status = this._logEnd(completionOptions.model, prompt, completion, interaction, undefined)
- } catch (e) {
- console.error(e as Error, {
- context: "llm_stream_complete",
- model: completionOptions.model,
- provider: this.providerName,
- useOpenAIAdapter: this.shouldUseOpenAIAdapter("streamComplete"),
- streamEnabled: completionOptions.stream !== false,
- })
-
- status = this._logEnd(completionOptions.model, prompt, completion, interaction, undefined, e)
- throw e
- } finally {
- if (status === "in_progress") {
- this._logEnd(completionOptions.model, prompt, completion, interaction, undefined, "cancel")
- }
- }
-
- return {
- modelTitle: this.title ?? completionOptions.model,
- modelProvider: this.underlyingProviderName,
- prompt,
- completion,
- completionOptions,
- }
- }
-
- async chat(messages: ChatMessage[], signal: AbortSignal, options: LLMFullCompletionOptions = {}) {
- let completion = ""
- for await (const message of this.streamChat(messages, signal, options)) {
- completion += renderChatMessage(message)
- }
- return { role: "assistant" as const, content: completion }
- }
-
- compileChatMessages(message: ChatMessage[], options: LLMFullCompletionOptions) {
- let { completionOptions } = this.parseCompletionOptions(options)
- completionOptions = this._modifyCompletionOptions(completionOptions)
-
- return compileChatMessages({
- modelName: completionOptions.model,
- msgs: message,
- knownContextLength: this._contextLength,
- maxTokens: completionOptions.maxTokens ?? DEFAULT_MAX_TOKENS,
- })
- }
-
- protected modifyChatBody(body: ChatCompletionCreateParams): ChatCompletionCreateParams {
- return body
- }
-
- private _modifyCompletionOptions(completionOptions: CompletionOptions): CompletionOptions {
- // As of 01/14/25 streaming is currently not available with o1
- // See these threads:
- // - https://github.com/continuedev/continue/issues/3698
- // - https://community.openai.com/t/streaming-support-for-o1-o1-2024-12-17-resulting-in-400-unsupported-value/1085043
- if (completionOptions.model === "o1") {
- completionOptions.stream = false
- }
-
- return completionOptions
- }
-
- async *streamChat(
- _messages: ChatMessage[],
- signal: AbortSignal,
- options: LLMFullCompletionOptions = {},
- messageOptions?: MessageOption,
- ): AsyncGenerator {
- this.lastRequestId = undefined
- let { completionOptions } = this.parseCompletionOptions(options)
- const { logEnabled } = this.parseCompletionOptions(options)
- const interaction = logEnabled ? this.logger?.createInteractionLog() : undefined
- let status: InteractionStatus = "in_progress"
-
- completionOptions = this._modifyCompletionOptions(completionOptions)
-
- let messages = _messages
-
- // If not precompiled, compile the chat messages
- if (!messageOptions?.precompiled) {
- const { compiledChatMessages } = compileChatMessages({
- modelName: completionOptions.model,
- msgs: _messages,
- knownContextLength: this._contextLength,
- maxTokens: completionOptions.maxTokens ?? DEFAULT_MAX_TOKENS,
- })
-
- messages = compiledChatMessages
- }
-
- const prompt = this.templateMessages ? this.templateMessages(messages) : this.formatChatMessages(messages)
- if (logEnabled) {
- interaction?.logItem({
- kind: "startChat",
- messages,
- options: completionOptions,
- provider: this.providerName,
- })
- if (this.llmRequestHook) {
- this.llmRequestHook(completionOptions.model, prompt)
- }
- }
-
- let completion = ""
- let usage: Usage | undefined = undefined
-
- try {
- if (this.templateMessages) {
- for await (const chunk of this._streamComplete(prompt, signal, completionOptions)) {
- completion += chunk
- interaction?.logItem({
- kind: "chunk",
- chunk: chunk,
- })
- yield { role: "assistant", content: chunk }
- }
- } else {
- if (this.shouldUseOpenAIAdapter("streamChat") && this.openaiAdapter) {
- let body = toChatBody(messages, completionOptions)
- body = this.modifyChatBody(body)
-
- if (completionOptions.stream === false) {
- // Stream false
- const response = await this.openaiAdapter.chatCompletionNonStream({ ...body, stream: false }, signal)
- this.lastRequestId = response.id ?? this.lastRequestId
- const msg = fromChatResponse(response)
- yield msg
- completion = this._formatChatMessage(msg)
- interaction?.logItem({
- kind: "message",
- message: msg,
- })
- } else {
- // Stream true
- const stream = this.openaiAdapter.chatCompletionStream(
- {
- ...body,
- stream: true,
- },
- signal,
- )
- for await (const chunk of stream) {
- if (!this.lastRequestId && typeof (chunk as any).id === "string") {
- this.lastRequestId = (chunk as any).id
- }
- const result = fromChatCompletionChunk(chunk)
- if (result) {
- completion += this._formatChatMessage(result)
- interaction?.logItem({
- kind: "message",
- message: result,
- })
- yield result
- }
- }
- }
- } else {
- for await (const chunk of this._streamChat(messages, signal, completionOptions)) {
- if (chunk.role === "assistant") {
- completion += this._formatChatMessage(chunk)
- }
-
- interaction?.logItem({
- kind: "message",
- message: chunk,
- })
-
- if (chunk.role === "assistant" && chunk.usage) {
- usage = chunk.usage
- }
-
- yield chunk
- }
- }
- }
- status = this._logEnd(completionOptions.model, prompt, completion, interaction, usage)
- } catch (e) {
- console.error(e as Error, {
- context: "llm_stream_chat",
- model: completionOptions.model,
- provider: this.providerName,
- useOpenAIAdapter: this.shouldUseOpenAIAdapter("streamChat"),
- streamEnabled: completionOptions.stream !== false,
- templateMessages: !!this.templateMessages,
- })
-
- status = this._logEnd(completionOptions.model, prompt, completion, interaction, usage, e)
- throw e
- } finally {
- if (status === "in_progress") {
- this._logEnd(completionOptions.model, prompt, completion, interaction, usage, "cancel")
- }
- }
-
- return {
- modelTitle: this.title ?? completionOptions.model,
- modelProvider: this.underlyingProviderName,
- prompt,
- completion,
- }
- }
-
- async rerank(query: string, chunks: Chunk[]): Promise {
- if (this.shouldUseOpenAIAdapter("rerank") && this.openaiAdapter) {
- const results = await this.openaiAdapter.rerank({
- model: this.model,
- query,
- documents: chunks.map((chunk) => chunk.content),
- })
-
- // Standard OpenAI format
- if (results.data && Array.isArray(results.data)) {
- return results.data
- .sort((a: { index: number }, b: { index: number }) => a.index - b.index)
- .map((result: { relevance_score: number }) => result.relevance_score)
- }
-
- throw new Error(
- `Unexpected rerank response format from ${this.providerName}. ` +
- `Expected 'data' array but got: ${JSON.stringify(Object.keys(results))}`,
- )
- }
-
- throw new Error(`Reranking is not supported for provider type ${this.providerName}`)
- }
-
- protected async *_streamComplete(
- _prompt: string,
- _signal: AbortSignal,
- _options: CompletionOptions,
- ): AsyncGenerator {
- throw new Error("Not implemented")
- }
-
- protected async *_streamChat(
- messages: ChatMessage[],
- signal: AbortSignal,
- options: CompletionOptions,
- ): AsyncGenerator {
- if (!this.templateMessages) {
- throw new Error("You must either implement templateMessages or _streamChat")
- }
-
- for await (const chunk of this._streamComplete(this.templateMessages(messages), signal, options)) {
- yield { role: "assistant", content: chunk }
- }
- }
-
- protected async _complete(prompt: string, signal: AbortSignal, options: CompletionOptions) {
- let completion = ""
- for await (const chunk of this._streamComplete(prompt, signal, options)) {
- completion += chunk
- }
- return completion
- }
-
- countTokens(text: string): number {
- return countTokens(text, this.model)
- }
-}
diff --git a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/llm/llms/Mock.ts b/packages/kilo-vscode/src/services/autocomplete/continuedev/core/llm/llms/Mock.ts
deleted file mode 100644
index 38e9a6f3836..00000000000
--- a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/llm/llms/Mock.ts
+++ /dev/null
@@ -1,66 +0,0 @@
-import { ChatMessage, CompletionOptions, LLMOptions } from "../../index.js"
-import { BaseLLM } from "../index.js"
-
-type MockMessage = ChatMessage | "REPEAT_LAST_MSG" | "REPEAT_SYSTEM_MSG" | "ERROR"
-
-class MockLLM extends BaseLLM {
- public completion: string = "Test Completion"
- public chatStreams: MockMessage[][] | undefined
- static override providerName = "mock"
-
- constructor(options: LLMOptions) {
- super(options)
- this.templateMessages = undefined
- this.chatStreams = options.chatStreams
- }
-
- protected override async *_streamComplete(
- _prompt: string,
- _signal: AbortSignal,
- _options: CompletionOptions,
- ): AsyncGenerator {
- yield this.completion
- }
-
- protected override async *_streamChat(
- messages: ChatMessage[],
- _signal: AbortSignal,
- _options: CompletionOptions,
- ): AsyncGenerator {
- if (this.chatStreams) {
- const chatStream = this.chatStreams?.[messages.filter((m) => m.role === "user").length - 1]
- if (chatStream) {
- for (const message of chatStream) {
- switch (message) {
- case "REPEAT_LAST_MSG":
- yield {
- role: "assistant",
- content: messages[messages.length - 1].content,
- }
- break
- case "REPEAT_SYSTEM_MSG":
- yield {
- role: "assistant",
- content: messages.find((m) => m.role === "system")?.content || "",
- }
- break
- case "ERROR":
- throw new Error("Intentional error")
- default:
- yield message
- }
- }
- }
- return
- }
-
- for (const char of this.completion) {
- yield {
- role: "assistant",
- content: char,
- }
- }
- }
-}
-
-export { MockLLM }
diff --git a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/llm/messages.ts b/packages/kilo-vscode/src/services/autocomplete/continuedev/core/llm/messages.ts
deleted file mode 100644
index 3433699dc21..00000000000
--- a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/llm/messages.ts
+++ /dev/null
@@ -1,31 +0,0 @@
-import { ChatMessage } from ".."
-
-function messageIsEmpty(message: ChatMessage): boolean {
- if (typeof message.content === "string") {
- return message.content.trim() === ""
- }
- if (Array.isArray(message.content)) {
- return message.content.every((item) => item.type === "text" && item.text?.trim() === "")
- }
- return false
-}
-
-// some providers don't support empty messages
-export function addSpaceToAnyEmptyMessages(messages: ChatMessage[]): ChatMessage[] {
- return messages.map((message) => {
- if (messageIsEmpty(message)) {
- message.content = " "
- }
- return message
- })
-}
-
-export function chatMessageIsEmpty(message: ChatMessage): boolean {
- switch (message.role) {
- case "system":
- case "user":
- return typeof message.content === "string" && message.content.trim() === ""
- case "assistant":
- return typeof message.content === "string" && message.content.trim() === ""
- }
-}
diff --git a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/llm/model-info/index.ts b/packages/kilo-vscode/src/services/autocomplete/continuedev/core/llm/model-info/index.ts
deleted file mode 100644
index 7f32ff6a0ce..00000000000
--- a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/llm/model-info/index.ts
+++ /dev/null
@@ -1,22 +0,0 @@
-import { OpenAi } from "./providers/openai.js"
-import { LlmInfoWithProvider, ModelProvider } from "./types.js"
-
-const allModelProviders: ModelProvider[] = [OpenAi]
-
-const allLlms: LlmInfoWithProvider[] = allModelProviders.flatMap((provider) =>
- provider.models.map((model) => ({ ...model, provider: provider.id })),
-)
-
-export function findLlmInfo(model: string, preferProviderId?: string): LlmInfoWithProvider | undefined {
- if (preferProviderId) {
- const provider = allModelProviders.find((p) => p.id === preferProviderId)
- const info = provider?.models.find((llm) => (llm.regex ? llm.regex.test(model) : llm.model === model))
- if (info) {
- return {
- ...info,
- provider: preferProviderId,
- }
- }
- }
- return allLlms.find((llm) => (llm.regex ? llm.regex.test(model) : llm.model === model))
-}
diff --git a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/llm/model-info/providers/openai.ts b/packages/kilo-vscode/src/services/autocomplete/continuedev/core/llm/model-info/providers/openai.ts
deleted file mode 100644
index 21f7f9e33c9..00000000000
--- a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/llm/model-info/providers/openai.ts
+++ /dev/null
@@ -1,139 +0,0 @@
-import { ModelProvider } from "../types.js"
-
-export const OpenAi: ModelProvider = {
- models: [
- {
- model: "gpt-3.5-turbo",
- displayName: "GPT-3.5 Turbo",
- contextLength: 16385,
- maxCompletionTokens: 4096,
- },
- {
- model: "gpt-3.5-turbo-0613",
- displayName: "GPT-3.5 Turbo",
- contextLength: 16385,
- maxCompletionTokens: 4096,
- },
- {
- model: "gpt-3.5-turbo-16k",
- displayName: "GPT-3.5 Turbo 16K",
- contextLength: 16384,
- maxCompletionTokens: 4096,
- },
- {
- model: "gpt-35-turbo-16k",
- displayName: "GPT-3.5 Turbo 16K",
- contextLength: 16384,
- maxCompletionTokens: 4096,
- },
- {
- model: "gpt-35-turbo-0613",
- displayName: "GPT-3.5 Turbo (0613)",
- contextLength: 4096,
- maxCompletionTokens: 4096,
- },
- {
- model: "gpt-35-turbo",
- displayName: "GPT-3.5 Turbo",
- contextLength: 4096,
- maxCompletionTokens: 4096,
- },
- // gpt-4
- {
- model: "gpt-4",
- displayName: "GPT-4",
- contextLength: 8192,
- maxCompletionTokens: 8192,
- },
- {
- model: "gpt-4-32k",
- displayName: "GPT-4 32K",
- contextLength: 32000,
- maxCompletionTokens: 8192,
- },
- {
- model: "gpt-4-turbo-preview",
- displayName: "GPT-4 Turbo Preview",
- contextLength: 128000,
- maxCompletionTokens: 4096,
- },
- {
- model: "gpt-4-vision",
- displayName: "GPT-4 Vision",
- contextLength: 128000,
- maxCompletionTokens: 4096,
- },
- {
- model: "gpt-4-0125-preview",
- displayName: "GPT-4 (0125 Preview)",
- contextLength: 128000,
- maxCompletionTokens: 4096,
- },
- {
- model: "gpt-4-1106-preview",
- displayName: "GPT-4 (1106 Preview)",
- contextLength: 128000,
- maxCompletionTokens: 4096,
- },
- // gpt-5
- {
- model: "gpt-5",
- displayName: "GPT-5",
- contextLength: 400000,
- maxCompletionTokens: 128000,
- regex: /gpt-5/,
- recommendedFor: ["chat"],
- },
- // gpt-4o
- {
- model: "gpt-4o",
- displayName: "GPT-4o",
- contextLength: 128000,
- recommendedFor: ["chat"],
- },
- {
- model: "gpt-4o-mini",
- displayName: "GPT-4o Mini",
- contextLength: 128000,
- recommendedFor: ["chat"],
- },
- // o1
- {
- model: "o1-preview",
- displayName: "o1 Preview",
- contextLength: 128000,
- maxCompletionTokens: 32768,
- recommendedFor: ["chat"],
- },
- {
- model: "o1-mini",
- displayName: "o1 Mini",
- contextLength: 128000,
- maxCompletionTokens: 65536,
- recommendedFor: ["chat"],
- },
- {
- model: "o3-mini",
- displayName: "o3 Mini",
- contextLength: 128000,
- maxCompletionTokens: 65536,
- recommendedFor: ["chat"],
- },
- // embed
- {
- model: "text-embedding-3-large",
- displayName: "Text Embedding 3-Large",
- recommendedFor: ["embed"],
- },
- {
- model: "text-embedding-3-small",
- displayName: "Text Embedding 3-Small",
- },
- {
- model: "text-embedding-ada-002",
- displayName: "Text Embedding Ada-002",
- },
- ],
- id: "openai",
- displayName: "OpenAI",
-}
diff --git a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/llm/model-info/types.ts b/packages/kilo-vscode/src/services/autocomplete/continuedev/core/llm/model-info/types.ts
deleted file mode 100644
index e516fa45419..00000000000
--- a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/llm/model-info/types.ts
+++ /dev/null
@@ -1,58 +0,0 @@
-type UseCase = "chat" | "autocomplete" | "rerank" | "embed"
-
-type ParameterType = "string" | "number" | "boolean"
-
-interface Parameter {
- key: string
- required: boolean
- valueType: ParameterType
- displayName?: string
- description?: string
- defaultValue?: any
-}
-
-enum ChatTemplate {
- None = "none",
- // TODO
-}
-
-interface LlmInfo {
- model: string
- // providers: string[]; // TODO: uncomment and deal with the consequences
- displayName?: string
- description?: string
- contextLength?: number
- maxCompletionTokens?: number
- regex?: RegExp
- chatTemplate?: ChatTemplate
-
- /** If not set, assumes "text" only */
- mediaTypes?: MediaType[]
- recommendedFor?: UseCase[]
-
- /** Any additional parameters required to configure the model */
- extraParameters?: Parameter[]
-}
-
-export type LlmInfoWithProvider = LlmInfo & {
- provider: string
-}
-
-enum MediaType {
- Text = "text",
- Image = "image",
- Audio = "audio",
- Video = "video",
-}
-
-export interface ModelProvider {
- id: string
- displayName: string
- models: Omit[]
-
- /** Any additional parameters required to configure the model
- *
- * (other than apiKey, apiBase, which are assumed always. And of course model and provider always required)
- */
- extraParameters?: Parameter[]
-}
diff --git a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/llm/openaiTypeConverters.ts b/packages/kilo-vscode/src/services/autocomplete/continuedev/core/llm/openaiTypeConverters.ts
deleted file mode 100644
index 4ae6c57a017..00000000000
--- a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/llm/openaiTypeConverters.ts
+++ /dev/null
@@ -1,108 +0,0 @@
-import {
- ChatCompletion,
- ChatCompletionChunk,
- ChatCompletionCreateParams,
- ChatCompletionMessageParam,
- CompletionCreateParams,
-} from "openai/resources/index"
-
-import { ChatMessage, CompletionOptions, TextMessagePart } from ".."
-
-function toChatMessage(message: ChatMessage): ChatCompletionMessageParam {
- if (message.role === "system") {
- return {
- role: "system",
- content: message.content,
- }
- }
-
- if (message.role === "assistant") {
- return {
- role: "assistant",
- content:
- typeof message.content === "string"
- ? message.content || " " // LM Studio (and other providers) don't accept empty content
- : message.content.filter((part) => part.type === "text").map((part) => part as TextMessagePart), // can remove with newer typescript version
- }
- } else {
- if (typeof message.content === "string") {
- return {
- role: "user",
- content: message.content ?? " ", // LM Studio (and other providers) don't accept empty content
- }
- }
-
- // Extract text from message parts
- return {
- role: "user",
- content: message.content.map((item) => (item as TextMessagePart).text).join("") || " ",
- }
- }
-}
-
-export function toChatBody(messages: ChatMessage[], options: CompletionOptions): ChatCompletionCreateParams {
- return {
- messages: messages.map(toChatMessage),
- model: options.model,
- max_tokens: options.maxTokens,
- temperature: options.temperature,
- top_p: options.topP,
- frequency_penalty: options.frequencyPenalty,
- presence_penalty: options.presencePenalty,
- stream: options.stream ?? true,
- stop: options.stop,
- }
-}
-
-export function toCompleteBody(prompt: string, options: CompletionOptions): CompletionCreateParams {
- return {
- prompt,
- model: options.model,
- max_tokens: options.maxTokens,
- temperature: options.temperature,
- top_p: options.topP,
- frequency_penalty: options.frequencyPenalty,
- presence_penalty: options.presencePenalty,
- stream: options.stream ?? true,
- stop: options.stop,
- }
-}
-
-export function toFimBody(prefix: string, suffix: string, options: CompletionOptions): Record {
- return {
- model: options.model,
- prompt: prefix,
- suffix,
- max_tokens: options.maxTokens,
- temperature: options.temperature,
- top_p: options.topP,
- frequency_penalty: options.frequencyPenalty,
- presence_penalty: options.presencePenalty,
- stop: options.stop,
- stream: true,
- } as any
-}
-
-export function fromChatResponse(response: ChatCompletion): ChatMessage {
- const message = response.choices[0].message
-
- return {
- role: "assistant",
- content: message.content ?? "",
- }
-}
-
-export function fromChatCompletionChunk(chunk: ChatCompletionChunk): ChatMessage | undefined {
- const delta = chunk.choices?.[0]?.delta
-
- if (delta?.content) {
- return {
- role: "assistant",
- content: delta.content,
- }
- }
-
- return undefined
-}
-
-export type LlmApiRequestType = "chat" | "streamChat" | "streamComplete" | "streamFim" | "rerank"
diff --git a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/llm/templates/edit.ts b/packages/kilo-vscode/src/services/autocomplete/continuedev/core/llm/templates/edit.ts
deleted file mode 100644
index 963bbece826..00000000000
--- a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/llm/templates/edit.ts
+++ /dev/null
@@ -1,253 +0,0 @@
-import { ChatMessage, PromptTemplate } from "../../index.js"
-import { gptEditPrompt } from "./edit/gpt.js"
-
-const simplifiedEditPrompt = `Consider the following code:
-\`\`\`{{{language}}}
-{{{codeToEdit}}}
-\`\`\`
-Edit the code to perfectly satisfy the following user request:
-{{{userInput}}}
-Output nothing except for the code. No code block, no English explanation, no start/end tags.`
-
-const simplestEditPrompt = `Here is the code before editing:
-\`\`\`{{{language}}}
-{{{codeToEdit}}}
-\`\`\`
-
-Here is the edit requested:
-"{{{userInput}}}"
-
-Here is the code after editing:`
-
-const codellamaInfillEditPrompt = "{{filePrefix}}{{fileSuffix}}"
-
-const START_TAG = ""
-const osModelsEditPrompt: PromptTemplate = (history, otherData) => {
- // "No sufix" means either there is no suffix OR
- // it's a clean break at end of function or something
- // (what we're trying to avoid is just the language model trying to complete the closing brackets of a function or something)
- const firstCharOfFirstLine = otherData.suffix?.split("\n")[0]?.[0]?.trim()
- const isSuffix =
- otherData.suffix?.trim() !== "" &&
- // First character of first line is whitespace
- // Otherwise we assume it's a clean break
- !firstCharOfFirstLine
- const suffixTag = isSuffix ? "" : ""
- const suffixExplanation = isSuffix ? ' When you get to "", end your response.' : ""
-
- // If neither prefilling nor /v1/completions are supported, we have to use a chat prompt without putting words in the model's mouth
- if (otherData.supportsCompletions !== "true" && otherData.supportsPrefill !== "true") {
- return gptEditPrompt(history, otherData)
- }
-
- // Use a different prompt when there's neither prefix nor suffix
- if (otherData.prefix?.trim() === "" && otherData.suffix?.trim() === "") {
- return [
- {
- role: "user",
- content: `\`\`\`${otherData.language}
-${otherData.codeToEdit}
-${suffixTag}
-\`\`\`
-
-Please rewrite the entire code block above in order to satisfy the following request: "${otherData.userInput}". You should rewrite the entire code block without leaving placeholders, even if the code is the same as before.${suffixExplanation}`,
- },
- {
- role: "assistant",
- content: `Sure! Here's the entire rewritten code block:
-\`\`\`${otherData.language}
-`,
- },
- ]
- }
-
- return [
- {
- role: "user",
- content: `\`\`\`${otherData.language}
-${otherData.prefix}${START_TAG}
-${otherData.codeToEdit}
-${suffixTag}
-\`\`\`
-
-Please rewrite the entire code block above, editing the portion below "${START_TAG}" in order to satisfy the following request: "${otherData.userInput}". You should rewrite the entire code block without leaving placeholders, even if the code is the same as before.${suffixExplanation}
-`,
- },
- {
- role: "assistant",
- content: `Sure! Here's the entire code block, including the rewritten portion:
-\`\`\`${otherData.language}
-${otherData.prefix}${START_TAG}
-`,
- },
- ]
-}
-
-const mistralEditPrompt = `[INST] You are a helpful code assistant. Your task is to rewrite the following code with these instructions: "{{{userInput}}}"
-\`\`\`{{{language}}}
-{{{codeToEdit}}}
-\`\`\`
-
-Just rewrite the code without explanations: [/INST]
-\`\`\`{{{language}}}`
-
-const alpacaEditPrompt = `Below is an instruction that describes a task, paired with an input that provides further context. Write a response that appropriately completes the request.
-
-### Instruction: Rewrite the code to satisfy this request: "{{{userInput}}}"
-
-### Input:
-
-\`\`\`{{{language}}}
-{{{codeToEdit}}}
-\`\`\`
-
-### Response:
-
-Sure! Here's the code you requested:
-\`\`\`{{{language}}}
-`
-
-const phindEditPrompt = `### System Prompt
-You are an expert programmer and write code on the first attempt without any errors or fillers.
-
-### User Message:
-Rewrite the code to satisfy this request: "{{{userInput}}}"
-
-\`\`\`{{{language}}}
-{{{codeToEdit}}}
-\`\`\`
-
-### Assistant:
-Sure! Here's the code you requested:
-
-\`\`\`{{{language}}}
-`
-
-const deepseekEditPrompt = `### System Prompt
-You are an AI programming assistant, utilizing the DeepSeek Coder model, developed by DeepSeek Company, and your role is to assist with questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will not answer.
-### Instruction:
-Rewrite the code to satisfy this request: "{{{userInput}}}"
-
-\`\`\`{{{language}}}
-{{{codeToEdit}}}
-\`\`\`<|EOT|>
-### Response:
-Sure! Here's the code you requested:
-
-\`\`\`{{{language}}}
-`
-
-const zephyrEditPrompt = `<|system|>
-You are an expert programmer and write code on the first attempt without any errors or fillers.
-<|user|>
-Rewrite the code to satisfy this request: "{{{userInput}}}"
-
-\`\`\`{{{language}}}
-{{{codeToEdit}}}
-\`\`\`
-<|assistant|>
-Sure! Here's the code you requested:
-
-\`\`\`{{{language}}}
-`
-
-const openchatEditPrompt = `GPT4 Correct User: You are an expert programmer and personal assistant. You are asked to rewrite the following code in order to {{{userInput}}}.
-\`\`\`{{{language}}}
-{{{codeToEdit}}}
-\`\`\`
-Please only respond with code and put it inside of a markdown code block. Do not give any explanation, but your code should perfectly satisfy the user request.<|end_of_turn|>GPT4 Correct Assistant: Sure thing! Here is the rewritten code that you requested:
-\`\`\`{{{language}}}
-`
-
-const xWinCoderEditPrompt = `: You are an AI coding agent that helps people with programming. Write a response that appropriately completes the user's request.
-: Please rewrite the following code with these instructions: "{{{userInput}}}"
-\`\`\`{{{language}}}
-{{{codeToEdit}}}
-\`\`\`
-
-Just rewrite the code without explanations:
-:
-\`\`\`{{{language}}}`
-
-const neuralChatEditPrompt = `### System:
-You are an expert programmer and write code on the first attempt without any errors or fillers.
-### User:
-Rewrite the code to satisfy this request: "{{{userInput}}}"
-
-\`\`\`{{{language}}}
-{{{codeToEdit}}}
-\`\`\`
-### Assistant:
-Sure! Here's the code you requested:
-
-\`\`\`{{{language}}}
-`
-
-const codeLlama70bEditPrompt = `Source: system\n\n You are an expert programmer and write code on the first attempt without any errors or fillers. Source: user\n\n Rewrite the code to satisfy this request: "{{{userInput}}}"
-
-\`\`\`{{{language}}}
-{{{codeToEdit}}}
-\`\`\` Source: assistant\nDestination: user\n\n `
-
-const claudeEditPrompt: PromptTemplate = (history: ChatMessage[], otherData: Record) => [
- {
- role: "user",
- content: `\
-\`\`\`${otherData.language}
-${otherData.codeToEdit}
-\`\`\`
-
-You are an expert programmer. You will rewrite the above code to do the following:
-
-${otherData.userInput}
-
-Output only a code block with the rewritten code:
-`,
- },
- {
- role: "assistant",
- content: `Sure! Here is the rewritten code:
-\`\`\`${otherData.language}`,
- },
-]
-
-const llama3EditPrompt: PromptTemplate = `<|begin_of_text|><|start_header_id|>user<|end_header_id|>
-\`\`\`{{{language}}}
-{{{codeToEdit}}}
-\`\`\`
-
-Rewrite the above code to satisfy this request: "{{{userInput}}}"<|eot_id|><|start_header_id|>assistant<|end_header_id|>
-Sure! Here's the code you requested:
-\`\`\`{{{language}}}`
-
-const gemmaEditPrompt = `user
-You are an expert programmer and write code on the first attempt without any errors or fillers. Rewrite the code to satisfy this request: "{{{userInput}}}"
-
-\`\`\`{{{language}}}
-{{{codeToEdit}}}
-\`\`\`
-model
-Sure! Here's the code you requested:
-
-\`\`\`{{{language}}}
-`
-
-export {
- alpacaEditPrompt,
- claudeEditPrompt,
- codeLlama70bEditPrompt,
- codellamaInfillEditPrompt,
- deepseekEditPrompt,
- gemmaEditPrompt,
- gptEditPrompt,
- llama3EditPrompt,
- mistralEditPrompt,
- neuralChatEditPrompt,
- openchatEditPrompt,
- osModelsEditPrompt,
- phindEditPrompt,
- simplestEditPrompt,
- simplifiedEditPrompt,
- xWinCoderEditPrompt,
- zephyrEditPrompt,
-}
diff --git a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/llm/templates/edit/gpt.ts b/packages/kilo-vscode/src/services/autocomplete/continuedev/core/llm/templates/edit/gpt.ts
deleted file mode 100644
index d13cdc8d0f5..00000000000
--- a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/llm/templates/edit/gpt.ts
+++ /dev/null
@@ -1,72 +0,0 @@
-import { PromptTemplateFunction } from "../../.."
-import { dedent } from "../../../util"
-
-const gptInsertionEditPrompt: PromptTemplateFunction = (_, otherData) => {
- return dedent`
- \`\`\`${otherData.language}
- ${otherData.prefix}[BLANK]${otherData.codeToEdit}${otherData.suffix}
- \`\`\`
-
- Above is the file of code that the user is currently editing in. Their cursor is located at the "[BLANK]". They have requested that you fill in the "[BLANK]" with code that satisfies the following request:
-
- "${otherData.userInput}"
-
- Please generate this code. Your output will be only the code that should replace the "[BLANK]", without repeating any of the prefix or suffix, without any natural language explanation, and without messing up indentation. Here is the code that will replace the "[BLANK]":`
-}
-
-const gptFullFileEditPrompt: PromptTemplateFunction = (_, otherData) => {
- return dedent`
- \`\`\`${otherData.language}
- ${otherData.codeToEdit}
- \`\`\`
-
- Please rewrite the above file to address the following request:
-
- ${otherData.userInput}
-
- You should rewrite the entire file without any natural language explanation. DO NOT surround the code in a code block and DO NOT explain yourself.`
-}
-
-export const gptEditPrompt: PromptTemplateFunction = (history, otherData) => {
- if (otherData?.codeToEdit?.trim().length === 0) {
- return gptInsertionEditPrompt(history, otherData)
- } else if (otherData?.prefix?.trim().length === 0 && otherData?.suffix?.trim().length === 0) {
- return gptFullFileEditPrompt(history, otherData)
- }
-
- const paragraphs = ["The user has requested a section of code in a file to be rewritten."]
-
- if (otherData.prefix?.trim().length > 0) {
- paragraphs.push(dedent`
- This is the prefix of the file:
- \`\`\`${otherData.language}
- ${otherData.prefix}
- \`\`\``)
- }
-
- if (otherData.suffix?.trim().length > 0) {
- paragraphs.push(dedent`
- This is the suffix of the file:
- \`\`\`${otherData.language}
- ${otherData.suffix}
- \`\`\``)
- }
-
- paragraphs.push(dedent`
- This is the code to rewrite:
- \`\`\`${otherData.language}
- ${otherData.codeToEdit}
- \`\`\`
-
- The user's request is: "${otherData.userInput}"
-
- DO NOT output any natural language, only output the code changes.
-
- Here is the rewritten code:`)
-
- return paragraphs.join("\n\n")
-}
-
-export const defaultApplyPrompt: PromptTemplateFunction = (history, otherData) => {
- return `${otherData.original_code}\n\nThe following code was suggested as an edit:\n\`\`\`\n${otherData.new_code}\n\`\`\`\nPlease apply it to the previous code.`
-}
diff --git a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/test/FakeConfigHandler.ts b/packages/kilo-vscode/src/services/autocomplete/continuedev/core/test/FakeConfigHandler.ts
deleted file mode 100644
index c071f588265..00000000000
--- a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/test/FakeConfigHandler.ts
+++ /dev/null
@@ -1,87 +0,0 @@
-import type { ILLM, TabAutocompleteOptions } from "../index.js"
-import { MinimalConfigProvider } from "../autocomplete/MinimalConfig.js"
-
-/**
- * Minimal config structure for testing.
- * Matches the shape of config returned by MinimalConfigProvider.loadConfig()
- */
-interface MinimalTestConfig {
- modelsByRole?: {
- autocomplete?: ILLM[]
- }
- selectedModelByRole?: {
- autocomplete?: ILLM
- edit?: ILLM
- chat?: ILLM
- rerank?: ILLM
- }
- rules?: unknown[]
-}
-
-/**
- * Options for customizing FakeConfigHandler behavior.
- * All options are optional and will use sensible defaults if not provided.
- */
-interface FakeConfigHandlerOptions {
- /** Configuration to return from loadConfig() */
- config?: Partial
-
- /** Autocomplete model to use (shorthand for setting selectedModelByRole.autocomplete) */
- autocompleteModel?: ILLM
-
- /** Whether static contextualization is enabled */
- enableStaticContextualization?: boolean
-
- /** Tab autocomplete options */
- tabAutocompleteOptions?: TabAutocompleteOptions
-
- /** Profile type for logging */
- profileType?: "control-plane" | "local" | "platform"
-}
-
-export class FakeConfigHandler extends MinimalConfigProvider {
- /** Track calls to onConfigUpdate for assertions */
- public configUpdateCallbacks: Array<(event: { config: MinimalTestConfig; configLoadInterrupted: boolean }) => void> =
- []
-
- constructor(options: FakeConfigHandlerOptions = {}) {
- // Build config from options
- const autocompleteModel = options.autocompleteModel
-
- const config = {
- tabAutocompleteOptions: options.tabAutocompleteOptions,
- experimental: {
- enableStaticContextualization: options.enableStaticContextualization ?? false,
- },
- modelsByRole: {
- autocomplete: autocompleteModel ? [autocompleteModel] : [],
- },
- selectedModelByRole: {
- autocomplete: autocompleteModel,
- },
- ...options.config,
- }
-
- // Call parent constructor with merged config
- super(config)
-
- // Set profile if provided
- if (options.profileType) {
- this.currentProfile = {
- profileDescription: {
- profileType: options.profileType,
- },
- }
- }
- }
-
- /**
- * Register config update handler
- * Overrides parent to track callbacks for test assertions
- */
- override onConfigUpdate(
- handler: (event: { config: MinimalTestConfig; configLoadInterrupted: boolean }) => void,
- ): void {
- this.configUpdateCallbacks.push(handler)
- }
-}
diff --git a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/test/FakeIDE.ts b/packages/kilo-vscode/src/services/autocomplete/continuedev/core/test/FakeIDE.ts
deleted file mode 100644
index a99e458b971..00000000000
--- a/packages/kilo-vscode/src/services/autocomplete/continuedev/core/test/FakeIDE.ts
+++ /dev/null
@@ -1,150 +0,0 @@
-import type {
- DocumentSymbol,
- FileStatsMap,
- IDE,
- IdeInfo,
- Location,
- Range,
- RangeInFile,
- SignatureHelp,
-} from "../index.js"
-
-/**
- * Options for customizing FakeIDE behavior.
- * All options are optional and will use sensible defaults if not provided.
- */
-interface FakeIDEOptions {
- /** File contents to return for readFile calls. Maps filepath -> content */
- fileContents?: Map
-
- /** Workspace directories to return */
- workspaceDirs?: string[]
-
- /** IDE info to return */
- ideInfo?: IdeInfo
-
- /** Open files to return */
- openFiles?: string[]
-
- /** Current file to return */
- currentFile?: {
- isUntitled: boolean
- path: string
- contents: string
- }
-
- /** Clipboard content to return */
- clipboardContent?: { text: string; copiedAt: string }
-
- /** Unique ID to return */
- uniqueId?: string
-}
-
-export class FakeIDE implements IDE {
- private options: FakeIDEOptions
-
- /** Track calls to onDidChangeActiveTextEditor for assertions */
- public activeTextEditorCallbacks: Array<(fileUri: string) => void> = []
-
- constructor(options: FakeIDEOptions = {}) {
- this.options = options
- }
-
- async getIdeInfo(): Promise {
- return (
- this.options.ideInfo ?? {
- ideType: "vscode",
- }
- )
- }
-
- async getClipboardContent(): Promise<{ text: string; copiedAt: string }> {
- return (
- this.options.clipboardContent ?? {
- text: "",
- copiedAt: new Date().toISOString(),
- }
- )
- }
-
- async getUniqueId(): Promise {
- return this.options.uniqueId ?? "fake-unique-id"
- }
-
- async getWorkspaceDirs(): Promise
-
-
-
-
-`,
- llmOutput: `() {
- return this.firstName + ' ' + this.lastName;
- }`,
- expectedCompletion: `() {
- return this.firstName + ' ' + this.lastName;
- }`,
- },
- {
- description: "Should autocomplete Vue method using props",
- filename: "TodoItem.vue",
- input: `
- User Full Name: {{ fullName }}
-{{ title }}
- --
- {#each items as item}
-
- {item} - {/each<|fim|> -
-
- );
-};`,
- llmOutput: "return () => clearInterval(interval);",
- expectedCompletion: undefined,
- filename: "Timer.tsx",
- },
- {
- description: "Should autocomplete simple return statement in TypeScript",
- filename: "file.ts",
- input: `
- multiply(number) {
- this.result *= number;
- return <|fim|>
- }
-
- divide(number) {
- if (number === 0) {
- throw new Error("Cannot divide by zero");
- }
- this.result /= number;
- return this;
- }
-`,
- llmOutput: ` this;`,
- expectedCompletion: `this;`,
- },
- {
- description: "Should complete YAML list item and preserve structure",
- filename: "test.yaml",
- input: `
- services:
- - name: web
- image: nginx
- - name: app<|fim|>
- volumes:
- - volume1
- - volume2
- `,
- llmOutput: `
- image: node
- `,
- expectedCompletion: `
- image: node`,
- },
- {
- description: "Should complete YAML key-value pair inside a nested structure",
- filename: "test.yaml",
- input: `
- version: '3'
- services:
- db:
- image: postgres
- environment:
- POSTGRES_USER: user
- POSTGRES_PASSWORD: pass
- POSTGRES_DB: mydb<|fim|>
- `,
- llmOutput: `
- PGDATA: /var/lib/postgresql/data/pgdata
- `,
- expectedCompletion: `
- PGDATA: /var/lib/postgresql/data/pgdata`,
- },
- {
- description: "Should complete YAML block within an existing block",
- filename: "test.yaml",
- input: `
- pipelines:
- branches:
- master:
- - step:
- name: Build and Test
- script:
- - npm install
- - npm run test
- - step:
- name: Deploy<|fim|>
- `,
- llmOutput: `
- script:
- - npm run deploy
- `,
- expectedCompletion: `
- script:
- - npm run deploy`,
- },
- {
- description: "Should autocomplete SQL query with subquery and alias in SELECT clause",
- filename: "complex_query.sql",
- input: `SELECT u.id,
- u.name,
- (SELECT COUNT(*) FROM orders o WHERE o.user_id = u.id) AS order_count
- FROM users u
- WHERE u.active = 1
- <|fim|>`,
- llmOutput: " AND EXISTS (SELECT 1 FROM transactions t WHERE t.user_id = u.id AND t.amount > 100)",
- expectedCompletion: "AND EXISTS (SELECT 1 FROM transactions t WHERE t.user_id = u.id AND t.amount > 100)",
- },
-]
-
-export const TEST_CASES_WITHOUT_DIFF: AutocompleteFileringTestInput[] = [
- {
- description: "should pass",
- filename: "test.js",
- input: "console.log('Hello <|fim|>!');",
- llmOutput: "World",
- expectedCompletion: "World",
- },
- {
- description: "Should preserve closing brackets when the opening bracket is not a part of the completion.",
- filename: "test.js",
- input: dedent`
- class Calculator {
- constructor() {
- this.result = 0;
- }
-
- add(number) {
- this.result += number;
- return this;
- }
-
- subtract(number) {
- this.result -= number;
- return this;
- }
-
- multiply(number) {
- this.result *= number;
- return this;
- }
-
- divide(number) {
- <|fim|>
-
- getResult() {
- return this.result;
- }
-
- reset() {
- this.result = 0;
- return this;
- }
- }
- `,
- llmOutput: dedent`if (number === 0) {
- throw new Error("Cannot divide by zero");
- }
- this.result /= number;
- return this;
- }`,
- expectedCompletion: dedent`if (number === 0) {
- throw new Error("Cannot divide by zero");
- }
- this.result /= number;
- return this;
- }`,
- },
- {
- description: "Should multiline-autocomplete CSS blocks",
- input: `body {
- font-family: Arial, sans-serif;
- font-size: 16px;
- color: #333333;
-}
-
-h1 {
- font-size: 24px;
- font-weight: bold;
- color: #000000;
-}
-
-h4<|fim|>
-
-a {
- text-decoration: none;
- color: #007bff;
-}
-
-.container {
- width: 100%;
- max-width: 1200px;
- margin: 0 auto;
- padding: 20px;
-}
-
-.button {
- display: inline-block;
- padding: 10px 20px;
- background-color: #007bff;
- color: #ffffff;`,
- llmOutput: ` {
- font-size: 18px;
- font-weight: bold;
- color: #000000;
-}`,
- expectedCompletion: ` {
- font-size: 18px;
- font-weight: bold;
- color: #000000;
-}`,
- filename: "test.css",
- },
- {
- description: "Should complete CSS rules inside a nested selector",
- filename: "styles.css",
- input: `
-.container {
- display: flex;
- justify-content: center;
- align-items: center;
- width: 100%;
- height: 100vh;
-
- .inner {
- <|fim|>
- }
-}
-`,
- llmOutput: `width: 50%;
- height: 50%;
- background-color: #f0f0f0;`,
- expectedCompletion: `width: 50%;
- height: 50%;
- background-color: #f0f0f0;`,
- },
-
- {
- description: "Should complete a CSS rule when the property is partially typed",
- filename: "styles.css",
- input: `
-button {
- border: 2px solid #000;
- border-radius<|fim|>
-}`,
- llmOutput: ": 5px;",
- expectedCompletion: ": 5px;",
- },
-
- {
- description: "Should handle CSS autocomplete with a single bracket present",
- filename: "styles.css",
- input: `
-.card {
- box-shadow: 0 4px 8px rgba(0,0,0,0.2);
- transition: 0.3s;
- padding: 16px;
- border-bottom-left-radius: <|fim|>px;
- border-bottom-right-radius: 8px;
-}
-`,
- llmOutput: "8",
- expectedCompletion: "8",
- },
-
- {
- description: "Should autocomplete CSS pseudoclass",
- filename: "pseudoClass.css",
- input: `
-input:focus {
- outline: none;
- border: 2px solid <|fim|>;
-}
-`,
- llmOutput: "#4CAF50;",
- expectedCompletion: "#4CAF50;",
- },
-
- {
- description: "Should handle CSS variable syntax",
- filename: "variables.css",
- input: `
-:root {
- --primary-color: #3498db;
- --padding: 10px;
-}
-
-.section {
- background-color: var(<|fim|>);
- padding: var(--padding);
-}
-`,
- llmOutput: "--primary-color",
- expectedCompletion: "--primary-color",
- },
- {
- description: "Should complete CSS grid template columns",
- filename: "grid.css",
- input: `
-.grid-container {
- display: grid;
- grid-template-columns: repeat(<|fim|>);
- grid-gap: 10px;
-}
-`,
- llmOutput: "3, 1fr",
- expectedCompletion: "3, 1fr",
- },
-
- {
- description: "Should complete PHP function inside a class with comments",
- input: `name = $name;
- $this->email = $email;
- }
-
- public function <|fim|>
-
- public function setEmail($email) {
- $this->email = $email;
- }
-}`,
- llmOutput: `getDetails() {
- return "Name: " . $this->name . ", Email: " . $this->email;
- }`,
- expectedCompletion: `getDetails() {
- return "Name: " . $this->name . ", Email: " . $this->email;
- }`,
- filename: "User.php",
- },
-
- {
- description: "Should autocomplete PHP function with inline logic",
- input: `
-}
-
-echo calculateArea(5, 3);`,
- llmOutput: "return $length * $width;",
- expectedCompletion: "return $length * $width;",
- filename: "areaCalculator.php",
- },
-
- {
- description: "Should handle PHP completion in the middle of an array",
- input: `);
-
-echo "First color is: " . $colors[0];`,
- llmOutput: '"Blue"',
- expectedCompletion: '"Blue"',
- filename: "colors.php",
- },
- {
- description: "Should autocomplete React return statements (jsx)",
- input: `import React from "react";
-
-export const Button = ({
- onClick,
- children,
-}: {
- children: React.ReactNode;
- onClick: () => void;
-}) => {
- return (
-<|fim|>
- );
-};`,
- llmOutput: ``,
- expectedCompletion: ``,
- filename: "Button.tsx",
- },
- {
- description: "Should autocomplete React state initialization",
- input: `import React, { useState } from "react";
-
-export const Counter = () => {
- const [count, setCount] = useState(<|fim|>);
-
- return (
- {seconds} seconds have passed.
-
-
- );
-};`,
- llmOutput: "0",
- expectedCompletion: "0",
- filename: "Counter.tsx",
- },
- {
- description: "Should autocomplete React component methods",
- input: `import React from "react";
-
-class Form extends React.Component {
- constructor(props) {
- super(props);
- this.state = { name: '' };
- }
-
- handleChange = (event) => {
- <|fim|>
- }
-
- handleSubmit = (event) => {
- event.preventDefault();
- alert('A name was submitted: ' + this.state.name);
- }
-
- render() {
- return (
-
- );
- }
-}`,
- llmOutput: "this.setState({ name: event.target.value });",
- expectedCompletion: "this.setState({ name: event.target.value });",
- filename: "Form.tsx",
- },
- {
- description: "Should autocomplete Python function definition",
- filename: "test.py",
- input: `def calculate_area(length, width):
- area = length * width
- return area
-
-def calculate_perimeter(length, width):
- <|fim|>
-`,
- llmOutput: `perimeter = 2 * (length + width)
- return perimeter`,
- expectedCompletion: `perimeter = 2 * (length + width)
- return perimeter`,
- },
- {
- description: "Should complete Python class method with self",
- filename: "test.py",
- input: `class BankAccount:
- def __init__(self, owner, balance=0):
- self.owner = owner
- self.balance = balance
-
- def deposit(self, amount):
- self.balance += amount
- return self.balance
-
- def withdraw(self, amount):
- <|fim|>
-`,
- llmOutput: `if amount > self.balance:
- return "Insufficient funds"
- self.balance -= amount
- return self.balance`,
- expectedCompletion: `if amount > self.balance:
- return "Insufficient funds"
- self.balance -= amount
- return self.balance`,
- },
- {
- description: "Should autocomplete Python list comprehension",
- filename: "test.py",
- input: `squares = [x**2 for x in range(10)]
-even_squares = [x for x in squares if x % 2 == 0]
-print(even_squares)
-
-odd_squares = [<|fim|>
-print(odd_squares)
-`,
- llmOutput: "x for x in squares if x % 2 != 0",
- expectedCompletion: "x for x in squares if x % 2 != 0",
- },
- {
- description: "Should autocomplete a simple Go function declaration",
- filename: "simpleFunction.go",
- input: `package main
-
-import (
- "fmt"
-)
-
-func main() {
- fmt.Println("Hello, World!")
-}
-
-func calculateArea<|fim|>`,
- llmOutput: `(length float64, width float64) float64 {
- return length * width
-}`,
- expectedCompletion: `(length float64, width float64) float64 {
- return length * width
-}`,
- },
-
- {
- description: "Should handle autocomplete in the middle of a Go struct definition",
- filename: "structDefinition.go",
- input: `package main
-
-type Person struct {
- FirstName string
- LastName string
- Age int
- Address Address
-}
-
-type Address struct {
- Street string
- City <|fim|>
-}
-
-func main() {}`,
- llmOutput: `string
- State string
- ZipCode string
-}`,
- expectedCompletion: `string
- State string
- ZipCode string`,
- },
-
- {
- description: "Should autocomplete a missing Go function body bracket",
- filename: "missingBracket.go",
- input: `package main
-
-func add(a int, b int) int {
- return a + b<|fim|>
-
-func multiply(a int, b int) int {
- return a * b
-}
-
-func main() {
- result1 := add(2, 3)
- result2 := multiply(4, 5)
- println(result1, result2)
-}`,
- llmOutput: `
-}`,
- expectedCompletion: `
-}`,
- },
- {
- description: "Should autocomplete SQL query with nested functions and missing bracket",
- filename: "_nested_function.sql",
- input: `SELECT name, ROUND(AVG(rating), 2) as avg_rating
- FROM movies
- WHERE release_year > 2000 AND director = 'Christopher Nolan'
- GROUP BY name
- HAVING avg_rating > <|fim|>`,
- llmOutput: "8.5)",
- expectedCompletion: "8.5)",
- },
- {
- description: "Should autocomplete SQL script with employee and product tables",
- filename: "database.sql",
- input: `
- CREATE TABLE employees (
- id INT AUTO_INCREMENT PRIMARY KEY,
- name VARCHAR(100) NOT NULL,
- age INT NOT NULL,
- position VARCHAR(100)
- );
-
- CREATE TABLE products (
- id INT AUTO_INCREMENT PRIMARY KEY,
- name VARCHAR(100),
- price DECIMAL(8,2) NOT NULL<|fim|> '0.00',
- quantity INT NOT NULL DEFAULT '0'
- );
-
- INSERT INTO employees (name, age, position) VALUES ('John Doe', 30, 'Developer');
- INSERT INTO products (name, price, quantity) VALUES ('Apple', '1.99', '47');
-
- SELECT * FROM products ORDER BY name DESC LIMIT 3;
- SELECT * FROM products WHERE price > '0';
- SELECT * FROM products WHERE quantity > '100';
- SELECT * FROM employees WHERE age > 25;
- `,
- llmOutput: " DEFAULT",
- expectedCompletion: " DEFAULT",
- },
- {
- description: "Should autocomplete multi-line SQL query with CASE statements",
- filename: "case_statement.sql",
- input: `SELECT order_id,
- order_date,
- CASE
- WHEN status = 'shipped' THEN 'Completed'
- WHEN status = 'pending' THEN 'Pending Approval'
- <|fim|>
- ELSE 'Unknown'
- END as order_status
- FROM orders`,
- llmOutput: "WHEN status = 'cancelled' THEN 'Cancelled'",
- expectedCompletion: "WHEN status = 'cancelled' THEN 'Cancelled'",
- },
- {
- description: "Should autocomplete HTML paragraph content",
- input: `
-
- You clicked {count} times
- -<|fim|>
- -`, - llmOutput: "This is a paragraph with some sample text.", - expectedCompletion: "This is a paragraph with some sample text.", - filename: "test.html", - }, - { - description: "Should autocomplete HTML attributes within a tag", - input: `
- 
>
-
`,
- llmOutput: 'alt="Description of image"',
- expectedCompletion: 'alt="Description of image"',
- filename: "test.html",
- },
- {
- description: "Should autocomplete HTML nested tags",
- input: `>
-
-
-Title
-Description text.
--
-
- Item 1 -
- Item 2 -
- Item 3 -
-
-
-
-
-
-`,
- llmOutput: `() {
- this.count = 0;
- }`,
- expectedCompletion: `() {
- this.count = 0;
- }`,
- },
- {
- description: "Should autocomplete Vue computed property",
- filename: "UserComponent.vue",
- input: `
- Count: {{ count }}
-
-
-
-
-
-`,
- llmOutput: `() {
- return this.firstName + ' ' + this.lastName;
- }`,
- expectedCompletion: `() {
- return this.firstName + ' ' + this.lastName;
- }`,
- },
- {
- description: "Should autocomplete Vue method using props",
- filename: "TodoItem.vue",
- input: `
- User Full Name: {{ fullName }}
-{{ title }}
- -Hello Svelte
--
- {#each items as item}
-
- {item} - {/each<|fim|> -