improve: show Roo history import progress

Author: taltas

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

@@ -102,6 +102,7 @@ export interface ExtensionMessage {
 		| "worktreeIncludeStatus"
 		| "branchWorktreeIncludeResult"
 		| "folderSelected"
+		| "rooHistoryImportProgress"
 		| "skills"
 		| "fileContent"
 	text?: string
@@ -237,6 +238,16 @@ export interface ExtensionMessage {
 	copyProgressItemName?: string
 	// folderSelected
 	path?: string
+	// rooHistoryImportProgress
+	rooHistoryImportProgress?: {
+		status: "starting" | "copying" | "finished" | "failed"
+		copiedFileCount: number
+		totalFileCount: number
+		importedTaskCount: number
+		totalTaskCount: number
+		currentTaskId?: string
+		currentFileName?: string
+	}
 }
 
 export interface OpenAiCodexRateLimitsMessage {

src/core/task-persistence/__tests__/importRooTaskHistory.spec.ts

@@ -146,6 +146,70 @@ describe("importRooTaskHistory", () => {
 		})
 	})
 
+	it("reports Roo history import progress as files are copied", async () => {
+		const zooGlobalStoragePath = path.join(tempRoot, "globalStorage", "zoocodeorganization.zoo-code")
+		const rooDefaultStorageRoot = path.join(tempRoot, "globalStorage", "rooveterinaryinc.roo-cline")
+		const onProgress = vi.fn()
+
+		mockStorageConfiguration()
+
+		await fs.mkdir(path.join(rooDefaultStorageRoot, "tasks", "task-progress"), { recursive: true })
+		await fs.writeFile(
+			path.join(rooDefaultStorageRoot, "tasks", "task-progress", "history_item.json"),
+			JSON.stringify({ id: "task-progress" }),
+		)
+		await fs.writeFile(path.join(rooDefaultStorageRoot, "tasks", "task-progress", "ui_messages.json"), "ui")
+		await fs.writeFile(
+			path.join(rooDefaultStorageRoot, "tasks", "task-progress", "api_conversation_history.json"),
+			"api",
+		)
+
+		await importRooTaskHistory(zooGlobalStoragePath, onProgress)
+
+		expect(onProgress.mock.calls).toEqual([
+			[
+				{
+					copiedFileCount: 0,
+					totalFileCount: 3,
+					importedTaskCount: 0,
+					totalTaskCount: 1,
+					currentTaskId: undefined,
+					currentFileName: undefined,
+				},
+			],
+			[
+				{
+					copiedFileCount: 1,
+					totalFileCount: 3,
+					importedTaskCount: 1,
+					totalTaskCount: 1,
+					currentTaskId: "task-progress",
+					currentFileName: "history_item.json",
+				},
+			],
+			[
+				{
+					copiedFileCount: 2,
+					totalFileCount: 3,
+					importedTaskCount: 1,
+					totalTaskCount: 1,
+					currentTaskId: "task-progress",
+					currentFileName: "ui_messages.json",
+				},
+			],
+			[
+				{
+					copiedFileCount: 3,
+					totalFileCount: 3,
+					importedTaskCount: 1,
+					totalTaskCount: 1,
+					currentTaskId: "task-progress",
+					currentFileName: "api_conversation_history.json",
+				},
+			],
+		])
+	})
+
 	it("imports only top-level task history files and skips checkpoint directories", async () => {
 		const zooGlobalStoragePath = path.join(tempRoot, "globalStorage", "zoocodeorganization.zoo-code")
 		const rooDefaultStorageRoot = path.join(tempRoot, "globalStorage", "rooveterinaryinc.roo-cline")

src/core/task-persistence/importRooTaskHistory.ts

@@ -29,6 +29,21 @@ export interface RooHistoryImportResult extends RooHistoryImportPaths {
 	importedFileCount: number
 }
 
+export interface RooHistoryImportProgress {
+	copiedFileCount: number
+	totalFileCount: number
+	importedTaskCount: number
+	totalTaskCount: number
+	currentTaskId?: string
+	currentFileName?: string
+}
+
+interface ImportableTaskPlan {
+	taskId: string
+	sourceTaskDirectory: string
+	fileNames: string[]
+}
+
 const toComparablePath = (candidatePath: string) => {
 	const resolvedPath = path.resolve(candidatePath)
 	return process.platform === "win32" ? resolvedPath.toLowerCase() : resolvedPath
@@ -90,6 +105,70 @@ const pathExists = async (candidatePath: string) => {
 	}
 }
 
+const getImportableTaskFileNames = async (sourceTaskDirectory: string) => {
+	const fileNames: string[] = []
+
+	for (const fileName of IMPORTABLE_TASK_FILE_NAMES) {
+		try {
+			await fs.access(path.join(sourceTaskDirectory, fileName))
+			fileNames.push(fileName)
+		} catch (error) {
+			if (isSkippableImportError(error)) {
+				continue
+			}
+
+			throw error
+		}
+	}
+
+	return fileNames
+}
+
+const collectImportableTaskPlans = async (sourceRoots: string[]) => {
+	const taskPlans: ImportableTaskPlan[] = []
+	const taskIds = new Set<string>()
+
+	for (const sourceRoot of sourceRoots) {
+		const sourceTasksRoot = path.join(sourceRoot, "tasks")
+		let entries: Dirent[]
+
+		try {
+			entries = await fs.readdir(sourceTasksRoot, { withFileTypes: true })
+		} catch (error) {
+			const nodeError = error as NodeJS.ErrnoException
+			if (nodeError.code === "ENOENT") {
+				continue
+			}
+			throw error
+		}
+
+		for (const entry of entries) {
+			if (!entry.isDirectory() || entry.name.startsWith(".") || entry.name.startsWith("_")) {
+				continue
+			}
+
+			const sourceTaskDirectory = path.join(sourceTasksRoot, entry.name)
+			const fileNames = await getImportableTaskFileNames(sourceTaskDirectory)
+
+			if (!fileNames.includes(GlobalFileNames.historyItem)) {
+				continue
+			}
+
+			taskPlans.push({
+				taskId: entry.name,
+				sourceTaskDirectory,
+				fileNames,
+			})
+			taskIds.add(entry.name)
+		}
+	}
+
+	return {
+		taskPlans,
+		totalTaskCount: taskIds.size,
+	}
+}
+
 export const resolveRooHistoryImportPaths = async (globalStoragePath: string): Promise<RooHistoryImportPaths> => {
 	const zooExtensionDomain = `${Package.publisher}.${Package.name}`
 	const zooStorageRoot = await getStorageBasePath(globalStoragePath)
@@ -104,65 +183,77 @@ export const resolveRooHistoryImportPaths = async (globalStoragePath: string): P
 	}
 }
 
-export const importRooTaskHistory = async (globalStoragePath: string): Promise<RooHistoryImportResult> => {
+export const importRooTaskHistory = async (
+	globalStoragePath: string,
+	onProgress?: (progress: RooHistoryImportProgress) => Promise<void> | void,
+): Promise<RooHistoryImportResult> => {
 	const paths = await resolveRooHistoryImportPaths(globalStoragePath)
 	const destinationComparablePath = toComparablePath(paths.zooStorageRoot)
 	const sourceRoots = paths.rooStorageRoots.filter(
 		(sourceRoot) => toComparablePath(sourceRoot) !== destinationComparablePath,
 	)
 	const destinationTasksRoot = path.join(paths.zooStorageRoot, "tasks")
+	const { taskPlans, totalTaskCount } = await collectImportableTaskPlans(sourceRoots)
 	const importedTaskIds = new Set<string>()
 	let importedFileCount = 0
+	let totalFileCount = taskPlans.reduce((count, taskPlan) => count + taskPlan.fileNames.length, 0)
+	let copiedFileCount = 0
+
+	const reportProgress = async (currentTaskId?: string, currentFileName?: string) => {
+		if (!onProgress) {
+			return
+		}
+
+		await onProgress({
+			copiedFileCount,
+			totalFileCount,
+			importedTaskCount: importedTaskIds.size,
+			totalTaskCount,
+			currentTaskId,
+			currentFileName,
+		})
+	}
 
 	await fs.mkdir(destinationTasksRoot, { recursive: true })
 
-	for (const sourceRoot of sourceRoots) {
-		const sourceTasksRoot = path.join(sourceRoot, "tasks")
-		let entries: Dirent[]
+	await reportProgress()
 
-		try {
-			entries = await fs.readdir(sourceTasksRoot, { withFileTypes: true })
-		} catch (error) {
-			const nodeError = error as NodeJS.ErrnoException
-			if (nodeError.code === "ENOENT") {
-				continue
+	for (const taskPlan of taskPlans) {
+		const destinationTaskDirectory = path.join(destinationTasksRoot, taskPlan.taskId)
+		const destinationTaskDirectoryExisted = await pathExists(destinationTaskDirectory)
+		const historyItemCopied = await copyTaskFileIfPresent(
+			taskPlan.sourceTaskDirectory,
+			destinationTaskDirectory,
+			GlobalFileNames.historyItem,
+		)
+
+		if (!historyItemCopied) {
+			totalFileCount -= taskPlan.fileNames.length
+			if (!destinationTaskDirectoryExisted) {
+				await fs.rm(destinationTaskDirectory, { recursive: true, force: true })
 			}
-			throw error
+			await reportProgress(taskPlan.taskId, GlobalFileNames.historyItem)
+			continue
 		}
 
-		for (const entry of entries) {
-			if (!entry.isDirectory() || entry.name.startsWith(".") || entry.name.startsWith("_")) {
-				continue
-			}
+		importedTaskIds.add(taskPlan.taskId)
+		importedFileCount += 1
+		copiedFileCount += 1
+		await reportProgress(taskPlan.taskId, GlobalFileNames.historyItem)
 
-			const sourceTaskDirectory = path.join(sourceTasksRoot, entry.name)
-			const destinationTaskDirectory = path.join(destinationTasksRoot, entry.name)
-			const destinationTaskDirectoryExisted = await pathExists(destinationTaskDirectory)
-			const historyItemCopied = await copyTaskFileIfPresent(
-				sourceTaskDirectory,
-				destinationTaskDirectory,
-				GlobalFileNames.historyItem,
-			)
-
-			if (!historyItemCopied) {
-				if (!destinationTaskDirectoryExisted) {
-					await fs.rm(destinationTaskDirectory, { recursive: true, force: true })
-				}
+		for (const fileName of taskPlan.fileNames) {
+			if (fileName === GlobalFileNames.historyItem) {
 				continue
 			}
 
-			importedTaskIds.add(entry.name)
-			importedFileCount += 1
-
-			for (const fileName of IMPORTABLE_TASK_FILE_NAMES) {
-				if (fileName === GlobalFileNames.historyItem) {
-					continue
-				}
-
-				if (await copyTaskFileIfPresent(sourceTaskDirectory, destinationTaskDirectory, fileName)) {
-					importedFileCount += 1
-				}
+			if (await copyTaskFileIfPresent(taskPlan.sourceTaskDirectory, destinationTaskDirectory, fileName)) {
+				importedFileCount += 1
+				copiedFileCount += 1
+			} else {
+				totalFileCount -= 1
 			}
+
+			await reportProgress(taskPlan.taskId, fileName)
 		}
 	}