@neovate/code 0.27.1 → 0.28.1

package/dist/index.d.ts

@@ -171,6 +171,7 @@ export declare type Argv = {
     resume?: string;
     systemPrompt?: string;
     tools?: string;
+    disableContextCache: boolean;
     port?: number;
     plugin: string[];
     mcpConfig: string[];
@@ -301,6 +302,14 @@ declare type Config = {
      * - 'maxOrXhigh': Prefer xhigh if available, otherwise max
      */
     thinkingLevel?: 'low' | 'medium' | 'high' | 'max' | 'xhigh' | 'maxOrXhigh';
+    /**
+     * Controls whether rewind checkpoints are enabled.
+     * When enabled, snapshots are created after each AI response to allow
+     * rewinding to previous states with code restoration.
+     *
+     * @default true
+     */
+    checkpoints?: boolean;
 };
 
 declare type ConfigGetInput = {
@@ -369,6 +378,7 @@ export declare class Context {
     argvConfig: Record<string, any>;
     mcpManager: MCPManager;
     backgroundTaskManager: BackgroundTaskManager;
+    fileHistoryManager: FileHistoryManager;
     skillManager?: SkillManager;
     messageBus?: MessageBus;
     agentManager?: AgentManager;
@@ -390,6 +400,7 @@ declare type ContextCreateOpts = {
     plugins: (string | Plugin_2)[];
     messageBus?: MessageBus;
     fetch?: typeof globalThis.fetch;
+    noContextCache?: boolean;
 };
 
 declare type ContextOpts = {
@@ -403,6 +414,7 @@ declare type ContextOpts = {
     argvConfig: Record<string, any>;
     mcpManager: MCPManager;
     backgroundTaskManager: BackgroundTaskManager;
+    fileHistoryManager: FileHistoryManager;
     skillManager?: SkillManager;
     messageBus?: MessageBus;
     agentManager?: AgentManager;
@@ -466,6 +478,177 @@ declare type EventMessage = BaseMessage & {
     data: any;
 };
 
+/**
+ * Backup metadata for a single file
+ */
+declare type FileBackupMeta = {
+    /** Backup file name, format: {hash}@v{version}, null means file was deleted */
+    backupFileName: string | null;
+    /** Version number (incremental) */
+    version: number;
+    /** Backup time */
+    backupTime: Date;
+};
+
+declare type FileDiff = {
+    path: string;
+    oldContent: string;
+    newContent: string;
+};
+
+/**
+ * File diff content for UI display
+ */
+declare type FileDiff_2 = {
+    path: string;
+    oldContent: string;
+    newContent: string;
+};
+
+declare class FileHistory {
+    private cwd;
+    private sessionId;
+    private backupDir;
+    private snapshots;
+    private trackedFiles;
+    private pendingBackups;
+    constructor(opts: {
+        cwd: string;
+        sessionId: string;
+        backupRoot?: string;
+        snapshots?: Snapshot[];
+    });
+    /**
+     * Factory method: Create FileHistory instance from session data
+     */
+    static fromSession(opts: {
+        cwd: string;
+        sessionId: string;
+        snapshots: SerializedSnapshot_2[];
+        backupRoot?: string;
+    }): FileHistory;
+    /**
+     * Add file to tracking list and create immediate backup.
+     * Accepts either absolute path or relative path (relative to cwd).
+     *
+     * This should be called BEFORE the file is modified, so we backup the OLD content.
+     */
+    trackFile(filePath: string): void;
+    /**
+     * Track a new file (does not exist yet) before it gets created.
+     * Records backupFileName as null to indicate the file was newly created.
+     */
+    trackNewFile(filePath: string): void;
+    /**
+     * Check if message has a snapshot
+     */
+    hasSnapshot(messageId: string): boolean;
+    /**
+     * Generate backup file name: SHA256(relativePath).slice(0,16)@v{version}
+     */
+    private generateBackupFileName;
+    /**
+     * Detect if file has changed compared to backup (metadata-first)
+     */
+    private hasFileChanged;
+    /**
+     * Create file backup
+     */
+    private createBackup;
+    /**
+     * Check if there are pending backups waiting to be snapshotted.
+     * Use this to determine if a snapshot should be created for this turn.
+     */
+    hasPendingBackups(): boolean;
+    /**
+     * Create snapshot using pending backups created by trackFile.
+     * Only files with pending backups (modified this turn) are included.
+     * Returns null if no files were modified this turn.
+     */
+    createSnapshot(messageId: string): Snapshot | null;
+    /**
+     * Get all snapshot previews
+     */
+    getSnapshotPreviews(): SnapshotPreview_2[];
+    /**
+     * Calculate file diff using real line-by-line comparison
+     */
+    private calculateDiff;
+    /**
+     * Restore single file
+     */
+    private restoreFile;
+    /**
+     * Rewind to specified message's snapshot.
+     * Restores files to the state AT the target snapshot, reverting all changes
+     * made by snapshots after the target.
+     */
+    rewindToMessage(messageId: string, dryRun?: boolean): RewindResult_2;
+    /**
+     * Read file content safely, returns empty string if file doesn't exist
+     */
+    private readFileContent;
+    /**
+     * Get file contents for diff display
+     */
+    private getFileDiffContents;
+    /**
+     * Preview rewind (dry run)
+     * @param cumulative - If true, calculates changes from this point to current state (for UI display)
+     *                     If false, only shows changes in this specific snapshot
+     */
+    previewRewind(messageId: string, cumulative?: boolean): RewindResult_2;
+}
+
+declare class FileHistoryManager {
+    private instances;
+    private cwd;
+    private backupRoot;
+    constructor(opts: FileHistoryManagerOpts);
+    /**
+     * Gets or creates a FileHistory instance for the given sessionId.
+     * If sessionLogPath is provided, attempts to load existing snapshots from session.jsonl.
+     *
+     * @param sessionId - Session ID (can be main session or agent session like 'agent-xxx')
+     * @param sessionLogPath - Optional path to session.jsonl for loading existing snapshots
+     * @returns FileHistory instance for the session
+     */
+    getOrCreate(sessionId: string, sessionLogPath?: string): FileHistory;
+    /**
+     * Directly sets a FileHistory instance for a session.
+     * Used by snapshot.loadFromSession handler.
+     *
+     * @param sessionId - Session ID
+     * @param fileHistory - FileHistory instance to set
+     */
+    set(sessionId: string, fileHistory: FileHistory): void;
+    /**
+     * Gets a FileHistory instance without creating it.
+     * Returns undefined if no instance exists.
+     *
+     * @param sessionId - Session ID
+     * @returns FileHistory instance or undefined
+     */
+    get(sessionId: string): FileHistory | undefined;
+    /**
+     * Clears FileHistory instance(s).
+     *
+     * @param sessionId - Optional session ID. If provided, clears only that session.
+     *                    If not provided, clears all sessions.
+     */
+    clear(sessionId?: string): void;
+    /**
+     * Destroys all FileHistory instances.
+     * Called when the Context is destroyed.
+     */
+    destroy(): void;
+}
+
+declare interface FileHistoryManagerOpts {
+    cwd: string;
+    backupRoot: string;
+}
+
 declare type GitCloneInput = {
     url: string;
     destination: string;
@@ -691,6 +874,10 @@ declare type HandlerMap = {
         input: ModelsTestInput;
         output: ModelsTestOutput;
     };
+    'models.getVariants': {
+        input: ModelsGetVariantsInput;
+        output: ModelsGetVariantsOutput;
+    };
     'outputStyles.list': {
         input: OutputStylesListInput;
         output: OutputStylesListOutput;
@@ -947,6 +1134,34 @@ declare type HandlerMap = {
         input: ToolApprovalInput;
         output: ToolApprovalOutput;
     };
+    'snapshot.trackFile': {
+        input: SnapshotTrackFileInput;
+        output: SuccessResponse;
+    };
+    'snapshot.create': {
+        input: SnapshotCreateInput;
+        output: SnapshotCreateOutput;
+    };
+    'snapshot.list': {
+        input: SnapshotListInput;
+        output: SnapshotListOutput;
+    };
+    'snapshot.has': {
+        input: SnapshotHasInput;
+        output: SnapshotHasOutput;
+    };
+    'snapshot.rewind': {
+        input: SnapshotRewindInput;
+        output: SnapshotRewindOutput;
+    };
+    'snapshot.previewRewind': {
+        input: SnapshotPreviewRewindInput;
+        output: SnapshotPreviewRewindOutput;
+    };
+    'snapshot.loadFromSession': {
+        input: SnapshotLoadFromSessionInput;
+        output: SuccessResponse;
+    };
 };
 
 declare type ImagePart = {
@@ -1212,6 +1427,22 @@ declare interface ModelModalities {
     output: ('text' | 'audio' | 'image')[];
 }
 
+declare type ModelsGetVariantsInput = {
+    cwd?: string;
+    model: string;
+};
+
+declare type ModelsGetVariantsOutput = {
+    success: true;
+    data: {
+        model: string;
+        variants: Record<string, any>;
+    };
+} | {
+    success: false;
+    error: string;
+};
+
 declare type ModelsListInput = {
     cwd: string;
 };
@@ -1325,6 +1556,7 @@ declare class Paths {
     globalConfigDir: string;
     globalProjectDir: string;
     projectConfigDir: string;
+    fileHistoryDir: string;
     constructor(opts: {
         productName: string;
         cwd: string;
@@ -1855,6 +2087,30 @@ export declare function resumeSession(sessionId: string, options: SDKSessionOpti
 
 declare type ReturnDisplay = string | DiffViewerReturnDisplay | TodoWriteReturnDisplay | AgentResultReturnDisplay | PlanModeExitReturnDisplay;
 
+declare type RewindResult = {
+    success: boolean;
+    error?: string;
+    filesChanged: string[];
+    insertions: number;
+    deletions: number;
+    fileDiffs?: FileDiff[];
+};
+
+/**
+ * Rewind operation result
+ */
+declare type RewindResult_2 = {
+    success: boolean;
+    error?: string;
+    /** List of restored files */
+    filesChanged: string[];
+    /** Change statistics */
+    insertions: number;
+    deletions: number;
+    /** File diffs for UI display (only in preview mode) */
+    fileDiffs?: FileDiff_2[];
+};
+
 export declare function runNeovate(opts: {
     productName: string;
     productASCIIArt?: string;
@@ -1945,6 +2201,29 @@ export declare type SDKUserMessage = {
     sessionId: string;
 };
 
+declare type SerializedSnapshot = {
+    messageId: string;
+    timestamp: string;
+    trackedFileBackups: Record<string, {
+        backupFileName: string | null;
+        version: number;
+        backupTime: string;
+    }>;
+};
+
+/**
+ * Serialized snapshot data (for JSONL storage)
+ */
+declare type SerializedSnapshot_2 = {
+    messageId: string;
+    timestamp: string;
+    trackedFileBackups: Record<string, {
+        backupFileName: string | null;
+        version: number;
+        backupTime: string;
+    }>;
+};
+
 declare type SessionAddMessagesInput = {
     cwd: string;
     sessionId: string;
@@ -2428,6 +2707,129 @@ declare type SlashCommandListOutput = {
     };
 };
 
+/**
+ * File state snapshot at a specific message point
+ */
+declare type Snapshot = {
+    /** Associated message UUID */
+    messageId: string;
+    /** Snapshot creation time */
+    timestamp: Date;
+    /** Relative path -> backup metadata mapping */
+    trackedFileBackups: Record<string, FileBackupMeta>;
+};
+
+declare type SnapshotCreateInput = {
+    cwd: string;
+    sessionId: string;
+    messageId: string;
+    description?: string;
+};
+
+declare type SnapshotCreateOutput = {
+    success: boolean;
+    data: {
+        snapshot: SnapshotPreview | null;
+    };
+};
+
+declare type SnapshotHasInput = {
+    cwd: string;
+    sessionId: string;
+    messageId: string;
+};
+
+declare type SnapshotHasOutput = {
+    success: boolean;
+    data: {
+        hasSnapshot: boolean;
+    };
+};
+
+declare type SnapshotListInput = {
+    cwd: string;
+    sessionId: string;
+};
+
+declare type SnapshotListOutput = {
+    success: boolean;
+    data: {
+        snapshots: SnapshotPreview[];
+    };
+};
+
+declare type SnapshotLoadFromSessionInput = {
+    cwd: string;
+    sessionId: string;
+    snapshots: SerializedSnapshot[];
+};
+
+declare type SnapshotPreview = {
+    messageId: string;
+    timestamp: Date;
+    fileCount: number;
+    changes?: {
+        insertions: number;
+        deletions: number;
+        filesChanged: number;
+    };
+};
+
+/**
+ * Snapshot preview info (for UI display)
+ */
+declare type SnapshotPreview_2 = {
+    messageId: string;
+    timestamp: Date;
+    fileCount: number;
+    /** Change statistics relative to previous snapshot */
+    changes?: {
+        insertions: number;
+        deletions: number;
+        filesChanged: number;
+    };
+};
+
+declare type SnapshotPreviewRewindInput = {
+    cwd: string;
+    sessionId: string;
+    messageId: string;
+    cumulative?: boolean;
+};
+
+declare type SnapshotPreviewRewindOutput = {
+    success: true;
+    data: {
+        result: RewindResult;
+    };
+} | {
+    success: false;
+    error: string;
+};
+
+declare type SnapshotRewindInput = {
+    cwd: string;
+    sessionId: string;
+    messageId: string;
+};
+
+declare type SnapshotRewindOutput = {
+    success: true;
+    data: {
+        result: RewindResult;
+    };
+} | {
+    success: false;
+    error: string;
+};
+
+declare type SnapshotTrackFileInput = {
+    cwd: string;
+    sessionId: string;
+    filePath: string;
+    isNewFile?: boolean;
+};
+
 declare type Status = Record<string, {
     description?: string;
     items: string[];
@@ -2774,6 +3176,7 @@ declare type WorkspaceData = {
     repoPath: string;
     branch: string;
     worktreePath: string;
+    globalProjectDir: string;
     sessionIds: string[];
     gitState: {
         currentCommit: string;