@voria/cli 0.0.4 → 0.0.5

package/python/voria/core/llm/minimax_provider.py

@@ -0,0 +1,187 @@
+"""MiniMax LLM Provider via NVIDIA Integrate API"""
+
+import logging
+from typing import List, Dict, Any, Optional
+import httpx
+
+from .base import BaseLLMProvider, Message, LLMResponse
+
+logger = logging.getLogger(__name__)
+
+
+class MiniMaxProvider(BaseLLMProvider):
+    """MiniMax LLM Provider using NVIDIA's OpenAI-compatible API"""
+
+    API_ENDPOINT = "https://integrate.api.nvidia.com/v1/chat/completions"
+    DEFAULT_MODEL = "minimaxai/minimax-m2.7"
+
+    def __init__(self, api_key: str, model: str = DEFAULT_MODEL):
+        """
+        Initialize MiniMax provider
+
+        Args:
+            api_key: NVIDIA API key
+            model: Model (minimaxai/minimax-m2.7, etc)
+        """
+        super().__init__(api_key, model)
+        self.client = httpx.AsyncClient(
+            headers={
+                "Authorization": f"Bearer {api_key}",
+                "Content-Type": "application/json",
+            },
+            timeout=300.0,
+        )
+
+    async def generate(
+        self, messages: List[Message], max_tokens: int = 2000, temperature: float = 0.7
+    ) -> LLMResponse:
+        """Generate response using MiniMax"""
+        try:
+            payload = {
+                "model": self.model,
+                "messages": [
+                    {"role": msg.role, "content": msg.content} for msg in messages
+                ],
+                "max_tokens": max_tokens,
+                "temperature": temperature,
+                "top_p": 0.95,
+                "stream": False,
+            }
+
+            logger.debug(f"Calling MiniMax API with {len(messages)} messages")
+            logger.info(f"Sending generation request to MiniMax model {self.model}...")
+
+            response = await self.client.post(self.API_ENDPOINT, json=payload)
+            response.raise_for_status()
+
+            data = response.json()
+            content = data["choices"][0]["message"]["content"]
+            tokens_used = data.get("usage", {}).get("total_tokens", 0)
+
+            logger.info(f"MiniMax API response: {tokens_used} tokens used")
+
+            return LLMResponse(
+                content=content,
+                tokens_used=tokens_used,
+                model=self.model,
+                provider="MiniMax",
+            )
+
+        except httpx.HTTPError as e:
+            logger.error(f"MiniMax API error: {e}")
+            raise
+        except Exception as e:
+            logger.error(f"Error generating with MiniMax: {e}")
+            raise
+
+    async def stream_generate(
+        self, messages: List[Message], max_tokens: int = 2000, temperature: float = 0.7
+    ):
+        """Stream generation from MiniMax"""
+        try:
+            payload = {
+                "model": self.model,
+                "messages": [
+                    {"role": msg.role, "content": msg.content} for msg in messages
+                ],
+                "max_tokens": max_tokens,
+                "temperature": temperature,
+                "top_p": 0.95,
+                "stream": True,
+            }
+
+            import json
+
+            async with self.client.stream("POST", self.API_ENDPOINT, json=payload) as response:
+                response.raise_for_status()
+                async for line in response.aiter_lines():
+                    if not line: continue
+                    if line.startswith("data: "):
+                        data_str = line[6:]
+                        if data_str == "[DONE]": break
+                        try:
+                            data = json.loads(data_str)
+                            delta = data["choices"][0].get("delta", {})
+                            if "content" in delta:
+                                yield delta["content"]
+                        except Exception as e:
+                            logger.error(f"Error parsing stream chunk: {e}")
+                            continue
+
+        except Exception as e:
+            logger.error(f"Error in MiniMax stream: {e}")
+            raise
+
+    async def plan(self, issue_description: str) -> str:
+        """Generate implementation plan"""
+        system_message = Message(
+            role="system",
+            content="""You are an expert software architect.
+Create a detailed implementation plan for fixing this GitHub issue.""",
+        )
+
+        user_message = Message(role="user", content=f"Issue:\n{issue_description}")
+
+        response = await self.generate([system_message, user_message], max_tokens=2000)
+
+        return response.content
+
+    async def generate_patch(
+        self,
+        issue_description: str,
+        context_files: Dict[str, str],
+        previous_errors: Optional[str] = None,
+    ) -> str:
+        """Generate code patch in unified diff format"""
+        system_message = Message(
+            role="system",
+            content="""Generate a unified diff format patch.
+Format:
+--- a/path
++++ b/path
+@@ -line,count +line,count @@""",
+        )
+
+        context = f"Issue:\n{issue_description}\n\n"
+        for filename, content in context_files.items():
+            context += f"\n--- {filename} ---\n{content}\n"
+
+        if previous_errors:
+            context += f"\nPrevious Errors:\n{previous_errors}"
+
+        user_message = Message(role="user", content=context)
+
+        response = await self.generate(
+            [system_message, user_message], max_tokens=3000, temperature=0.5
+        )
+
+        return response.content
+
+    async def analyze_test_failure(
+        self, test_output: str, code_context: str
+    ) -> Dict[str, Any]:
+        """Analyze test failure"""
+        system_message = Message(
+            role="system", content="Analyze the test failure and suggest fixes."
+        )
+
+        user_message = Message(
+            role="user",
+            content=f"""Test Output:
+{test_output}
+
+Code:
+{code_context}""",
+        )
+
+        response = await self.generate([system_message, user_message], max_tokens=1500)
+
+        return {
+            "analysis": response.content,
+            "provider": "MiniMax",
+            "tokens_used": response.tokens_used,
+        }
+
+    async def close(self):
+        """Close HTTP client"""
+        await self.client.aclose()

package/python/voria/core/llm/modal_provider.py

@@ -214,6 +214,39 @@ Code Context:
             "tokens_used": response.tokens_used,
         }
 
+    async def stream_generate(
+        self, messages: List[Message], max_tokens: int = 2000, temperature: float = 0.7
+    ):
+        """Stream response tokens from Modal"""
+        import json as _json
+        try:
+            payload = {
+                "model": self.model,
+                "messages": [{"role": m.role, "content": m.content} for m in messages],
+                "max_tokens": max_tokens,
+                "temperature": temperature,
+                "stream": True,
+            }
+            async with self.client.stream("POST", self.API_ENDPOINT, json=payload) as response:
+                response.raise_for_status()
+                async for line in response.aiter_lines():
+                    if not line:
+                        continue
+                    if line.startswith("data: "):
+                        data_str = line[6:]
+                        if data_str == "[DONE]":
+                            break
+                        try:
+                            data = _json.loads(data_str)
+                            delta = data["choices"][0].get("delta", {})
+                            if "content" in delta:
+                                yield delta["content"]
+                        except Exception:
+                            continue
+        except Exception as e:
+            logger.error(f"Modal stream error: {e}")
+            raise
+
     async def close(self):
         """Close HTTP client"""
         await self.client.aclose()

package/python/voria/core/llm/model_discovery.py

@@ -28,7 +28,9 @@ class ModelDiscovery:
     """Fetch available models from LLM providers."""
 
     @staticmethod
-    async def fetch_generic_openai_compatible(api_key: str, base_url: str, provider_name: str) -> List[ModelInfo]:
+    async def fetch_generic_openai_compatible(
+        api_key: str, base_url: str, provider_name: str
+    ) -> List[ModelInfo]:
         """Fetch models from an OpenAI-compatible API."""
         try:
             async with httpx.AsyncClient() as client:
@@ -51,7 +53,9 @@ class ModelDiscovery:
                         )
                     return models
                 else:
-                    logger.warning(f"{provider_name} API returned {response.status_code}")
+                    logger.warning(
+                        f"{provider_name} API returned {response.status_code}"
+                    )
                     return []
         except Exception as e:
             logger.warning(f"Failed to fetch {provider_name} models: {e}")
@@ -79,7 +83,9 @@ class ModelDiscovery:
                                 description=f"Modal Z.ai - {model.get('created', 'N/A')}",
                             )
                         )
-                    return models if models else await ModelDiscovery._get_modal_fallback()
+                    return (
+                        models if models else await ModelDiscovery._get_modal_fallback()
+                    )
                 return await ModelDiscovery._get_modal_fallback()
         except Exception:
             return await ModelDiscovery._get_modal_fallback()
@@ -108,8 +114,14 @@ class ModelDiscovery:
                     for model in data.get("data", []):
                         model_id = model.get("id", "")
                         if any(model_id.startswith(p) for p in suitable_prefixes):
-                            models.append(ModelInfo(name=model_id, display_name=model_id))
-                    return models if models else await ModelDiscovery._get_openai_fallback()
+                            models.append(
+                                ModelInfo(name=model_id, display_name=model_id)
+                            )
+                    return (
+                        models
+                        if models
+                        else await ModelDiscovery._get_openai_fallback()
+                    )
                 return await ModelDiscovery._get_openai_fallback()
         except Exception:
             return await ModelDiscovery._get_openai_fallback()
@@ -137,7 +149,11 @@ class ModelDiscovery:
                         name = model.get("name", "").replace("models/", "")
                         if "gemini" in name.lower():
                             models.append(ModelInfo(name=name, display_name=name))
-                    return models if models else await ModelDiscovery._get_gemini_fallback()
+                    return (
+                        models
+                        if models
+                        else await ModelDiscovery._get_gemini_fallback()
+                    )
                 return await ModelDiscovery._get_gemini_fallback()
         except Exception:
             return await ModelDiscovery._get_gemini_fallback()
@@ -150,14 +166,30 @@ class ModelDiscovery:
         ]
 
     @staticmethod
-    async def fetch_claude_models(api_key: str) -> List[ModelInfo]:
-        # Anthropic doesn't have a models endpoint, just return hardcoded
+    async def _get_claude_fallback() -> List[ModelInfo]:
         return [
-            ModelInfo(name="claude-3-5-sonnet-20240620", display_name="Claude 3.5 Sonnet"),
+            ModelInfo(
+                name="claude-3-5-sonnet-20240620", display_name="Claude 3.5 Sonnet"
+            ),
             ModelInfo(name="claude-3-opus-20240229", display_name="Claude 3 Opus"),
             ModelInfo(name="claude-3-haiku-20240307", display_name="Claude 3 Haiku"),
         ]
 
+    @staticmethod
+    async def fetch_claude_models(api_key: str) -> List[ModelInfo]:
+        # Anthropic doesn't have a models endpoint, just return hardcoded
+        return await ModelDiscovery._get_claude_fallback()
+
+    @staticmethod
+    async def _get_minimax_fallback() -> List[ModelInfo]:
+        return [
+            ModelInfo(
+                name="minimaxai/minimax-m2.7",
+                display_name="MiniMax M2.7",
+                description="MiniMax M2.7 via NVIDIA",
+            ),
+        ]
+
     @staticmethod
     async def discover_all(provider: str, api_key: str) -> List[ModelInfo]:
         provider = provider.lower().strip()
@@ -170,27 +202,37 @@ class ModelDiscovery:
         elif provider == "claude":
             return await ModelDiscovery.fetch_claude_models(api_key)
         elif provider == "deepseek":
-            return await ModelDiscovery.fetch_generic_openai_compatible(api_key, "https://api.deepseek.com/v1", "DeepSeek")
+            return await ModelDiscovery.fetch_generic_openai_compatible(
+                api_key, "https://api.deepseek.com/v1", "DeepSeek"
+            )
         elif provider == "kimi":
-            return await ModelDiscovery.fetch_generic_openai_compatible(api_key, "https://api.moonshot.cn/v1", "Kimi")
+            return await ModelDiscovery.fetch_generic_openai_compatible(
+                api_key, "https://api.moonshot.cn/v1", "Kimi"
+            )
         elif provider == "minimax":
-            return await ModelDiscovery.fetch_generic_openai_compatible(api_key, "https://api.minimax.chat/v1", "Minimax")
+            return await ModelDiscovery.fetch_generic_openai_compatible(
+                api_key, "https://integrate.api.nvidia.com/v1", "MiniMax"
+            )
         elif provider == "siliconflow":
-            return await ModelDiscovery.fetch_generic_openai_compatible(api_key, "https://api.siliconflow.cn/v1", "SiliconFlow")
+            return await ModelDiscovery.fetch_generic_openai_compatible(
+                api_key, "https://api.siliconflow.cn/v1", "SiliconFlow"
+            )
         else:
             return []
 
+
 if __name__ == "__main__":
     import sys
+
     if len(sys.argv) < 3:
         print(json.dumps([]))
         sys.exit(0)
-    
+
     provider = sys.argv[1]
     api_key = sys.argv[2]
-    
+
     async def main():
         models = await ModelDiscovery.discover_all(provider, api_key)
         print(json.dumps([asdict(m) for m in models]))
-    
+
     asyncio.run(main())

package/python/voria/core/llm/openai_provider.py

@@ -141,6 +141,39 @@ Code:
             "tokens_used": response.tokens_used,
         }
 
+    async def stream_generate(
+        self, messages: List[Message], max_tokens: int = 2000, temperature: float = 0.7
+    ):
+        """Stream response tokens from OpenAI"""
+        import json as _json
+        try:
+            payload = {
+                "model": self.model,
+                "messages": [{"role": m.role, "content": m.content} for m in messages],
+                "max_tokens": max_tokens,
+                "temperature": temperature,
+                "stream": True,
+            }
+            async with self.client.stream("POST", self.API_ENDPOINT, json=payload) as response:
+                response.raise_for_status()
+                async for line in response.aiter_lines():
+                    if not line:
+                        continue
+                    if line.startswith("data: "):
+                        data_str = line[6:]
+                        if data_str == "[DONE]":
+                            break
+                        try:
+                            data = _json.loads(data_str)
+                            delta = data["choices"][0].get("delta", {})
+                            if "content" in delta:
+                                yield delta["content"]
+                        except Exception:
+                            continue
+        except Exception as e:
+            logger.error(f"OpenAI stream error: {e}")
+            raise
+
     async def close(self):
         """Close HTTP client"""
         await self.client.aclose()

package/python/voria/core/llm/siliconflow_provider.py

@@ -0,0 +1,109 @@
+"""SiliconFlow LLM Provider
+
+SiliconFlow provides access to multiple open-source models via OpenAI-compatible API.
+"""
+
+import json
+import logging
+from typing import List, Dict, Any, Optional
+import httpx
+
+from .base import BaseLLMProvider, Message, LLMResponse
+
+logger = logging.getLogger(__name__)
+
+
+class SiliconFlowProvider(BaseLLMProvider):
+    """SiliconFlow LLM Provider (OpenAI-compatible API)"""
+
+    API_ENDPOINT = "https://api.siliconflow.cn/v1/chat/completions"
+    DEFAULT_MODEL = "deepseek-ai/DeepSeek-V2.5"
+
+    def __init__(self, api_key: str, model: str = DEFAULT_MODEL):
+        super().__init__(api_key, model)
+        self.client = httpx.AsyncClient(
+            headers={
+                "Authorization": f"Bearer {api_key}",
+                "Content-Type": "application/json",
+            },
+            timeout=300.0,
+        )
+
+    async def generate(
+        self, messages: List[Message], max_tokens: int = 2000, temperature: float = 0.7
+    ) -> LLMResponse:
+        try:
+            payload = {
+                "model": self.model,
+                "messages": [
+                    {"role": msg.role, "content": msg.content} for msg in messages
+                ],
+                "max_tokens": max_tokens,
+                "temperature": temperature,
+            }
+            response = await self.client.post(self.API_ENDPOINT, json=payload)
+            response.raise_for_status()
+            data = response.json()
+            content = data["choices"][0]["message"]["content"]
+            tokens_used = data.get("usage", {}).get("total_tokens", 0)
+            return LLMResponse(content=content, tokens_used=tokens_used, model=self.model, provider="SiliconFlow")
+        except Exception as e:
+            logger.error(f"SiliconFlow API error: {e}")
+            raise
+
+    async def stream_generate(
+        self, messages: List[Message], max_tokens: int = 2000, temperature: float = 0.7
+    ):
+        try:
+            payload = {
+                "model": self.model,
+                "messages": [{"role": m.role, "content": m.content} for m in messages],
+                "max_tokens": max_tokens,
+                "temperature": temperature,
+                "stream": True,
+            }
+            async with self.client.stream("POST", self.API_ENDPOINT, json=payload) as response:
+                response.raise_for_status()
+                async for line in response.aiter_lines():
+                    if not line:
+                        continue
+                    if line.startswith("data: "):
+                        data_str = line[6:]
+                        if data_str == "[DONE]":
+                            break
+                        try:
+                            data = json.loads(data_str)
+                            delta = data["choices"][0].get("delta", {})
+                            if "content" in delta:
+                                yield delta["content"]
+                        except Exception:
+                            continue
+        except Exception as e:
+            logger.error(f"SiliconFlow stream error: {e}")
+            raise
+
+    async def plan(self, issue_description: str) -> str:
+        system_message = Message(role="system", content="You are an expert software architect. Create a detailed implementation plan.")
+        user_message = Message(role="user", content=f"Issue:\n{issue_description}")
+        response = await self.generate([system_message, user_message], max_tokens=2000)
+        return response.content
+
+    async def generate_patch(self, issue_description: str, context_files: Dict[str, str], previous_errors: Optional[str] = None) -> str:
+        system_message = Message(role="system", content="Generate a unified diff format patch.")
+        context = f"Issue:\n{issue_description}\n\n"
+        for filename, content in context_files.items():
+            context += f"\n--- {filename} ---\n{content}\n"
+        if previous_errors:
+            context += f"\nPrevious Errors:\n{previous_errors}"
+        user_message = Message(role="user", content=context)
+        response = await self.generate([system_message, user_message], max_tokens=3000, temperature=0.5)
+        return response.content
+
+    async def analyze_test_failure(self, test_output: str, code_context: str) -> Dict[str, Any]:
+        system_message = Message(role="system", content="Analyze the test failure and suggest fixes.")
+        user_message = Message(role="user", content=f"Test Output:\n{test_output}\n\nCode:\n{code_context}")
+        response = await self.generate([system_message, user_message], max_tokens=1500)
+        return {"analysis": response.content, "provider": "SiliconFlow", "tokens_used": response.tokens_used}
+
+    async def close(self):
+        await self.client.aclose()

package/python/voria/core/setup.py

@@ -80,6 +80,8 @@ class ProviderSetup:
                 models = await ModelDiscovery._get_gemini_fallback()
             elif provider_name == "claude":
                 models = await ModelDiscovery._get_claude_fallback()
+            elif provider_name == "minimax":
+                models = await ModelDiscovery._get_minimax_fallback()
 
         # Step 4: Choose model
         chosen_model = await self._choose_model(models)
@@ -117,7 +119,7 @@ class ProviderSetup:
 
         while True:
             try:
-                choice = input("\nEnter number (1-4): ").strip()
+                choice = input(f"\nEnter number (1-{len(providers)}): ").strip()
                 idx = int(choice) - 1
                 if 0 <= idx < len(providers):
                     return providers[idx]
@@ -133,6 +135,7 @@ class ProviderSetup:
             "openai": ["OPENAI_API_KEY"],
             "gemini": ["GOOGLE_API_KEY", "GEMINI_API_KEY"],
             "claude": ["ANTHROPIC_API_KEY", "CLAUDE_API_KEY"],
+            "minimax": ["MINIMAX_API_KEY", "NVIDIA_API_KEY"],
         }
 
         for env_var in env_vars.get(provider_name, []):

package/python/voria/core/testing/definitions.py

@@ -0,0 +1,87 @@
+"""
+Definitions for 50+ different types of testing supported by voria.
+Combines security (pentesting) and production/reliability tests.
+"""
+
+from dataclasses import dataclass
+from enum import Enum
+from typing import List, Dict, Any, Optional
+
+class TestCategory(Enum):
+    SECURITY = "Security (Pentesting)"
+    PRODUCTION = "Production & Reliability"
+    PERFORMANCE = "Performance & Latency"
+    STRESS = "Stress Testing"
+    QUALITY = "Code Quality & Compliance"
+
+@dataclass
+class TestInfo:
+    id: str
+    name: str
+    category: TestCategory
+    description: str
+    impact: str  # High, Medium, Low
+    type: str  # "static" (code analysis) or "dynamic" (runtime)
+
+# The master list of all 52 tests
+TEST_DEFINITIONS: List[TestInfo] = [
+    # --- SECURITY (25 tests) ---
+    TestInfo("sql_injection", "SQL Injection Scan", TestCategory.SECURITY, "Checks for improper sanitization of database queries.", "Critical", "static"),
+    TestInfo("xss", "Cross-Site Scripting (XSS)", TestCategory.SECURITY, "Checks for reflected or stored XSS vulnerabilities in web code.", "High", "static"),
+    TestInfo("csrf", "CSRF Protection Audit", TestCategory.SECURITY, "Verifies presence of CSRF tokens in state-changing requests.", "High", "static"),
+    TestInfo("path_traversal", "Path Traversal Probe", TestCategory.SECURITY, "Detects insecure file path handling that could allow unauthorized access.", "High", "static"),
+    TestInfo("insecure_deserialization", "Insecure Deserialization", TestCategory.SECURITY, "Identifies unsafe decoding of serialized data.", "Critical", "static"),
+    TestInfo("hardcoded_secrets", "Hardcoded Secret Detection", TestCategory.SECURITY, "Scans codebase for API keys, passwords, and private certificates.", "Critical", "static"),
+    TestInfo("insecure_jwt", "Insecure JWT Handling", TestCategory.SECURITY, "Checks for weak JWT algorithms or lack of signature verification.", "High", "static"),
+    TestInfo("broken_access_control", "Broken Access Control", TestCategory.SECURITY, "Analyzes authorization logic for potential bypasses.", "High", "static"),
+    TestInfo("open_redirect", "Open Redirect Audit", TestCategory.SECURITY, "Checks for unsafe user-controlled redirection URLs.", "Medium", "static"),
+    TestInfo("security_headers", "Security Headers Audit", TestCategory.SECURITY, "Verifies presence of CSP, HSTS, and X-Content-Type headers.", "Medium", "static"),
+    TestInfo("clickjacking", "Clickjacking Vulnerability", TestCategory.SECURITY, "Checks for X-Frame-Options or suitable CSP directives.", "Low", "static"),
+    TestInfo("bruteforce_protection", "Bruteforce Protection", TestCategory.SECURITY, "Identifies lack of rate limiting or account lockout logic.", "Medium", "static"),
+    TestInfo("weak_crypto", "Weak Cryptography", TestCategory.SECURITY, "Detects use of MD5, SHA1, or other deprecated algorithms.", "High", "static"),
+    TestInfo("sensitive_data_exposure", "Sensitive Data Exposure", TestCategory.SECURITY, "Checks for PII or sensitive info leaked in logs or error messages.", "High", "static"),
+    TestInfo("xxe", "XML External Entity (XXE)", TestCategory.SECURITY, "Checks for insecure XML parsers allowed to resolve external entities.", "High", "static"),
+    TestInfo("insecure_upload", "Insecure File Upload", TestCategory.SECURITY, "Analyzes file upload handling for potential malicious file execution.", "High", "static"),
+    TestInfo("command_injection", "Command Injection Scan", TestCategory.SECURITY, "Checks for shell commands built using untrusted user input.", "Critical", "static"),
+    TestInfo("directory_listing", "Directory Listing Probe", TestCategory.SECURITY, "Checks web config for inadvertent directory listing enablement.", "Medium", "static"),
+    TestInfo("ssrf", "Server-Side Request Forgery", TestCategory.SECURITY, "Detects code that makes requests to user-controlled internal URLs.", "High", "static"),
+    TestInfo("session_management", "Improper Session Management", TestCategory.SECURITY, "Analyzes session lifecycle, fixation, and timeout logic.", "Medium", "static"),
+    TestInfo("rate_limiting", "Lack of Rate Limiting", TestCategory.SECURITY, "Checks for API endpoints vulnerable to abuse without throttling.", "Medium", "static"),
+    TestInfo("info_leakage", "Information Leakage Scan", TestCategory.SECURITY, "Detects server versions or stack traces exposed to end users.", "Low", "static"),
+    TestInfo("vulnerable_components", "Known Vulnerable Components", TestCategory.SECURITY, "Audit dependencies against known vulnerability databases.", "High", "static"),
+    TestInfo("integrity_checks", "Lack of Integrity Checks", TestCategory.SECURITY, "Checks if downloaded assets or code lack checksum verification.", "Medium", "static"),
+    TestInfo("error_handling_leak", "Error Handling Leakage", TestCategory.SECURITY, "Verifies that catch blocks don't expose system internals.", "Low", "static"),
+
+    # --- PRODUCTION & RELIABILITY (10 tests) ---
+    TestInfo("latency_baseline", "Latency Baseline Audit", TestCategory.PRODUCTION, "Establishes baseline response times for core functions.", "Medium", "dynamic"),
+    TestInfo("deadlock_detection", "Potential Deadlock Scan", TestCategory.PRODUCTION, "Analyzes lock acquisition order for potential circular dependencies.", "High", "static"),
+    TestInfo("race_condition", "Race Condition Check", TestCategory.PRODUCTION, "Identifies non-atomic operations on shared state.", "High", "static"),
+    TestInfo("unhandled_exceptions", "Unhandled Exception Scan", TestCategory.PRODUCTION, "Checks for paths where exceptions could crash the process.", "High", "static"),
+    TestInfo("memory_leak_static", "Memory Leak static Scan", TestCategory.PRODUCTION, "Identifies patterns like growing collections or unclosed resources.", "Medium", "static"),
+    TestInfo("connection_exhaustion", "Conn Pool Exhaustion Probe", TestCategory.PRODUCTION, "Analyzes resource cleanup to prevent pool starvation.", "High", "static"),
+    TestInfo("slow_query", "Slow Query Detection", TestCategory.PRODUCTION, "Scans for unoptimized DB queries without indices.", "Medium", "static"),
+    TestInfo("cache_consistency", "Cache Inconsistency Scan", TestCategory.PRODUCTION, "Checks for missing cache invalidation after updates.", "Medium", "static"),
+    TestInfo("timeout_handling", "Missing Timeout Logic", TestCategory.PRODUCTION, "Detects blocking calls without explicit timeouts.", "Medium", "static"),
+    TestInfo("circular_dep", "Circular Dependency Audit", TestCategory.PRODUCTION, "Maps module imports for circularities that impair startup.", "Low", "static"),
+
+    # --- PERFORMANCE & STRESS (10 tests) ---
+    TestInfo("cpu_stress", "CPU Stress Resilience", TestCategory.STRESS, "Simulates heavy computational load to test stability.", "Medium", "dynamic"),
+    TestInfo("mem_stress", "Memory Stress Resilience", TestCategory.STRESS, "Simulates high memory allocation to test GC and OOM handling.", "Medium", "dynamic"),
+    TestInfo("concurrent_users", "High Concurrency Simulation", TestCategory.STRESS, "Simulates massive parallel user requests.", "High", "dynamic"),
+    TestInfo("payload_stress", "Large Payload Resilience", TestCategory.STRESS, "Tests handling of extremely large input data.", "Medium", "dynamic"),
+    TestInfo("network_latency", "Network Latency Simulation", TestCategory.PERFORMANCE, "Simulates slow network conditions (jitter/latency).", "Low", "dynamic"),
+    TestInfo("p99_latency", "P99 Latency Audit", TestCategory.PERFORMANCE, "Measures tail latency under normal load.", "Medium", "dynamic"),
+    TestInfo("throughput_max", "Max Throughput Benchmark", TestCategory.PERFORMANCE, "Determines the saturation point of the service.", "Medium", "dynamic"),
+    TestInfo("bundle_size", "Asset Bundle Size Audit", TestCategory.PERFORMANCE, "Analyzes production assets for excessive size.", "Low", "static"),
+    TestInfo("cold_start", "Cold Start Analysis", TestCategory.PERFORMANCE, "Measures startup time and initialization performance.", "Low", "dynamic"),
+    TestInfo("db_index_audit", "DB Index Optimization", TestCategory.PERFORMANCE, "Suggests missing indices based on query patterns.", "Medium", "static"),
+
+    # --- QUALITY & COMPLIANCE (7 tests) ---
+    TestInfo("license_compliance", "License Compliance Audit", TestCategory.QUALITY, "Checks dependencies for copyleft or restrictive licenses.", "Medium", "static"),
+    TestInfo("dep_graph", "Dependency Health Audit", TestCategory.QUALITY, "Analyzes depth and variety of project dependencies.", "Low", "static"),
+    TestInfo("doc_completeness", "Documentation Completeness", TestCategory.QUALITY, "Checks for missing docstrings or exported API docs.", "Low", "static"),
+    TestInfo("coverage_gap", "Test Coverage Gap Analysis", TestCategory.QUALITY, "Identifies critical paths missing automated tests.", "Medium", "static"),
+    TestInfo("lint_security", "Security-focused Linting", TestCategory.QUALITY, "Runs specialized security linter rules.", "Medium", "static"),
+    TestInfo("complexity_drift", "Complexity Drift Scan", TestCategory.QUALITY, "Detects increasing cyclomatic complexity over time.", "Low", "static"),
+    TestInfo("redundant_calls", "Redundant API Call Detection", TestCategory.QUALITY, "Identifies duplicate data fetching patterns.", "Low", "static"),
+]