+
+ e.preventDefault()}
+ onClick={handleCopy}
+ aria-label={copied() ? i18n.t("ui.message.copied") : i18n.t("ui.message.copyResponse")}
+ />
+
+
+
-
+
-
+
): 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 1421a25b0ab..62bc0b9960e 100644
--- a/packages/kilo-vscode/src/KiloProvider.ts
+++ b/packages/kilo-vscode/src/KiloProvider.ts
@@ -35,7 +35,7 @@ import {
import { GitOps } from "./agent-manager/GitOps"
import { GitStatsPoller, type LocalStats } from "./agent-manager/GitStatsPoller"
import { getWorkspaceRoot } from "./review-utils"
-import { MarketplaceService } from "./services/marketplace"
+import { MarketplaceService, type MarketplaceItem, type RemoveResult } from "./services/marketplace"
import { resolveProjectDirectory } from "./project-directory"
import { getBusySessionCount, seedSessionStatuses } from "./session-status"
import { retry } from "./services/cli-backend/retry"
@@ -96,12 +96,26 @@ import {
saveCustomProvider as saveCustomProviderAction,
} from "./provider-actions"
import { fetchOpenAIModels, FetchModelsError } from "./shared/fetch-models"
+import type { Agent } from "@kilocode/sdk/v2/client"
type KiloProviderOptions = {
projectDirectory?: string | null
slimEditMetadata?: boolean
}
+// Helper to map agent data to the subset of fields sent to the webview
+const mapAgent = (a: Agent) => ({
+ name: a.name,
+ displayName: a.displayName,
+ description: a.description,
+ mode: a.mode,
+ native: a.native,
+ hidden: a.hidden,
+ color: a.color,
+ deprecated: a.deprecated,
+ permission: a.permission,
+})
+
export class KiloProvider implements vscode.WebviewViewProvider, TelemetryPropertiesProvider {
public static readonly viewType = "kilo-code.SidebarProvider"
@@ -189,6 +203,8 @@ 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
+
constructor(
private readonly extensionUri: vscode.Uri,
private readonly connectionService: KiloConnectionService,
@@ -207,6 +223,10 @@ export class KiloProvider implements vscode.WebviewViewProvider, TelemetryProper
this.postMessage({ type: "workspaceDirectoryChanged", directory: directory ?? "" })
}
+ public setDiffVirtualProvider(provider: import("./DiffVirtualProvider").DiffVirtualProvider): void {
+ this.diffVirtualProvider = provider
+ }
+
getTelemetryProperties(): Record {
return {
appName: "kilo-code",
@@ -619,6 +639,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) => {
@@ -982,12 +1007,8 @@ export class KiloProvider implements vscode.WebviewViewProvider, TelemetryProper
break
}
case "removeInstalledMarketplaceItem": {
- const workspace = this.getProjectDirectory(this.currentSession?.id)
const scope = message.mpInstallOptions?.target ?? "project"
- const result = await this.getMarketplace().remove(message.mpItem, scope, workspace)
- if (result.success) {
- await this.invalidateAfterMarketplaceChange(scope)
- }
+ const result = await this.removeMarketplaceItem(message.mpItem, scope)
this.postMessage({
type: "marketplaceRemoveResult",
success: result.success,
@@ -1171,6 +1192,7 @@ export class KiloProvider implements vscode.WebviewViewProvider, TelemetryProper
])
this.sendNotificationSettings()
this.sendTimelineSetting()
+ this.postMessage({ type: "extensionDataReady" })
// Start polling worktree diff stats for the sidebar badge
this.startStatsPolling()
@@ -1640,15 +1662,8 @@ export class KiloProvider implements vscode.WebviewViewProvider, TelemetryProper
const message = {
type: "agentsLoaded",
- agents: visible.map((a) => ({
- name: a.name,
- displayName: a.displayName,
- description: a.description,
- mode: a.mode,
- native: a.native,
- color: a.color,
- deprecated: a.deprecated,
- })),
+ agents: visible.map(mapAgent),
+ allAgents: agents.map(mapAgent),
defaultAgent,
}
this.cachedAgentsMessage = message
@@ -1762,59 +1777,87 @@ export class KiloProvider implements vscode.WebviewViewProvider, TelemetryProper
*/
private async handleRemoveMode(name: string): Promise {
if (!this.client) return
- let removed = false
// 1. Try CLI removal (handles .md files and legacy .kilocodemodes)
try {
const dir = this.getWorkspaceDirectory()
const result = await this.client.kilocode.removeAgent({ name, directory: dir })
- if (!result.error) removed = true
+ if (!result.error) {
+ this.cachedAgentsMessage = null
+ await this.fetchAndSendAgents()
+ return
+ }
} catch {
// CLI removal failed — agent may be in kilo.json instead
}
// 2. Try removing from kilo.json (handles marketplace-installed modes)
- if (!removed) {
- const workspace = this.getProjectDirectory(this.currentSession?.id)
- const mp = this.getMarketplace()
- const stub = { id: name, type: "mode" as const, name, description: "", content: "" }
- const project = await mp.remove(stub, "project", workspace)
- const global = await mp.remove(stub, "global", workspace)
- if (project.success || global.success) {
- await this.disposeCliInstance("global")
- removed = true
- }
- }
-
+ const stub = { id: name, type: "mode" as const, name, description: "", content: "" }
+ const removed = await this.removeMarketplaceItemFromAllScopes(stub)
if (!removed) {
console.error("[Kilo New] KiloProvider: Failed to remove mode:", name)
}
-
- this.cachedAgentsMessage = null
- await this.fetchAndSendAgents()
}
private async handleRemoveMcp(name: string): Promise {
- const workspace = this.getProjectDirectory(this.currentSession?.id)
- const mp = this.getMarketplace()
+ // Remove from legacy files first so that the subsequent invalidation
+ // causes the CLI to re-read config without the legacy entry.
+ await this.removeLegacyMcp(name)
+
const stub = { id: name, type: "mcp" as const, name, description: "", url: "", content: "" }
-
- // Remove from both scopes — an MCP could exist in project, global, or both
- const project = await mp.remove(stub, "project", workspace)
- const global = await mp.remove(stub, "global", workspace)
-
- if (project.success || global.success) {
- // Use global scope when removed from global (or both) so the global
- // config cache is also invalidated; project scope is a subset.
- const scope = global.success ? "global" : "project"
- await this.disposeCliInstance(scope)
- this.cachedConfigMessage = null
- await this.fetchAndSendConfig()
- } else {
+ const removed = await this.removeMarketplaceItemFromAllScopes(stub)
+ if (!removed) {
console.error("[Kilo New] KiloProvider: Failed to remove MCP server:", name)
}
}
+ /**
+ * Remove an MCP server from legacy config files (.kilo/mcp.json, .kilocode/mcp.json,
+ * and the VS Code global storage mcp_settings.json). These files are read by the
+ * CLI-side McpMigrator and merged into config at the lowest precedence level.
+ * Returns true if the entry was found and removed from at least one file.
+ */
+ private async removeLegacyMcp(name: string): Promise {
+ const workspace = this.getProjectDirectory(this.currentSession?.id)
+ const files: vscode.Uri[] = []
+
+ // Project-level legacy files
+ if (workspace) {
+ files.push(vscode.Uri.file(path.join(workspace, ".kilo", "mcp.json")))
+ files.push(vscode.Uri.file(path.join(workspace, ".kilocode", "mcp.json")))
+ }
+
+ // Global legacy file (VS Code extension global storage)
+ const storage = this.extensionContext?.globalStorageUri
+ if (storage) {
+ files.push(vscode.Uri.joinPath(storage, "settings", "mcp_settings.json"))
+ }
+
+ let removed = false
+ for (const uri of files) {
+ const bytes = await vscode.workspace.fs.readFile(uri).then(
+ (b) => b,
+ () => null,
+ )
+ if (!bytes) continue
+
+ try {
+ const parsed = JSON.parse(Buffer.from(bytes).toString("utf8")) as Record
+ const servers = parsed.mcpServers as Record | undefined
+ if (!servers?.[name]) continue
+
+ delete servers[name]
+ const content = Buffer.from(JSON.stringify(parsed, null, 2), "utf8")
+ await vscode.workspace.fs.writeFile(uri, content)
+ removed = true
+ } catch (err) {
+ console.warn("[Kilo New] KiloProvider: Failed to remove legacy MCP from", uri.fsPath, err)
+ }
+ }
+
+ return removed
+ }
+
private async fetchAndSendMcpStatus(): Promise {
if (!this.client) {
if (this.cachedMcpStatusMessage) {
@@ -1861,23 +1904,35 @@ export class KiloProvider implements vscode.WebviewViewProvider, TelemetryProper
}
/**
- * Dispose the CLI backend instance so it re-reads config from disk.
- * Call after any marketplace install/remove that writes config files directly.
- * Global-scope changes need global.dispose() to also reset the global config cache.
+ * Remove a marketplace item from a single scope and invalidate CLI caches.
*/
- private async disposeCliInstance(scope: "project" | "global"): Promise {
- if (!this.client) return
- if (scope === "global") {
- await this.client.global.dispose().catch((e: unknown) => {
- console.warn("[Kilo New] global.dispose() after marketplace change failed:", e)
- })
+ private async removeMarketplaceItem(item: MarketplaceItem, scope: "project" | "global"): Promise {
+ const workspace = this.getProjectDirectory(this.currentSession?.id)
+ const result = await this.getMarketplace().remove(item, scope, workspace)
+ if (result.success) {
+ await this.invalidateAfterMarketplaceChange(scope)
}
- // Always dispose the per-project instance so it rebuilds state from
- // the (possibly updated) global + project config on the next request.
- const dir = this.getWorkspaceDirectory()
- await this.client.instance.dispose({ directory: dir }).catch((e: unknown) => {
- console.warn("[Kilo New] instance.dispose() after marketplace change failed:", e)
- })
+ return result
+ }
+
+ /**
+ * Remove a marketplace item from both project and global scopes.
+ * mp.remove returns success even when the entry doesn't exist (no-op),
+ * so we must attempt both scopes to cover dual-scope installations.
+ * Returns true if at least one scope removal succeeded.
+ */
+ private async removeMarketplaceItemFromAllScopes(item: MarketplaceItem): Promise {
+ const workspace = this.getProjectDirectory(this.currentSession?.id)
+ const mp = this.getMarketplace()
+ const project = await mp.remove(item, "project", workspace)
+ const global = await mp.remove(item, "global", workspace)
+
+ if (project.success || global.success) {
+ const scope = global.success ? "global" : "project"
+ await this.invalidateAfterMarketplaceChange(scope)
+ return true
+ }
+ return false
}
/**
diff --git a/packages/kilo-vscode/src/agent-manager/AgentManagerProvider.ts b/packages/kilo-vscode/src/agent-manager/AgentManagerProvider.ts
index 8ebb82f9a89..bebd61406a2 100644
--- a/packages/kilo-vscode/src/agent-manager/AgentManagerProvider.ts
+++ b/packages/kilo-vscode/src/agent-manager/AgentManagerProvider.ts
@@ -6,6 +6,7 @@ import { getErrorMessage } from "../kilo-provider-utils"
import { isAbsolutePath } from "../path-utils"
import { WorktreeManager, type CreateWorktreeResult } from "./WorktreeManager"
import { WorktreeStateManager, remoteRef } from "./WorktreeStateManager"
+import { handleSection } from "./section-handler"
import { chooseBaseBranch, normalizeBaseBranch } from "./base-branch"
import { GitStatsPoller, type WorktreePresenceResult } from "./GitStatsPoller"
import { PRStatusBridge } from "./pr-status-bridge"
@@ -341,6 +342,7 @@ export class AgentManagerProvider implements Disposable {
this.state?.setSessionsCollapsed(m.collapsed)
return null
}
+ if (this.handleSection(m)) return null
if (m.type === "agentManager.setReviewDiffStyle") {
this.state?.setReviewDiffStyle(m.style)
return null
@@ -1488,6 +1490,7 @@ export class AgentManagerProvider implements Disposable {
type: "agentManager.state",
worktrees,
sessions: state.getSessions(),
+ sections: state.getSections(),
staleWorktreeIds,
tabOrder: state.getTabOrder(),
worktreeOrder: state.getWorktreeOrder(),
@@ -1911,6 +1914,10 @@ export class AgentManagerProvider implements Disposable {
)
}
+ private handleSection(m: AgentManagerInMessage): boolean {
+ return handleSection(this.state, m, () => this.pushState())
+ }
+
public postMessage(message: unknown): void {
this.panel?.postMessage(message)
}
diff --git a/packages/kilo-vscode/src/agent-manager/PRStatusPoller.ts b/packages/kilo-vscode/src/agent-manager/PRStatusPoller.ts
index a1d37297c16..6ec85c11ea1 100644
--- a/packages/kilo-vscode/src/agent-manager/PRStatusPoller.ts
+++ b/packages/kilo-vscode/src/agent-manager/PRStatusPoller.ts
@@ -14,6 +14,9 @@ interface PRStatusPollerOptions {
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
@@ -27,6 +30,8 @@ export class PRStatusPoller {
private ghProbeTime = 0
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
constructor(private readonly options: PRStatusPollerOptions) {
@@ -48,9 +53,13 @@ export class PRStatusPoller {
this.visible = visible
if (!this.active) return
if (visible) {
- // Resume — poll immediately then schedule normally
+ // Resume — expire all PR caches and fetch all worktrees once to catch up,
+ // then resume the normal active-only poll cycle.
if (this.timer) clearTimeout(this.timer)
this.timer = undefined
+ this.prCache.clear()
+ this.lastHash.clear()
+ this.lastFullSync = 0
void this.poll()
return
}
@@ -74,16 +83,24 @@ export class PRStatusPoller {
this.ghAvailable = undefined
this.ghProbeTime = 0
this.cachedRepo = undefined
+ this.prCache.clear()
+ this.lastFullSync = 0
}
- /** Force-refresh a specific worktree immediately. */
+ /** Force-refresh a specific worktree immediately, bypassing the PR cache. */
refresh(worktreeId: string): void {
if (!this.active) return
+ const wt = this.options.getWorktrees().find((w) => w.id === worktreeId)
+ if (wt) this.prCache.delete(wt.branch)
void this.fetchOne(worktreeId)
}
setActiveWorktreeId(id: string | undefined): void {
+ const prev = this.activeWorktreeId
this.activeWorktreeId = id
+ // When switching to a different worktree, fetch it immediately so the
+ // badge updates without waiting for the next poll cycle.
+ if (id && id !== prev && this.active) void this.fetchOne(id)
}
private start(): void {
@@ -146,8 +163,27 @@ export class PRStatusPoller {
}
this.lastError = undefined
+
+ // 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 results = await Promise.allSettled(worktrees.map((wt) => this.fetchOne(wt.id)))
+ const now = Date.now()
+ const initial = this.lastHash.size === 0
+ 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 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
@@ -164,7 +200,7 @@ export class PRStatusPoller {
if (!this.options.getWorkspaceRoot()) return
try {
- const pr = await this.fetchPRForBranch(wt.branch, wt.path)
+ const pr = await this.cachedFetchPR(wt.branch, wt.path)
if (!pr) {
const hash = `${worktreeId}:none`
if (this.lastHash.get(worktreeId) === hash) return
@@ -217,6 +253,17 @@ export class PRStatusPoller {
private static readonly PR_JSON_FIELDS =
"number,title,url,state,isDraft,reviewDecision,additions,deletions,changedFiles,headRefName,headRefOid"
+ /** Return a cached PR lookup if still fresh, otherwise fetch and cache.
+ * Keyed by branch name so multiple worktrees on the same branch share
+ * the cache, and a branch switch in a worktree naturally misses. */
+ private async cachedFetchPR(branch: string, cwd: string): Promise {
+ const cached = this.prCache.get(branch)
+ if (cached && Date.now() < cached.expires) return cached.result
+ const result = await this.fetchPRForBranch(branch, cwd)
+ this.prCache.set(branch, { result, expires: Date.now() + PR_LOOKUP_TTL })
+ return result
+ }
+
private async fetchPRForBranch(branch: string, cwd: string): Promise {
// Strategy 1: bare `gh pr view` — resolves via the branch's tracking ref.
// Works for fork PRs checked out with `gh pr checkout` (tracking ref = refs/pull/N/head).
@@ -484,3 +531,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/WorktreeStateManager.ts b/packages/kilo-vscode/src/agent-manager/WorktreeStateManager.ts
index c41ce547aa8..3765785d96f 100644
--- a/packages/kilo-vscode/src/agent-manager/WorktreeStateManager.ts
+++ b/packages/kilo-vscode/src/agent-manager/WorktreeStateManager.ts
@@ -35,6 +35,18 @@ export interface Worktree {
/** Original branch created with the worktree, used for cleanup on deletion.
* Set automatically when `branch` is updated via live sync. */
originalBranch?: string
+ /** Section this worktree belongs to, or undefined for ungrouped. */
+ sectionId?: string
+}
+
+export interface Section {
+ id: string
+ name: string
+ /** Color label (e.g. "Red", "Blue") mapped to VS Code theme CSS vars at render time, or null for default. */
+ color: string | null
+ /** Position among top-level sidebar children (interleaved with ungrouped worktrees). */
+ order: number
+ collapsed: boolean
}
/**
@@ -55,6 +67,7 @@ export interface ManagedSession {
interface StateFile {
worktrees: Record>
sessions: Record>
+ sections?: Record>
tabOrder?: Record
worktreeOrder?: string[]
sessionsCollapsed?: boolean
@@ -76,6 +89,7 @@ export class WorktreeStateManager {
private readonly file: string
private worktrees = new Map()
private sessions = new Map()
+ private sections = new Map()
private tabOrder: Record = {}
private worktreeOrder: string[] = []
private collapsed = false
@@ -204,12 +218,12 @@ export class WorktreeStateManager {
const removed = this.worktrees.delete(id)
if (!removed) return []
- // Dissociate all sessions from this worktree (set worktreeId to null)
+ // Collect and remove all sessions belonging to this worktree
const orphaned: ManagedSession[] = []
for (const s of this.sessions.values()) {
if (s.worktreeId === id) {
- s.worktreeId = null
- orphaned.push(s)
+ orphaned.push({ ...s })
+ this.sessions.delete(s.id)
}
}
@@ -220,7 +234,7 @@ export class WorktreeStateManager {
const idx = this.worktreeOrder.indexOf(id)
if (idx !== -1) this.worktreeOrder.splice(idx, 1)
- this.log(`Removed worktree ${id}, orphaned ${orphaned.length} sessions`)
+ this.log(`Removed worktree ${id}, removed ${orphaned.length} sessions`)
void this.save()
return orphaned
}
@@ -284,7 +298,128 @@ export class WorktreeStateManager {
}
setWorktreeOrder(order: string[]): void {
- this.worktreeOrder = order
+ const top = new Set()
+ for (const sec of this.sections.values()) top.add(sec.id)
+ for (const wt of this.worktrees.values()) {
+ if (!wt.sectionId) top.add(wt.id)
+ }
+ this.worktreeOrder = order.filter((id) => top.has(id))
+ void this.save()
+ }
+
+ // ---------------------------------------------------------------------------
+ // Sections
+ // ---------------------------------------------------------------------------
+
+ getSections(): Section[] {
+ return [...this.sections.values()]
+ }
+
+ getSection(id: string): Section | undefined {
+ return this.sections.get(id)
+ }
+
+ addSection(name: string, color: string | null, worktreeIds?: string[]): Section {
+ const id = generateId("sec")
+ const order = this.worktreeOrder.length
+ const sec: Section = { id, name, color, order, collapsed: false }
+ this.sections.set(id, sec)
+ this.worktreeOrder.push(id)
+ if (worktreeIds) {
+ for (const wtId of worktreeIds) {
+ const wt = this.worktrees.get(wtId)
+ if (wt) {
+ wt.sectionId = id
+ // Remove from top-level worktreeOrder since it's now inside a section
+ const idx = this.worktreeOrder.indexOf(wtId)
+ if (idx !== -1) this.worktreeOrder.splice(idx, 1)
+ }
+ }
+ }
+ this.log(`Added section ${id}: "${name}"`)
+ void this.save()
+ return sec
+ }
+
+ renameSection(id: string, name: string): void {
+ const sec = this.sections.get(id)
+ if (!sec || !name) return
+ sec.name = name
+ this.log(`Renamed section ${id} to "${name}"`)
+ void this.save()
+ }
+
+ setSectionColor(id: string, color: string | null): void {
+ const sec = this.sections.get(id)
+ if (!sec) return
+ sec.color = color
+ void this.save()
+ }
+
+ toggleSection(id: string): void {
+ const sec = this.sections.get(id)
+ if (!sec) return
+ sec.collapsed = !sec.collapsed
+ void this.save()
+ }
+
+ deleteSection(id: string): void {
+ if (!this.sections.delete(id)) return
+ // Ungroup all worktrees in this section — do NOT delete them
+ for (const wt of this.worktrees.values()) {
+ if (wt.sectionId === id) {
+ wt.sectionId = undefined
+ if (!this.worktreeOrder.includes(wt.id)) this.worktreeOrder.push(wt.id)
+ }
+ }
+ // Remove from sidebar order
+ const idx = this.worktreeOrder.indexOf(id)
+ if (idx !== -1) this.worktreeOrder.splice(idx, 1)
+ this.log(`Deleted section ${id}, ungrouped its worktrees`)
+ void this.save()
+ }
+
+ moveSection(id: string, dir: -1 | 1): void {
+ const top = this.worktreeOrder.filter((item) => {
+ if (this.sections.has(item)) return true
+ const wt = this.worktrees.get(item)
+ return !!wt && !wt.sectionId
+ })
+ const idx = top.indexOf(id)
+ const next = idx + dir
+ if (idx === -1 || next < 0 || next >= top.length) return
+ const target = top[next]!
+ const result = [...this.worktreeOrder]
+ const fi = result.indexOf(id)
+ if (fi === -1 || result.indexOf(target) === -1) return
+ result.splice(fi, 1)
+ const insertAt = result.indexOf(target) + (dir === 1 ? 1 : 0)
+ result.splice(insertAt, 0, id)
+ this.worktreeOrder = result
+ void this.save()
+ }
+
+ moveToSection(worktreeIds: string[], sectionId: string | null): void {
+ // Expand to include all multi-version siblings (same groupId)
+ const expanded = new Set(worktreeIds)
+ for (const wtId of worktreeIds) {
+ const wt = this.worktrees.get(wtId)
+ if (!wt?.groupId) continue
+ for (const sibling of this.worktrees.values()) {
+ if (sibling.groupId === wt.groupId) expanded.add(sibling.id)
+ }
+ }
+ for (const wtId of expanded) {
+ const wt = this.worktrees.get(wtId)
+ if (!wt) continue
+ wt.sectionId = sectionId ?? undefined
+ if (sectionId) {
+ const idx = this.worktreeOrder.indexOf(wtId)
+ if (idx !== -1) this.worktreeOrder.splice(idx, 1)
+ } else {
+ if (!this.worktreeOrder.includes(wtId)) this.worktreeOrder.push(wtId)
+ }
+ }
void this.save()
}
@@ -343,6 +478,7 @@ export class WorktreeStateManager {
const data = JSON.parse(content) as StateFile
this.worktrees.clear()
this.sessions.clear()
+ this.sections.clear()
this.tabOrder = {}
this.worktreeOrder = []
this.reviewDiffStyle = "unified"
@@ -355,21 +491,42 @@ export class WorktreeStateManager {
}) ?? wt.path
this.worktrees.set(id, { id, ...wt, path: fixed })
}
+ let pruned = 0
for (const [id, s] of Object.entries(data.sessions ?? {})) {
+ // Skip orphaned sessions (null worktreeId or referencing a deleted worktree)
+ if (!s.worktreeId || !this.worktrees.has(s.worktreeId)) {
+ pruned++
+ continue
+ }
this.sessions.set(id, { id, ...s })
}
+ for (const [id, sec] of Object.entries(data.sections ?? {})) {
+ this.sections.set(id, { id, ...sec })
+ }
if (data.tabOrder) {
this.tabOrder = data.tabOrder
}
if (data.worktreeOrder) {
this.worktreeOrder = data.worktreeOrder
}
+ // Normalize: ensure all section IDs and ungrouped worktree IDs are in worktreeOrder
+ const present = new Set(this.worktreeOrder)
+ for (const id of this.sections.keys()) {
+ if (!present.has(id)) this.worktreeOrder.push(id)
+ }
+ for (const wt of this.worktrees.values()) {
+ if (!wt.sectionId && !present.has(wt.id)) this.worktreeOrder.push(wt.id)
+ }
this.collapsed = data.sessionsCollapsed ?? false
if (data.reviewDiffStyle === "split") {
this.reviewDiffStyle = "split"
}
this.defaultBase = data.defaultBaseBranch
this.log(`Loaded state: ${this.worktrees.size} worktrees, ${this.sessions.size} sessions`)
+ if (pruned > 0) {
+ this.log(`Pruned ${pruned} orphaned sessions`)
+ void this.save()
+ }
} catch (error) {
const code = (error as NodeJS.ErrnoException).code
if (code !== "ENOENT") {
@@ -379,7 +536,7 @@ export class WorktreeStateManager {
return migration
}
- /** Remove worktrees whose directories no longer exist on disk. */
+ /** Remove worktrees whose directories no longer exist on disk and prune orphaned sessions. */
async validate(root: string): Promise {
let changed = false
for (const wt of [...this.worktrees.values()]) {
@@ -390,7 +547,17 @@ export class WorktreeStateManager {
changed = true
}
}
- if (changed) await this.save()
+ // Prune orphaned sessions (worktreeId is null or references a deleted worktree)
+ for (const s of [...this.sessions.values()]) {
+ if (!s.worktreeId || !this.worktrees.has(s.worktreeId)) {
+ this.sessions.delete(s.id)
+ changed = true
+ }
+ }
+ if (changed) {
+ this.log(`Pruned orphaned sessions during validation`)
+ await this.save()
+ }
}
/** Wait for any in-flight save to complete without triggering a new one. */
@@ -433,6 +600,13 @@ export class WorktreeStateManager {
const { id: _, ...rest } = s
data.sessions[id] = rest
}
+ if (this.sections.size > 0) {
+ data.sections = {}
+ for (const [id, sec] of this.sections) {
+ const { id: _, ...rest } = sec
+ data.sections[id] = rest
+ }
+ }
if (Object.keys(this.tabOrder).length > 0) {
data.tabOrder = this.tabOrder
}
diff --git a/packages/kilo-vscode/src/agent-manager/section-handler.ts b/packages/kilo-vscode/src/agent-manager/section-handler.ts
new file mode 100644
index 00000000000..624a23eb10e
--- /dev/null
+++ b/packages/kilo-vscode/src/agent-manager/section-handler.ts
@@ -0,0 +1,21 @@
+import type { WorktreeStateManager } from "./WorktreeStateManager"
+import type { AgentManagerInMessage } from "./types"
+
+/** Handle section CRUD messages. Returns true if handled. */
+export function handleSection(
+ state: WorktreeStateManager | undefined,
+ m: AgentManagerInMessage,
+ push: () => void,
+): boolean {
+ if (!state) return false
+ if (m.type === "agentManager.createSection") state.addSection(m.name, m.color ?? null, m.worktreeIds)
+ else if (m.type === "agentManager.renameSection") state.renameSection(m.sectionId, m.name)
+ else if (m.type === "agentManager.deleteSection") state.deleteSection(m.sectionId)
+ else if (m.type === "agentManager.setSectionColor") state.setSectionColor(m.sectionId, m.color)
+ else if (m.type === "agentManager.toggleSectionCollapsed") state.toggleSection(m.sectionId)
+ else if (m.type === "agentManager.moveToSection") state.moveToSection(m.worktreeIds, m.sectionId)
+ else if (m.type === "agentManager.moveSection") state.moveSection(m.sectionId, m.dir)
+ else return false
+ push()
+ return true
+}
diff --git a/packages/kilo-vscode/src/agent-manager/types.ts b/packages/kilo-vscode/src/agent-manager/types.ts
index 6c116034638..264f1f46107 100644
--- a/packages/kilo-vscode/src/agent-manager/types.ts
+++ b/packages/kilo-vscode/src/agent-manager/types.ts
@@ -8,7 +8,7 @@
*/
import type { FileDiff } from "@kilocode/sdk/v2/client"
-import type { Worktree, ManagedSession } from "./WorktreeStateManager"
+import type { Worktree, ManagedSession, Section } from "./WorktreeStateManager"
import type { WorktreeStats, LocalStats } from "./GitStatsPoller"
import type { ApplyConflict } from "./GitOps"
import type { BranchListItem, WorktreeSetupErrorCode } from "./git-import"
@@ -118,6 +118,7 @@ interface StateMessage {
type: "agentManager.state"
worktrees: Worktree[]
sessions: ManagedSession[]
+ sections?: Section[]
staleWorktreeIds?: string[]
tabOrder?: Record
worktreeOrder?: string[]
@@ -523,6 +524,47 @@ interface ContinueInWorktreeIn {
sessionId: string
}
+interface CreateSectionIn {
+ type: "agentManager.createSection"
+ name: string
+ color?: string
+ worktreeIds?: string[]
+}
+
+interface RenameSectionIn {
+ type: "agentManager.renameSection"
+ sectionId: string
+ name: string
+}
+
+interface DeleteSectionIn {
+ type: "agentManager.deleteSection"
+ sectionId: string
+}
+
+interface SetSectionColorIn {
+ type: "agentManager.setSectionColor"
+ sectionId: string
+ color: string | null
+}
+
+interface ToggleSectionCollapsedIn {
+ type: "agentManager.toggleSectionCollapsed"
+ sectionId: string
+}
+
+interface MoveToSectionIn {
+ type: "agentManager.moveToSection"
+ worktreeIds: string[]
+ sectionId: string | null
+}
+
+interface MoveSectionIn {
+ type: "agentManager.moveSection"
+ sectionId: string
+ dir: -1 | 1
+}
+
/** All messages the Agent Manager expects from the webview (onMessage input). */
export type AgentManagerInMessage =
| CreateWorktreeIn
@@ -570,3 +612,10 @@ export type AgentManagerInMessage =
| ClearSessionIn
| AbortIn
| ContinueInWorktreeIn
+ | CreateSectionIn
+ | RenameSectionIn
+ | DeleteSectionIn
+ | SetSectionColorIn
+ | ToggleSectionCollapsedIn
+ | MoveToSectionIn
+ | MoveSectionIn
diff --git a/packages/kilo-vscode/src/agent-manager/vscode-host.ts b/packages/kilo-vscode/src/agent-manager/vscode-host.ts
index 7ea4403cbc0..d0eadb6e381 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,
})
diff --git a/packages/kilo-vscode/src/extension.ts b/packages/kilo-vscode/src/extension.ts
index 438b26c3a9c..df9681c0fc1 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"
@@ -105,6 +106,7 @@ export function activate(context: vscode.ExtensionContext) {
tabProvider.setContinueInWorktreeHandler((sessionId, progress) =>
agentManagerProvider.continueFromSidebar(sessionId, progress),
)
+ tabProvider.setDiffVirtualProvider(diffVirtualProvider)
tabProvider.resolveWebviewPanel(panel)
tabPanels.set(panel, tabProvider)
panel.onDidDispose(
@@ -128,6 +130,12 @@ 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)
context.subscriptions.push(settingsEditorProvider)
@@ -221,7 +229,7 @@ export function activate(context: vscode.ExtensionContext) {
provider.postMessage({ type: "triggerTask", text: `Generate a terminal command: ${input}` })
}),
vscode.commands.registerCommand("kilo-code.new.openInTab", () => {
- return openKiloInNewTab(context, connectionService, agentManagerProvider, tabPanels)
+ return openKiloInNewTab(context, connectionService, agentManagerProvider, tabPanels, diffVirtualProvider)
}),
vscode.commands.registerCommand("kilo-code.new.showChanges", () => {
diffViewerProvider.openPanel()
@@ -353,6 +361,7 @@ async function openKiloInNewTab(
connectionService: KiloConnectionService,
agentManagerProvider: AgentManagerProvider,
tabPanels: Map,
+ diffVirtualProvider: DiffVirtualProvider,
) {
const lastCol = Math.max(...vscode.window.visibleTextEditors.map((e) => e.viewColumn || 0), 0)
const hasVisibleEditors = vscode.window.visibleTextEditors.length > 0
@@ -378,6 +387,7 @@ async function openKiloInNewTab(
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/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}}}
-\`\`\`
-
-
-
-
-`,
- 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|> -