@cjhyy/code-shell-core 0.8.9 → 0.8.11

package/dist/session/file-history.d.ts

@@ -10,6 +10,10 @@ export interface FileSnapshot {
     backupPath: string;
     hash: string;
     size: number;
+    /** Original POSIX permission bits, restored independently of backup privacy. */
+    mode?: number;
+    /** Canonical location at capture time, used to detect parent symlink swaps. */
+    realPath?: string;
     /**
      * The conversation turn (one user message = one turn) this snapshot was taken
      * in. Powers turn-level undo (`latestTurnUndoTargets`). Optional so snapshots
@@ -37,6 +41,12 @@ export interface RedoRecord {
     turnSeq: number;
     /** Backup of the post-turn content to re-apply on redo. */
     backupPath: string;
+    /** False when the turn's result was file absence (for example a delete). */
+    existedAfter?: boolean;
+    /** Post-turn POSIX permission bits to restore on redo. */
+    mode?: number;
+    /** Canonical location of the target at capture time. */
+    realPath?: string;
     /**
      * Whether the file EXISTED before this turn (had a pre-turn snapshot). False
      * means the turn CREATED it — undo deleted it, so redo must recreate it (and
@@ -55,10 +65,20 @@ export interface RedoRecord {
 export interface CreatedMarker {
     filePath: string;
     turnSeq: number;
+    /** Canonical destination planned before the creating tool ran. */
+    realPath?: string;
     undone?: boolean;
 }
+export interface TurnUndoPlan {
+    /** Undefined denotes a legacy, pre-turnSeq history bucket. */
+    turnSeq?: number;
+    snapshots: FileSnapshot[];
+    createdPaths: string[];
+    filePaths: string[];
+}
 export declare class FileHistory {
     private readonly historyDir;
+    private lockDepth;
     private snapshots;
     /**
      * Redo material for undone turns, kept SEPARATE from `snapshots` so it never
@@ -77,6 +97,7 @@ export declare class FileHistory {
      * latestTurnUndoTargets). Omit it for callers without turn context.
      */
     saveSnapshot(filePath: string, turnSeq?: number): FileSnapshot | null;
+    private saveSnapshotUnlocked;
     /**
      * Record that `filePath` was CREATED in `turnSeq` — called by the engine hook
      * when the pre-edit saveSnapshot returns null (file did not exist yet). Idempotent
@@ -86,8 +107,27 @@ export declare class FileHistory {
      * re-armed) — only fresh turns create new markers.
      */
     recordCreated(filePath: string, turnSeq: number): void;
+    private recordCreatedUnlocked;
+    /**
+     * Capture a create marker before the tool runs, but do not persist it yet.
+     * `lstat` (rather than `existsSync`) deliberately treats dangling symlinks as
+     * existing: a failed/no-follow Write must never turn such a path into a
+     * create marker that a later undo would remove.
+     */
+    prepareCreated(filePath: string, turnSeq: number): CreatedMarker | null;
+    /** Persist a marker previously returned by prepareCreated after tool success. */
+    commitCreated(marker: CreatedMarker): void;
+    private commitCreatedUnlocked;
     /** Redo material captured by past undos (see RedoRecord). Returns a copy. */
     getRedoRecords(): RedoRecord[];
+    /** Latest redo records after accounting for create-only live turns. */
+    getLatestRedoRecords(): RedoRecord[];
+    /**
+     * Authoritative latest-turn plan, including turns that only created files.
+     * Keeping this decision in FileHistory prevents UI callers from accidentally
+     * selecting an older snapshot-only turn.
+     */
+    getLatestTurnUndoPlan(): TurnUndoPlan | null;
     /**
      * Get all snapshots for a specific file.
      */
@@ -138,8 +178,7 @@ export declare class FileHistory {
         filePath: string;
         ok: boolean;
     }>;
-    /** Greatest turnSeq among not-yet-undone created markers, or undefined. */
-    private latestLiveCreatedTurn;
+    private undoLatestTurnUnlocked;
     /**
      * Turn-level redo: re-apply a previously undone turn. For each redo target,
      * write the stashed post-turn content back to disk (existedBefore:false
@@ -153,6 +192,7 @@ export declare class FileHistory {
         filePath: string;
         ok: boolean;
     }>;
+    private redoLatestTurnUnlocked;
     /**
      * All snapshots in record (chronological) order. Used by undo to pick the
      * single most-recent modification across every file (see latestUndoTarget).
@@ -161,4 +201,25 @@ export declare class FileHistory {
     getAllSnapshots(): FileSnapshot[];
     private saveIndex;
     static loadFromDir(sessionDir: string): FileHistory;
+    /** Serialize every read-modify-write and refresh after taking the lock. */
+    private withCurrentIndex;
+    private reloadIndex;
+    private isSafeBackup;
+    private isContainedBackupPath;
+    /** Never follow a destination symlink while restoring an old file version. */
+    private isSafeDestination;
+    private canonicalizeNewPath;
+    private matchesRecordedLocation;
+    private restoreSnapshot;
+    private readMode;
+    private restoreMode;
+    private discardRedoTurn;
+    private turnKey;
+    private latestTurnUndoPlanInternal;
+    private isExactSnapshotSet;
+    private sameSnapshot;
+    private findSnapshot;
+    private findRedoRecord;
+    private isSnapshot;
+    private isRedoRecord;
 }