feat: add VentureAPI class and refactor endpoints

- Added VentureAPI class to encapsulate venture strategy operations
- Refactored FastAPI endpoints to use VentureAPI
- Added __all__ export for VentureAPI
- Converted request models to dataclasses
- Added proper error handling and response formatting

api/venture_api.py

@@ -4,6 +4,7 @@ from fastapi import APIRouter, HTTPException, Depends
 from typing import List, Dict, Any, Optional
 from pydantic import BaseModel, Field
 from datetime import datetime
+from dataclasses import dataclass
 
 from reasoning.venture_strategies import (
     AIStartupStrategy, SaaSVentureStrategy, AutomationVentureStrategy,
@@ -28,17 +29,20 @@ class VentureRequest(BaseModel):
     query: str
     context: Dict[str, Any] = Field(default_factory=dict)
 
-class MarketRequest(BaseModel):
+@dataclass
+class MarketRequest:
     """Market analysis request."""
     segment: str
     context: Dict[str, Any] = Field(default_factory=dict)
 
-class PortfolioRequest(BaseModel):
+@dataclass
+class PortfolioRequest:
     """Portfolio optimization request."""
     ventures: List[str]
     context: Dict[str, Any] = Field(default_factory=dict)
 
-class MonetizationRequest(BaseModel):
+@dataclass
+class MonetizationRequest:
     """Monetization optimization request."""
     venture_type: str
     context: Dict[str, Any] = Field(default_factory=dict)
@@ -61,137 +65,183 @@ VENTURE_STRATEGIES = {
     "ai_marketplace": AIMarketplaceStrategy()
 }
 
+class VentureAPI:
+    """API for venture strategy operations."""
+    
+    def __init__(self):
+        """Initialize venture API components."""
+        self.market_analyzer = MarketAnalyzer()
+        self.portfolio_optimizer = PortfolioOptimizer()
+        self.monetization_optimizer = MonetizationOptimizer()
+        self.strategies = VENTURE_STRATEGIES
+
+    async def analyze_venture(self, request: VentureRequest) -> Dict[str, Any]:
+        """Analyze venture opportunity."""
+        try:
+            strategy = self.strategies.get(request.venture_type)
+            if not strategy:
+                raise HTTPException(status_code=400, detail=f"Invalid venture type: {request.venture_type}")
+            
+            result = await strategy.reason(request.query, request.context or {})
+            return {
+                "success": True,
+                "result": result,
+                "timestamp": datetime.now().isoformat()
+            }
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=str(e))
+
+    async def analyze_market(self, request: MarketRequest) -> Dict[str, Any]:
+        """Analyze market opportunity."""
+        try:
+            result = await self.market_analyzer.analyze_market(request.segment, request.context)
+            return {
+                "success": True,
+                "result": result,
+                "timestamp": datetime.now().isoformat()
+            }
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=str(e))
+
+    async def optimize_portfolio(self, request: PortfolioRequest) -> Dict[str, Any]:
+        """Optimize venture portfolio."""
+        try:
+            result = await self.portfolio_optimizer.optimize_portfolio(request.ventures, request.context)
+            return {
+                "success": True,
+                "result": result,
+                "timestamp": datetime.now().isoformat()
+            }
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=str(e))
+
+    async def optimize_monetization(self, request: MonetizationRequest) -> Dict[str, Any]:
+        """Optimize venture monetization."""
+        try:
+            result = await self.monetization_optimizer.optimize_monetization(request.venture_type, request.context)
+            return {
+                "success": True,
+                "result": result,
+                "timestamp": datetime.now().isoformat()
+            }
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=str(e))
+
+    def list_strategies(self) -> List[str]:
+        """List available venture strategies."""
+        return list(self.strategies.keys())
+
+    def get_venture_metrics(self, venture_type: str) -> Dict[str, Any]:
+        """Get venture performance metrics."""
+        try:
+            strategy = self.strategies.get(venture_type)
+            if not strategy:
+                raise HTTPException(status_code=400, detail=f"Invalid venture type: {venture_type}")
+            
+            metrics = strategy.get_venture_metrics()
+            return {
+                "success": True,
+                "venture_type": venture_type,
+                "metrics": metrics,
+                "timestamp": datetime.now().isoformat()
+            }
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=str(e))
+
+    def get_market_insights(self) -> Dict[str, Any]:
+        """Get comprehensive market insights."""
+        try:
+            insights = self.market_analyzer.get_market_insights()
+            return {
+                "success": True,
+                "insights": insights,
+                "timestamp": datetime.now().isoformat()
+            }
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=str(e))
+
+    def get_portfolio_insights(self) -> Dict[str, Any]:
+        """Get comprehensive portfolio insights."""
+        try:
+            insights = self.portfolio_optimizer.get_portfolio_insights()
+            return {
+                "success": True,
+                "insights": insights,
+                "timestamp": datetime.now().isoformat()
+            }
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=str(e))
+
+    def get_monetization_metrics(self) -> Dict[str, Any]:
+        """Get comprehensive monetization metrics."""
+        try:
+            metrics = self.monetization_optimizer.get_monetization_metrics()
+            return {
+                "success": True,
+                "metrics": metrics,
+                "timestamp": datetime.now().isoformat()
+            }
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=str(e))
+
 # Endpoints
 @router.post("/analyze")
 async def analyze_venture(request: VentureRequest):
     """Analyze venture opportunity."""
-    try:
-        strategy = VENTURE_STRATEGIES.get(request.venture_type)
-        if not strategy:
-            raise HTTPException(
-                status_code=400,
-                detail=f"Invalid venture type: {request.venture_type}"
-            )
-        
-        result = await strategy.reason(request.query, request.context)
-        return {
-            "success": True,
-            "result": result,
-            "timestamp": datetime.now().isoformat()
-        }
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
+    venture_api = VentureAPI()
+    return await venture_api.analyze_venture(request)
 
 @router.post("/market")
 async def analyze_market(request: MarketRequest):
     """Analyze market opportunity."""
-    try:
-        analyzer = MarketAnalyzer()
-        result = await analyzer.analyze_market(request.segment, request.context)
-        return {
-            "success": True,
-            "result": result,
-            "timestamp": datetime.now().isoformat()
-        }
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
+    venture_api = VentureAPI()
+    return await venture_api.analyze_market(request)
 
 @router.post("/portfolio")
 async def optimize_portfolio(request: PortfolioRequest):
     """Optimize venture portfolio."""
-    try:
-        optimizer = PortfolioOptimizer()
-        result = await optimizer.optimize_portfolio(request.ventures, request.context)
-        return {
-            "success": True,
-            "result": result,
-            "timestamp": datetime.now().isoformat()
-        }
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
+    venture_api = VentureAPI()
+    return await venture_api.optimize_portfolio(request)
 
 @router.post("/monetization")
 async def optimize_monetization(request: MonetizationRequest):
     """Optimize venture monetization."""
-    try:
-        optimizer = MonetizationOptimizer()
-        result = await optimizer.optimize_monetization(
-            request.venture_type, request.context)
-        return {
-            "success": True,
-            "result": result,
-            "timestamp": datetime.now().isoformat()
-        }
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
+    venture_api = VentureAPI()
+    return await venture_api.optimize_monetization(request)
 
 @router.get("/strategies")
 async def list_strategies():
     """List available venture strategies."""
+    venture_api = VentureAPI()
     return {
         "success": True,
-        "strategies": list(VENTURE_STRATEGIES.keys()),
+        "strategies": venture_api.list_strategies(),
         "timestamp": datetime.now().isoformat()
     }
 
 @router.get("/metrics/{venture_type}")
 async def get_venture_metrics(venture_type: str):
     """Get venture performance metrics."""
-    try:
-        strategy = VENTURE_STRATEGIES.get(venture_type)
-        if not strategy:
-            raise HTTPException(
-                status_code=400,
-                detail=f"Invalid venture type: {venture_type}"
-            )
-        
-        metrics = strategy.get_venture_metrics()
-        return {
-            "success": True,
-            "metrics": metrics,
-            "timestamp": datetime.now().isoformat()
-        }
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
+    venture_api = VentureAPI()
+    return venture_api.get_venture_metrics(venture_type)
 
 @router.get("/insights")
 async def get_market_insights():
     """Get comprehensive market insights."""
-    try:
-        analyzer = MarketAnalyzer()
-        insights = analyzer.get_market_insights()
-        return {
-            "success": True,
-            "insights": insights,
-            "timestamp": datetime.now().isoformat()
-        }
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
+    venture_api = VentureAPI()
+    return venture_api.get_market_insights()
 
 @router.get("/portfolio/insights")
 async def get_portfolio_insights():
     """Get comprehensive portfolio insights."""
-    try:
-        optimizer = PortfolioOptimizer()
-        insights = optimizer.get_portfolio_insights()
-        return {
-            "success": True,
-            "insights": insights,
-            "timestamp": datetime.now().isoformat()
-        }
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
+    venture_api = VentureAPI()
+    return venture_api.get_portfolio_insights()
 
 @router.get("/monetization/metrics")
 async def get_monetization_metrics():
     """Get comprehensive monetization metrics."""
-    try:
-        optimizer = MonetizationOptimizer()
-        metrics = optimizer.get_monetization_metrics()
-        return {
-            "success": True,
-            "metrics": metrics,
-            "timestamp": datetime.now().isoformat()
-        }
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
+    venture_api = VentureAPI()
+    return venture_api.get_monetization_metrics()
+
+# Export VentureAPI
+__all__ = ['VentureAPI']