Check git out - Checkpoints 2.0

**Branch-Per-Task:** Each repo now has a single Shadow Git repo, with separate branches per task (instead of one Shadow Git repo per task).
-   **Legacy Support:** Existing Checkpoints remain functional, while all new Checkpoints use branch-per-task.

-   **Commits:** Legacy tasks commit to legacy Checkpoints; new tasks commit using branch-per-task.
-   **Diffing & Deletions:** Both legacy and branch-per-task Checkpoints support diffing and deletion.

No migration needed—existing tasks stay as-is, and new tasks adopt **branch-per-task** automatically.

Author: canvrno

.changeset/silly-coats-switch.md

@@ -0,0 +1,11 @@
+---
+"claude-dev": minor
+---
+
+-   **Branch-Per-Task:** Each repo now has a single Shadow Git repo, with separate branches per task (instead of one Shadow Git repo per task).
+-   **Legacy Support:** Existing Checkpoints remain functional, while all new Checkpoints use branch-per-task.
+
+-   **Commits:** Legacy tasks commit to legacy Checkpoints; new tasks commit using branch-per-task.
+-   **Diffing & Deletions:** Both legacy and branch-per-task Checkpoints support diffing and deletion.
+
+No migration needed—existing tasks stay as-is, and new tasks adopt **branch-per-task** automatically.

src/core/Cline.ts

@@ -301,7 +301,10 @@ export class Cline {
 			case "workspace":
 				if (!this.checkpointTracker) {
 					try {
-						this.checkpointTracker = await CheckpointTracker.create(this.taskId, this.providerRef.deref())
+						this.checkpointTracker = await CheckpointTracker.create(
+							this.taskId,
+							this.providerRef.deref()?.context.globalStorageUri.fsPath,
+						)
 						this.checkpointTrackerErrorMessage = undefined
 					} catch (error) {
 						const errorMessage = error instanceof Error ? error.message : "Unknown error"
@@ -414,7 +417,10 @@ export class Cline {
 		// TODO: handle if this is called from outside original workspace, in which case we need to show user error message we cant show diff outside of workspace?
 		if (!this.checkpointTracker) {
 			try {
-				this.checkpointTracker = await CheckpointTracker.create(this.taskId, this.providerRef.deref())
+				this.checkpointTracker = await CheckpointTracker.create(
+					this.taskId,
+					this.providerRef.deref()?.context.globalStorageUri.fsPath,
+				)
 				this.checkpointTrackerErrorMessage = undefined
 			} catch (error) {
 				const errorMessage = error instanceof Error ? error.message : "Unknown error"
@@ -518,7 +524,10 @@ export class Cline {
 
 		if (!this.checkpointTracker) {
 			try {
-				this.checkpointTracker = await CheckpointTracker.create(this.taskId, this.providerRef.deref())
+				this.checkpointTracker = await CheckpointTracker.create(
+					this.taskId,
+					this.providerRef.deref()?.context.globalStorageUri.fsPath,
+				)
 				this.checkpointTrackerErrorMessage = undefined
 			} catch (error) {
 				const errorMessage = error instanceof Error ? error.message : "Unknown error"
@@ -2940,7 +2949,7 @@ export class Cline {
 		}
 
 		/*
-		Seeing out of bounds is fine, it means that the next too call is being built up and ready to add to assistantMessageContent to present. 
+		Seeing out of bounds is fine, it means that the next too call is being built up and ready to add to assistantMessageContent to present.
 		When you see the UI inactive during this, it means that a tool is breaking without presenting any UI. For example the write_to_file tool was breaking when relpath was undefined, and for invalid relpath it never presented UI.
 		*/
 		this.presentAssistantMessageLocked = false // this needs to be placed here, if not then calling this.presentAssistantMessage below would fail (sometimes) since it's locked
@@ -3047,7 +3056,10 @@ export class Cline {
 		// isNewTask &&
 		if (!this.checkpointTracker) {
 			try {
-				this.checkpointTracker = await CheckpointTracker.create(this.taskId, this.providerRef.deref())
+				this.checkpointTracker = await CheckpointTracker.create(
+					this.taskId,
+					this.providerRef.deref()?.context.globalStorageUri.fsPath,
+				)
 				this.checkpointTrackerErrorMessage = undefined
 			} catch (error) {
 				const errorMessage = error instanceof Error ? error.message : "Unknown error"

src/core/webview/ClineProvider.ts

@@ -8,6 +8,7 @@ import pWaitFor from "p-wait-for"
 import * as path from "path"
 import * as vscode from "vscode"
 import { buildApiHandler } from "../../api"
+import CheckpointTracker from "../../integrations/checkpoints/CheckpointTracker"
 import { downloadTask } from "../../integrations/misc/export-markdown"
 import { openFile, openImage } from "../../integrations/misc/open-file"
 import { fetchOpenGraphData, isImageUrl } from "../../integrations/misc/link-preview"
@@ -1661,12 +1662,29 @@ Here is the project's README to help you get started:\n\n${mcpDetails.readmeCont
 	}
 
 	async deleteTaskWithId(id: string) {
+		console.info("deleteTaskWithId: ", id)
+
 		if (id === this.cline?.taskId) {
 			await this.clearTask()
+			console.debug("cleared task")
 		}
 
 		const { taskDirPath, apiConversationHistoryFilePath, uiMessagesFilePath } = await this.getTaskWithId(id)
 
+		// Delete checkpoints
+		// deleteCheckpoints will determine if the task has legacy checkpoints or not and handle it accordingly
+		console.info("deleting checkpoints")
+		const taskHistory = ((await this.getGlobalState("taskHistory")) as HistoryItem[] | undefined) || []
+		const historyItem = taskHistory.find((item) => item.id === id)
+		//console.log("historyItem: ", historyItem)
+		if (historyItem) {
+			try {
+				await CheckpointTracker.deleteCheckpoints(id, historyItem, this.context.globalStorageUri.fsPath)
+			} catch (error) {
+				console.error(`Failed to delete checkpoints for task ${id}:`, error)
+			}
+		}
+
 		await this.deleteTaskFromState(id)
 
 		// Delete the task files
@@ -1683,21 +1701,12 @@ Here is the project's README to help you get started:\n\n${mcpDetails.readmeCont
 			await fs.unlink(legacyMessagesFilePath)
 		}
 
-		// Delete the checkpoints directory if it exists
-		const checkpointsDir = path.join(taskDirPath, "checkpoints")
-		if (await fileExistsAtPath(checkpointsDir)) {
-			try {
-				await fs.rm(checkpointsDir, { recursive: true, force: true })
-			} catch (error) {
-				console.error(`Failed to delete checkpoints directory for task ${id}:`, error)
-				// Continue with deletion of task directory - don't throw since this is a cleanup operation
-			}
-		}
-
 		await fs.rmdir(taskDirPath) // succeeds if the dir is empty
 	}
 
 	async deleteTaskFromState(id: string) {
+		console.log("deleteTaskFromState: ", id)
+
 		// Remove the task from history
 		const taskHistory = ((await this.getGlobalState("taskHistory")) as HistoryItem[] | undefined) || []
 		const updatedTaskHistory = taskHistory.filter((task) => task.id !== id)
@@ -1768,7 +1777,7 @@ Here is the project's README to help you get started:\n\n${mcpDetails.readmeCont
 
 	/*
 	It seems that some API messages do not comply with vscode state requirements. Either the Anthropic library is manipulating these values somehow in the backend in a way thats creating cyclic references, or the API returns a function or a Symbol as part of the message content.
-	VSCode docs about state: "The value must be JSON-stringifyable ... value — A value. MUST not contain cyclic references."
+	VSCode docs about state: "The value must be JSON-stringifyable ... value  A value. MUST not contain cyclic references."
 	For now we'll store the conversation history in memory, and if we need to store in state directly we'd need to do a manual conversion to ensure proper json stringification.
 	*/
 

src/integrations/checkpoints/Checkpoint-test-utils.ts.bak

@@ -0,0 +1,73 @@
+import * as vscode from "vscode"
+import fs from "fs/promises"
+import path from "path"
+import os from "os"
+import CheckpointTracker from "./CheckpointTracker"
+
+export async function createTestEnvironment() {
+    // Create temp directory structure
+    const tempDir = path.join(os.tmpdir(), `checkpoint-test-${Date.now()}`)
+    await fs.mkdir(tempDir, { recursive: true })
+
+    // Create storage path outside of working directory to avoid submodule issues
+    const globalStoragePath = path.join(os.tmpdir(), `storage-${Date.now()}`)
+    await fs.mkdir(globalStoragePath, { recursive: true })
+
+    // Create test file in a subdirectory
+    const testDir = path.join(tempDir, "src")
+    await fs.mkdir(testDir, { recursive: true })
+    const testFilePath = path.join(testDir, "test.txt")
+
+    // Create .gitignore to prevent git from treating directories as submodules
+    await fs.writeFile(path.join(tempDir, ".gitignore"), "storage/\n")
+
+    // Mock VS Code workspace
+    const mockWorkspaceFolders = [
+        {
+            uri: { fsPath: tempDir },
+            name: "test",
+            index: 0,
+        },
+    ]
+
+    const originalDescriptor = Object.getOwnPropertyDescriptor(vscode.workspace, "workspaceFolders")
+    Object.defineProperty(vscode.workspace, "workspaceFolders", {
+        get: () => mockWorkspaceFolders,
+    })
+
+    // Mock findFiles to return no nested git repos
+    const originalFindFiles = vscode.workspace.findFiles
+    vscode.workspace.findFiles = async () => []
+
+    // Mock VS Code configuration
+    const originalGetConfiguration = vscode.workspace.getConfiguration
+    vscode.workspace.getConfiguration = () =>
+        ({
+            get: (key: string) => (key === "enableCheckpoints" ? true : undefined),
+        }) as any
+
+    return {
+        tempDir,
+        globalStoragePath,
+        testFilePath,
+        originalDescriptor,
+        originalFindFiles,
+        originalGetConfiguration,
+        cleanup: async () => {
+            // Restore VS Code mocks
+            if (originalDescriptor) {
+                Object.defineProperty(vscode.workspace, "workspaceFolders", originalDescriptor)
+            }
+            vscode.workspace.getConfiguration = originalGetConfiguration
+            vscode.workspace.findFiles = originalFindFiles
+
+            // Clean up temp directories
+            await fs.rm(tempDir, { recursive: true, force: true })
+            await fs.rm(globalStoragePath, { recursive: true, force: true })
+        }
+    }
+}
+
+export async function createTestTracker(globalStoragePath?: string, taskId = "test-task-1") {
+    return await CheckpointTracker.create(taskId, globalStoragePath)
+}

src/integrations/checkpoints/CheckpointCommit.test.ts.bak

@@ -0,0 +1,153 @@
+import { expect } from "chai"
+import { describe, it, beforeEach, afterEach } from "mocha"
+import fs from "fs/promises"
+import path from "path"
+import { createTestEnvironment, createTestTracker } from "./Checkpoint-test-utils"
+
+describe("Checkpoint Commit Operations", () => {
+    let env: Awaited<ReturnType<typeof createTestEnvironment>>
+
+    beforeEach(async () => {
+        env = await createTestEnvironment()
+    })
+
+    afterEach(async () => {
+        await env.cleanup()
+    })
+
+    it("should create commit with single file changes", async () => {
+        const tracker = await createTestTracker(env.globalStoragePath)
+        if (!tracker) {throw new Error("Failed to create tracker")}
+
+        // Create initial file
+        await fs.writeFile(env.testFilePath, "initial content")
+
+        // Create first commit
+        const firstCommit = await tracker.commit()
+        expect(firstCommit).to.be.a("string").and.not.empty
+
+        // Modify file
+        await fs.writeFile(env.testFilePath, "modified content")
+
+        // Create second commit
+        const secondCommit = await tracker.commit()
+        expect(secondCommit).to.be.a("string").and.not.empty
+        expect(secondCommit).to.not.equal(firstCommit)
+
+        // Verify commits are different
+        const diffSet = await tracker.getDiffSet(firstCommit, secondCommit)
+        expect(diffSet).to.have.lengthOf(1)
+        expect(diffSet[0].before).to.equal("initial content")
+        expect(diffSet[0].after).to.equal("modified content")
+    })
+
+    it("should create commit with multiple file changes", async () => {
+        const tracker = await createTestTracker(env.globalStoragePath)
+        if (!tracker) {throw new Error("Failed to create tracker")}
+
+        // Create initial files with newlines
+        const testFile2Path = path.join(env.tempDir, "src", "test2.txt")
+        await fs.writeFile(env.testFilePath, "file1 initial\n")
+        await fs.writeFile(testFile2Path, "file2 initial\n")
+
+        // Create first commit
+        const firstCommit = await tracker.commit()
+        expect(firstCommit).to.be.a("string").and.not.empty
+
+        // Modify both files with newlines
+        await fs.writeFile(env.testFilePath, "file1 modified\n")
+        await fs.writeFile(testFile2Path, "file2 modified\n")
+
+        // Create second commit
+        const secondCommit = await tracker.commit()
+        expect(secondCommit).to.be.a("string").and.not.empty
+        expect(secondCommit).to.not.equal(firstCommit)
+
+        // Get diff between commits
+        const diffSet = await tracker.getDiffSet(firstCommit, secondCommit)
+        expect(diffSet).to.have.lengthOf(2)
+
+        // Sort diffSet by path for consistent ordering
+        const sortedDiffs = diffSet.sort((a, b) => a.relativePath.localeCompare(b.relativePath))
+
+        // Verify file paths
+        expect(sortedDiffs[0].relativePath).to.equal("src/test.txt")
+        expect(sortedDiffs[1].relativePath).to.equal("src/test2.txt")
+
+        // Verify file contents
+        expect(sortedDiffs[0].before).to.equal("file1 initial\nfile2 initial\n")
+        expect(sortedDiffs[0].after).to.equal("file1 modified\nfile2 modified\n")
+    })
+
+    it("should create commit when files are deleted", async () => {
+        const tracker = await createTestTracker(env.globalStoragePath)
+        if (!tracker) {throw new Error("Failed to create tracker")}
+
+        // Create and commit initial file
+        await fs.writeFile(env.testFilePath, "initial content")
+        const firstCommit = await tracker.commit()
+        expect(firstCommit).to.be.a("string").and.not.empty
+
+        // Delete file
+        await fs.unlink(env.testFilePath)
+
+        // Create second commit
+        const secondCommit = await tracker.commit()
+        expect(secondCommit).to.be.a("string").and.not.empty
+        expect(secondCommit).to.not.equal(firstCommit)
+
+        // Verify file deletion was committed
+        const diffSet = await tracker.getDiffSet(firstCommit, secondCommit)
+        expect(diffSet).to.have.lengthOf(1)
+        expect(diffSet[0].before).to.equal("initial content")
+        expect(diffSet[0].after).to.equal("")
+    })
+
+    it("should create empty commit when no changes", async () => {
+        const tracker = await createTestTracker(env.globalStoragePath)
+        if (!tracker) {throw new Error("Failed to create tracker")}
+
+        // Create and commit initial file
+        await fs.writeFile(env.testFilePath, "test content")
+        const firstCommit = await tracker.commit()
+        expect(firstCommit).to.be.a("string").and.not.empty
+
+        // Create commit without changes
+        const secondCommit = await tracker.commit()
+        expect(secondCommit).to.be.a("string").and.not.empty
+        expect(secondCommit).to.not.equal(firstCommit)
+
+        // Verify no changes between commits
+        const diffSet = await tracker.getDiffSet(firstCommit, secondCommit)
+        expect(diffSet).to.have.lengthOf(0)
+    })
+
+    it("should handle files in nested directories", async () => {
+        const tracker = await createTestTracker(env.globalStoragePath)
+        if (!tracker) {throw new Error("Failed to create tracker")}
+
+        // Create nested directory structure
+        const nestedDir = path.join(env.tempDir, "src", "deep", "nested")
+        await fs.mkdir(nestedDir, { recursive: true })
+        const nestedFilePath = path.join(nestedDir, "nested.txt")
+
+        // Create and commit file in nested directory
+        await fs.writeFile(nestedFilePath, "nested content")
+        const firstCommit = await tracker.commit()
+        expect(firstCommit).to.be.a("string").and.not.empty
+
+        // Modify nested file
+        await fs.writeFile(nestedFilePath, "modified nested content")
+
+        // Create second commit
+        const secondCommit = await tracker.commit()
+        expect(secondCommit).to.be.a("string").and.not.empty
+
+        // Verify changes were committed
+        const diffSet = await tracker.getDiffSet(firstCommit, secondCommit)
+        expect(diffSet).to.have.lengthOf(1)
+        expect(diffSet[0].relativePath).to.equal("src/deep/nested/nested.txt")
+        expect(diffSet[0].before).to.equal("nested content")
+        expect(diffSet[0].after).to.equal("modified nested content")
+    })
+})