Claude-Code-Workflow/.claude/workflows/gemini-intelligent-context.md

Gemini Intelligent Context System

Smart context detection and file targeting system for Gemini CLI analysis.

Overview

The intelligent context system automatically resolves file paths and context based on user input, analysis type, and project structure detection, enabling precise and efficient codebase analysis.

Smart Path Detection

Technology Stack Detection

def detect_technology_stack(project_path):
    """Detect technologies used in the project"""
    indicators = {
        'React': ['package.json contains react', '**/*.jsx', '**/*.tsx'],
        'Vue': ['package.json contains vue', '**/*.vue'],
        'Angular': ['angular.json', '**/*.component.ts'],
        'Node.js': ['package.json', 'server.js', 'app.js'],
        'Python': ['requirements.txt', '**/*.py', 'setup.py'],
        'Java': ['pom.xml', '**/*.java', 'build.gradle'],
        'TypeScript': ['tsconfig.json', '**/*.ts'],
        'Express': ['package.json contains express'],
        'FastAPI': ['**/*main.py', 'requirements.txt contains fastapi'],
        'Spring': ['pom.xml contains spring', '**/*Application.java']
    }
    return analyze_indicators(indicators, project_path)

Project Structure Detection

def detect_project_structure(project_path):
    """Identify common project patterns"""
    patterns = {
        'src_based': has_directory('src/'),
        'lib_based': has_directory('lib/'),
        'app_based': has_directory('app/'),
        'modules_based': has_directory('modules/'),
        'packages_based': has_directory('packages/'),
        'microservices': has_multiple_services(),
        'monorepo': has_workspaces_or_lerna()
    }
    return analyze_structure_patterns(patterns)

Domain Context Detection

def extract_domain_keywords(user_input):
    """Extract domain-specific keywords for smart targeting"""
    domain_mapping = {
        'auth': ['authentication', 'login', 'session', 'auth', 'oauth', 'jwt', 'token'],
        'api': ['api', 'endpoint', 'route', 'controller', 'service'],
        'frontend': ['component', 'ui', 'view', 'react', 'vue', 'angular'],
        'backend': ['server', 'backend', 'api', 'database', 'model'],
        'database': ['database', 'db', 'model', 'query', 'migration', 'schema'],
        'security': ['security', 'vulnerability', 'xss', 'csrf', 'injection'],
        'performance': ['performance', 'slow', 'optimization', 'bottleneck'],
        'testing': ['test', 'spec', 'mock', 'unit', 'integration', 'e2e'],
        'state': ['state', 'redux', 'context', 'store', 'vuex'],
        'config': ['config', 'environment', 'settings', 'env']
    }
    return match_domains(user_input.lower(), domain_mapping)

Intelligent File Targeting

Context-Aware Path Generation

Domain Context	Generated File Patterns
Authentication	@{**/*auth*,**/*login*,**/*session*,**/middleware/*auth*,**/guards/**/*}
API Endpoints	@{**/api/**/*,**/routes/**/*,**/controllers/**/*,**/handlers/**/*}
Frontend Components	@{src/components/**/*,src/ui/**/*,src/views/**/*,components/**/*}
Database Layer	@{**/models/**/*,**/db/**/*,**/migrations/**/*,**/repositories/**/*}
State Management	@{**/store/**/*,**/redux/**/*,**/context/**/*,**/state/**/*}
Configuration	@{*.config.*,**/config/**/*,.env*,**/settings/**/*}
Testing	@{**/*.test.*,**/*.spec.*,**/test/**/*,**/spec/**/*,**/__tests__/**/*}
Security	@{**/*security*,**/*auth*,**/*crypto*,**/middleware/**/*}
Performance	@{**/core/**/*,**/services/**/*,**/utils/**/*,**/lib/**/*}

Technology-Specific Extensions

def get_tech_extensions(technology_stack):
    """Get relevant file extensions based on detected technologies"""
    extension_mapping = {
        'React': ['.jsx', '.tsx', '.js', '.ts'],
        'Vue': ['.vue', '.js', '.ts'], 
        'Angular': ['.component.ts', '.service.ts', '.module.ts'],
        'Node.js': ['.js', '.ts', '.mjs'],
        'Python': ['.py', '.pyx', '.pyi'],
        'Java': ['.java', '.kt', '.scala'],
        'TypeScript': ['.ts', '.tsx', '.d.ts'],
        'CSS': ['.css', '.scss', '.sass', '.less', '.styl']
    }
    return build_extension_patterns(technology_stack, extension_mapping)

Dynamic Context Enhancement

Smart Prompt Construction

def build_intelligent_context(user_input, analysis_type, project_info):
    """Build context-aware Gemini CLI prompt"""
    
    # Step 1: Detect domains and technologies
    domains = extract_domain_keywords(user_input)
    tech_stack = project_info.technology_stack
    
    # Step 2: Generate smart file patterns
    file_patterns = generate_file_patterns(domains, tech_stack, analysis_type)
    
    # Step 3: Include relevant CLAUDE.md contexts
    claude_patterns = generate_claude_patterns(domains, project_info.structure)
    
    # Step 4: Build context-enriched prompt
    return construct_enhanced_prompt(
        base_prompt=user_input,
        file_patterns=file_patterns,
        claude_context=claude_patterns,
        analysis_focus=get_analysis_focus(analysis_type),
        tech_context=tech_stack
    )

Context Validation and Fallbacks

def validate_and_fallback_context(generated_patterns, project_path):
    """Ensure generated patterns match actual project structure"""
    validated_patterns = []
    
    for pattern in generated_patterns:
        if has_matching_files(pattern, project_path):
            validated_patterns.append(pattern)
        else:
            # Try fallback patterns
            fallback = generate_fallback_pattern(pattern, project_path)
            if fallback:
                validated_patterns.append(fallback)
    
    return validated_patterns or get_generic_patterns(project_path)

Integration Patterns

Command Integration Examples

def gather_gemini_insights(user_input, base_enhancement):
    # Use intelligent context system
    context = build_intelligent_context(
        user_input=user_input,
        analysis_type=determine_analysis_type(base_enhancement),
        project_info=get_project_info()
    )
    
    # Select appropriate template
    template = select_template(base_enhancement.complexity, base_enhancement.domains)
    
    # Execute with enhanced context
    return execute_template(template, context)

Agent Workflow Integration

# Before agent execution, collect enhanced context
def collect_enhanced_gemini_context(task_description):
    domains = extract_domain_keywords(task_description)
    analysis_types = determine_required_analysis(domains)
    
    context_results = {}
    for analysis_type in analysis_types:
        # Use appropriate template file based on analysis type
        if analysis_type.startswith('dms'):
            template_path = f"workflows/gemini-dms-templates.md#{analysis_type}"
        elif analysis_type in ['planning-agent-context', 'code-developer-context', 'code-review-context', 'ui-design-context']:
            template_path = f"workflows/gemini-agent-templates.md#{analysis_type}"
        else:
            template_path = f"workflows/gemini-core-templates.md#{analysis_type}"
        
        context_results[analysis_type] = execute_template_by_reference(
            template_path, 
            task_description
        )
    
    return consolidate_context(context_results)

Smart Template Selection

def select_optimal_template(task_complexity, domains, tech_stack):
    template_matrix = {
        ('simple', ['frontend']): 'pattern-analysis',
        ('medium', ['frontend', 'api']): ['pattern-analysis', 'architecture-analysis'],
        ('complex', ['security', 'auth']): ['security-analysis', 'architecture-analysis', 'quality-analysis'],
        ('critical', ['payment', 'crypto']): ['security-analysis', 'performance-analysis', 'dependencies-analysis']
    }
    
    return template_matrix.get((task_complexity, sorted(domains)), ['pattern-analysis'])

Usage Guidelines

Performance Optimization

1. Scope file patterns appropriately - Too broad patterns slow analysis
2. Use technology-specific extensions - More precise targeting improves results
3. Implement pattern validation - Check patterns match files before execution
4. Consider project size - Large projects may need pattern chunking

Maintenance

1. Update templates regularly - Keep pace with new technologies and patterns
2. Validate anchor links - Ensure cross-references remain accurate
3. Test intelligent context - Verify smart targeting works across project types
4. Monitor template performance - Track analysis quality and speed

This intelligent context system provides the foundation for all Gemini CLI analysis, ensuring efficient and precise codebase understanding across different commands and agents.