CSV Editor

Instructions

Implementation Reference

• src/csv_editor/tools/auto_save_operations.py:14-106 (handler)

  The core implementation of the configure_auto_save tool handler. This function configures auto-save settings for a CSV session by building a config dict and calling session.enable_auto_save().

  async def configure_auto_save(
      session_id: str,
      enabled: bool = True,
      mode: str = "after_operation",
      strategy: str = "backup",
      interval_seconds: Optional[int] = None,
      max_backups: Optional[int] = None,
      backup_dir: Optional[str] = None,
      custom_path: Optional[str] = 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=f"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: {str(e)}")
          if ctx:
              await ctx.error(f"Failed to configure auto-save: {str(e)}")
          return OperationResult(
              success=False,
              message="Failed to configure auto-save",
              error=str(e)
          ).model_dump()

• src/csv_editor/server.py:435-460 (registration)

  Tool registration for configure_auto_save using @mcp.tool decorator in the main server.py file. Imports the handler from auto_save_operations.py and provides a thin wrapper.

  from .tools.auto_save_operations import (
      configure_auto_save as _configure_auto_save,
      disable_auto_save as _disable_auto_save,
      get_auto_save_status as _get_auto_save_status,
      trigger_manual_save as _trigger_manual_save
  )
  
  @mcp.tool
  async def configure_auto_save(
      session_id: str,
      enabled: bool = True,
      mode: str = "after_operation",
      strategy: str = "backup",
      interval_seconds: Optional[int] = None,
      max_backups: Optional[int] = None,
      backup_dir: Optional[str] = None,
      custom_path: Optional[str] = None,
      format: str = "csv",
      encoding: str = "utf-8",
      ctx: Context = None
  ) -> Dict[str, Any]:
      """Configure auto-save settings for a session."""
      return await _configure_auto_save(
          session_id, enabled, mode, strategy, interval_seconds,
          max_backups, backup_dir, custom_path, format, encoding, ctx
      )