feat: add parameter presets system for quick workflow configuration

Adds a new presets feature that allows users to quickly apply optimized
parameter configurations with a single click. Key changes:

- ParameterManager: Added load_presets(), get_preset_names(),
  get_preset_description(), and apply_preset() methods
- StreamlitUI: Added preset_buttons() method that renders a grid of
  preset buttons with tooltips
- parameter_section() now displays preset buttons when available
- Created presets.json with example presets for the TOPP workflow
  (High Sensitivity, High Specificity, Fast Analysis, Metabolomics Default)

The feature is opt-in and backward compatible: workflows without a
presets.json file will not show any preset buttons.

https://claude.ai/code/session_01BnipAqTf16J7kJVfnzah2U

Author: claude

presets.json

@@ -0,0 +1,45 @@
+{
+    "topp-workflow": {
+        "High Sensitivity": {
+            "_description": "Optimized for detecting low-abundance features with higher noise tolerance",
+            "FeatureFinderMetabo": {
+                "algorithm:common:noise_threshold_int": 500.0,
+                "algorithm:common:chrom_peak_snr": 2.0,
+                "algorithm:mtd:mass_error_ppm": 15.0
+            }
+        },
+        "High Specificity": {
+            "_description": "Strict parameters for high-confidence feature detection",
+            "FeatureFinderMetabo": {
+                "algorithm:common:noise_threshold_int": 5000.0,
+                "algorithm:common:chrom_peak_snr": 5.0,
+                "algorithm:mtd:mass_error_ppm": 5.0
+            }
+        },
+        "Fast Analysis": {
+            "_description": "Faster processing with relaxed parameters for quick exploration",
+            "FeatureFinderMetabo": {
+                "algorithm:common:noise_threshold_int": 2000.0,
+                "algorithm:ffm:isotope_filtering_model": "none"
+            },
+            "FeatureLinkerUnlabeledKD": {
+                "algorithm:link:rt_tol": 60.0,
+                "algorithm:link:mz_tol": 15.0
+            }
+        },
+        "Metabolomics Default": {
+            "_description": "Balanced parameters for general metabolomics analysis",
+            "FeatureFinderMetabo": {
+                "algorithm:common:noise_threshold_int": 1000.0,
+                "algorithm:common:chrom_peak_snr": 3.0,
+                "algorithm:mtd:mass_error_ppm": 10.0,
+                "algorithm:ffm:charge_lower_bound": 1,
+                "algorithm:ffm:charge_upper_bound": 3
+            },
+            "FeatureLinkerUnlabeledKD": {
+                "algorithm:link:rt_tol": 30.0,
+                "algorithm:link:mz_tol": 10.0
+            }
+        }
+    }
+}

src/workflow/ParameterManager.py

@@ -167,4 +167,98 @@ def reset_to_default_parameters(self) -> None:
         JSON file.
         """
         # Delete custom params json file
-        self.params_file.unlink(missing_ok=True)
+        self.params_file.unlink(missing_ok=True)
+
+    def load_presets(self) -> dict:
+        """
+        Load preset definitions from presets.json file.
+
+        Returns:
+            dict: Dictionary of presets for the current workflow, or empty dict if
+                  presets.json doesn't exist or has no presets for this workflow.
+        """
+        presets_file = Path("presets.json")
+        if not presets_file.exists():
+            return {}
+
+        try:
+            with open(presets_file, "r", encoding="utf-8") as f:
+                all_presets = json.load(f)
+        except (json.JSONDecodeError, IOError):
+            return {}
+
+        # Get workflow name from the workflow directory stem
+        workflow_name = self.ini_dir.parent.stem
+        return all_presets.get(workflow_name, {})
+
+    def get_preset_names(self) -> list:
+        """
+        Get list of available preset names for the current workflow.
+
+        Returns:
+            list: List of preset names (strings), excluding special keys like _description.
+        """
+        presets = self.load_presets()
+        return [name for name in presets.keys() if not name.startswith("_")]
+
+    def get_preset_description(self, preset_name: str) -> str:
+        """
+        Get the description for a specific preset.
+
+        Args:
+            preset_name: Name of the preset
+
+        Returns:
+            str: Description text for the preset, or empty string if not found.
+        """
+        presets = self.load_presets()
+        preset = presets.get(preset_name, {})
+        return preset.get("_description", "")
+
+    def apply_preset(self, preset_name: str) -> bool:
+        """
+        Apply a preset to the current session state and save to params.json.
+
+        This method updates session state keys for both TOPP tool parameters and
+        general workflow parameters based on the preset definition.
+
+        Args:
+            preset_name: Name of the preset to apply
+
+        Returns:
+            bool: True if preset was applied successfully, False otherwise.
+        """
+        presets = self.load_presets()
+        preset = presets.get(preset_name)
+        if not preset:
+            return False
+
+        # Load existing parameters
+        current_params = self.get_parameters_from_json()
+
+        for key, value in preset.items():
+            # Skip description key
+            if key == "_description":
+                continue
+
+            if key == "_general":
+                # Handle general workflow parameters
+                for param_name, param_value in value.items():
+                    session_key = f"{self.param_prefix}{param_name}"
+                    st.session_state[session_key] = param_value
+                    current_params[param_name] = param_value
+            elif isinstance(value, dict) and not key.startswith("_"):
+                # Handle TOPP tool parameters
+                tool_name = key
+                if tool_name not in current_params:
+                    current_params[tool_name] = {}
+                for param_name, param_value in value.items():
+                    session_key = f"{self.topp_param_prefix}{tool_name}:1:{param_name}"
+                    st.session_state[session_key] = param_value
+                    current_params[tool_name][param_name] = param_value
+
+        # Save updated parameters
+        with open(self.params_file, "w", encoding="utf-8") as f:
+            json.dump(current_params, f, indent=4)
+
+        return True

src/workflow/StreamlitUI.py

@@ -1061,6 +1061,45 @@ def zip_and_download_files(self, directory: str):
             use_container_width=True,
         )
 
+    def preset_buttons(self, num_cols: int = 4) -> None:
+        """
+        Renders a grid of preset buttons for the current workflow.
+
+        When a preset button is clicked, the preset parameters are applied to the
+        session state and saved to params.json, then the page is reloaded.
+
+        Args:
+            num_cols: Number of columns for the button grid. Defaults to 4.
+        """
+        preset_names = self.parameter_manager.get_preset_names()
+        if not preset_names:
+            return
+
+        st.markdown("---")
+        st.markdown("**Parameter Presets**")
+        st.caption("Click a preset to apply optimized parameters")
+
+        # Create button grid
+        cols = st.columns(num_cols)
+        for i, preset_name in enumerate(preset_names):
+            col_idx = i % num_cols
+            description = self.parameter_manager.get_preset_description(preset_name)
+            with cols[col_idx]:
+                if st.button(
+                    preset_name,
+                    key=f"preset_{preset_name}",
+                    help=description if description else None,
+                    use_container_width=True,
+                ):
+                    if self.parameter_manager.apply_preset(preset_name):
+                        st.success(f"Applied preset: {preset_name}")
+                        streamlit_js_eval(js_expressions="parent.window.location.reload()")
+                    else:
+                        st.error(f"Failed to apply preset: {preset_name}")
+            # Start new row if needed
+            if col_idx == num_cols - 1 and i < len(preset_names) - 1:
+                cols = st.columns(num_cols)
+
     def file_upload_section(self, custom_upload_function) -> None:
         custom_upload_function()
         c1, _ = st.columns(2)
@@ -1070,6 +1109,9 @@ def file_upload_section(self, custom_upload_function) -> None:
     def parameter_section(self, custom_parameter_function) -> None:
         st.toggle("Show advanced parameters", value=False, key="advanced")
 
+        # Display preset buttons if presets are available for this workflow
+        self.preset_buttons()
+
         custom_parameter_function()
 
         # File Import / Export section