Cross-Feature Integration Guide

# Base pattern for all integrated features
from services.intent_service.canonical_handlers import CanonicalHandlers

class FeatureWorkflow:
    def __init__(self, canonical_handlers: Optional[CanonicalHandlers] = None):
        self.canonical_handlers = canonical_handlers

    async def canonical_query_integration(self, query: str, user_id: str) -> Dict[str, Any]:
        """Standard integration interface for cross-feature communication"""
        # Feature-specific integration logic
        pass

# Morning Standup integration method
async def generate_with_issues(self, user_id: str) -> StandupResult:
    # Get base standup
    base_standup = await self.generate_standup(user_id)

    # Add issue context via canonical query
    try:
        if hasattr(self, 'canonical_handlers') and self.canonical_handlers:
            issue_engine = IssueIntelligenceCanonicalQueryEngine(
                user_id=user_id,
                canonical_handlers=self.canonical_handlers
            )

            # Create intent for issue intelligence
            intent = Intent(
                user_id=user_id,
                text="what needs attention",
                category=IntentCategory.PROJECT_MANAGEMENT,
                confidence_score=1.0
            )

            # Get enhanced results
            enhanced_result = await issue_engine.enhance_canonical_query(intent, f"session_{user_id}")

            # Integrate issue priorities into standup
            if enhanced_result and enhanced_result.issue_intelligence.get("priority_issues"):
                issue_priorities = enhanced_result.issue_intelligence["priority_issues"][:3]
                for issue in issue_priorities:
                    base_standup.today_priorities.append(f"🎯 Issue #{issue.get('number')}: {issue.get('title')}")

    except Exception as e:
        # Graceful degradation
        base_standup.today_priorities.append(f"⚠️ Issue priorities unavailable: {str(e)[:50]}...")

    return base_standup

# Standard integration interface
async def canonical_query_integration(self, query: str, user_id: str) -> Dict[str, Any]:
    """
    Standard method all integrable features should implement

    Returns:
        Dict with standardized keys: context, source, integration_time_ms, error (optional)
    """
    pass

try:
    # Attempt integration
    integrated_result = await other_feature.canonical_query_integration(query, user_id)
    # Use integrated result
except Exception as e:
    # Log error but continue with base functionality
    logger.warning(f"Integration failed: {e}")
    # Provide user-friendly fallback
    fallback_message = f"⚠️ {feature_name} unavailable: {str(e)[:50]}..."

# Unit tests for integration methods
@pytest.mark.asyncio
async def test_feature_integration():
    feature = FeatureWorkflow(canonical_handlers=mock_handlers)
    result = await feature.canonical_query_integration("test query", "user_id")
    assert "context" in result
    assert "integration_time_ms" in result

# Integration tests for end-to-end functionality
@pytest.mark.integration
async def test_cross_feature_integration():
    # Test actual feature integration
    standup = MorningStandupWorkflow(canonical_handlers=real_handlers)
    result = await standup.generate_with_issues("test_user")
    assert len(result.today_priorities) > 0

class NewFeatureWorkflow:
    def __init__(self, canonical_handlers: Optional[CanonicalHandlers] = None):
        self.canonical_handlers = canonical_handlers

    async def canonical_query_integration(self, query: str, user_id: str) -> Dict[str, Any]:
        """Implement standard integration interface"""
        return {
            "context": feature_specific_context,
            "source": "new_feature_canonical",
            "integration_time_ms": processing_time,
        }

# Add timeout handling to integration calls
async def safe_integration_call(feature, query, user_id):
    try:
        return await asyncio.wait_for(
            feature.canonical_query_integration(query, user_id),
            timeout=5.0  # 5-second timeout
        )
    except asyncio.TimeoutError:
        return {"error": "Integration timeout", "source": "timeout_handler"}

# Ensure context isolation between features
integration_context = {
    "user_id": user_id,
    "session_id": f"integration_{timestamp}",
    "source_feature": self.__class__.__name__
}

# Add timing to integration calls
import time

start_time = time.time()
result = await feature.canonical_query_integration(query, user_id)
integration_time = (time.time() - start_time) * 1000

if integration_time > 200:  # 200ms threshold
    logger.warning(f"Slow integration: {integration_time}ms")