refactor: use external file for storing task history

Author: elianiva

src/__mocks__/fs/promises.ts

@@ -1,3 +1,5 @@
+import * as vscode from "vscode"
+
 // Mock file system data
 const mockFiles = new Map()
 const mockDirectories = new Set()
@@ -44,7 +46,18 @@ const ensureDirectoryExists = (path: string) => {
 	}
 }
 
-const mockFs = {
+// Mock types for vscode workspace fs
+type MockFileSystem = {
+	readFile: jest.Mock<Promise<Uint8Array>, [vscode.Uri]>
+	writeFile: jest.Mock<Promise<void>, [vscode.Uri, Uint8Array]>
+	mkdir: jest.Mock<Promise<void>, [vscode.Uri, { recursive?: boolean }]>
+	access: jest.Mock<Promise<void>, [vscode.Uri]>
+	rename: jest.Mock<Promise<void>, [vscode.Uri, vscode.Uri]>
+	delete: jest.Mock<Promise<void>, [vscode.Uri]>
+	[key: string]: any // Allow additional properties to match vscode API
+}
+
+const mockFs: MockFileSystem = {
 	readFile: jest.fn().mockImplementation(async (filePath: string, _encoding?: string) => {
 		// Return stored content if it exists
 		if (mockFiles.has(filePath)) {
@@ -148,6 +161,12 @@ const mockFs = {
 		throw error
 	}),
 
+	delete: jest.fn().mockImplementation(async (path: string) => {
+		// Delete file
+		mockFiles.delete(path)
+		return Promise.resolve()
+	}),
+
 	constants: jest.requireActual("fs").constants,
 
 	// Expose mock data for test assertions
@@ -181,6 +200,22 @@ const mockFs = {
 				mockDirectories.add(currentPath)
 			}
 		})
+
+		// Set up taskHistory file
+		const tasks = [
+			{
+				id: "1",
+				number: 1,
+				ts: Date.now(),
+				task: "test",
+				tokensIn: 100,
+				tokensOut: 50,
+				totalCost: 0.001,
+				cacheWrites: 0,
+				cacheReads: 0,
+			},
+		]
+		mockFiles.set("/mock/storage/path/taskHistory.jsonl", tasks.map((t) => JSON.stringify(t)).join("\n") + "\n")
 	},
 }
 

src/core/config/ContextProxy.ts

@@ -22,7 +22,7 @@ type GlobalStateKey = keyof GlobalState
 type SecretStateKey = keyof SecretState
 type RooCodeSettingsKey = keyof RooCodeSettings
 
-const PASS_THROUGH_STATE_KEYS = ["taskHistory"]
+const PASS_THROUGH_STATE_KEYS: string[] = []
 
 export const isPassThroughStateKey = (key: string) => PASS_THROUGH_STATE_KEYS.includes(key)
 
@@ -50,6 +50,31 @@ export class ContextProxy {
 		return this._isInitialized
 	}
 
+	private async readTaskHistoryFile(): Promise<any[]> {
+		try {
+			const taskHistoryUri = vscode.Uri.joinPath(this.globalStorageUri, "taskHistory.jsonl")
+			const fileContent = await vscode.workspace.fs.readFile(taskHistoryUri)
+			const lines = fileContent.toString().split("\n").filter(Boolean)
+			return lines.map((line) => JSON.parse(line))
+		} catch (error) {
+			if (error instanceof vscode.FileSystemError && error.code === "FileNotFound") {
+				return []
+			}
+			logger.error(`Error reading task history file: ${error instanceof Error ? error.message : String(error)}`)
+			return []
+		}
+	}
+
+	private async writeTaskHistoryFile(tasks: any[]): Promise<void> {
+		try {
+			const taskHistoryUri = vscode.Uri.joinPath(this.globalStorageUri, "taskHistory.jsonl")
+			const content = tasks.map((task) => JSON.stringify(task)).join("\n") + "\n"
+			await vscode.workspace.fs.writeFile(taskHistoryUri, Buffer.from(content))
+		} catch (error) {
+			logger.error(`Error writing task history file: ${error instanceof Error ? error.message : String(error)}`)
+		}
+	}
+
 	public async initialize() {
 		for (const key of GLOBAL_STATE_KEYS) {
 			try {
@@ -60,6 +85,31 @@ export class ContextProxy {
 			}
 		}
 
+		// Load task history from file
+		if (GLOBAL_STATE_KEYS.includes("taskHistory")) {
+			const tasks = await this.readTaskHistoryFile()
+			this.stateCache.taskHistory = tasks
+
+			// Migrate task history from global state if global state has data
+			const globalStateTasks = this.originalContext.globalState.get("taskHistory")
+			if (Array.isArray(globalStateTasks) && globalStateTasks.length > 0) {
+				try {
+					// Append global state tasks to existing file content
+					const combinedTasks = [...tasks, ...globalStateTasks]
+					await this.writeTaskHistoryFile(combinedTasks)
+					this.stateCache.taskHistory = combinedTasks
+					await this.originalContext.globalState.update("taskHistory", undefined)
+					vscode.window.showInformationMessage(
+						"Task history has been migrated using an append strategy to preserve existing entries.",
+					)
+				} catch (error) {
+					logger.error(
+						`Error migrating task history: ${error instanceof Error ? error.message : String(error)}`,
+					)
+				}
+			}
+		}
+
 		const promises = SECRET_STATE_KEYS.map(async (key) => {
 			try {
 				this.secretCache[key] = await this.originalContext.secrets.get(key)
@@ -105,18 +155,17 @@ export class ContextProxy {
 	getGlobalState<K extends GlobalStateKey>(key: K): GlobalState[K]
 	getGlobalState<K extends GlobalStateKey>(key: K, defaultValue: GlobalState[K]): GlobalState[K]
 	getGlobalState<K extends GlobalStateKey>(key: K, defaultValue?: GlobalState[K]): GlobalState[K] {
-		if (isPassThroughStateKey(key)) {
-			const value = this.originalContext.globalState.get<GlobalState[K]>(key)
-			return value === undefined || value === null ? defaultValue : value
-		}
-
 		const value = this.stateCache[key]
 		return value !== undefined ? value : defaultValue
 	}
 
-	updateGlobalState<K extends GlobalStateKey>(key: K, value: GlobalState[K]) {
-		if (isPassThroughStateKey(key)) {
-			return this.originalContext.globalState.update(key, value)
+	async updateGlobalState<K extends GlobalStateKey>(key: K, value: GlobalState[K]) {
+		if (key === "taskHistory") {
+			this.stateCache[key] = value
+			if (Array.isArray(value)) {
+				await this.writeTaskHistoryFile(value)
+			}
+			return
 		}
 
 		this.stateCache[key] = value
@@ -264,6 +313,18 @@ export class ContextProxy {
 		this.stateCache = {}
 		this.secretCache = {}
 
+		// Delete task history file
+		try {
+			const taskHistoryUri = vscode.Uri.joinPath(this.globalStorageUri, "taskHistory.jsonl")
+			await vscode.workspace.fs.delete(taskHistoryUri)
+		} catch (error) {
+			if (!(error instanceof vscode.FileSystemError && error.code === "FileNotFound")) {
+				logger.error(
+					`Error deleting task history file: ${error instanceof Error ? error.message : String(error)}`,
+				)
+			}
+		}
+
 		await Promise.all([
 			...GLOBAL_STATE_KEYS.map((key) => this.originalContext.globalState.update(key, undefined)),
 			...SECRET_STATE_KEYS.map((key) => this.originalContext.secrets.delete(key)),

src/core/config/__tests__/ContextProxy.test.ts

@@ -2,18 +2,25 @@
 
 import * as vscode from "vscode"
 import { ContextProxy } from "../ContextProxy"
-
+import type { HistoryItem } from "../../../schemas"
 import { GLOBAL_STATE_KEYS, SECRET_STATE_KEYS } from "../../../schemas"
 
 jest.mock("vscode", () => ({
 	Uri: {
 		file: jest.fn((path) => ({ path })),
+		joinPath: jest.fn((base, ...paths) => ({ path: `${base.path}/${paths.join("/")}` })),
 	},
 	ExtensionMode: {
 		Development: 1,
 		Production: 2,
 		Test: 3,
 	},
+	FileSystemError: class extends Error {
+		code = "FileNotFound"
+	},
+	window: {
+		showInformationMessage: jest.fn(),
+	},
 }))
 
 describe("ContextProxy", () => {
@@ -54,6 +61,18 @@ describe("ContextProxy", () => {
 		// Create proxy instance
 		proxy = new ContextProxy(mockContext)
 		await proxy.initialize()
+
+		// Ensure fs mock is properly initialized
+		const mockFs = jest.requireMock("fs/promises")
+		mockFs._setInitialMockData()
+
+		// Use it for vscode.workspace.fs operations
+		jest.mock("vscode", () => ({
+			...jest.requireMock("vscode"),
+			workspace: {
+				fs: mockFs,
+			},
+		}))
 	})
 
 	describe("read-only pass-through properties", () => {
@@ -102,39 +121,34 @@ describe("ContextProxy", () => {
 			expect(result).toBe("deepseek")
 		})
 
-		it("should bypass cache for pass-through state keys", async () => {
-			// Setup mock return value
-			mockGlobalState.get.mockReturnValue("pass-through-value")
-
-			// Use a pass-through key (taskHistory)
-			const result = proxy.getGlobalState("taskHistory")
-
-			// Should get value directly from original context
-			expect(result).toBe("pass-through-value")
-			expect(mockGlobalState.get).toHaveBeenCalledWith("taskHistory")
-		})
-
-		it("should respect default values for pass-through state keys", async () => {
-			// Setup mock to return undefined
-			mockGlobalState.get.mockReturnValue(undefined)
-
-			// Use a pass-through key with default value
-			const historyItems = [
+		it("should read task history from file", async () => {
+			const mockTasks: HistoryItem[] = [
 				{
 					id: "1",
 					number: 1,
-					ts: 1,
+					ts: Date.now(),
 					task: "test",
-					tokensIn: 1,
-					tokensOut: 1,
-					totalCost: 1,
+					tokensIn: 100,
+					tokensOut: 50,
+					totalCost: 0.001,
+					cacheWrites: 0,
+					cacheReads: 0,
 				},
 			]
 
-			const result = proxy.getGlobalState("taskHistory", historyItems)
+			const result = proxy.getGlobalState("taskHistory")
+			expect(result).toEqual(mockTasks)
+			expect(vscode.workspace.fs.readFile).toHaveBeenCalled()
+		})
+
+		it("should return empty array when task history file doesn't exist", async () => {
+			const vscode = jest.requireMock("vscode")
+
+			const error = new vscode.FileSystemError("File not found")
+			vscode.workspace.fs.readFile.mockRejectedValue(error)
 
-			// Should return default value when original context returns undefined
-			expect(result).toBe(historyItems)
+			const result = proxy.getGlobalState("taskHistory")
+			expect(result).toEqual([])
 		})
 	})
 
@@ -150,31 +164,37 @@ describe("ContextProxy", () => {
 			expect(storedValue).toBe("deepseek")
 		})
 
-		it("should bypass cache for pass-through state keys", async () => {
-			const historyItems = [
+		it("should write task history to file", async () => {
+			const historyItems: HistoryItem[] = [
 				{
 					id: "1",
 					number: 1,
-					ts: 1,
+					ts: Date.now(),
 					task: "test",
-					tokensIn: 1,
-					tokensOut: 1,
-					totalCost: 1,
+					tokensIn: 100,
+					tokensOut: 50,
+					totalCost: 0.001,
+					cacheWrites: 0,
+					cacheReads: 0,
 				},
 			]
 
 			await proxy.updateGlobalState("taskHistory", historyItems)
 
-			// Should update original context
-			expect(mockGlobalState.update).toHaveBeenCalledWith("taskHistory", historyItems)
+			// Should write to file
+			const expectedContent = JSON.stringify(historyItems[0]) + "\n"
+			expect(vscode.workspace.fs.writeFile).toHaveBeenCalledWith(
+				expect.objectContaining({ path: expect.stringContaining("taskHistory.jsonl") }),
+				Buffer.from(expectedContent),
+			)
 
-			// Setup mock for subsequent get
-			mockGlobalState.get.mockReturnValue(historyItems)
+			// Should update cache
+			expect(proxy.getGlobalState("taskHistory")).toEqual(historyItems)
+		})
 
-			// Should get fresh value from original context
-			const storedValue = proxy.getGlobalState("taskHistory")
-			expect(storedValue).toBe(historyItems)
-			expect(mockGlobalState.get).toHaveBeenCalledWith("taskHistory")
+		it("should handle undefined task history", async () => {
+			await proxy.updateGlobalState("taskHistory", undefined)
+			expect(vscode.workspace.fs.writeFile).not.toHaveBeenCalled()
 		})
 	})
 
@@ -390,6 +410,13 @@ describe("ContextProxy", () => {
 			expect(mockGlobalState.update).toHaveBeenCalledTimes(expectedUpdateCalls)
 		})
 
+		it("should delete task history file when resetting state", async () => {
+			await proxy.resetAllState()
+			expect(vscode.workspace.fs.delete).toHaveBeenCalledWith(
+				expect.objectContaining({ path: expect.stringContaining("taskHistory.jsonl") }),
+			)
+		})
+
 		it("should delete all secrets", async () => {
 			// Setup initial secrets
 			await proxy.storeSecret("apiKey", "test-api-key")