@cjhyy/code-shell-core 0.5.0-rc.2 → 0.6.0-rc.1

package/dist/session/file-history.js

@@ -4,12 +4,20 @@
  * Stores snapshots in the session directory under file-history/.
  * Supports restoring files to a previous state.
  */
-import { mkdirSync, existsSync, readFileSync, writeFileSync, copyFileSync } from "node:fs";
+import { mkdirSync, existsSync, readFileSync, writeFileSync, copyFileSync, rmSync, } from "node:fs";
 import { join, resolve } from "node:path";
 import { createHash } from "node:crypto";
+import { earliestSnapshotsPerFile } from "./undo-target.js";
 export class FileHistory {
     historyDir;
     snapshots = [];
+    /**
+     * Redo material for undone turns, kept SEPARATE from `snapshots` so it never
+     * pollutes undo selection (latestTurnUndoTargets / earliestSnapshotsPerFile).
+     */
+    redoRecords = [];
+    /** Per-turn "this file was created" markers (see CreatedMarker). */
+    created = [];
     constructor(sessionDir) {
         this.historyDir = join(sessionDir, "file-history");
         mkdirSync(this.historyDir, { recursive: true });
@@ -17,16 +25,23 @@ export class FileHistory {
     /**
      * Save a snapshot of a file before it is modified.
      * Returns the snapshot record, or null if the file doesn't exist.
+     *
+     * `turnSeq` tags the snapshot with the current conversation turn so a later
+     * `/undo` can revert exactly the files that turn changed (see
+     * latestTurnUndoTargets). Omit it for callers without turn context.
      */
-    saveSnapshot(filePath) {
+    saveSnapshot(filePath, turnSeq) {
         const absPath = resolve(filePath);
         if (!existsSync(absPath))
             return null;
         try {
             const content = readFileSync(absPath);
             const hash = createHash("md5").update(content).digest("hex");
-            // Check if we already have this exact version
-            const existing = this.snapshots.find((s) => s.filePath === absPath && s.hash === hash);
+            // Check if we already have this exact (path, content) for this turn. Dedup
+            // is per-turn: the same content re-snapshotted in a later turn is a real
+            // new pre-turn baseline and must be recorded, or turn-level undo would
+            // miss it. Within a turn, re-snapshotting unchanged content is a no-op.
+            const existing = this.snapshots.find((s) => s.filePath === absPath && s.hash === hash && s.turnSeq === turnSeq);
             if (existing)
                 return existing;
             // Create backup. The filename must uniquely identify (path, content): a
@@ -47,6 +62,7 @@ export class FileHistory {
                 backupPath,
                 hash,
                 size: content.length,
+                ...(turnSeq === undefined ? {} : { turnSeq }),
             };
             this.snapshots.push(snapshot);
             // Write index
@@ -57,6 +73,26 @@ export class FileHistory {
             return null;
         }
     }
+    /**
+     * 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
+     * per (path, turn): a file built then edited again in the same turn is recorded
+     * once, so undo deletes it (rather than restoring an intra-turn snapshot). A
+     * marker already flipped `undone` from a prior undo is reused as-is (not
+     * re-armed) — only fresh turns create new markers.
+     */
+    recordCreated(filePath, turnSeq) {
+        const absPath = resolve(filePath);
+        const existing = this.created.find((c) => c.filePath === absPath && c.turnSeq === turnSeq);
+        if (existing)
+            return;
+        this.created.push({ filePath: absPath, turnSeq });
+        this.saveIndex();
+    }
+    /** Redo material captured by past undos (see RedoRecord). Returns a copy. */
+    getRedoRecords() {
+        return [...this.redoRecords];
+    }
     /**
      * Get all snapshots for a specific file.
      */
@@ -97,10 +133,180 @@ export class FileHistory {
     getTrackedFiles() {
         return [...new Set(this.snapshots.map((s) => s.filePath))];
     }
+    /**
+     * Restore EVERY tracked file to its earliest snapshot — the state before the
+     * first AI edit this session. Powers `/undo all`. Targets are computed up
+     * front (restore() appends a new snapshot, so reading them lazily mid-loop
+     * would be unstable). Returns a per-file result so a partial failure doesn't
+     * hide which files reverted.
+     */
+    restoreAllToEarliest() {
+        const targets = earliestSnapshotsPerFile(this.snapshots);
+        return targets.map((snap) => ({ filePath: snap.filePath, ok: this.restore(snap) }));
+    }
+    /**
+     * Capture the file's CURRENT on-disk content into a fresh redo backup and
+     * append a RedoRecord. `existedBefore` distinguishes a modified file (true,
+     * redo re-applies content) from a turn-created file (false, redo recreates it).
+     * Returns false if the file can't be read (then no record is added).
+     */
+    captureRedoBackup(filePath, turnSeq, existedBefore) {
+        try {
+            if (!existsSync(filePath))
+                return false;
+            const content = readFileSync(filePath);
+            const hash = createHash("md5").update(content).digest("hex");
+            const timestamp = Date.now();
+            const pathHash = createHash("md5").update(filePath).digest("hex").slice(0, 8);
+            const safeName = filePath.replace(/[/\\:]/g, "_").slice(-80);
+            const backupPath = join(this.historyDir, `redo_${timestamp}_${pathHash}_${hash.slice(0, 8)}_${safeName}`);
+            copyFileSync(filePath, backupPath);
+            this.redoRecords.push({ filePath, turnSeq, backupPath, existedBefore });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Turn-level undo: revert every file the most recent conversation turn changed
+     * back to its pre-turn state. Unlike the earlier "delete on undo" approach this
+     * now (a) captures the turn's RESULT as redo material so `redoLatestTurn` can
+     * re-apply it, and (b) MARKS the turn's snapshots `undone` rather than deleting
+     * them — `latestTurnUndoTargets` skips undone turns, so a subsequent `/undo`
+     * still peels the previous turn ("onion"). Powers `/undo`.
+     *
+     * Files the turn CREATED (recorded via recordCreated) are DELETED on undo (with
+     * existedBefore:false redo material) instead of restored. `targets` come from
+     * latestTurnUndoTargets so preview and restore agree. Returns per-file results.
+     */
+    undoLatestTurn(targets) {
+        // The turn being undone = the turnSeq shared by the targets (all from the
+        // same latest live turn). Created-only turns may have no snapshot targets, so
+        // fall back to the created markers' turn.
+        const undoneTurn = targets[0]?.turnSeq ?? this.latestLiveCreatedTurn();
+        if (undoneTurn === undefined)
+            return [];
+        const results = [];
+        // Files created this turn: delete them (after stashing redo material). Skip
+        // files that are also a restore target — created wins (the file didn't exist
+        // pre-turn, so its "pre-turn state" is "absent" → delete, not restore).
+        const createdThisTurn = this.created.filter((c) => !c.undone && c.turnSeq === undoneTurn);
+        const createdPaths = new Set(createdThisTurn.map((c) => c.filePath));
+        for (const c of createdThisTurn) {
+            this.captureRedoBackup(c.filePath, undoneTurn, false);
+            let ok = true;
+            try {
+                if (existsSync(c.filePath))
+                    rmSync(c.filePath, { force: true });
+            }
+            catch {
+                ok = false;
+            }
+            results.push({ filePath: c.filePath, ok });
+        }
+        // Modified (pre-existing) files: stash the current result as redo material,
+        // then restore the pre-turn content.
+        for (const snap of targets) {
+            if (createdPaths.has(snap.filePath))
+                continue;
+            this.captureRedoBackup(snap.filePath, undoneTurn, true);
+            results.push({ filePath: snap.filePath, ok: this.restore(snap) });
+        }
+        // Mark the turn undone (snapshots + created markers) — keep them on disk so
+        // redo has material and the turn is re-applyable.
+        for (const s of this.snapshots) {
+            if (s.turnSeq === undoneTurn)
+                s.undone = true;
+        }
+        for (const c of this.created) {
+            if (c.turnSeq === undoneTurn)
+                c.undone = true;
+        }
+        this.saveIndex();
+        return results;
+    }
+    /** Greatest turnSeq among not-yet-undone created markers, or undefined. */
+    latestLiveCreatedTurn() {
+        let max;
+        for (const c of this.created) {
+            if (c.undone)
+                continue;
+            if (max === undefined || c.turnSeq > max)
+                max = c.turnSeq;
+        }
+        return max;
+    }
+    /**
+     * Turn-level redo: re-apply a previously undone turn. For each redo target,
+     * write the stashed post-turn content back to disk (existedBefore:false
+     * records RECREATE a turn-created file). Then clear the `undone` flags on that
+     * turn's snapshots and created markers, and drop the consumed redo records.
+     *
+     * `redoTargets` come from latestRedoTargets (which guarantees they are the
+     * latest still-undone turn). Returns per-file results.
+     */
+    redoLatestTurn(redoTargets) {
+        if (redoTargets.length === 0)
+            return [];
+        const turn = redoTargets[0].turnSeq;
+        const results = redoTargets.map((rec) => {
+            let ok = false;
+            try {
+                if (existsSync(rec.backupPath)) {
+                    copyFileSync(rec.backupPath, rec.filePath);
+                    ok = true;
+                }
+            }
+            catch {
+                ok = false;
+            }
+            return { filePath: rec.filePath, ok };
+        });
+        // Un-mark the turn: it is live again, so undo can re-target it.
+        for (const s of this.snapshots) {
+            if (s.turnSeq === turn)
+                s.undone = false;
+        }
+        for (const c of this.created) {
+            if (c.turnSeq === turn)
+                c.undone = false;
+        }
+        // Consume the redo records for this turn (and remove their backups).
+        const consumed = new Set(redoTargets);
+        this.redoRecords = this.redoRecords.filter((r) => {
+            if (consumed.has(r) || r.turnSeq === turn) {
+                try {
+                    if (existsSync(r.backupPath))
+                        rmSync(r.backupPath, { force: true });
+                }
+                catch {
+                    // best-effort cleanup
+                }
+                return false;
+            }
+            return true;
+        });
+        this.saveIndex();
+        return results;
+    }
+    /**
+     * All snapshots in record (chronological) order. Used by undo to pick the
+     * single most-recent modification across every file (see latestUndoTarget).
+     * Returns a copy so callers can't mutate the internal list.
+     */
+    getAllSnapshots() {
+        return [...this.snapshots];
+    }
     saveIndex() {
         try {
             const indexPath = join(this.historyDir, "index.json");
-            writeFileSync(indexPath, JSON.stringify(this.snapshots, null, 2), "utf-8");
+            const index = {
+                snapshots: this.snapshots,
+                redoRecords: this.redoRecords,
+                created: this.created,
+            };
+            writeFileSync(indexPath, JSON.stringify(index, null, 2), "utf-8");
         }
         catch {
             // Silent fail
@@ -111,7 +317,17 @@ export class FileHistory {
         const indexPath = join(history.historyDir, "index.json");
         if (existsSync(indexPath)) {
             try {
-                history.snapshots = JSON.parse(readFileSync(indexPath, "utf-8"));
+                const parsed = JSON.parse(readFileSync(indexPath, "utf-8"));
+                if (Array.isArray(parsed)) {
+                    // Legacy v1: bare FileSnapshot[]. No redo/created material existed yet.
+                    history.snapshots = parsed;
+                }
+                else {
+                    const index = parsed;
+                    history.snapshots = index.snapshots ?? [];
+                    history.redoRecords = index.redoRecords ?? [];
+                    history.created = index.created ?? [];
+                }
             }
             catch {
                 // Start fresh

package/dist/session/memory.d.ts

@@ -19,7 +19,16 @@
  * Deletes are SOFT — files are moved to <baseDir>/memory-trash/<ISO>/<scope>/
  * rather than removed, so accidental deletions are recoverable.
  */
-export type MemoryScope = "user" | "dream";
+/**
+ * Memory scopes (storage subdirs under a memory root):
+ *  - user    user-owned; tool writes here are permission-gated
+ *  - dream   the auto-consolidation workspace (LLM free-write)
+ *  - pending 待审批门 (用户拍板): auto-extracted memories the LLM 判为"提全局"
+ *            land here (global root only) and are NOT injected. The user
+ *            approves (→ moves to user/) or rejects (→ trash) in the settings
+ *            panel. Keeps the global layer curated — nothing auto-lands global.
+ */
+export type MemoryScope = "user" | "dream" | "pending";
 export interface MemoryEntry {
     name: string;
     description: string;
@@ -27,7 +36,45 @@ export interface MemoryEntry {
     content: string;
     fileName: string;
     scope: MemoryScope;
+    /** File mtime in epoch ms — drives maxAge filtering (TODO 8.1). 0 if unknown. */
+    updatedAt?: number;
+    /**
+     * 固定/置顶 (feedback#18 方案 A): a pinned memory is exempt from maxAge
+     * injection filtering and sorts first in the injected context. UI surfaces
+     * pin/unpin; auto flows never set it.
+     */
+    pinned?: boolean;
+    /**
+     * Provenance (方案 C): "auto" = written by the end-of-session extractor,
+     * "manual" (or absent — legacy files) = written by the user/UI. Lets the
+     * UI distinguish curated memories from extractor noise.
+     */
+    origin?: "auto" | "manual";
+    /**
+     * Recall lifecycle (召回 TTL). `usageCount` increments each time MemoryRead
+     * hits this entry; `lastUsed` is the ISO timestamp of that last hit; `created`
+     * is set on first save and preserved across UPDATE. Drives recall-based TTL:
+     * a `project`-type memory not read for N days is pruned. Stored in frontmatter
+     * — no SQLite. Legacy files lacking these fields read back as
+     * {usageCount:0, lastUsed/created ← mtime}, never hidden.
+     */
+    usageCount?: number;
+    lastUsed?: string;
+    created?: string;
+    /**
+     * 审批门 (用户拍板): for `pending`-scope entries, the project cwd the memory
+     * was extracted in. On "不批准/降级" the entry falls back to THIS project's
+     * user store (not the current one). Absent → fall back to no-repo / global.
+     */
+    originProject?: string;
 }
+/**
+ * Drop memories older than `maxAgeDays` (by file mtime) for context injection
+ * (TODO 8.1). A non-positive/undefined maxAge means no filtering. Entries with
+ * an unknown mtime (updatedAt 0/undefined) are KEPT — we never hide a memory
+ * just because we couldn't read its timestamp. Pure + testable.
+ */
+export declare function filterByAge(entries: MemoryEntry[], maxAgeDays?: number, now?: number): MemoryEntry[];
 export interface MemoryManagerOptions {
     /** Project root path; when set, memories are scoped under projects/<hash>/memory. */
     projectDir?: string;
@@ -61,12 +108,57 @@ export declare class MemoryManager {
      * Load a single memory file.
      */
     private loadFile;
+    /**
+     * Parse a memory file's frontmatter + body into a MemoryEntry. Shared by both
+     * loadFile (own scope) and loadScope (cross-scope) so the parsing of every
+     * field — including the lifecycle fields — lives in exactly one place.
+     * Returns null on missing file / unparseable frontmatter.
+     */
+    private parseMemoryFile;
     /**
      * Soft-delete a memory by name or filename — moves the file into
      * <baseDir>/memory-trash/<ISO>/<scope>/ instead of unlinking it. The user
      * can recover by moving it back; we never hard-delete from this code path.
      */
     delete(nameOrFile: string): boolean;
+    /**
+     * Record a recall: a MemoryRead hit this entry. Bumps usageCount and sets
+     * lastUsed=now, rewriting only the frontmatter (content untouched). This is
+     * the signal that drives recall-based TTL — a memory that keeps getting read
+     * never ages out. Idempotent-safe: missing entry → false, no throw.
+     */
+    recordRecall(nameOrFile: string, now?: Date): boolean;
+    /**
+     * Recall-based TTL sweep. Soft-deletes `project`-type memories not read for
+     * more than `ttlDays` (by lastUsed). Stable types (user/feedback/reference)
+     * and pinned entries are NEVER pruned — only ephemeral project events age out.
+     * Returns the names pruned. ttlDays<=0 disables the sweep.
+     */
+    pruneByRecall(ttlDays: number, now?: Date): string[];
+    /**
+     * Approve a pending memory: move it from the pending scope into the user scope
+     * of the SAME memory root (pending only ever exists at the global root — the
+     * approval门 only gates global writes). Must be called on a pending-scope
+     * manager. Returns the new user filename, or null if not found / wrong scope.
+     *
+     * 审批门 (用户拍板): the only path that moves an auto-extracted memory into the
+     * curated, injected global user store.
+     */
+    approvePending(nameOrFile: string): string | null;
+    /**
+     * Demote a pending memory: 不批准升全局,但它仍是有用记忆 → 落回它来源项目的
+     * user store (originProject)。无 originProject 时落全局 user(兜底,不丢)。
+     */
+    demotePending(nameOrFile: string): string | null;
+    /** Shared move for approve(→global user)/demote(→origin-project user). */
+    private movePending;
+    /**
+     * Promote a project-level user memory to the GLOBAL user store (用户手动点
+     * "提升到全局")。Must be called on a project-scoped user manager. Copies the
+     * entry into global user/ and soft-deletes the project copy. Returns the new
+     * global filename, or null if not found.
+     */
+    promoteToGlobal(nameOrFile: string): string | null;
     /**
      * Get the MEMORY.md index content for injection into prompts.
      */
@@ -78,7 +170,29 @@ export declare class MemoryManager {
      * tagged with their origin so the model can tell user-owned from
      * dream-generated.
      */
-    buildMemoryContext(): string;
+    buildMemoryContext(opts?: {
+        maxAgeDays?: number;
+        now?: number;
+    }): string;
+    /**
+     * Two-layer injection index (用户拍板). Merges GLOBAL (cross-project
+     * experience) + PROJECT (this repo's facts) memories into a compact index —
+     * one line per entry, name + description only, NO body. The model reads a
+     * specific entry's full content on demand via MemoryRead (which records a
+     * recall → drives TTL + UI visibility).
+     *
+     * This is what fixes "global memory never shows up": global memories are now
+     * injected alongside project ones, every session, regardless of cwd.
+     *
+     * Static because it must construct two managers (global = no projectDir,
+     * project = with projectDir). `projectDir` undefined → only global is shown.
+     */
+    static buildInjectionIndex(opts: {
+        projectDir?: string;
+        baseDir?: string;
+        maxAgeDays?: number;
+        now?: number;
+    }): string;
     /**
      * Load every entry belonging to the given scope, without changing the
      * manager's own scope. Used by buildMemoryContext to merge user + dream