added sentry_logged_errors_fix skill

Author: teg-atlassian

.env.example

@@ -29,4 +29,12 @@ ATLASCODE_EXP_OVERRIDES_STRING="exp3_name=something, exp4_name=something else"
 SENTRY_ENABLED=false
 SENTRY_DSN=https://9cd7b899fbe34098d8742b4d5735f44c@o55978.ingest.us.sentry.io/4510634894688256
 SENTRY_ENVIRONMENT=production
-SENTRY_SAMPLE_RATE=1.0
+SENTRY_SAMPLE_RATE=1.0
+
+#
+# Sentry API Configuration for Error Fixing Workflow
+# Get API token from: https://sentry.io/settings/account/api/auth-tokens/
+#
+SENTRY_API_TOKEN=YOUR_SENTRY_API_TOKEN_HERE
+SENTRY_ORG=atlassian-2y
+SENTRY_PROJECT=atlascode-vscode

.rovodev/prompts.yml

@@ -5,3 +5,6 @@ prompts:
   - name: error-handling
     description: Error handling and logging guidelines
     content_file: error-handling.md
+  - name: sentry-logged-errors-fix
+    description: Retrieve errors from Sentry, analyze root causes, fix code, and create PRs
+    content_file: sentry_logged_errors_fix.md

.rovodev/sentry_logged_errors_fix.md

@@ -0,0 +1,296 @@
+# Sentry Logged Errors Fix Skill
+
+This skill provides a systematic workflow for retrieving errors from Sentry, analyzing root causes, fixing code issues, and creating pull requests.
+
+## Prerequisites
+
+- **SENTRY_API_TOKEN**: Add to `.env` file (get from Sentry → Settings → API → Auth Tokens)
+- **SENTRY_ORG**: Your Sentry organization slug
+- **SENTRY_PROJECT**: Your Sentry project slug
+- **Dependencies**: Load `error-handling.md` skill before using this skill
+
+## Workflow
+
+### 1. Configure Environment
+
+Add to your `.env` file:
+```bash
+SENTRY_API_TOKEN=your_token_here
+SENTRY_ORG=your_org_slug
+SENTRY_PROJECT=your_project_slug
+```
+
+### 2. Retrieve Recent Errors from Sentry
+
+Use Sentry API to fetch errors from the last 24 hours, sorted by frequency:
+
+```
+GET https://sentry.io/api/0/projects/{SENTRY_ORG}/{SENTRY_PROJECT}/issues/
+  ?statsPeriod=24h
+  &sort=freq
+  &limit=50
+```
+
+Headers:
+```
+Authorization: Bearer {SENTRY_API_TOKEN}
+```
+
+**Key fields to extract:**
+- `id` - Issue ID
+- `title` - Error title/message
+- `culprit` - Function/method where error occurred
+- `metadata.value` - Error details
+- `count` - Frequency (for prioritization)
+- `level` - Severity (error, warning, etc.)
+- `lastSeen` - Most recent occurrence
+
+### 3. Get Error Details and Stack Trace
+
+For each error to fix, retrieve detailed information:
+
+```
+GET https://sentry.io/api/0/issues/{ISSUE_ID}/events/latest/
+```
+
+**Extract:**
+- Full stack trace with file paths and line numbers
+- Error context (variables, state)
+- Breadcrumbs (user actions leading to error)
+- Tags (environment, release, user info)
+
+### 4. Analyze Root Cause
+
+For each error:
+
+1. **Locate the problematic code** using stack trace file paths and line numbers
+2. **Examine error context** to understand the failure scenario
+3. **Check related code** for similar patterns that might have the same issue
+4. **Identify the root cause**:
+   - Missing null/undefined checks
+   - Unhandled promise rejections
+   - Missing error handling in async operations
+   - Type mismatches
+   - Race conditions
+   - Missing retry logic for network calls
+
+### 5. Fix Code Following Error Handling Guidelines
+
+Apply fixes based on the `error-handling.md` skill:
+
+#### Check Severity Level
+- **ERROR level**: Unexpected system failures, critical issues
+- **WARN level**: User-related errors (401, 403, 4xx status codes)
+- **DEBUG level**: Expected errors, informational only
+
+#### Implement Fix with Proper Logging
+```typescript
+try {
+    // operation
+} catch (error) {
+    // Choose appropriate level based on error type
+    if (isUserError(error)) {
+        logger.warn('User operation failed', error);
+    } else {
+        logger.error('System operation failed', error);
+    }
+    
+    // Ensure dual logging to Sentry AND Amplitude
+    sentryClient.captureException(error);
+    amplitudeClient.logEvent('error_occurred', { error: error.message });
+}
+```
+
+#### Handle Retry Loops Correctly
+```typescript
+let lastError;
+for (let attempt = 0; attempt < maxRetries; attempt++) {
+    try {
+        return await operation();
+    } catch (error) {
+        lastError = error;
+        // Only log on final failure
+        if (attempt === maxRetries - 1) {
+            logger.error('Operation failed after retries', error);
+            sentryClient.captureException(error);
+            amplitudeClient.logEvent('retry_exhausted', { attempts: maxRetries });
+        }
+    }
+}
+```
+
+#### Avoid Duplicate Logging
+- Log each error only once at the appropriate level
+- If re-throwing, don't log again at higher levels
+- Check if error has already been logged
+
+### 6. Create Branch and Commit Fix
+
+Use GitHub MCP tools:
+
+```typescript
+// 1. Create a branch
+create_branch({
+    owner: "repo-owner",
+    repo: "repo-name",
+    branch: "fix/sentry-{ISSUE_ID}-{short-description}",
+    from_branch: "main"
+})
+
+// 2. Commit the fix
+push_files({
+    owner: "repo-owner",
+    repo: "repo-name",
+    branch: "fix/sentry-{ISSUE_ID}-{short-description}",
+    files: [
+        {
+            path: "path/to/fixed/file.ts",
+            content: "fixed-file-content"
+        }
+    ],
+    message: "fix: resolve {error-title} (Sentry #{ISSUE_ID})\n\nFixes error occurring {count} times in last 24h.\n\nRoot cause: {description}\nSolution: {solution-description}"
+})
+```
+
+### 7. Validate Fix
+
+Before creating PR:
+
+1. **Run relevant tests**:
+   ```bash
+   npm test -- path/to/fixed/file.test.ts
+   ```
+
+2. **Run linting**:
+   ```bash
+   npm run lint:fix
+   ```
+
+3. **Verify the fix addresses the root cause**, not just symptoms
+
+### 8. Create Pull Request
+
+```typescript
+create_pull_request({
+    owner: "repo-owner",
+    repo: "repo-name",
+    title: "fix: resolve {error-title} (Sentry #{ISSUE_ID})",
+    body: `## Problem
+Error occurring ${count} times in last 24 hours.
+
+**Sentry Issue**: https://sentry.io/organizations/{org}/issues/{ISSUE_ID}/
+
+**Error**: ${error_message}
+
+**Root Cause**: ${root_cause_description}
+
+## Solution
+${solution_description}
+
+## Testing
+- [ ] Unit tests pass
+- [ ] Linting passes
+- [ ] Manual testing completed
+- [ ] Follows error-handling.md guidelines
+
+## Checklist
+- [ ] Appropriate severity level (ERROR/WARN/DEBUG)
+- [ ] Dual logging to Sentry and Amplitude
+- [ ] No duplicate logging
+- [ ] Retry logic handles errors correctly (if applicable)
+`,
+    head: "fix/sentry-{ISSUE_ID}-{short-description}",
+    base: "main",
+    draft: false
+})
+```
+
+## Prioritization Strategy
+
+Process errors in this order:
+1. **Highest frequency first** (most impactful)
+2. Within same frequency, prioritize by severity
+3. Group similar errors and fix together when possible
+
+## Batch Processing Tips
+
+For efficiency when fixing multiple errors:
+
+1. **Group by root cause** - Multiple errors might stem from same issue
+2. **Fix similar patterns** - If one file has an issue, check others with same pattern
+3. **Create one PR per logical fix** - Don't combine unrelated fixes
+4. **Limit to 5-10 errors per session** - Avoid overwhelming reviewers
+
+## Error Fix Checklist
+
+Before submitting each PR:
+- [ ] Root cause identified and addressed
+- [ ] Fix follows `error-handling.md` guidelines
+- [ ] Appropriate severity level used
+- [ ] Dual logging (Sentry + Amplitude) implemented
+- [ ] No duplicate logging
+- [ ] Retry logic correct (if applicable)
+- [ ] Tests pass
+- [ ] Linting passes
+- [ ] PR description links to Sentry issue
+- [ ] PR includes before/after context
+
+## Common Error Patterns and Fixes
+
+### Pattern 1: Unhandled Promise Rejections
+```typescript
+// Before (error prone)
+async function fetchData() {
+    const data = await apiCall(); // Can throw
+    return data;
+}
+
+// After (proper error handling)
+async function fetchData() {
+    try {
+        const data = await apiCall();
+        return data;
+    } catch (error) {
+        logger.error('Failed to fetch data', error);
+        throw error; // Re-throw if caller should handle
+    }
+}
+```
+
+### Pattern 2: Missing Null Checks
+```typescript
+// Before
+const userName = user.profile.name; // user or profile might be null
+
+// After
+const userName = user?.profile?.name ?? 'Unknown';
+```
+
+### Pattern 3: Network Errors Without Retry
+```typescript
+// Before
+const response = await fetch(url);
+
+// After (with retry)
+let lastError;
+for (let attempt = 0; attempt < 3; attempt++) {
+    try {
+        const response = await fetch(url);
+        return response;
+    } catch (error) {
+        lastError = error;
+        if (attempt === 2) {
+            logger.error('Fetch failed after retries', error);
+        }
+        await sleep(1000 * (attempt + 1)); // Exponential backoff
+    }
+}
+throw lastError;
+```
+
+## Notes
+
+- Always load the `error-handling.md` skill before starting fixes
+- Update `.env.example` if adding new Sentry configuration variables
+- Link Sentry issues in commit messages and PR descriptions
+- Consider resolving the Sentry issue after PR is merged