snow-ai 0.2.6 → 0.2.7

package/dist/ui/components/SessionListPanel.js

@@ -0,0 +1,171 @@
+import React, { useState, useEffect, useCallback } from 'react';
+import { Box, Text, useInput } from 'ink';
+import { sessionManager } from '../../utils/sessionManager.js';
+export default function SessionListPanel({ onSelectSession, onClose }) {
+    const [sessions, setSessions] = useState([]);
+    const [loading, setLoading] = useState(true);
+    const [selectedIndex, setSelectedIndex] = useState(0);
+    const [scrollOffset, setScrollOffset] = useState(0);
+    const [markedSessions, setMarkedSessions] = useState(new Set());
+    const VISIBLE_ITEMS = 5; // Number of items to show at once
+    // Load sessions on mount
+    useEffect(() => {
+        const loadSessions = async () => {
+            setLoading(true);
+            try {
+                const sessionList = await sessionManager.listSessions();
+                setSessions(sessionList);
+            }
+            catch (error) {
+                console.error('Failed to load sessions:', error);
+                setSessions([]);
+            }
+            finally {
+                setLoading(false);
+            }
+        };
+        void loadSessions();
+    }, []);
+    // Format date to relative time
+    const formatDate = useCallback((timestamp) => {
+        const date = new Date(timestamp);
+        const now = new Date();
+        const diffMs = now.getTime() - date.getTime();
+        const diffMinutes = Math.floor(diffMs / (1000 * 60));
+        const diffHours = Math.floor(diffMinutes / 60);
+        const diffDays = Math.floor(diffHours / 24);
+        if (diffMinutes < 1)
+            return 'now';
+        if (diffMinutes < 60)
+            return `${diffMinutes}m`;
+        if (diffHours < 24)
+            return `${diffHours}h`;
+        if (diffDays < 7)
+            return `${diffDays}d`;
+        return date.toLocaleDateString('en-US', { month: 'short', day: 'numeric' });
+    }, []);
+    // Handle keyboard input
+    useInput((input, key) => {
+        if (loading)
+            return;
+        if (key.escape) {
+            onClose();
+            return;
+        }
+        if (key.upArrow) {
+            setSelectedIndex(prev => {
+                const newIndex = Math.max(0, prev - 1);
+                // Adjust scroll offset if needed
+                if (newIndex < scrollOffset) {
+                    setScrollOffset(newIndex);
+                }
+                return newIndex;
+            });
+            return;
+        }
+        if (key.downArrow) {
+            setSelectedIndex(prev => {
+                const newIndex = Math.min(sessions.length - 1, prev + 1);
+                // Adjust scroll offset if needed
+                if (newIndex >= scrollOffset + VISIBLE_ITEMS) {
+                    setScrollOffset(newIndex - VISIBLE_ITEMS + 1);
+                }
+                return newIndex;
+            });
+            return;
+        }
+        // Space to toggle mark
+        if (input === ' ') {
+            const currentSession = sessions[selectedIndex];
+            if (currentSession) {
+                setMarkedSessions(prev => {
+                    const next = new Set(prev);
+                    if (next.has(currentSession.id)) {
+                        next.delete(currentSession.id);
+                    }
+                    else {
+                        next.add(currentSession.id);
+                    }
+                    return next;
+                });
+            }
+            return;
+        }
+        // D to delete marked sessions
+        if (input === 'd' || input === 'D') {
+            if (markedSessions.size > 0) {
+                const deleteMarked = async () => {
+                    const ids = Array.from(markedSessions);
+                    await Promise.all(ids.map(id => sessionManager.deleteSession(id)));
+                    // Reload sessions
+                    const sessionList = await sessionManager.listSessions();
+                    setSessions(sessionList);
+                    setMarkedSessions(new Set());
+                    // Reset selection if needed
+                    if (selectedIndex >= sessionList.length && sessionList.length > 0) {
+                        setSelectedIndex(sessionList.length - 1);
+                    }
+                };
+                void deleteMarked();
+            }
+            return;
+        }
+        if (key.return && sessions.length > 0) {
+            const selectedSession = sessions[selectedIndex];
+            if (selectedSession) {
+                onSelectSession(selectedSession.id);
+            }
+            return;
+        }
+    });
+    if (loading) {
+        return (React.createElement(Box, { borderStyle: "round", borderColor: "cyan", paddingX: 1 },
+            React.createElement(Text, { color: "gray", dimColor: true }, "Loading sessions...")));
+    }
+    if (sessions.length === 0) {
+        return (React.createElement(Box, { borderStyle: "round", borderColor: "yellow", paddingX: 1 },
+            React.createElement(Text, { color: "gray", dimColor: true }, "No conversations found \u2022 Press ESC to close")));
+    }
+    // Calculate visible sessions based on scroll offset
+    const visibleSessions = sessions.slice(scrollOffset, scrollOffset + VISIBLE_ITEMS);
+    const hasMore = sessions.length > scrollOffset + VISIBLE_ITEMS;
+    const hasPrevious = scrollOffset > 0;
+    const currentSession = sessions[selectedIndex];
+    return (React.createElement(Box, { borderStyle: "round", borderColor: "cyan", paddingX: 1, flexDirection: "column" },
+        React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Text, { color: "cyan", dimColor: true },
+                "Resume (",
+                selectedIndex + 1,
+                "/",
+                sessions.length,
+                ")",
+                currentSession && ` • ${currentSession.messageCount} msgs`,
+                markedSessions.size > 0 && React.createElement(Text, { color: "yellow" },
+                    " \u2022 ",
+                    markedSessions.size,
+                    " marked")),
+            React.createElement(Text, { color: "gray", dimColor: true }, "\u2191\u2193 navigate \u2022 Space mark \u2022 D delete \u2022 Enter select \u2022 ESC close")),
+        hasPrevious && (React.createElement(Text, { color: "gray", dimColor: true },
+            "  \u2191 ",
+            scrollOffset,
+            " more above")),
+        visibleSessions.map((session, index) => {
+            const actualIndex = scrollOffset + index;
+            const isSelected = actualIndex === selectedIndex;
+            const isMarked = markedSessions.has(session.id);
+            const title = session.title || 'Untitled';
+            const timeStr = formatDate(session.updatedAt);
+            const truncatedLabel = title.length > 50 ? title.slice(0, 47) + '...' : title;
+            return (React.createElement(Box, { key: session.id },
+                React.createElement(Text, { color: isMarked ? 'green' : 'gray' }, isMarked ? '✔ ' : '  '),
+                React.createElement(Text, { color: isSelected ? 'green' : 'gray' }, isSelected ? '❯ ' : '  '),
+                React.createElement(Text, { color: isSelected ? 'cyan' : isMarked ? 'green' : 'white' }, truncatedLabel),
+                React.createElement(Text, { color: "gray", dimColor: true },
+                    " \u2022 ",
+                    timeStr)));
+        }),
+        hasMore && (React.createElement(Text, { color: "gray", dimColor: true },
+            "  \u2193 ",
+            sessions.length - scrollOffset - VISIBLE_ITEMS,
+            " more below"))));
+}

package/dist/ui/pages/ChatScreen.js

@@ -5,20 +5,22 @@ import Gradient from 'ink-gradient';
 import ChatInput from '../components/ChatInput.js';
 import PendingMessages from '../components/PendingMessages.js';
 import MCPInfoScreen from '../components/MCPInfoScreen.js';
-import SessionListScreenWrapper from '../components/SessionListScreenWrapper.js';
+import MCPInfoPanel from '../components/MCPInfoPanel.js';
+import SessionListPanel from '../components/SessionListPanel.js';
 import MarkdownRenderer from '../components/MarkdownRenderer.js';
 import ToolConfirmation from '../components/ToolConfirmation.js';
 import DiffViewer from '../components/DiffViewer.js';
 import ToolResultPreview from '../components/ToolResultPreview.js';
 import TodoTree from '../components/TodoTree.js';
+import FileRollbackConfirmation from '../components/FileRollbackConfirmation.js';
 import { getOpenAiConfig } from '../../utils/apiConfig.js';
 import { sessionManager } from '../../utils/sessionManager.js';
 import { useSessionSave } from '../../hooks/useSessionSave.js';
-import { useSessionManagement } from '../../hooks/useSessionManagement.js';
 import { useToolConfirmation } from '../../hooks/useToolConfirmation.js';
 import { handleConversationWithTools } from '../../hooks/useConversation.js';
 import { parseAndValidateFileReferences, createMessageWithFileInstructions, getSystemInfo } from '../../utils/fileUtils.js';
 import { compressContext } from '../../utils/contextCompressor.js';
+import { incrementalSnapshotManager } from '../../utils/incrementalSnapshot.js';
 // Import commands to register them
 import '../../utils/commands/clear.js';
 import '../../utils/commands/resume.js';
@@ -68,6 +70,10 @@ export default function ChatScreen({}) {
     const [editorContext, setEditorContext] = useState({});
     const [isCompressing, setIsCompressing] = useState(false);
     const [compressionError, setCompressionError] = useState(null);
+    const [showSessionPanel, setShowSessionPanel] = useState(false);
+    const [showMcpPanel, setShowMcpPanel] = useState(false);
+    const [snapshotFileCount, setSnapshotFileCount] = useState(new Map());
+    const [pendingRollback, setPendingRollback] = useState(null);
     const { stdout } = useStdout();
     const terminalHeight = stdout?.rows || 24;
     const workingDirectory = process.cwd();
@@ -81,8 +87,6 @@ export default function ChatScreen({}) {
     }, [pendingMessages]);
     // Use tool confirmation hook
     const { pendingToolConfirmation, requestToolConfirmation, isToolAutoApproved, addMultipleToAlwaysApproved } = useToolConfirmation();
-    // Use session management hook
-    const { showSessionList, setShowSessionList, handleSessionSelect, handleBackFromSessionList } = useSessionManagement(setMessages, setPendingMessages, setIsStreaming, setRemountKey, initializeFromSession);
     // Animation for streaming/saving indicator
     useEffect(() => {
         if (!isStreaming && !isSaving)
@@ -171,6 +175,21 @@ export default function ChatScreen({}) {
             unsubscribe();
         };
     }, [vscodeConnectionStatus]);
+    // Load snapshot file counts when session changes
+    useEffect(() => {
+        const loadSnapshotFileCounts = async () => {
+            const currentSession = sessionManager.getCurrentSession();
+            if (!currentSession)
+                return;
+            const snapshots = await incrementalSnapshotManager.listSnapshots(currentSession.id);
+            const counts = new Map();
+            for (const snapshot of snapshots) {
+                counts.set(snapshot.messageIndex, snapshot.fileCount);
+            }
+            setSnapshotFileCount(counts);
+        };
+        loadSnapshotFileCounts();
+    }, [messages.length]); // Reload when messages change
     // Pending messages are now handled inline during tool execution in useConversation
     // Auto-send pending messages when streaming completely stops (as fallback)
     useEffect(() => {
@@ -184,6 +203,24 @@ export default function ChatScreen({}) {
     }, [isStreaming, pendingMessages.length]);
     // ESC key handler to interrupt streaming or close overlays
     useInput((_, key) => {
+        if (pendingRollback) {
+            if (key.escape) {
+                setPendingRollback(null);
+            }
+            return;
+        }
+        if (showSessionPanel) {
+            if (key.escape) {
+                setShowSessionPanel(false);
+            }
+            return;
+        }
+        if (showMcpPanel) {
+            if (key.escape) {
+                setShowMcpPanel(false);
+            }
+            return;
+        }
         if (showMcpInfo) {
             if (key.escape) {
                 setShowMcpInfo(false);
@@ -193,7 +230,7 @@ export default function ChatScreen({}) {
         if (key.escape && isStreaming && abortController) {
             // Abort the controller
             abortController.abort();
-            // Immediately add discontinued message
+            // Add discontinued message
             setMessages(prev => [...prev, {
                     role: 'assistant',
                     content: '',
@@ -293,8 +330,14 @@ export default function ChatScreen({}) {
             };
             setMessages([commandMessage]);
         }
-        else if (result.success && result.action === 'resume') {
-            setShowSessionList(true);
+        else if (result.success && result.action === 'showSessionPanel') {
+            setShowSessionPanel(true);
+            const commandMessage = {
+                role: 'command',
+                content: '',
+                commandName: commandName
+            };
+            setMessages(prev => [...prev, commandMessage]);
         }
         else if (result.success && result.action === 'showMcpInfo') {
             setShowMcpInfo(true);
@@ -306,6 +349,15 @@ export default function ChatScreen({}) {
             };
             setMessages(prev => [...prev, commandMessage]);
         }
+        else if (result.success && result.action === 'showMcpPanel') {
+            setShowMcpPanel(true);
+            const commandMessage = {
+                role: 'command',
+                content: '',
+                commandName: commandName
+            };
+            setMessages(prev => [...prev, commandMessage]);
+        }
         else if (result.success && result.action === 'goHome') {
             navigateTo('welcome');
         }
@@ -330,11 +382,53 @@ export default function ChatScreen({}) {
             processMessage(result.prompt, undefined, true, true);
         }
     };
-    const handleHistorySelect = (selectedIndex, _message) => {
+    const handleHistorySelect = async (selectedIndex, _message) => {
+        // Check if there are files to rollback
+        const fileCount = snapshotFileCount.get(selectedIndex) || 0;
+        if (fileCount > 0) {
+            // Show confirmation dialog
+            setPendingRollback({ messageIndex: selectedIndex, fileCount });
+        }
+        else {
+            // No files to rollback, just rollback conversation
+            performRollback(selectedIndex, false);
+        }
+    };
+    const performRollback = async (selectedIndex, rollbackFiles) => {
+        // Rollback workspace to checkpoint if requested
+        if (rollbackFiles) {
+            const currentSession = sessionManager.getCurrentSession();
+            if (currentSession) {
+                await incrementalSnapshotManager.rollbackToSnapshot(currentSession.id, selectedIndex);
+            }
+        }
         // Truncate messages array to remove the selected user message and everything after it
         setMessages(prev => prev.slice(0, selectedIndex));
         clearSavedMessages();
         setRemountKey(prev => prev + 1);
+        // Clear pending rollback dialog
+        setPendingRollback(null);
+    };
+    const handleRollbackConfirm = (rollbackFiles) => {
+        if (pendingRollback) {
+            performRollback(pendingRollback.messageIndex, rollbackFiles);
+        }
+    };
+    const handleSessionPanelSelect = async (sessionId) => {
+        setShowSessionPanel(false);
+        try {
+            const session = await sessionManager.loadSession(sessionId);
+            if (session) {
+                initializeFromSession(session.messages);
+                setMessages(session.messages);
+                setPendingMessages([]);
+                setIsStreaming(false);
+                setRemountKey(prev => prev + 1);
+            }
+        }
+        catch (error) {
+            console.error('Failed to load session:', error);
+        }
     };
     const handleMessageSubmit = async (message, images) => {
         // If streaming, add to pending messages instead of sending immediately
@@ -342,6 +436,15 @@ export default function ChatScreen({}) {
             setPendingMessages(prev => [...prev, message]);
             return;
         }
+        // Create checkpoint (lightweight, only tracks modifications)
+        const currentSession = sessionManager.getCurrentSession();
+        if (!currentSession) {
+            await sessionManager.createNewSession();
+        }
+        const session = sessionManager.getCurrentSession();
+        if (session) {
+            await incrementalSnapshotManager.createSnapshot(session.id, messages.length);
+        }
         // Process the message normally
         await processMessage(message, images);
     };
@@ -393,7 +496,8 @@ export default function ChatScreen({}) {
                 setContextUsage,
                 useBasicModel,
                 getPendingMessages: () => pendingMessagesRef.current,
-                clearPendingMessages: () => setPendingMessages([])
+                clearPendingMessages: () => setPendingMessages([]),
+                setIsStreaming
             });
         }
         catch (error) {
@@ -455,7 +559,8 @@ export default function ChatScreen({}) {
                 yoloMode,
                 setContextUsage,
                 getPendingMessages: () => pendingMessagesRef.current,
-                clearPendingMessages: () => setPendingMessages([])
+                clearPendingMessages: () => setPendingMessages([]),
+                setIsStreaming
             });
         }
         catch (error) {
@@ -477,10 +582,6 @@ export default function ChatScreen({}) {
             setStreamTokenCount(0);
         }
     };
-    // If showing session list, only render that
-    if (showSessionList) {
-        return (React.createElement(SessionListScreenWrapper, { onBack: handleBackFromSessionList, onSelectSession: handleSessionSelect }));
-    }
     if (showMcpInfo) {
         return (React.createElement(MCPInfoScreen, { onClose: () => setShowMcpInfo(false), panelKey: mcpPanelKey }));
     }
@@ -499,7 +600,7 @@ export default function ChatScreen({}) {
             React.createElement(Box, { marginTop: 1 },
                 React.createElement(Text, { color: "gray", dimColor: true }, "Please resize your terminal window to continue."))));
     }
-    return (React.createElement(Box, { flexDirection: "column" },
+    return (React.createElement(Box, { flexDirection: "column", height: "100%" },
         React.createElement(Static, { key: remountKey, items: [
                 React.createElement(Box, { key: "header", marginX: 1, borderColor: 'cyan', borderStyle: "round", paddingX: 2, paddingY: 1 },
                     React.createElement(Box, { flexDirection: "column" },
@@ -617,11 +718,18 @@ export default function ChatScreen({}) {
         React.createElement(Box, { marginX: 1 },
             React.createElement(PendingMessages, { pendingMessages: pendingMessages })),
         pendingToolConfirmation && (React.createElement(ToolConfirmation, { toolName: pendingToolConfirmation.batchToolNames || pendingToolConfirmation.tool.function.name, onConfirm: pendingToolConfirmation.resolve })),
-        !pendingToolConfirmation && !isCompressing && (React.createElement(React.Fragment, null,
+        showSessionPanel && (React.createElement(Box, { marginX: 1 },
+            React.createElement(SessionListPanel, { onSelectSession: handleSessionPanelSelect, onClose: () => setShowSessionPanel(false) }))),
+        showMcpPanel && (React.createElement(Box, { marginX: 1, flexDirection: "column" },
+            React.createElement(MCPInfoPanel, null),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { color: "gray", dimColor: true }, "Press ESC to close")))),
+        pendingRollback && (React.createElement(FileRollbackConfirmation, { fileCount: pendingRollback.fileCount, onConfirm: handleRollbackConfirm })),
+        !pendingToolConfirmation && !isCompressing && !showSessionPanel && !showMcpPanel && !pendingRollback && (React.createElement(React.Fragment, null,
             React.createElement(ChatInput, { onSubmit: handleMessageSubmit, onCommand: handleCommandExecution, placeholder: "Ask me anything about coding...", disabled: !!pendingToolConfirmation, chatHistory: messages, onHistorySelect: handleHistorySelect, yoloMode: yoloMode, contextUsage: contextUsage ? {
                     inputTokens: contextUsage.prompt_tokens,
                     maxContextTokens: getOpenAiConfig().maxContextTokens || 4000
-                } : undefined }),
+                } : undefined, snapshotFileCount: snapshotFileCount }),
             vscodeConnectionStatus !== 'disconnected' && (React.createElement(Box, { marginTop: 1 },
                 React.createElement(Text, { color: vscodeConnectionStatus === 'connecting' ? 'yellow' :
                         vscodeConnectionStatus === 'connected' ? 'green' :

package/dist/utils/checkpointManager.d.ts

@@ -0,0 +1,74 @@
+/**
+ * File checkpoint data structure
+ */
+export interface FileCheckpoint {
+    path: string;
+    content: string;
+    timestamp: number;
+    exists: boolean;
+}
+/**
+ * Conversation checkpoint data structure
+ */
+export interface ConversationCheckpoint {
+    sessionId: string;
+    messageCount: number;
+    fileSnapshots: FileCheckpoint[];
+    timestamp: number;
+}
+/**
+ * Checkpoint Manager
+ * Manages file snapshots for rollback on ESC interrupt
+ */
+declare class CheckpointManager {
+    private readonly checkpointsDir;
+    private activeCheckpoint;
+    constructor();
+    /**
+     * Ensure checkpoints directory exists
+     */
+    private ensureCheckpointsDir;
+    /**
+     * Get checkpoint file path for a session
+     */
+    private getCheckpointPath;
+    /**
+     * Create a new checkpoint before AI response
+     * @param sessionId - Current session ID
+     * @param messageCount - Number of messages before AI response
+     */
+    createCheckpoint(sessionId: string, messageCount: number): Promise<void>;
+    /**
+     * Record a file snapshot before modification
+     * @param filePath - Absolute path to the file
+     */
+    recordFileSnapshot(filePath: string): Promise<void>;
+    /**
+     * Save current checkpoint to disk
+     */
+    private saveCheckpoint;
+    /**
+     * Load checkpoint from disk
+     */
+    loadCheckpoint(sessionId: string): Promise<ConversationCheckpoint | null>;
+    /**
+     * Rollback files to checkpoint state
+     * @param sessionId - Session ID to rollback
+     * @returns Number of messages to rollback to, or null if no checkpoint
+     */
+    rollback(sessionId: string): Promise<number | null>;
+    /**
+     * Clear checkpoint for a session
+     */
+    clearCheckpoint(sessionId: string): Promise<void>;
+    /**
+     * Get active checkpoint
+     */
+    getActiveCheckpoint(): ConversationCheckpoint | null;
+    /**
+     * Clear active checkpoint (used when conversation completes successfully)
+     */
+    commitCheckpoint(): Promise<void>;
+}
+export declare const checkpointManager: CheckpointManager;
+export {};

package/dist/utils/checkpointManager.js

@@ -0,0 +1,181 @@
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+/**
+ * Checkpoint Manager
+ * Manages file snapshots for rollback on ESC interrupt
+ */
+class CheckpointManager {
+    constructor() {
+        Object.defineProperty(this, "checkpointsDir", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "activeCheckpoint", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        this.checkpointsDir = path.join(os.homedir(), '.snow', 'checkpoints');
+    }
+    /**
+     * Ensure checkpoints directory exists
+     */
+    async ensureCheckpointsDir() {
+        try {
+            await fs.mkdir(this.checkpointsDir, { recursive: true });
+        }
+        catch (error) {
+            // Directory already exists or other error
+        }
+    }
+    /**
+     * Get checkpoint file path for a session
+     */
+    getCheckpointPath(sessionId) {
+        return path.join(this.checkpointsDir, `${sessionId}.json`);
+    }
+    /**
+     * Create a new checkpoint before AI response
+     * @param sessionId - Current session ID
+     * @param messageCount - Number of messages before AI response
+     */
+    async createCheckpoint(sessionId, messageCount) {
+        await this.ensureCheckpointsDir();
+        this.activeCheckpoint = {
+            sessionId,
+            messageCount,
+            fileSnapshots: [],
+            timestamp: Date.now()
+        };
+        // Save checkpoint immediately (will be updated as files are modified)
+        await this.saveCheckpoint();
+    }
+    /**
+     * Record a file snapshot before modification
+     * @param filePath - Absolute path to the file
+     */
+    async recordFileSnapshot(filePath) {
+        if (!this.activeCheckpoint) {
+            return; // No active checkpoint, skip
+        }
+        // Check if this file already has a snapshot
+        const existingSnapshot = this.activeCheckpoint.fileSnapshots.find(snapshot => snapshot.path === filePath);
+        if (existingSnapshot) {
+            return; // Already recorded, skip
+        }
+        try {
+            // Try to read existing file content
+            const content = await fs.readFile(filePath, 'utf-8');
+            this.activeCheckpoint.fileSnapshots.push({
+                path: filePath,
+                content,
+                timestamp: Date.now(),
+                exists: true
+            });
+        }
+        catch (error) {
+            // File doesn't exist, record as non-existent
+            this.activeCheckpoint.fileSnapshots.push({
+                path: filePath,
+                content: '',
+                timestamp: Date.now(),
+                exists: false
+            });
+        }
+        // Update checkpoint file
+        await this.saveCheckpoint();
+    }
+    /**
+     * Save current checkpoint to disk
+     */
+    async saveCheckpoint() {
+        if (!this.activeCheckpoint) {
+            return;
+        }
+        await this.ensureCheckpointsDir();
+        const checkpointPath = this.getCheckpointPath(this.activeCheckpoint.sessionId);
+        await fs.writeFile(checkpointPath, JSON.stringify(this.activeCheckpoint, null, 2));
+    }
+    /**
+     * Load checkpoint from disk
+     */
+    async loadCheckpoint(sessionId) {
+        try {
+            const checkpointPath = this.getCheckpointPath(sessionId);
+            const data = await fs.readFile(checkpointPath, 'utf-8');
+            return JSON.parse(data);
+        }
+        catch (error) {
+            return null;
+        }
+    }
+    /**
+     * Rollback files to checkpoint state
+     * @param sessionId - Session ID to rollback
+     * @returns Number of messages to rollback to, or null if no checkpoint
+     */
+    async rollback(sessionId) {
+        const checkpoint = await this.loadCheckpoint(sessionId);
+        if (!checkpoint) {
+            return null;
+        }
+        // Rollback all file snapshots
+        for (const snapshot of checkpoint.fileSnapshots) {
+            try {
+                if (snapshot.exists) {
+                    // Restore original file content
+                    await fs.writeFile(snapshot.path, snapshot.content, 'utf-8');
+                }
+                else {
+                    // Delete file that was created
+                    try {
+                        await fs.unlink(snapshot.path);
+                    }
+                    catch (error) {
+                        // File may already be deleted, ignore
+                    }
+                }
+            }
+            catch (error) {
+                console.error(`Failed to rollback file ${snapshot.path}:`, error);
+            }
+        }
+        // Clear checkpoint after rollback
+        await this.clearCheckpoint(sessionId);
+        return checkpoint.messageCount;
+    }
+    /**
+     * Clear checkpoint for a session
+     */
+    async clearCheckpoint(sessionId) {
+        try {
+            const checkpointPath = this.getCheckpointPath(sessionId);
+            await fs.unlink(checkpointPath);
+        }
+        catch (error) {
+            // Checkpoint may not exist, ignore
+        }
+        if (this.activeCheckpoint?.sessionId === sessionId) {
+            this.activeCheckpoint = null;
+        }
+    }
+    /**
+     * Get active checkpoint
+     */
+    getActiveCheckpoint() {
+        return this.activeCheckpoint;
+    }
+    /**
+     * Clear active checkpoint (used when conversation completes successfully)
+     */
+    async commitCheckpoint() {
+        if (this.activeCheckpoint) {
+            await this.clearCheckpoint(this.activeCheckpoint.sessionId);
+        }
+    }
+}
+export const checkpointManager = new CheckpointManager();