codeimpact 0.1.0

package/doc/ENTERPRISE-PLAN.md

@@ -0,0 +1,1282 @@
+# Code Impact Pro - Enterprise Product Plan
+
+## Executive Summary
+
+**Product:** Code Impact Pro - AI Code Intelligence Platform for Enterprise Teams
+
+**Core Value Proposition:** Reduce AI coding costs by 70% while improving code quality through intelligent context delivery, test impact analysis, and dependency-aware workflows.
+
+**Target Market:** Enterprise engineering teams (50-5000+ developers) spending $100K-$2M+ annually on AI coding tools.
+
+---
+
+## Market Validation: Will This Make Money?
+
+### The Problem is Real
+
+| Problem | Evidence | Source |
+|---------|----------|--------|
+| AI tools are expensive | Enterprises spend $100K-$2M+/year on AI coding tools | Jellyfish, 2025 |
+| AI code has quality issues | 50% of AI-generated code has potential security bugs | DevOps.com |
+| AI doesn't save time without process change | Developers using AI in unchanged workflows are SLOWER | VentureBeat |
+| Context is the bottleneck | AI assistants lack codebase understanding, ask redundant questions | Industry consensus |
+| Test suites are slow | Full CI runs take 30-60 mins when 5 mins would suffice | Common enterprise pain |
+
+### Competitive Landscape
+
+| Competitor | What They Do | Gap We Fill |
+|------------|--------------|-------------|
+| GitHub Copilot | Code completion | No codebase memory, no impact analysis |
+| Sourcegraph Cody | Code search + AI | Expensive ($49/user), no test impact |
+| Tabnine | Code completion | No architectural awareness |
+| CodeScene | Technical debt analysis | No AI integration, no real-time |
+| NDepend/.NET tools | Static analysis | Single language, no AI workflow |
+
+**Our Unique Position:** We're not another AI coding assistant. We make EXISTING AI tools (Copilot, Claude, Cursor) smarter and cheaper by providing intelligent context.
+
+---
+
+## 🚨 NEW: Problems Created by AI Coding Tools
+
+AI coding assistants (Copilot, Claude, Cursor) have created NEW problems that didn't exist before. **We solve them.**
+
+### The 10 AI-Induced Problems
+
+| # | Problem | What Happens | Impact |
+|---|---------|--------------|--------|
+| 1 | **Hallucination** | AI invents functions/imports that don't exist | Broken code, wasted debugging time |
+| 2 | **Duplicate Code** | AI writes new code when identical code exists | Bloated codebase, maintenance hell |
+| 3 | **Breaking Changes** | AI modifies code without knowing dependencies | Production incidents |
+| 4 | **Ignores Patterns** | AI doesn't follow your team's coding standards | Inconsistent, messy codebase |
+| 5 | **Security Bugs** | 50% of AI code has security vulnerabilities | Data breaches, compliance failures |
+| 6 | **Context Limits** | AI can only see ~100K tokens, codebase is 1M+ | Bad suggestions, incomplete understanding |
+| 7 | **Token Explosion** | More AI usage = huge bills ($10K-50K/month) | AI becomes too expensive to use |
+| 8 | **Outdated Knowledge** | AI suggests deprecated packages/patterns | Technical debt from day one |
+| 9 | **No Verification** | Developers blindly accept AI code | Bugs reach production |
+| 10 | **Lost Understanding** | Nobody understands AI-generated code | Unmaintainable codebase |
+
+### Our AI-Specific Solutions
+
+| Problem | Our Solution | How It Works |
+|---------|--------------|--------------|
+| Hallucination | **Import Validator** | Checks if AI-suggested imports/functions exist in codebase |
+| Duplicate Code | **Duplicate Detector** | "Similar function exists at src/utils/format.ts:23" |
+| Breaking Changes | **Blast Radius Analysis** | Shows all files affected before changes |
+| Ignores Patterns | **Pattern Suggester** | "Your team uses ServiceLayer pattern, not raw SQL" |
+| Security Bugs | **AI Code Verifier** | Scans AI output for OWASP vulnerabilities |
+| Context Limits | **Smart Context API** | Gives AI only relevant files, not everything |
+| Token Explosion | **Context Optimizer** | Reduces tokens by 70-80% with targeted context |
+| Outdated Knowledge | **Deprecation Warner** | "moment.js is deprecated, use date-fns" |
+| No Verification | **PR Review Checklist** | Auto-verify AI code before merge |
+| Lost Understanding | **Decision Tracker** | Records why AI code was added |
+
+---
+
+## 🎯 AI-Specific Features (NEW)
+
+### A1. Import Validator
+**Selling Power: 💰💰💰💰💰**
+
+**Problem:** AI hallucinates imports that don't exist.
+
+```bash
+# AI suggests:
+import { validateUser } from '@auth/utils';  # ❌ Doesn't exist!
+
+# Code Impact catches it:
+codeimpact verify ai-code.ts
+
+# Output:
+❌ Import Error: '@auth/utils' not found
+   Did you mean: 'src/auth/helpers.ts' (has validateUser)?
+```
+
+**Implementation effort:** Low (1 week)
+
+---
+
+### A2. Duplicate Detector
+**Selling Power: 💰💰💰💰💰**
+
+**Problem:** AI creates new code when similar code already exists.
+
+```bash
+codeimpact check-duplicates ai-generated.ts
+
+# Output:
+⚠️ Potential duplicate detected!
+
+Your new code:
+  function formatDateString(date) { ... }
+
+Similar existing code:
+  src/utils/dates.ts:23 → formatDate(date, format)
+  Similarity: 87%
+
+Recommendation: Use existing formatDate() instead
+```
+
+**Implementation effort:** Low (1 week)
+
+---
+
+### A3. Pattern Suggester
+**Selling Power: 💰💰💰💰**
+
+**Problem:** AI ignores your team's coding patterns.
+
+```bash
+codeimpact check-patterns ai-code.ts
+
+# Output:
+⚠️ Pattern violation detected!
+
+AI wrote:
+  const user = await db.query('SELECT * FROM users WHERE id = ?', [id]);
+
+Your team pattern:
+  const user = await UserService.findById(id);
+
+Recommendation: Use UserService (see src/services/UserService.ts)
+```
+
+**Implementation effort:** Medium (2 weeks)
+
+---
+
+### A4. AI Code Verifier
+**Selling Power: 💰💰💰💰💰**
+
+**Problem:** AI-generated code has bugs and security issues.
+
+```bash
+codeimpact verify ai-code.ts
+
+# Output:
+🔍 AI Code Verification Report
+
+✅ Imports: All valid
+✅ Types: No errors
+❌ Security: SQL injection at line 45
+⚠️ Duplicates: 2 similar functions exist
+⚠️ Patterns: 1 violation
+
+Overall: NEEDS REVIEW
+```
+
+**Implementation effort:** Low (1 week) - we already have most of this
+
+---
+
+### A5. Smart Context API
+**Selling Power: 💰💰💰💰💰**
+
+**Problem:** AI tools waste tokens reading irrelevant files.
+
+```bash
+# Instead of AI reading 50 files (200K tokens, $6)
+# Code Impact provides targeted context:
+
+GET /api/context?query="refactor authentication"
+
+# Response (20K tokens, $0.60):
+{
+  "relevant_files": [
+    "src/auth/login.ts",
+    "src/auth/session.ts",
+    "src/middleware/auth.ts"
+  ],
+  "related_decisions": ["ADR-023: Use JWT"],
+  "existing_patterns": ["AuthService pattern"],
+  "tests_to_check": ["tests/auth/*.test.ts"]
+}
+```
+
+**Token savings: 70-80%**
+
+**Implementation effort:** Medium (2 weeks)
+
+---
+
+### A6. Deprecation Warner
+**Selling Power: 💰💰💰💰**
+
+**Problem:** AI suggests outdated/deprecated packages.
+
+```bash
+codeimpact check-deps ai-code.ts
+
+# Output:
+⚠️ Deprecated Dependencies Detected:
+
+Line 1: import moment from 'moment'
+        → moment.js deprecated since 2020
+        → Your codebase uses: date-fns
+        → Suggestion: import { format } from 'date-fns'
+
+Line 5: import request from 'request'
+        → request deprecated since 2019
+        → Suggestion: Use native fetch or axios
+```
+
+**Implementation effort:** Low (1 week)
+
+---
+
+## New Positioning: "The Safety Net for AI Code"
+
+**Old messaging:**
+> "Code intelligence platform"
+
+**New messaging:**
+> "AI writes code in seconds. We make sure it actually works."
+
+**Taglines:**
+- "Copilot writes. We verify. You ship."
+- "The QA layer for AI-generated code."
+- "Because 50% of AI code has bugs."
+
+---
+
+### Revenue Potential
+
+**Conservative Estimate (Year 1):**
+- 50 enterprise customers × $500/month average = $300K ARR
+
+**Optimistic Estimate (Year 2):**
+- 200 enterprise customers × $1,000/month average = $2.4M ARR
+
+**Why enterprises will pay:**
+1. Direct cost savings (token reduction = $ saved)
+2. CI time savings (test impact analysis)
+3. Risk reduction (blast radius analysis)
+4. Developer productivity (less context switching)
+
+---
+
+## Complete Feature List with Ratings
+
+### Rating Scale
+- **💰💰💰💰💰** = Must-have, enterprises will pay premium
+- **💰💰💰💰** = High value, strong selling point
+- **💰💰💰** = Good value, nice to have
+- **💰💰** = Moderate value, competitive feature
+- **💰** = Low value, won't drive sales alone
+
+---
+
+## TIER 1: Money-Making Features (Ship First)
+
+### 1. Test Impact Analysis CLI
+**Selling Power: 💰💰💰💰💰**
+
+**What:** Only run tests affected by code changes.
+
+**Command:**
+```bash
+codeimpact ci --changed src/auth/login.ts
+# Output:
+# Impacted files: 23
+# Tests to run: 8 (instead of 847)
+# Estimated time: 2m (instead of 45m)
+# Cost saved: $12.50 (CI compute)
+```
+
+**Why it sells:**
+- Immediate, measurable ROI
+- Every enterprise has slow CI
+- Easy to demo: "Your 45-min build becomes 5 mins"
+- Competitors don't have this integrated with AI context
+
+**Implementation effort:** Medium (2 weeks)
+
+---
+
+### 2. Token/Cost Analytics Dashboard
+**Selling Power: 💰💰💰💰💰**
+
+**What:** Show exactly how much money Code Impact saves.
+
+**Dashboard:**
+```
+┌─────────────────────────────────────────────────────┐
+│  CODE IMPACT PRO - Cost Savings Dashboard           │
+├─────────────────────────────────────────────────────┤
+│                                                     │
+│  This Month's Savings                               │
+│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐ │
+│  │   $4,230    │  │   127hrs    │  │    89%      │ │
+│  │ Token Cost  │  │  CI Time    │  │ Efficiency  │ │
+│  │   Saved     │  │   Saved     │  │   Score     │ │
+│  └─────────────┘  └─────────────┘  └─────────────┘ │
+│                                                     │
+│  Token Usage Comparison                             │
+│  Without Code Impact: ████████████████████ 450K    │
+│  With Code Impact:    █████ 95K                    │
+│                                                     │
+│  ROI: 447% return on subscription cost             │
+└─────────────────────────────────────────────────────┘
+```
+
+**Why it sells:**
+- CFOs love dashboards showing cost savings
+- Justifies subscription to management
+- Creates urgency: "You're wasting $X without this"
+- Upsell trigger: "Upgrade for more savings"
+
+**Implementation effort:** Medium (2 weeks)
+
+---
+
+### 3. Blast Radius / Risk Analysis
+**Selling Power: 💰💰💰💰💰**
+
+**What:** Show deployment risk before making changes.
+
+**Output:**
+```json
+{
+  "file": "src/billing/payments.ts",
+  "risk_score": 87,
+  "risk_level": "CRITICAL",
+  "blast_radius": {
+    "direct_dependents": 8,
+    "transitive_dependents": 34,
+    "critical_paths": [
+      "src/api/checkout.ts (payment flow)",
+      "src/webhooks/stripe.ts (revenue)"
+    ]
+  },
+  "tests": {
+    "covering": 12,
+    "missing_coverage": ["processRefund()"]
+  },
+  "recommendation": "Senior review required. Affects payment flow."
+}
+```
+
+**Why it sells:**
+- Risk-averse enterprises LOVE this
+- Prevents production incidents
+- Visual and impressive in demos
+- Unique differentiator
+
+**Implementation effort:** Low (1 week - we already have the data)
+
+---
+
+### 4. PR Impact Analysis (GitHub/GitLab Integration)
+**Selling Power: 💰💰💰💰**
+
+**What:** Automatic PR comments showing impact analysis.
+
+**PR Comment:**
+```markdown
+## 🔍 Code Impact Analysis
+
+| Metric | Value | Status |
+|--------|-------|--------|
+| Risk Score | 72/100 | ⚠️ Medium |
+| Files Changed | 5 | |
+| Blast Radius | 23 files | |
+| Tests Needed | 8 | ✅ |
+| Coverage Gaps | 2 functions | ⚠️ |
+
+### ⚠️ Attention Required
+- `src/auth/middleware.ts` affects 15 downstream files
+- Missing tests for `validateToken()` and `refreshSession()`
+
+### 💡 Suggested Reviewers
+@alice (auth team), @bob (security)
+```
+
+**Why it sells:**
+- Fits existing workflow (PRs)
+- No behavior change required
+- Visible to entire team
+- Blocks risky merges automatically
+
+**Implementation effort:** High (3 weeks)
+
+---
+
+## TIER 2: High Value Features (Ship Second)
+
+### 5. Dependency Graph Visualization (Web UI)
+**Selling Power: 💰💰💰💰**
+
+**What:** Interactive browser-based dependency visualization.
+
+**Why it sells:**
+- Impressive demos ("wow factor")
+- Architects love it
+- Helps onboarding new developers
+- Shows value visually
+
+**Why not Tier 1:**
+- Takes longer to build
+- Doesn't directly save money
+- More "nice to have" than "must have"
+
+**Implementation effort:** High (4 weeks)
+
+---
+
+### 6. Semantic Code Search (Enhanced)
+**Selling Power: 💰💰💰💰**
+
+**What:** Find code by meaning, not just text.
+
+```bash
+codeimpact search "authentication middleware"
+# Returns: Relevant files ranked by semantic similarity
+```
+
+**Why it sells:**
+- Developers use this daily
+- Better than grep/IDE search
+- Reduces time finding code
+- Foundation for other features
+
+**Implementation effort:** Low (already exists, needs polish)
+
+---
+
+### 7. Decision/ADR Management
+**Selling Power: 💰💰💰**
+
+**What:** Track architectural decisions with team workflows.
+
+**Why it sells:**
+- Enterprises care about documentation
+- Audit trail for compliance
+- Prevents "why did we do this?" conversations
+- Team collaboration feature
+
+**Why not higher:**
+- Not directly cost-saving
+- Confluence/Notion already do this
+- Slower adoption curve
+
+**Implementation effort:** Medium (2 weeks)
+
+---
+
+### 8. Opinionated Workflow Templates
+**Selling Power: 💰💰💰**
+
+**What:** Ready-made prompts and workflows for common tasks.
+
+**Templates:**
+- Safe Refactor: impact → tests → plan → patch
+- New Feature: search → decisions → align → implement
+- Bug Fix: trace → blast radius → minimal fix → verify
+
+**Why it sells:**
+- Makes adoption easier
+- Best practices built-in
+- Differentiates from generic tools
+
+**Implementation effort:** Low (documentation + prompts)
+
+---
+
+## TIER 3: Competitive Features (Ship Later)
+
+### 9. Multi-Project / Org Memory
+**Selling Power: 💰💰💰**
+
+**What:** Search across all repos in organization.
+
+```bash
+codeimpact search --org "deprecated payment API"
+# Searches all 50 repos in organization
+```
+
+**Why it sells:**
+- Large enterprises have many repos
+- Finding cross-cutting concerns
+- Microservice dependency tracking
+
+**Why Tier 3:**
+- Only valuable for large enterprises
+- Complex to implement
+- Needs organization/team setup first
+
+**Implementation effort:** Very High (6+ weeks)
+
+---
+
+### 10. Real-time Collaboration
+**Selling Power: 💰💰**
+
+**What:** See what teammates are working on, live cursors.
+
+**Why it's low:**
+- VS Code Live Share exists
+- Not core to our value prop
+- Expensive to build
+
+**Implementation effort:** Very High (8+ weeks)
+
+---
+
+### 11. VS Code Extension
+**Selling Power: 💰💰💰**
+
+**What:** Inline impact warnings in editor.
+
+**Why Tier 3:**
+- HTTP API covers most use cases
+- Extension maintenance overhead
+- Users can use web dashboard
+
+**Implementation effort:** High (4 weeks)
+
+---
+
+### 12. Custom Security Rules
+**Selling Power: 💰💰**
+
+**What:** Define custom security patterns to detect.
+
+**Why it's low:**
+- Snyk/SonarQube already dominate
+- Not our core competency
+- Compliance is a separate sale
+
+**Implementation effort:** High (4 weeks)
+
+---
+
+## TIER 4: Nice-to-Have (Maybe Never)
+
+### 13. AI-Generated Documentation
+**Selling Power: 💰**
+
+**What:** Auto-generate docs from code.
+
+**Why it's low:**
+- Many tools do this
+- Quality is questionable
+- Not a selling point
+
+---
+
+### 14. Code Review Automation
+**Selling Power: 💰💰**
+
+**What:** AI-powered code review comments.
+
+**Why it's low:**
+- GitHub Copilot does this
+- Crowded market
+- Not our differentiator
+
+---
+
+## Feature Priority Matrix
+
+```
+                    HIGH SELLING POWER
+                          ▲
+                          │
+    ┌─────────────────────┼─────────────────────┐
+    │                     │                     │
+    │  SHIP LATER         │   SHIP FIRST        │
+    │  (Nice demos)       │   (Money makers)    │
+    │                     │                     │
+    │  • Dependency UI    │   • Test Impact     │
+    │  • VS Code Ext      │   • Cost Dashboard  │
+    │  • Multi-project    │   • Blast Radius    │
+    │                     │   • PR Integration  │
+LOW ├─────────────────────┼─────────────────────┤ HIGH
+EFFORT                    │                     EFFORT
+    │                     │                     │
+    │  SKIP               │   CONSIDER          │
+    │  (Low value)        │   (Strategic)       │
+    │                     │                     │
+    │  • Auto docs        │   • Security rules  │
+    │  • Code review      │   • Real-time collab│
+    │                     │                     │
+    └─────────────────────┼─────────────────────┘
+                          │
+                          ▼
+                    LOW SELLING POWER
+```
+
+---
+
+## Recommended Roadmap
+
+### Phase 1: MVP (Weeks 1-4) - "Prove the Value"
+**Goal:** Ship features that directly save money.
+
+| Week | Feature | Effort |
+|------|---------|--------|
+| 1-2 | Test Impact Analysis CLI | 2 weeks |
+| 2-3 | Token/Cost Analytics (basic) | 1 week |
+| 3-4 | Blast Radius API + docs | 1 week |
+
+**Deliverable:** CLI that shows "you saved X tests, Y minutes, $Z"
+
+---
+
+### Phase 2: Enterprise Ready (Weeks 5-8) - "Sell to Teams"
+**Goal:** Features that justify team purchase.
+
+| Week | Feature | Effort |
+|------|---------|--------|
+| 5-6 | GitHub PR Integration | 2 weeks |
+| 7 | Cost Dashboard (full) | 1 week |
+| 8 | Docker self-hosted package | 1 week |
+
+**Deliverable:** GitHub App + dashboard showing ROI
+
+---
+
+### Phase 3: Visual Polish (Weeks 9-12) - "Impress in Demos"
+**Goal:** Visual features for sales demos.
+
+| Week | Feature | Effort |
+|------|---------|--------|
+| 9-12 | Dependency Graph Web UI | 4 weeks |
+
+**Deliverable:** Beautiful interactive graph visualization
+
+---
+
+### Phase 4: Scale (Weeks 13-16) - "Enterprise Tier"
+**Goal:** Features for larger deals.
+
+| Week | Feature | Effort |
+|------|---------|--------|
+| 13-14 | Multi-project support | 2 weeks |
+| 15-16 | Team/workspace management | 2 weeks |
+
+**Deliverable:** Org-wide deployment option
+
+---
+
+## Pricing Strategy
+
+### Tier 1: Developer (Free)
+- Single project
+- Basic impact analysis
+- Community support
+- **Purpose:** Adoption, word of mouth
+
+### Tier 2: Team ($49/month)
+- Up to 10 users
+- Test Impact Analysis
+- Cost Dashboard
+- PR Integration
+- **Purpose:** Small team conversion
+
+### Tier 3: Business ($199/month)
+- Up to 50 users
+- All Team features
+- Multi-project
+- Priority support
+- **Purpose:** Mid-market
+
+### Tier 4: Enterprise (Custom)
+- Unlimited users
+- Self-hosted option
+- SSO/SAML
+- SLA + dedicated support
+- **Purpose:** Large deals ($10K+/year)
+
+---
+
+## Additional High-Value Feature Ideas
+
+### 15. "AI Cost Predictor"
+**Selling Power: 💰💰💰💰💰**
+
+Before running an AI query, predict:
+- Estimated tokens needed
+- Estimated cost
+- Suggest optimizations
+
+```
+Your query will use ~45K tokens ($1.35).
+💡 Tip: Narrow scope to src/auth/ to reduce to ~8K tokens ($0.24)
+```
+
+### 16. "Context Budget" for Teams
+**Selling Power: 💰💰💰💰**
+
+Set monthly AI budget per team/project. Alert when approaching limit.
+
+```
+Team "Backend" has used 78% of monthly AI budget ($780/$1000).
+Projected overage: $340 by month end.
+```
+
+### 17. "Smart Context Injection"
+**Selling Power: 💰💰💰💰💰**
+
+Automatically inject only relevant context into AI prompts.
+
+Instead of AI reading 50 files, we inject:
+- 3 most relevant files
+- Key decisions
+- Related tests
+- Recent changes
+
+**Result:** 80% token reduction, better answers.
+
+### 18. "Incident Prevention Score"
+**Selling Power: 💰💰💰💰**
+
+Daily/weekly report:
+```
+Incident Risk Report - Week 47
+
+High Risk Areas (address soon):
+• src/billing/ - 3 recent changes, low test coverage
+• src/auth/session.ts - circular dependency detected
+
+Improvements Made:
+• Test coverage +5% in core modules
+• 2 circular dependencies resolved
+```
+
+### 19. "Onboarding Accelerator"
+**Selling Power: 💰💰💰**
+
+New developer joins → Code Impact generates:
+- Architecture overview
+- Key files to read first
+- Team decisions summary
+- "Start here" guide
+
+---
+
+## 🔥 KILLER FEATURES - Game Changers
+
+These are unique, high-value features that differentiate us from ALL competitors.
+
+| Feature | Value | Unique? | Effort |
+|---------|-------|---------|--------|
+| Code Change Simulator | 🔥🔥🔥🔥🔥 | YES | Medium |
+| Dead Code Detector | 🔥🔥🔥🔥🔥 | Somewhat | Low |
+| Complexity Hotspots | 🔥🔥🔥🔥 | Somewhat | Low |
+| Migration Assistant | 🔥🔥🔥🔥🔥 | YES | High |
+| Architecture Drift Detector | 🔥🔥🔥🔥 | Somewhat | Medium |
+| PR Review Copilot | 🔥🔥🔥🔥🔥 | YES (with context) | Medium |
+
+---
+
+### 20. Code Change Simulator
+**Value: 🔥🔥🔥🔥🔥 | Unique: YES | Effort: Medium**
+
+Before you make a change, simulate what would break:
+
+```bash
+codeimpact simulate --change "rename function validateUser to validateAccount"
+
+# Output:
+# Simulating change...
+#
+# WOULD BREAK:
+# ❌ src/auth/login.ts:45 - calls validateUser()
+# ❌ src/api/users.ts:23 - imports validateUser
+# ❌ tests/auth.test.ts:12 - tests validateUser
+#
+# SAFE TO CHANGE:
+# ✅ src/billing/ - no references
+# ✅ src/utils/ - no references
+#
+# Automated fix available: Apply rename across 3 files? [y/n]
+```
+
+**Why it's a killer:**
+- Developers FEAR breaking things
+- This removes fear completely
+- No competitor does this with full codebase context
+- Instant "wow" in demos
+
+---
+
+### 21. Dead Code Detector
+**Value: 🔥🔥🔥🔥🔥 | Unique: Somewhat | Effort: Low**
+
+Find code that's never used anywhere:
+
+```bash
+codeimpact deadcode
+
+# Output:
+# UNUSED CODE DETECTED:
+#
+# 🗑️  src/utils/legacy.ts - entire file (0 imports)
+# 🗑️  src/auth/oldLogin.ts:45-89 - function deprecatedAuth() (0 calls)
+# 🗑️  src/api/v1/ - entire folder (0 references)
+#
+# Total: 4,230 lines of dead code
+# Estimated cleanup: Remove 12% of codebase
+#
+# Safe to delete? [Generate PR]
+```
+
+**Why it's a killer:**
+- Every old codebase has dead code (10-30%)
+- Developers are AFRAID to delete (might break something)
+- We PROVE it's safe with dependency analysis
+- Instant cleanup = faster builds, less confusion
+
+---
+
+### 22. Complexity Hotspots
+**Value: 🔥🔥🔥🔥 | Unique: Somewhat | Effort: Low**
+
+Find the most problematic areas of code:
+
+```bash
+codeimpact hotspots
+
+# Output:
+# 🔥 COMPLEXITY HOTSPOTS (high risk areas):
+#
+# 1. src/billing/payments.ts
+#    - Complexity: 89/100 (very high)
+#    - Dependencies: 34 files depend on this
+#    - Test coverage: 23% (low!)
+#    - Last incident: 3 bugs in past month
+#    - RECOMMENDATION: Refactor or add tests urgently
+#
+# 2. src/auth/session.ts
+#    - Complexity: 76/100
+#    - Circular dependency detected
+#    - RECOMMENDATION: Break circular dependency
+#
+# 3. src/api/legacy/v1.ts
+#    - Complexity: 71/100
+#    - 0% test coverage
+#    - RECOMMENDATION: Add tests or deprecate
+```
+
+**Why it's a killer:**
+- Shows EXACTLY where to focus engineering effort
+- Prevents incidents before they happen
+- Engineering managers LOVE this for planning
+- Easy to build (we already have the data)
+
+---
+
+### 23. Migration Assistant
+**Value: 🔥🔥🔥🔥🔥 | Unique: YES | Effort: High**
+
+Help upgrade dependencies or refactor patterns automatically:
+
+```bash
+codeimpact migrate --from "moment.js" --to "date-fns"
+
+# Output:
+# MIGRATION PLAN: moment.js → date-fns
+#
+# Files affected: 23
+# Functions to change: 47
+#
+# STEP 1: Install date-fns
+#    npm install date-fns
+#
+# STEP 2: Update imports in 23 files
+#    - import moment from 'moment' → import { format, addDays } from 'date-fns'
+#
+# STEP 3: Replace function calls:
+#    moment().format('YYYY-MM-DD') → format(new Date(), 'yyyy-MM-dd')
+#    moment().add(1, 'day')        → addDays(new Date(), 1)
+#    moment().subtract(1, 'week')  → subWeeks(new Date(), 1)
+#    ... (44 more replacements)
+#
+# Estimated effort: 4 hours (manual) or 10 minutes (auto-apply)
+#
+# [Generate PR with all changes]
+```
+
+**Why it's a killer:**
+- Migrations are the WORST part of maintenance
+- Usually takes days/weeks, we make it minutes
+- Handles the scary "what if I miss something" fear
+- Enterprises pay BIG money for this
+
+---
+
+### 24. Architecture Drift Detector
+**Value: 🔥🔥🔥🔥 | Unique: Somewhat | Effort: Medium**
+
+Detect when code violates intended architecture rules:
+
+```bash
+codeimpact architecture-check
+
+# Output:
+# 🚨 ARCHITECTURE VIOLATIONS DETECTED:
+#
+# ❌ LAYER VIOLATION
+#    src/api/users.ts imports from src/billing/internal.ts
+#    Rule: API layer should not access internal billing modules
+#    Suggestion: Use BillingService interface instead
+#
+# ❌ DEPENDENCY EXPLOSION
+#    src/utils/helpers.ts has 45 dependents
+#    Rule: Utility modules should have <10 dependents
+#    Suggestion: Split into domain-specific utilities
+#
+# ❌ CIRCULAR DEPENDENCY
+#    auth → users → permissions → auth
+#    Rule: No circular dependencies allowed
+#    Suggestion: Extract shared types to src/common/types.ts
+#
+# ⚠️  POTENTIAL ISSUE
+#    src/config/database.ts imported in 67 files
+#    Consider: Dependency injection pattern
+#
+# Summary: 3 violations, 1 warning
+# Run 'codeimpact architecture-fix' for auto-remediation suggestions
+```
+
+**Why it's a killer:**
+- Keeps codebase clean OVER TIME
+- Prevents "how did our architecture get so messy?"
+- Architects and tech leads LOVE this
+- Can block PRs that violate rules
+
+---
+
+### 25. PR Review Copilot (Context-Aware)
+**Value: 🔥🔥🔥🔥🔥 | Unique: YES (with full context) | Effort: Medium**
+
+AI reviews PRs with FULL codebase understanding:
+
+```markdown
+## 🤖 Code Impact Pro - PR Review
+
+### What This PR Does
+Adds rate limiting to user authentication to prevent brute force attacks.
+
+### Codebase Context Check
+✅ **Consistent with patterns** - Similar to existing rate limiting in `src/api/rateLimit.ts`
+✅ **Follows team decisions** - Aligns with ADR-023 "Use Redis for rate limiting"
+✅ **Tests included** - 4 test cases covering main scenarios
+⚠️ **Missing edge case** - No test for Redis connection failure
+
+### Code Quality
+| Check | Status |
+|-------|--------|
+| Security scan | ✅ Pass |
+| Pattern compliance | ✅ Pass |
+| Test coverage | ⚠️ 78% (target: 80%) |
+| Complexity | ✅ Low |
+
+### Suggestions
+1. **Line 45:** Consider using `RATE_LIMIT_WINDOW` constant from `src/config/constants.ts` instead of hardcoded `60`
+2. **Line 67:** Similar logic exists in `src/auth/throttle.ts:23-45` - consider extracting to shared utility
+3. **Line 89:** Add try-catch for Redis connection failure
+
+### Impact Assessment
+- **Risk Level:** Low (isolated change)
+- **Blast Radius:** 3 files directly affected
+- **Tests Covering:** 8 existing + 4 new
+- **Breaking Changes:** None
+
+### Verdict
+✅ **APPROVE** - Safe to merge after addressing missing test case
+
+---
+*Review generated by Code Impact Pro with full codebase context*
+```
+
+**Why it's a killer:**
+- AI review WITHOUT context = generic, useless
+- AI review WITH context = actually helpful
+- Finds issues that humans miss (duplicate code, pattern violations)
+- Saves senior developer review time
+- This is what makes AI ACTUALLY useful in code review
+
+---
+
+## Updated Feature Priority Matrix
+
+```
+                         HIGH VALUE + UNIQUE
+                               ▲
+                               │
+     ┌─────────────────────────┼─────────────────────────┐
+     │                         │                         │
+     │  BUILD NEXT             │   BUILD FIRST           │
+     │  (Differentiators)      │   (Money + Unique)      │
+     │                         │                         │
+     │  • Migration Assistant  │   • Code Change Sim     │
+     │  • Architecture Drift   │   • Dead Code Detector  │
+     │  • PR Review Copilot    │   • Test Impact CLI     │
+     │                         │   • Blast Radius        │
+     │                         │                         │
+LOW  ├─────────────────────────┼─────────────────────────┤ HIGH
+EFFORT                         │                         EFFORT
+     │                         │                         │
+     │  EASY WINS              │   STRATEGIC             │
+     │  (Quick value)          │   (Long-term)           │
+     │                         │                         │
+     │  • Complexity Hotspots  │   • Dependency Graph UI │
+     │  • Cost Dashboard       │   • Multi-project       │
+     │                         │   • VS Code Extension   │
+     │                         │                         │
+     └─────────────────────────┼─────────────────────────┘
+                               │
+                               ▼
+                         COMMON FEATURES
+```
+
+---
+
+## Updated Roadmap with ALL Features
+
+### Phase 1: MVP (Weeks 1-4) - "AI Safety Net"
+**Focus:** Solve AI-specific problems first (unique positioning)
+
+| Week | Feature | Type | Effort |
+|------|---------|------|--------|
+| 1 | Import Validator | 🤖 AI-Fix | 1 week |
+| 1 | Duplicate Detector | 🤖 AI-Fix | 1 week |
+| 2 | AI Code Verifier | 🤖 AI-Fix | 1 week |
+| 2 | Deprecation Warner | 🤖 AI-Fix | 1 week |
+| 3 | Dead Code Detector | 🔥 Killer | 1 week |
+| 3 | Complexity Hotspots | 🔥 Killer | 1 week |
+| 4 | Test Impact Analysis CLI | 💰 Core | 1 week |
+
+**Deliverable:** CLI that verifies AI code + finds dead code + runs smart tests
+
+---
+
+### Phase 2: Context & Cost (Weeks 5-8) - "Save Money"
+**Focus:** Token reduction = direct ROI proof
+
+| Week | Feature | Type | Effort |
+|------|---------|------|--------|
+| 5-6 | Smart Context API | 🤖 AI-Fix | 2 weeks |
+| 6-7 | Pattern Suggester | 🤖 AI-Fix | 2 weeks |
+| 7-8 | Cost Dashboard | 💰 Core | 2 weeks |
+
+**Deliverable:** "You saved $4,230 in AI costs this month"
+
+---
+
+### Phase 3: Risk & Safety (Weeks 9-12) - "Prevent Incidents"
+**Focus:** Blast radius + simulation = enterprise trust
+
+| Week | Feature | Type | Effort |
+|------|---------|------|--------|
+| 9-10 | Code Change Simulator | 🔥 Killer | 2 weeks |
+| 10-11 | Blast Radius + Risk API | 💰 Core | 1 week |
+| 11-12 | GitHub PR Integration | 💰 Core | 2 weeks |
+
+**Deliverable:** PR comments showing impact + risk score
+
+---
+
+### Phase 4: Intelligence (Weeks 13-16) - "Beat Competition"
+**Focus:** Features nobody else has
+
+| Week | Feature | Type | Effort |
+|------|---------|------|--------|
+| 13-14 | PR Review Copilot | 🔥 Killer | 2 weeks |
+| 15-16 | Architecture Drift Detector | 🔥 Killer | 2 weeks |
+
+**Deliverable:** Context-aware AI code reviews
+
+---
+
+### Phase 5: Visual & Scale (Weeks 17-24) - "Enterprise Ready"
+**Focus:** Visual polish + multi-project
+
+| Week | Feature | Type | Effort |
+|------|---------|------|--------|
+| 17-20 | Dependency Graph UI | 📊 Visual | 4 weeks |
+| 21-22 | Migration Assistant | 🔥 Killer | 2 weeks |
+| 23-24 | Multi-project Support | 🏢 Scale | 2 weeks |
+
+**Deliverable:** Full web dashboard + org-wide deployment
+
+---
+
+## Complete Feature Summary
+
+### 🤖 AI-Specific Features (NEW - Our Unique Angle)
+| Feature | Solves | Effort | Priority |
+|---------|--------|--------|----------|
+| Import Validator | Hallucination | 1 week | P0 |
+| Duplicate Detector | Code bloat | 1 week | P0 |
+| AI Code Verifier | Quality issues | 1 week | P0 |
+| Deprecation Warner | Outdated code | 1 week | P0 |
+| Smart Context API | Token costs | 2 weeks | P0 |
+| Pattern Suggester | Inconsistency | 2 weeks | P1 |
+
+### 🔥 Killer Features (Differentiators)
+| Feature | Solves | Effort | Priority |
+|---------|--------|--------|----------|
+| Code Change Simulator | Fear of breaking | 2 weeks | P1 |
+| Dead Code Detector | Bloat | 1 week | P0 |
+| Complexity Hotspots | Risk areas | 1 week | P1 |
+| PR Review Copilot | Review quality | 2 weeks | P2 |
+| Architecture Drift | Tech debt | 2 weeks | P2 |
+| Migration Assistant | Painful upgrades | 2 weeks | P2 |
+
+### 💰 Core Features (Money Makers)
+| Feature | Solves | Effort | Priority |
+|---------|--------|--------|----------|
+| Test Impact Analysis | Slow CI | 2 weeks | P0 |
+| Blast Radius API | Risk assessment | 1 week | P0 |
+| GitHub PR Integration | Automation | 2 weeks | P1 |
+| Cost Dashboard | ROI proof | 2 weeks | P1 |
+
+### 📊 Visual & Scale
+| Feature | Solves | Effort | Priority |
+|---------|--------|--------|----------|
+| Dependency Graph UI | Visualization | 4 weeks | P2 |
+| Multi-project Support | Enterprise scale | 2 weeks | P2 |
+
+---
+
+## Total Development Time
+
+| Phase | Weeks | Focus |
+|-------|-------|-------|
+| Phase 1 | 4 | AI Safety Net |
+| Phase 2 | 4 | Cost Savings |
+| Phase 3 | 4 | Risk Prevention |
+| Phase 4 | 4 | Intelligence |
+| Phase 5 | 8 | Visual & Scale |
+| **Total** | **24 weeks** | **~6 months** |
+
+---
+
+## Final Assessment: Will This Make Money?
+
+### YES, because:
+
+1. **Clear ROI** - Token savings alone justify cost
+2. **Real Pain** - Every enterprise has slow CI, expensive AI
+3. **No Direct Competitor** - Unique combination of features
+4. **Low Switching Cost** - Works with existing tools
+5. **Land and Expand** - Free tier → Team → Enterprise
+
+### Risks:
+
+1. **GitHub/GitLab could build this** - But they're slow, we can move faster
+2. **AI costs may drop** - But relative savings still matter
+3. **Enterprise sales are slow** - Need patience and runway
+
+### Confidence Level: **HIGH (8/10)**
+
+The product solves real problems with measurable value. The key is executing Phase 1 quickly to prove the concept, then iterating based on customer feedback.
+
+---
+
+## Immediate Next Steps
+
+1. **Week 1:** Build Test Impact Analysis CLI
+2. **Week 2:** Add token tracking to existing API
+3. **Week 3:** Create demo script for sales calls
+4. **Week 4:** Reach out to 10 potential enterprise customers
+
+---
+
+## LLM Requirement Analysis: 100% Local Execution
+
+### Key Competitive Advantage
+
+**Code Impact Pro runs entirely locally with NO external LLM API calls required.**
+
+This means:
+- **$0 operational cost** - No per-token fees
+- **Works offline** - No internet required after installation
+- **Data never leaves machine** - Enterprise security compliance
+- **Instant responses** - No API latency
+- **No vendor lock-in** - Works with any AI assistant
+
+---
+
+### Feature-by-Feature LLM Requirements
+
+| # | Feature | Requires LLM? | Technology Used |
+|---|---------|:-------------:|-----------------|
+| 1 | Test Impact Analysis | ❌ NO | Tree-sitter AST + dependency graph |
+| 2 | Blast Radius / Impact | ❌ NO | Dependency graph traversal |
+| 3 | Cost Dashboard | ❌ NO | Token counting + usage tracking |
+| 4 | Dependency Graph UI | ❌ NO | D3.js visualization |
+| 5 | GitHub PR Integration | ❌ NO | REST API + analysis engine |
+| 6 | Import Validator | ❌ NO | AST parsing + file system check |
+| 7 | Duplicate Detector | ❌ NO | AST comparison + hashing |
+| 8 | AI Code Verifier | ❌ NO | Pattern matching + static analysis |
+| 9 | Deprecation Warner | ❌ NO | AST + package.json parsing |
+| 10 | Smart Context API | ❌ NO | Embeddings + relevance scoring |
+| 11 | Dead Code Detector | ❌ NO | Export/import analysis + call graph |
+| 12 | Complexity Hotspots | ❌ NO | Cyclomatic complexity + metrics |
+| 13 | Code Change Simulator | ❌ NO | AST + dependency analysis |
+| 14 | Architecture Drift | ❌ NO | Rule engine + graph analysis |
+| 15 | Multi-project Support | ❌ NO | Database + file system |
+| 16 | Pattern Suggester | ❌ NO | Pattern library + similarity matching |
+| 17 | **PR Review Copilot** | ⚡ OPTIONAL | LLM enhances but not required |
+| 18 | **Migration Assistant** | ⚡ OPTIONAL | LLM helps with edge cases |
+
+**Summary: 16 out of 18 features = NO LLM required**
+**2 features = LLM is optional enhancement, not required**
+
+---
+
+### Core Technology Stack (All Local)
+
+| Component | Technology | Purpose |
+|-----------|------------|---------|
+| **AST Parsing** | Tree-sitter WASM | Extract symbols, imports, exports with 100% accuracy |
+| **Embeddings** | Xenova/transformers | Local semantic embeddings (no API) |
+| **Storage** | SQLite + WAL | Fast, local database |
+| **Dependency Graph** | Custom engine | Traverse imports/exports |
+| **Similarity Search** | Cosine similarity | Match patterns and find duplicates |
+| **Complexity Analysis** | Custom metrics | Cyclomatic complexity, cognitive load |
+
+---
+
+### Why This Matters for Enterprise Sales
+
+```
+Traditional AI Tools              Code Impact Pro
+─────────────────────────────────────────────────────
+Per-query API costs ($$$)    →    $0 per query
+Data sent to cloud           →    100% on-premise
+Requires internet            →    Works offline
+Latency (100-500ms)          →    Instant (<10ms)
+Vendor API limits            →    Unlimited usage
+SOC2/HIPAA concerns          →    Full compliance
+```
+
+---
+
+### Sales Pitch
+
+> "Unlike tools that charge per token and send your code to the cloud, Code Impact Pro runs entirely on YOUR servers with YOUR data. Zero API costs, zero data exposure, zero latency. Install once, run forever."
+
+---
+
+### When LLM Integration IS Useful (Optional)
+
+For features that benefit from LLM enhancement:
+
+1. **PR Review Copilot** - LLM can write natural language summaries
+   - Without LLM: Shows data, patterns, violations
+   - With LLM: Also explains "why" and suggests fixes
+
+2. **Migration Assistant** - LLM helps with complex transformations
+   - Without LLM: Identifies all changes needed
+   - With LLM: Also generates replacement code
+
+**Important:** Both features provide full value WITHOUT LLM. LLM is a premium enhancement for teams that want it.
+
+---
+
+*Document created: March 2026*
+*Author: Code Impact Team*