@mseep/csv-editor 1.0.0

package/src/csv_editor/tools/auto_save_operations.py

@@ -0,0 +1,235 @@
+"""Auto-save operations for CSV sessions."""
+
+import logging
+from typing import Any
+
+from fastmcp import Context
+
+from ..models.csv_session import get_session_manager
+from ..models.data_models import OperationResult
+
+logger = logging.getLogger(__name__)
+
+
+async def configure_auto_save(
+    session_id: str,
+    enabled: bool = True,
+    mode: str = "after_operation",
+    strategy: str = "backup",
+    interval_seconds: int | None = None,
+    max_backups: int | None = None,
+    backup_dir: str | None = None,
+    custom_path: str | None = None,
+    format: str = "csv",
+    encoding: str = "utf-8",
+    ctx: Context = None,
+) -> dict[str, Any]:
+    """
+    Configure auto-save settings for a session.
+
+    Args:
+        session_id: Session identifier
+        enabled: Whether auto-save is enabled
+        mode: Auto-save mode ('disabled', 'after_operation', 'periodic', 'hybrid')
+        strategy: Save strategy ('overwrite', 'backup', 'versioned', 'custom')
+        interval_seconds: Interval for periodic saves (default 300)
+        max_backups: Maximum number of backup files to keep (default 10)
+        backup_dir: Directory for backup files
+        custom_path: Custom path for saves (when strategy='custom')
+        format: Export format ('csv', 'tsv', 'json', 'excel', 'parquet')
+        encoding: File encoding (default 'utf-8')
+        ctx: FastMCP context
+
+    Returns:
+        Dict with success status and configuration
+    """
+    try:
+        manager = get_session_manager()
+        session = manager.get_session(session_id)
+
+        if not session:
+            return OperationResult(
+                success=False,
+                message="Session not found",
+                error=f"No session with ID: {session_id}",
+            ).model_dump()
+
+        if ctx:
+            await ctx.info(f"Configuring auto-save for session {session_id}")
+
+        # Build configuration
+        config = {
+            "enabled": enabled,
+            "mode": mode,
+            "strategy": strategy,
+            "format": format,
+            "encoding": encoding,
+        }
+
+        if interval_seconds is not None:
+            config["interval_seconds"] = interval_seconds
+        if max_backups is not None:
+            config["max_backups"] = max_backups
+        if backup_dir is not None:
+            config["backup_dir"] = backup_dir
+        if custom_path is not None:
+            config["custom_path"] = custom_path
+
+        # Apply configuration
+        result = await session.enable_auto_save(config)
+
+        if result["success"]:
+            if ctx:
+                await ctx.info(f"Auto-save configured: {mode} mode, {strategy} strategy")
+
+            return OperationResult(
+                success=True,
+                message="Auto-save configured successfully",
+                session_id=session_id,
+                data=result["config"],
+            ).model_dump()
+        else:
+            return OperationResult(
+                success=False, message="Failed to configure auto-save", error=result.get("error")
+            ).model_dump()
+
+    except Exception as e:
+        logger.error(f"Error configuring auto-save: {e!s}")
+        if ctx:
+            await ctx.error(f"Failed to configure auto-save: {e!s}")
+        return OperationResult(
+            success=False, message="Failed to configure auto-save", error=str(e)
+        ).model_dump()
+
+
+async def disable_auto_save(session_id: str, ctx: Context = None) -> dict[str, Any]:
+    """
+    Disable auto-save for a session.
+
+    Args:
+        session_id: Session identifier
+        ctx: FastMCP context
+
+    Returns:
+        Dict with success status
+    """
+    try:
+        manager = get_session_manager()
+        session = manager.get_session(session_id)
+
+        if not session:
+            return OperationResult(
+                success=False,
+                message="Session not found",
+                error=f"No session with ID: {session_id}",
+            ).model_dump()
+
+        result = await session.disable_auto_save()
+
+        if result["success"]:
+            if ctx:
+                await ctx.info(f"Auto-save disabled for session {session_id}")
+
+            return OperationResult(
+                success=True, message="Auto-save disabled", session_id=session_id
+            ).model_dump()
+        else:
+            return OperationResult(
+                success=False, message="Failed to disable auto-save", error=result.get("error")
+            ).model_dump()
+
+    except Exception as e:
+        logger.error(f"Error disabling auto-save: {e!s}")
+        if ctx:
+            await ctx.error(f"Failed to disable auto-save: {e!s}")
+        return OperationResult(
+            success=False, message="Failed to disable auto-save", error=str(e)
+        ).model_dump()
+
+
+async def get_auto_save_status(session_id: str, ctx: Context = None) -> dict[str, Any]:
+    """
+    Get auto-save status for a session.
+
+    Args:
+        session_id: Session identifier
+        ctx: FastMCP context
+
+    Returns:
+        Dict with auto-save status
+    """
+    try:
+        manager = get_session_manager()
+        session = manager.get_session(session_id)
+
+        if not session:
+            return OperationResult(
+                success=False,
+                message="Session not found",
+                error=f"No session with ID: {session_id}",
+            ).model_dump()
+
+        status = session.get_auto_save_status()
+
+        if ctx:
+            await ctx.info(f"Auto-save status retrieved for session {session_id}")
+
+        return OperationResult(
+            success=True, message="Auto-save status retrieved", session_id=session_id, data=status
+        ).model_dump()
+
+    except Exception as e:
+        logger.error(f"Error getting auto-save status: {e!s}")
+        if ctx:
+            await ctx.error(f"Failed to get auto-save status: {e!s}")
+        return OperationResult(
+            success=False, message="Failed to get auto-save status", error=str(e)
+        ).model_dump()
+
+
+async def trigger_manual_save(session_id: str, ctx: Context = None) -> dict[str, Any]:
+    """
+    Manually trigger a save for a session.
+
+    Args:
+        session_id: Session identifier
+        ctx: FastMCP context
+
+    Returns:
+        Dict with save result
+    """
+    try:
+        manager = get_session_manager()
+        session = manager.get_session(session_id)
+
+        if not session:
+            return OperationResult(
+                success=False,
+                message="Session not found",
+                error=f"No session with ID: {session_id}",
+            ).model_dump()
+
+        if ctx:
+            await ctx.info(f"Triggering manual save for session {session_id}")
+
+        result = await session.manual_save()
+
+        if result["success"]:
+            if ctx:
+                await ctx.info(f"Manual save completed: {result.get('save_path')}")
+
+            return OperationResult(
+                success=True, message="Manual save completed", session_id=session_id, data=result
+            ).model_dump()
+        else:
+            return OperationResult(
+                success=False, message="Manual save failed", error=result.get("error")
+            ).model_dump()
+
+    except Exception as e:
+        logger.error(f"Error in manual save: {e!s}")
+        if ctx:
+            await ctx.error(f"Failed to trigger manual save: {e!s}")
+        return OperationResult(
+            success=False, message="Failed to trigger manual save", error=str(e)
+        ).model_dump()

package/src/csv_editor/tools/data_operations.py

@@ -0,0 +1,3 @@
+"""Data operations - imports from io_operations for compatibility."""
+
+# Re-export io_operations functions as data_operations

package/src/csv_editor/tools/history_operations.py

@@ -0,0 +1,315 @@
+"""History operations for CSV sessions."""
+
+import logging
+from typing import Any
+
+from fastmcp import Context
+
+from ..models.csv_session import get_session_manager
+from ..models.data_models import OperationResult
+
+logger = logging.getLogger(__name__)
+
+
+async def undo_operation(session_id: str, ctx: Context = None) -> dict[str, Any]:
+    """
+    Undo the last operation in a session.
+
+    Args:
+        session_id: Session identifier
+        ctx: FastMCP context
+
+    Returns:
+        Dict with success status and undo result
+    """
+    try:
+        manager = get_session_manager()
+        session = manager.get_session(session_id)
+
+        if not session:
+            return OperationResult(
+                success=False,
+                message="Session not found",
+                error=f"No session with ID: {session_id}",
+            ).model_dump()
+
+        if ctx:
+            await ctx.info(f"Undoing last operation for session {session_id}")
+
+        result = await session.undo()
+
+        if result["success"]:
+            if ctx:
+                await ctx.info(f"Successfully undid operation: {result.get('message')}")
+
+            return OperationResult(
+                success=True, message=result["message"], session_id=session_id, data=result
+            ).model_dump()
+        else:
+            return OperationResult(
+                success=False, message="Failed to undo operation", error=result.get("error")
+            ).model_dump()
+
+    except Exception as e:
+        logger.error(f"Error undoing operation: {e!s}")
+        if ctx:
+            await ctx.error(f"Failed to undo operation: {e!s}")
+        return OperationResult(
+            success=False, message="Failed to undo operation", error=str(e)
+        ).model_dump()
+
+
+async def redo_operation(session_id: str, ctx: Context = None) -> dict[str, Any]:
+    """
+    Redo a previously undone operation.
+
+    Args:
+        session_id: Session identifier
+        ctx: FastMCP context
+
+    Returns:
+        Dict with success status and redo result
+    """
+    try:
+        manager = get_session_manager()
+        session = manager.get_session(session_id)
+
+        if not session:
+            return OperationResult(
+                success=False,
+                message="Session not found",
+                error=f"No session with ID: {session_id}",
+            ).model_dump()
+
+        if ctx:
+            await ctx.info(f"Redoing operation for session {session_id}")
+
+        result = await session.redo()
+
+        if result["success"]:
+            if ctx:
+                await ctx.info(f"Successfully redid operation: {result.get('message')}")
+
+            return OperationResult(
+                success=True, message=result["message"], session_id=session_id, data=result
+            ).model_dump()
+        else:
+            return OperationResult(
+                success=False, message="Failed to redo operation", error=result.get("error")
+            ).model_dump()
+
+    except Exception as e:
+        logger.error(f"Error redoing operation: {e!s}")
+        if ctx:
+            await ctx.error(f"Failed to redo operation: {e!s}")
+        return OperationResult(
+            success=False, message="Failed to redo operation", error=str(e)
+        ).model_dump()
+
+
+async def get_operation_history(
+    session_id: str, limit: int | None = None, ctx: Context = None
+) -> dict[str, Any]:
+    """
+    Get operation history for a session.
+
+    Args:
+        session_id: Session identifier
+        limit: Maximum number of operations to return
+        ctx: FastMCP context
+
+    Returns:
+        Dict with history and statistics
+    """
+    try:
+        manager = get_session_manager()
+        session = manager.get_session(session_id)
+
+        if not session:
+            return OperationResult(
+                success=False,
+                message="Session not found",
+                error=f"No session with ID: {session_id}",
+            ).model_dump()
+
+        if ctx:
+            await ctx.info(f"Getting operation history for session {session_id}")
+
+        result = session.get_history(limit)
+
+        if result["success"]:
+            return OperationResult(
+                success=True,
+                message="History retrieved successfully",
+                session_id=session_id,
+                data=result,
+            ).model_dump()
+        else:
+            return OperationResult(
+                success=False, message="Failed to get history", error=result.get("error")
+            ).model_dump()
+
+    except Exception as e:
+        logger.error(f"Error getting history: {e!s}")
+        if ctx:
+            await ctx.error(f"Failed to get history: {e!s}")
+        return OperationResult(
+            success=False, message="Failed to get history", error=str(e)
+        ).model_dump()
+
+
+async def restore_to_operation(
+    session_id: str, operation_id: str, ctx: Context = None
+) -> dict[str, Any]:
+    """
+    Restore session data to a specific operation point.
+
+    Args:
+        session_id: Session identifier
+        operation_id: Operation ID to restore to
+        ctx: FastMCP context
+
+    Returns:
+        Dict with success status and restore result
+    """
+    try:
+        manager = get_session_manager()
+        session = manager.get_session(session_id)
+
+        if not session:
+            return OperationResult(
+                success=False,
+                message="Session not found",
+                error=f"No session with ID: {session_id}",
+            ).model_dump()
+
+        if ctx:
+            await ctx.info(f"Restoring session {session_id} to operation {operation_id}")
+
+        result = await session.restore_to_operation(operation_id)
+
+        if result["success"]:
+            if ctx:
+                await ctx.info(f"Successfully restored to operation {operation_id}")
+
+            return OperationResult(
+                success=True, message=result["message"], session_id=session_id, data=result
+            ).model_dump()
+        else:
+            return OperationResult(
+                success=False, message="Failed to restore to operation", error=result.get("error")
+            ).model_dump()
+
+    except Exception as e:
+        logger.error(f"Error restoring to operation: {e!s}")
+        if ctx:
+            await ctx.error(f"Failed to restore to operation: {e!s}")
+        return OperationResult(
+            success=False, message="Failed to restore to operation", error=str(e)
+        ).model_dump()
+
+
+async def clear_history(session_id: str, ctx: Context = None) -> dict[str, Any]:
+    """
+    Clear all operation history for a session.
+
+    Args:
+        session_id: Session identifier
+        ctx: FastMCP context
+
+    Returns:
+        Dict with success status
+    """
+    try:
+        manager = get_session_manager()
+        session = manager.get_session(session_id)
+
+        if not session:
+            return OperationResult(
+                success=False,
+                message="Session not found",
+                error=f"No session with ID: {session_id}",
+            ).model_dump()
+
+        if not session.history_manager:
+            return OperationResult(
+                success=False,
+                message="History is not enabled for this session",
+                error="History management is disabled",
+            ).model_dump()
+
+        if ctx:
+            await ctx.info(f"Clearing history for session {session_id}")
+
+        session.history_manager.clear_history()
+
+        return OperationResult(
+            success=True, message="History cleared successfully", session_id=session_id
+        ).model_dump()
+
+    except Exception as e:
+        logger.error(f"Error clearing history: {e!s}")
+        if ctx:
+            await ctx.error(f"Failed to clear history: {e!s}")
+        return OperationResult(
+            success=False, message="Failed to clear history", error=str(e)
+        ).model_dump()
+
+
+async def export_history(
+    session_id: str, file_path: str, format: str = "json", ctx: Context = None
+) -> dict[str, Any]:
+    """
+    Export operation history to a file.
+
+    Args:
+        session_id: Session identifier
+        file_path: Path to export history to
+        format: Export format ('json' or 'csv')
+        ctx: FastMCP context
+
+    Returns:
+        Dict with success status
+    """
+    try:
+        manager = get_session_manager()
+        session = manager.get_session(session_id)
+
+        if not session:
+            return OperationResult(
+                success=False,
+                message="Session not found",
+                error=f"No session with ID: {session_id}",
+            ).model_dump()
+
+        if not session.history_manager:
+            return OperationResult(
+                success=False,
+                message="History is not enabled for this session",
+                error="History management is disabled",
+            ).model_dump()
+
+        if ctx:
+            await ctx.info(f"Exporting history for session {session_id} to {file_path}")
+
+        success = session.history_manager.export_history(file_path, format)
+
+        if success:
+            return OperationResult(
+                success=True,
+                message=f"History exported to {file_path}",
+                session_id=session_id,
+                data={"file_path": file_path, "format": format},
+            ).model_dump()
+        else:
+            return OperationResult(
+                success=False, message="Failed to export history", error="Export operation failed"
+            ).model_dump()
+
+    except Exception as e:
+        logger.error(f"Error exporting history: {e!s}")
+        if ctx:
+            await ctx.error(f"Failed to export history: {e!s}")
+        return OperationResult(
+            success=False, message="Failed to export history", error=str(e)
+        ).model_dump()