Feature: Integrate Sentry for comprehensive error reporting and monitoring

## Feature Request

Integrate Sentry for real-time error tracking, performance monitoring, and crash reporting in the Electron application.

## Description

Sentry provides comprehensive error monitoring that will help identify, track, and resolve issues in production, improving app stability and user experience.

## Why Sentry?

### Key Benefits
- Real-time error tracking and alerts
- Detailed stack traces with source maps
- User context and breadcrumbs
- Performance monitoring
- Release tracking and regression detection
- Error grouping and deduplication
- Integration with GitHub for issue tracking
- Support for both main and renderer processes

## Implementation Requirements

### Core Integration
- Install @sentry/electron package
- Configure for both main and renderer processes
- Set up source map uploading
- Environment configuration (dev/staging/prod)
- User privacy controls (PII scrubbing)
- Error sampling rates

### Error Capture Features
```javascript
// Main process
Sentry.init({
dsn: process.env.SENTRY_DSN,
environment: process.env.NODE_ENV,
integrations: [
new Sentry.Integrations.MainProcessSession(),
new Sentry.Integrations.ElectronMinidump(),
new Sentry.Integrations.PreloadInjection(),
new Sentry.Integrations.AdditionalContext(),
],
beforeSend: (event) => {
// Scrub sensitive data
return event;
},
sampleRate: 1.0,
tracesSampleRate: 0.1,
});

// Renderer process
Sentry.init({
dsn: process.env.SENTRY_DSN,
integrations: [
new Sentry.Integrations.Breadcrumbs(),
new Sentry.Integrations.GlobalHandlers(),
],
});
```

### Error Context Enrichment
- User identification (anonymized)
- App version and release info
- OS and hardware information
- Network status
- Memory usage
- Custom tags and metadata
- User actions breadcrumbs
- Console logs capture

### Performance Monitoring
- Transaction tracking
- API call performance
- Renderer process metrics
- Memory leak detection
- Slow operation alerts
- Custom performance metrics

### Crash Reporting
- Native crash handling
- Minidump processing
- Automatic crash report submission
- Crash-free rate tracking
- Crash grouping by version

### Privacy & Compliance
- GDPR compliance settings
- PII data scrubbing rules
- User consent management
- Data retention policies
- IP anonymization
- Opt-out mechanism

### CI/CD Integration
- Automatic release creation
- Source map upload on build
- Deploy tracking
- GitHub commit association
- Release health monitoring

### Alert Configuration
- Error rate thresholds
- New error type alerts
- Regression notifications
- Performance degradation alerts
- Crash spike detection
- Custom alert rules

## Development Workflow

### Local Development
- Sentry tunnel for local testing
- Debug mode configuration
- Mock error generation
- Performance profiling tools

### Staging Environment
- Separate Sentry project
- Lower sampling rates
- Test error scenarios
- Performance benchmarking

### Production Monitoring
- Full error capture
- Release tracking
- User feedback collection
- Issue prioritization

## Dashboard & Reporting

- Error trends and patterns
- Release adoption and health
- Performance metrics
- User impact analysis
- Custom dashboards
- Weekly error reports

## Error Handling Best Practices

```javascript
// Structured error handling
try {
await riskyOperation();
} catch (error) {
Sentry.captureException(error, {
tags: {
section: 'data-processing',
action: 'file-upload'
},
contexts: {
userData: {
plan: user.plan,
feature_flags: user.features
}
},
level: 'error'
});

// Still handle error gracefully for user
showUserFriendlyError();
}

// Custom error boundaries
class ErrorBoundary extends React.Component {
componentDidCatch(error, errorInfo) {
Sentry.withScope((scope) => {
scope.setExtras(errorInfo);
Sentry.captureException(error);
});
}
}
```

## Cost Considerations

- Free tier: 5K errors/month
- Team plan: $26/month for 50K errors
- Custom volume discounts available
- Performance monitoring add-on
- Data retention options

## Acceptance Criteria

- [ ] Sentry SDK integrated in main and renderer processes
- [ ] Source maps uploaded automatically on build
- [ ] Errors are captured with full context
- [ ] Performance monitoring is functional
- [ ] Crash reports are collected
- [ ] Privacy settings implemented
- [ ] User opt-out mechanism available
- [ ] Alerts configured for critical errors
- [ ] Dashboard shows meaningful metrics
- [ ] Documentation for error handling patterns
- [ ] GitHub integration configured
- [ ] Release tracking works
- [ ] No performance degradation from SDK

## Resources

- [Sentry Electron Documentation](https://docs.sentry.io/platforms/javascript/guides/electron/)
- [Best Practices](https://docs.sentry.io/product/best-practices/)
- [Privacy & Legal](https://sentry.io/legal/privacy/)

🤖 Generated with [Claude Code](https://claude.ai/code)

The issue names no files, tests, or concrete entry points. Start by locating the Electron main and renderer entry points and the build configuration, then scope the SDK, privacy, release, and CI/CD requirements against the acceptance criteria; done requires all listed monitoring, crash reporting, privacy, alerting, documentation, and release-tracking checks to work.

Written by the indexing model from the issue text.