nebula-notebook 0.1.0

package/node-server/dist/notebook/undoRedoManager.js

@@ -0,0 +1,558 @@
+"use strict";
+/**
+ * Headless Undo/Redo Manager
+ *
+ * Manages undo/redo state for notebooks when operated via the headless backend (MCP).
+ * This mirrors the frontend UndoRedoManager but uses NebulaCell types.
+ *
+ * Note: This is a simplified version of lib/undoRedoCore.ts adapted for the backend.
+ * The core logic is intentionally similar to maintain feature parity.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HeadlessUndoRedoManager = void 0;
+exports.getUndoRedoManager = getUndoRedoManager;
+const uuid_1 = require("uuid");
+// ============================================================================
+// PURE FUNCTIONS
+// ============================================================================
+function cloneCell(cell) {
+    return {
+        ...cell,
+        outputs: (cell.outputs || []).map(output => ({ ...output }))
+    };
+}
+function stripCellOutputs(cell) {
+    return {
+        ...cell,
+        outputs: [],
+        isExecuting: false
+    };
+}
+function applyOperation(cells, op) {
+    switch (op.type) {
+        case 'insertCell': {
+            const newCells = [...cells];
+            newCells.splice(op.index, 0, cloneCell(op.cell));
+            return newCells;
+        }
+        case 'deleteCell': {
+            return cells.filter((_, i) => i !== op.index);
+        }
+        case 'moveCell': {
+            const newCells = [...cells];
+            const [moved] = newCells.splice(op.fromIndex, 1);
+            newCells.splice(op.toIndex, 0, moved);
+            return newCells;
+        }
+        case 'updateContent': {
+            return cells.map(c => c.id === op.cellId ? { ...c, content: op.newContent } : c);
+        }
+        case 'updateMetadata': {
+            return cells.map(c => {
+                if (c.id !== op.cellId)
+                    return c;
+                const updated = { ...c };
+                for (const [key, change] of Object.entries(op.changes)) {
+                    updated[key] = change.new;
+                }
+                return updated;
+            });
+        }
+        case 'batch': {
+            return op.operations.reduce((acc, subOp) => applyOperation(acc, subOp), cells);
+        }
+        default:
+            return cells;
+    }
+}
+function reverseOperation(op) {
+    switch (op.type) {
+        case 'insertCell':
+            return { type: 'deleteCell', index: op.index, cell: op.cell };
+        case 'deleteCell':
+            return { type: 'insertCell', index: op.index, cell: op.cell };
+        case 'moveCell':
+            return { type: 'moveCell', fromIndex: op.toIndex, toIndex: op.fromIndex };
+        case 'updateContent':
+            return {
+                type: 'updateContent',
+                cellId: op.cellId,
+                oldContent: op.newContent,
+                newContent: op.oldContent
+            };
+        case 'updateMetadata': {
+            const reversed = {};
+            for (const [key, change] of Object.entries(op.changes)) {
+                reversed[key] = { old: change.new, new: change.old };
+            }
+            return { type: 'updateMetadata', cellId: op.cellId, changes: reversed };
+        }
+        case 'batch':
+            return {
+                type: 'batch',
+                operations: op.operations.map(reverseOperation).reverse()
+            };
+        default:
+            return op;
+    }
+}
+function getAffectedCellIds(op, cells) {
+    switch (op.type) {
+        case 'insertCell':
+        case 'deleteCell':
+            return [op.cell.id];
+        case 'moveCell':
+            if (cells && op.toIndex >= 0 && op.toIndex < cells.length) {
+                return [cells[op.toIndex].id];
+            }
+            return [];
+        case 'updateContent':
+        case 'updateMetadata':
+            return [op.cellId];
+        case 'batch': {
+            const ids = new Set();
+            for (const subOp of op.operations) {
+                for (const id of getAffectedCellIds(subOp, cells)) {
+                    ids.add(id);
+                }
+            }
+            return Array.from(ids);
+        }
+        default:
+            return [];
+    }
+}
+// ============================================================================
+// HEADLESS UNDO/REDO MANAGER
+// ============================================================================
+/**
+ * Manages undo/redo state for multiple notebooks in the headless backend.
+ */
+class HeadlessUndoRedoManager {
+    states = new Map();
+    fsService;
+    constructor(fsService) {
+        this.fsService = fsService;
+    }
+    /**
+     * Get or initialize undo state for a notebook.
+     */
+    getState(notebookPath, cells) {
+        if (!this.states.has(notebookPath)) {
+            // Try to load existing history
+            let loadedHistory = [];
+            try {
+                loadedHistory = this.fsService.loadHistory(notebookPath);
+            }
+            catch (err) {
+                console.warn(`[UndoRedoManager] Failed to load history for ${notebookPath}:`, err);
+            }
+            // Initialize state
+            const state = {
+                undoStack: [],
+                redoStack: [],
+                fullHistory: loadedHistory.length > 0 ? loadedHistory : [{
+                        type: 'snapshot',
+                        cells: cells.map(stripCellOutputs),
+                        timestamp: Date.now()
+                    }],
+                lastContent: new Map(cells.map(c => [c.id, c.content]))
+            };
+            // Rebuild undo stack from history
+            if (loadedHistory.length > 0) {
+                state.undoStack = this.rebuildUndoStack(loadedHistory);
+            }
+            this.states.set(notebookPath, state);
+        }
+        return this.states.get(notebookPath);
+    }
+    /**
+     * Rebuild undo stack from history.
+     */
+    rebuildUndoStack(history) {
+        const undoneIds = new Set();
+        for (const op of history) {
+            if (op.isUndo && op.undoesOperationId) {
+                undoneIds.add(op.undoesOperationId);
+            }
+        }
+        const undoableOps = [];
+        for (const op of history) {
+            if (op.isUndo)
+                continue;
+            if (op.operationId && undoneIds.has(op.operationId))
+                continue;
+            if (op.type === 'insertCell' || op.type === 'deleteCell' ||
+                op.type === 'moveCell' || op.type === 'updateContent' ||
+                op.type === 'updateMetadata' || op.type === 'batch') {
+                const { timestamp, operationId, isUndo, undoesOperationId, ...operation } = op;
+                undoableOps.push(operation);
+            }
+        }
+        return undoableOps;
+    }
+    /**
+     * Record an operation (called by headless handler after executing an operation).
+     */
+    recordOperation(notebookPath, cells, op) {
+        const state = this.getState(notebookPath, cells);
+        // Clear redo stack (can't redo after new operation)
+        if (state.redoStack.length > 0) {
+            // Record the undos that would have been in redo stack
+            for (const redoOp of state.redoStack) {
+                const reversedOp = reverseOperation(redoOp);
+                const timestampedOp = {
+                    ...reversedOp,
+                    timestamp: Date.now(),
+                    operationId: (0, uuid_1.v4)(),
+                    isUndo: true,
+                    undoesOperationId: redoOp.operationId,
+                };
+                state.fullHistory.push(timestampedOp);
+            }
+            state.redoStack = [];
+        }
+        // Add operation to history
+        const operationId = (0, uuid_1.v4)();
+        const timestampedOp = {
+            ...op,
+            timestamp: Date.now(),
+            operationId,
+        };
+        state.fullHistory.push(timestampedOp);
+        // Add to undo stack
+        const opWithId = { ...op, operationId };
+        state.undoStack.push(opWithId);
+        // Update content tracking
+        if (op.type === 'updateContent') {
+            state.lastContent.set(op.cellId, op.newContent);
+        }
+        else if (op.type === 'insertCell') {
+            state.lastContent.set(op.cell.id, op.cell.content);
+        }
+        else if (op.type === 'deleteCell') {
+            state.lastContent.delete(op.cell.id);
+        }
+    }
+    /**
+     * Record a non-undoable log operation (history only).
+     */
+    recordLogOperation(notebookPath, cells, op) {
+        const state = this.getState(notebookPath, cells);
+        const timestampedOp = {
+            ...op,
+            timestamp: Date.now(),
+            operationId: (0, uuid_1.v4)(),
+        };
+        state.fullHistory.push(timestampedOp);
+    }
+    /**
+     * Undo the last operation.
+     */
+    undo(notebookPath, cells) {
+        const state = this.getState(notebookPath, cells);
+        if (state.undoStack.length === 0) {
+            return {
+                cells,
+                result: { success: false, affectedCellIds: [], operationType: '', error: 'Nothing to undo' }
+            };
+        }
+        const op = state.undoStack.pop();
+        const reversedOp = reverseOperation(op);
+        // Apply the reversed operation
+        const newCells = applyOperation(cells, reversedOp);
+        // Push to redo stack
+        state.redoStack.push(op);
+        // Update content tracking
+        this.updateContentTrackingAfterUndo(state, op, newCells);
+        return {
+            cells: newCells,
+            result: {
+                success: true,
+                affectedCellIds: getAffectedCellIds(reversedOp, newCells),
+                operationType: op.type
+            }
+        };
+    }
+    /**
+     * Redo the last undone operation.
+     */
+    redo(notebookPath, cells) {
+        const state = this.getState(notebookPath, cells);
+        if (state.redoStack.length === 0) {
+            return {
+                cells,
+                result: { success: false, affectedCellIds: [], operationType: '', error: 'Nothing to redo' }
+            };
+        }
+        const op = state.redoStack.pop();
+        // Apply the operation
+        const newCells = applyOperation(cells, op);
+        // Push to undo stack
+        state.undoStack.push(op);
+        // Update content tracking
+        this.updateContentTrackingAfterRedo(state, op, newCells);
+        return {
+            cells: newCells,
+            result: {
+                success: true,
+                affectedCellIds: getAffectedCellIds(op, newCells),
+                operationType: op.type
+            }
+        };
+    }
+    updateContentTrackingAfterUndo(state, op, cells) {
+        if (op.type === 'updateContent') {
+            state.lastContent.set(op.cellId, op.oldContent);
+        }
+        else if (op.type === 'insertCell') {
+            state.lastContent.delete(op.cell.id);
+        }
+        else if (op.type === 'deleteCell') {
+            state.lastContent.set(op.cell.id, op.cell.content);
+        }
+        else if (op.type === 'batch') {
+            for (let i = op.operations.length - 1; i >= 0; i--) {
+                this.updateContentTrackingAfterUndo(state, op.operations[i], cells);
+            }
+        }
+    }
+    updateContentTrackingAfterRedo(state, op, cells) {
+        if (op.type === 'updateContent') {
+            state.lastContent.set(op.cellId, op.newContent);
+        }
+        else if (op.type === 'insertCell') {
+            state.lastContent.set(op.cell.id, op.cell.content);
+        }
+        else if (op.type === 'deleteCell') {
+            state.lastContent.delete(op.cell.id);
+        }
+        else if (op.type === 'batch') {
+            for (const subOp of op.operations) {
+                this.updateContentTrackingAfterRedo(state, subOp, cells);
+            }
+        }
+    }
+    /**
+     * Check if undo is available.
+     */
+    canUndo(notebookPath, cells) {
+        const state = this.getState(notebookPath, cells);
+        return state.undoStack.length > 0;
+    }
+    /**
+     * Check if redo is available.
+     */
+    canRedo(notebookPath, cells) {
+        const state = this.getState(notebookPath, cells);
+        return state.redoStack.length > 0;
+    }
+    /**
+     * Get history for a notebook.
+     */
+    getHistory(notebookPath, cells) {
+        const state = this.getState(notebookPath, cells);
+        return state.fullHistory;
+    }
+    /**
+     * Clear state for a notebook (e.g., when closing).
+     */
+    clearState(notebookPath) {
+        this.states.delete(notebookPath);
+    }
+    /**
+     * Get updates since a timestamp (for agent awareness).
+     * Returns human-readable summaries of operations made between agent sessions.
+     * Includes both edits and non-undoable events (no source filtering).
+     */
+    getUpdatesSince(notebookPath, cells, sinceTimestamp) {
+        const state = this.getState(notebookPath, cells);
+        const summaries = [];
+        const describeEvent = (event, timestamp) => {
+            const cellId = event.target?.cellId;
+            const cellIndex = event.target?.cellIndex;
+            const data = event.data ? { ...event.data } : undefined;
+            if (data && event.name === 'runCellComplete' && 'output' in data) {
+                delete data.output;
+            }
+            let description = '';
+            switch (event.name) {
+                case 'runCell': {
+                    description = `Ran cell${cellIndex !== undefined ? ` #${cellIndex + 1}` : ''}`;
+                    break;
+                }
+                case 'runAllCells': {
+                    const count = typeof data?.cellCount === 'number'
+                        ? data.cellCount
+                        : (Array.isArray(data?.cellIds) ? data.cellIds.length : undefined);
+                    description = `Ran all cells${count !== undefined ? ` (${count})` : ''}`;
+                    break;
+                }
+                case 'runCellComplete': {
+                    const durationMs = typeof data?.durationMs === 'number' ? data.durationMs : undefined;
+                    const success = typeof data?.success === 'boolean' ? data.success : undefined;
+                    const status = success === undefined ? 'complete' : (success ? 'success' : 'failed');
+                    description = `Run complete${cellIndex !== undefined ? ` for cell #${cellIndex + 1}` : ''}${durationMs !== undefined ? ` (${durationMs}ms)` : ''} • ${status}`;
+                    break;
+                }
+                case 'interruptKernel':
+                    description = 'Kernel interrupted';
+                    break;
+                case 'restartKernel':
+                    description = 'Kernel restarted';
+                    break;
+                case 'startKernel': {
+                    const kernelName = typeof data?.kernelName === 'string' ? data.kernelName : undefined;
+                    description = `Kernel started${kernelName ? ` (${kernelName})` : ''}`;
+                    break;
+                }
+                case 'shutdownKernel':
+                    description = 'Kernel shutdown';
+                    break;
+                default:
+                    description = `Event: ${event.name}`;
+            }
+            summaries.push({
+                kind: 'event',
+                type: event.name,
+                category: event.category,
+                name: event.name,
+                cellId,
+                cellIndex,
+                timestamp,
+                description,
+                source: event.source,
+                runId: event.runId,
+                data,
+            });
+        };
+        const toEvent = (op) => {
+            if (op.type === 'event') {
+                return {
+                    category: op.category,
+                    name: op.name,
+                    target: op.target,
+                    data: op.data,
+                    runId: op.runId,
+                    source: op.source,
+                };
+            }
+            switch (op.type) {
+                case 'runCell':
+                    return {
+                        category: 'execution',
+                        name: 'runCell',
+                        target: { cellId: op.cellId, cellIndex: op.cellIndex },
+                        runId: op.runId,
+                    };
+                case 'runAllCells':
+                    return {
+                        category: 'execution',
+                        name: 'runAllCells',
+                        data: {
+                            cellCount: op.cellCount,
+                            cellIds: op.cellIds,
+                        },
+                    };
+                case 'runCellComplete':
+                    return {
+                        category: 'execution',
+                        name: 'runCellComplete',
+                        target: { cellId: op.cellId, cellIndex: op.cellIndex },
+                        data: {
+                            durationMs: op.durationMs,
+                            success: op.success,
+                            output: op.output,
+                        },
+                        runId: op.runId,
+                    };
+                case 'interruptKernel':
+                case 'restartKernel':
+                    return {
+                        category: 'kernel',
+                        name: op.type,
+                    };
+                default:
+                    return null;
+            }
+        };
+        for (const op of state.fullHistory) {
+            if (op.timestamp <= sinceTimestamp)
+                continue;
+            if (op.isUndo)
+                continue;
+            if (op.type === 'snapshot')
+                continue;
+            const event = toEvent(op);
+            if (event) {
+                describeEvent(event, op.timestamp);
+                continue;
+            }
+            let description = '';
+            let cellId;
+            let cellIndex;
+            switch (op.type) {
+                case 'insertCell':
+                    cellId = op.cell.id;
+                    cellIndex = op.index;
+                    description = `Inserted ${op.cell.type} cell at #${op.index + 1}`;
+                    break;
+                case 'deleteCell':
+                    cellId = op.cell.id;
+                    cellIndex = op.index;
+                    description = `Deleted cell #${op.index + 1}`;
+                    break;
+                case 'moveCell':
+                    if (op.toIndex >= 0 && op.toIndex < cells.length) {
+                        cellId = cells[op.toIndex].id;
+                    }
+                    description = `Moved cell from #${op.fromIndex + 1} to #${op.toIndex + 1}`;
+                    break;
+                case 'updateContent': {
+                    cellId = op.cellId;
+                    cellIndex = cells.findIndex(c => c.id === op.cellId);
+                    if (cellIndex === -1)
+                        cellIndex = undefined;
+                    const preview = op.newContent.slice(0, 50).replace(/\n/g, ' ');
+                    description = `Edited cell${cellIndex !== undefined ? ` #${cellIndex + 1}` : ''}: \"${preview}${preview.length >= 50 ? '...' : ''}\"`;
+                    break;
+                }
+                case 'updateMetadata': {
+                    cellId = op.cellId;
+                    cellIndex = cells.findIndex(c => c.id === op.cellId);
+                    if (cellIndex === -1)
+                        cellIndex = undefined;
+                    const changes = Object.keys(op.changes).join(', ');
+                    description = `Changed ${changes} on cell${cellIndex !== undefined ? ` #${cellIndex + 1}` : ''}`;
+                    break;
+                }
+                case 'batch':
+                    description = `Batch operation (${op.operations.length} changes)`;
+                    break;
+                default:
+                    description = `Operation: ${op.type}`;
+            }
+            summaries.push({
+                kind: 'edit',
+                type: op.type,
+                cellId,
+                cellIndex,
+                timestamp: op.timestamp,
+                description,
+                source: op.source,
+            });
+        }
+        return summaries;
+    }
+}
+exports.HeadlessUndoRedoManager = HeadlessUndoRedoManager;
+// Manager instances per FilesystemService to avoid cross-root leakage in tests/multi-root setups
+const managers = new WeakMap();
+function getUndoRedoManager(fsService) {
+    let manager = managers.get(fsService);
+    if (!manager) {
+        manager = new HeadlessUndoRedoManager(fsService);
+        managers.set(fsService, manager);
+    }
+    return manager;
+}

package/node-server/dist/output/display-data.d.ts

@@ -0,0 +1,14 @@
+import { JsonValue, MimeBundle, OutputType } from '../fs/types';
+export interface NormalizedDisplayOutput {
+    type: OutputType;
+    content: string;
+    mimeBundle: MimeBundle;
+    metadata?: Record<string, JsonValue>;
+    preferredMimeType: string;
+}
+export declare function stripAutoplayFromHtml(html: string): string;
+export declare function normalizeMimeValue(mimeType: string, value: unknown): JsonValue | null;
+export declare function normalizeMimeBundle(data: Record<string, unknown>): MimeBundle;
+export declare function pickPreferredMimeType(bundle: MimeBundle): string | null;
+export declare function buildDisplayOutput(data: Record<string, unknown>, metadata?: Record<string, unknown>): NormalizedDisplayOutput | null;
+export declare function convertMimeBundleToJupyter(bundle: MimeBundle): Record<string, JsonValue>;