The API should allow the switch of the debugger options.

### Description
The API should provide an endpoint that allows users to switch debugger options dynamically. This would enable users to turn debugging features on or off and modify debugger settings without restarting or reconfiguring the entire system.

### Rationale
1. **Dynamic Debugging**: Allowing the switch of debugger options through an API will enable developers to toggle debugging modes based on real-time needs, improving flexibility during development and troubleshooting.
2. **Efficiency**: Developers can adjust debugging settings without stopping the application, reducing downtime and maintaining system performance during issue resolution.
3. **Automation**: Integrating this capability into CI/CD pipelines or monitoring tools would allow automated switching of debug modes in response to specific events or triggers, ensuring faster issue identification and resolution.
4. **Customizability**: Different debugging levels can be applied depending on the environment or situation, ensuring the right level of information is captured when necessary.

### Expected Behavior
1. A new endpoint, such as `/debugger-options`, allows the user to:
- Enable or disable the debugger.
- Update specific debugger settings, but name.
2. The endpoint should allow both GET (to retrieve current debugger settings) and POST/PUT (to update debugger options).

### API Example

#### Retrieve Current Debugger Settings
```http
GET /debugger-options
```

#### Sample Response
```json
{
"all": true,
"repositories": false,
"issues": false,
"pushes": false
}
```

#### Update Debugger Settings
```http
PUT /debugger-options/all
Content-Type: application/json

{
"setting": false
}
```

### Sample Response
```json
{
"status": "success",
"message": "Debugger options updated successfully"
}
```

### Additional Notes
- The endpoint should validate input values (e.g., only accept predefined debug options).
- Include safeguards to prevent accidental disabling of critical debugging features.
- Consider adding environment-specific restrictions (e.g., disabling certain debugging modes in production environments).
- Optionally include support for different debugger types if the system allows multiple debugging mechanisms (e.g., logging-based, breakpoints, etc.).