Feature: Show Impact Analysis of PR Changes on Codebase Dependencies

## Feature Request: Code Impact Analysis for Pull Requests

### Problem Statement
When reviewing pull requests, it's difficult to understand the full impact of changes beyond the modified files. Changes to exported functions, interfaces, types, or components can have ripple effects throughout the codebase that aren't immediately visible in the PR diff.

### Proposed Solution
Implement an impact analysis feature that automatically identifies and displays:
- **Affected Files**: Which files import/use the changed exports
- **Dependency Graph**: Visual representation of how changes propagate
- **Breaking Changes**: Highlight potentially breaking modifications
- **Usage Context**: Show how the changed code is being used in dependent files

### Core Features
1. **Automatic Dependency Detection**
- Track exports modified in the PR (functions, classes, types, constants)
- Identify all files that import these exports
- Show transitive dependencies (files affected indirectly)

2. **Impact Visualization**
- Dependency tree showing affected files
- Inline annotations in PR view
- "Ripple effect" indicator showing impact severity
- Color-coded impact levels (direct, indirect, potential breaking)

3. **Smart Analysis**
- Detect signature changes in functions/methods
- Identify type/interface modifications
- Track renamed exports and their consumers
- Highlight removed exports that are still in use

### Use Cases
1. **API Changes**: Understanding which consumers are affected by API modifications
2. **Refactoring**: Ensuring all dependent code is updated when refactoring shared utilities
3. **Breaking Changes**: Quickly identify potential breaking changes before merge
4. **Code Review**: Reviewers can see the full context of changes
5. **Testing Scope**: Determine which test files might need updates

### Implementation Details
- **Static Analysis**: Use AST parsing to track imports/exports
- **Language Support**: Start with TypeScript/JavaScript, expand to other languages
- **Performance**: Incremental analysis with caching for large codebases
- **Integration**: Seamless integration with existing PR tree view

### UI/UX Suggestions
- Collapsible "Impact Analysis" section in PR view
- Badge indicators on changed files showing number of dependents
- Side panel showing affected files with preview of usage
- Filter options (direct/indirect impacts, by file type, by severity)
- "Jump to usage" navigation from changed code to dependent files

### Example Scenarios
```typescript
// If utils/api.ts changes this export:
export function fetchUser(id: string) { ... }
// ↓ becomes ↓
export function fetchUser(id: number) { ... }

// The feature would show:
// ⚠️ Breaking change affects 12 files:
// - components/UserProfile.tsx (line 23)
// - pages/Dashboard.tsx (line 45)
// - tests/api.test.ts (line 67)
// ... and 9 more
```

### Benefits
- **Prevent Bugs**: Catch breaking changes before they reach production
- **Faster Reviews**: Reviewers understand change impact immediately
- **Better Testing**: Know exactly what needs to be tested
- **Confident Refactoring**: Make large-scale changes with confidence
- **Documentation**: Automatic documentation of code dependencies

### Additional Features (Future)
- Runtime impact analysis (performance implications)
- Suggest automated fixes for simple breaking changes
- Integration with test coverage to show untested impacts
- Historical impact data (which changes frequently cause issues)
- Cross-repository impact analysis for monorepos

### Technical Considerations
- Support for various module systems (ES6, CommonJS, etc.)
- Handle dynamic imports and conditional exports
- Work with different build tools and configurations
- Respect .gitignore and other exclusion patterns

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

No repository files, tests, or entry points are identified. Start by locating the existing PR tree view and determining how TypeScript/JavaScript AST analysis could integrate with it. Done should include affected-file detection, dependency visualization, breaking-change identification, and usage context.

Written by the indexing model from the issue text.