16 KiB
16 KiB
File Chunking Process Diagram
Overview: How Files Are Processed in the AI Analysis Service
┌─────────────────────────────────────────────────────────────────────────────┐
│ LARGE FILE INPUT │
│ (e.g., 5000-line Python file) │
└─────────────────────┬───────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────────────────┐
│ LANGUAGE DETECTION │
│ • Detect file extension (.py, .js, .ts, .java) │
│ • Load language-specific patterns for intelligent chunking │
└─────────────────────┬───────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────────────────┐
│ INTELLIGENT CHUNKING │
│ │
│ ┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐ │
│ │ CHUNK 1: │ │ CHUNK 2: │ │ CHUNK 3: │ │
│ │ IMPORTS │ │ CLASSES │ │ FUNCTIONS │ │
│ │ • import os │ │ • class User │ │ • def auth() │ │
│ │ • from db │ │ • class Admin │ │ • def save() │ │
│ │ • typing │ │ • methods │ │ • def load() │ │
│ └─────────────────┘ └─────────────────┘ └─────────────────┘ │
│ │
│ ┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐ │
│ │ CHUNK 4: │ │ CHUNK 5: │ │ CHUNK 6: │ │
│ │ UTILITIES │ │ MAIN LOGIC │ │ TESTS │ │
│ │ • helpers │ │ • main() │ │ • test_* │ │
│ │ • validators │ │ • run() │ │ • fixtures │ │
│ │ • formatters │ │ • execute() │ │ • mocks │ │
│ └─────────────────┘ └─────────────────┘ └─────────────────┘ │
└─────────────────────┬───────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────────────────┐
│ CHUNK ANALYSIS WITH CLAUDE AI │
│ │
│ For each chunk: │
│ ┌─────────────────────────────────────────────────────────────────────┐ │
│ │ CHUNK 1 → CLAUDE AI │ │
│ │ Prompt: "Analyze this import section for..." │ │
│ │ Response: Issues found, recommendations, quality score │ │
│ └─────────────────────────────────────────────────────────────────────┘ │
│ │
│ ┌─────────────────────────────────────────────────────────────────────┐ │
│ │ CHUNK 2 → CLAUDE AI │ │
│ │ Prompt: "Analyze this class definition for..." │ │
│ │ Response: Issues found, recommendations, quality score │ │
│ └─────────────────────────────────────────────────────────────────────┘ │
│ │
│ ┌─────────────────────────────────────────────────────────────────────┐ │
│ │ CHUNK 3 → CLAUDE AI │ │
│ │ Prompt: "Analyze these functions for..." │ │
│ │ Response: Issues found, recommendations, quality score │ │
│ └─────────────────────────────────────────────────────────────────────┘ │
│ │
│ ... (and so on for each chunk) │
└─────────────────────┬───────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────────────────┐
│ RESULT COMBINATION │
│ │
│ ┌─────────────────────────────────────────────────────────────────────┐ │
│ │ COMBINED ANALYSIS RESULT │ │
│ │ • All issues from all chunks │ │
│ │ • Overall quality score (average of chunk scores) │ │
│ │ • Comprehensive recommendations │ │
│ │ • Chunking statistics (savings, efficiency) │ │
│ └─────────────────────────────────────────────────────────────────────┘ │
└─────────────────────┬───────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────────────────┐
│ FINAL REPORT │
│ • File path and language │
│ • Total lines of code │
│ • Quality score (1-10) │
│ • Issues found (with line numbers) │
│ • Recommendations for improvement │
│ • Chunking efficiency metrics │
└─────────────────────────────────────────────────────────────────────────────┘
Key Benefits of This Approach
1. Token Efficiency
Original File: 50,000 tokens
Chunked Files: 15,000 tokens (70% savings)
2. Focused Analysis
- Each chunk gets specialized attention
- Context-aware prompts for different code types
- Better quality analysis per section
3. Cost Optimization
- Smaller API calls = lower costs
- Parallel processing possible
- Caching of individual chunks
4. Scalability
- Can handle files of any size
- Memory efficient
- Rate limit friendly
Chunking Strategy by File Type
Python Files
┌─────────────┬──────────────┬─────────────────────────────────────────────┐
│ Chunk Type │ Pattern │ Example Content │
├─────────────┼──────────────┼─────────────────────────────────────────────┤
│ Imports │ ^import|^from│ import os, json, requests │
│ Classes │ ^class │ class User: def __init__(self): │
│ Functions │ ^def │ def authenticate_user(): │
│ Main Logic │ Other │ if __name__ == "__main__": │
└─────────────┴──────────────┴─────────────────────────────────────────────┘
JavaScript/TypeScript Files
┌─────────────┬──────────────┬─────────────────────────────────────────────┐
│ Chunk Type │ Pattern │ Example Content │
├─────────────┼──────────────┼─────────────────────────────────────────────┤
│ Imports │ ^import|^const|import React from 'react' │
│ Classes │ ^class │ class Component extends React.Component │
│ Functions │ ^function|^const|function myFunction() { │
│ Exports │ ^export │ export default MyComponent │
└─────────────┴──────────────┴─────────────────────────────────────────────┘
Memory and Context Integration
┌─────────────────────────────────────────────────────────────────────────────┐
│ CONTEXT AWARENESS │
│ │
│ Each chunk analysis includes: │
│ • Similar code patterns from repository │
│ • Best practices for that code type │
│ • Previous analysis results │
│ • Repository-specific patterns │
│ │
│ Example: │
│ "This function chunk is similar to 3 other functions in your repo │
│ that had security issues. Consider implementing the same fix here." │
└─────────────────────────────────────────────────────────────────────────────┘
Error Handling and Fallbacks
┌─────────────────────────────────────────────────────────────────────────────┐
│ ROBUST PROCESSING │
│ │
│ If chunking fails: │
│ • Fall back to original file analysis │
│ • Use content optimization instead │
│ • Continue with other files │
│ │
│ If Claude API fails: │
│ • Retry with exponential backoff │
│ • Use cached results if available │
│ • Provide fallback analysis │
└─────────────────────────────────────────────────────────────────────────────┘
This chunking system makes the AI analysis service much more powerful and efficient, allowing it to handle large codebases that would otherwise be too big for AI analysis.