@voria/cli 0.0.4 → 0.0.5

package/docs/CHANGELOG.md

@@ -7,6 +7,25 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ---
 
+## [v0.0.5] - April 14, 2026 ✅ TIER 1: SECURITY, STREAMING & RELIABILITY
+
+### 🛡️ Pentesting CLI (Enhanced)
+- **25+ Security Audits** running in parallel with `voria scan all`
+- **SARIF Support:** Export results for GitHub Security tab integration (`voria ci`)
+- **Security Diff:** Compare posture between git refs (`voria diff`)
+- **Watch Mode:** Automatic re-testing on file changes (`voria watch`)
+
+### ⚡ Performance & Reliability
+- **HTTP Benchmarking:** Real-world load testing with latency distribution (`voria benchmark`)
+- **Improved Stress Tests:** Real-time metrics for CPU, Memory, and Network tests
+- **NVIDIA Integrated API Support:** Native support for MiniMax model v2.7
+
+### 🤖 LLM & UX
+- **Streaming Output:** Real-time token-by-token streaming for plan and fix commands
+- **Auto-Fix:** AI-powered bug fixing with automatic patch application (`voria fix --auto`)
+- **Premium Blue UI:** Completely revamped CLI aesthetic with professional formatting
+- **Daemon-Ready IPC:** Infrastructure for persistent background engine acceleration
+
 ## [v0.0.3] - April 12, 2026 ✅ ADVANCED ANALYSIS & CHINESE MODELS
 
 ### 🔭 Advanced Code Analysis (New)

package/docs/USER_GUIDE.md

@@ -222,20 +222,49 @@ voria apply fix.patch -v
 
 ---
 
+### `voria test [NAME] [--list]`
+
+Run codebase security audits, stress tests, and performance probes.
+
+**Usage:**
+```bash
+# List all 50+ available tests
+voria test --list
+
+# Run a specific security scan (e.g., SQL Injection)
+voria test sql_injection
+
+# Perform a stress test
+voria test cpu_stress
+```
+
+**Categories Include:**
+- **Security (Pentesting):** SQLi, XSS, CSRF, JWT, SSRF, XXE, and 20+ more.
+- **Production Resilience:** Deadlock detection, Race conditions, Unhandled exceptions.
+- **Performance:** Latency baseline, P99 audits, Throughput benchmarks.
+- **Stress Testing:** CPU/Memory saturation, concurrent user simulation.
+- **Quality:** License compliance, dependency graph health.
+
+**What it does:**
+1. **Identifies** the test type (static analysis or dynamic probing).
+2. **Analyzes** code context using LLMs for security patterns.
+3. **Executes** runtime stress simulations for performance audits.
+4. **Reports** detailed findings, severity, and recommended fixes.
+
+---
+
 ##  Configuration
 
 voria stores configuration in `~/.voria/config.json`:
 
 ```json
 {
-  "llm_provider": "modal",
-  "modal_token": "sk-modal-...",
-  "github_token": "ghp_...",
   "llm_provider": "openai",
   "llm_api_key": "sk-...",
-  "llm_model": "gpt-4",
+  "llm_model": "gpt-4o",
+  "github_token": "ghp_...",
   "daily_budget": 10.0,
-  "max_retries": 1
+  "test_framework": "pytest"
 }
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voria/cli",
-  "version": "0.0.4",
+  "version": "0.0.5",
   "description": "AI-powered CLI tool for automated bug fixing - initialize with voria --init",
   "main": "bin/voria",
   "type": "module",

package/python/voria/__init__.py

@@ -1,6 +1,6 @@
 """voria: AI-powered CLI tool for open source contributors."""
 
-__version__ = "0.1.0"
+__version__ = "0.0.5"
 __author__ = "voria Contributors"
 
 from . import engine

package/python/voria/core/executor/executor.py

@@ -247,6 +247,10 @@ class JestParser:
         """Parse jest JSON output"""
 
         results = []
+        passed = 0
+        failed = 0
+        skipped = 0
+        duration = 0.0
 
         try:
             # Jest outputs JSON
@@ -289,6 +293,7 @@ class JestParser:
             # Fallback: parse text output
             passed = len(re.findall(r"✓", stdout))
             failed = len(re.findall(r"✕", stdout))
+            # skipped and duration keep their default values (0, 0.0)
 
         return TestSuiteResult(
             framework="jest",

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

@@ -5,6 +5,10 @@ Supports multiple LLM providers with dynamic model discovery:
 - OpenAI GPT-4 / GPT-3.5-turbo
 - Google Gemini Pro
 - Anthropic Claude 3
+- DeepSeek
+- SiliconFlow
+- Kimi (Moonshot AI)
+- MiniMax
 
 Dynamic Model Discovery:
     from voria.core.llm import LLMProviderFactory
@@ -34,12 +38,20 @@ from .modal_provider import ModalProvider
 from .openai_provider import OpenAIProvider
 from .gemini_provider import GeminiProvider
 from .claude_provider import ClaudeProvider
+from .minimax_provider import MiniMaxProvider
+from .deepseek_provider import DeepSeekProvider
+from .siliconflow_provider import SiliconFlowProvider
+from .kimi_provider import KimiProvider
 
 # Register all providers
 LLMProviderFactory.register("modal", ModalProvider)
 LLMProviderFactory.register("openai", OpenAIProvider)
 LLMProviderFactory.register("gemini", GeminiProvider)
 LLMProviderFactory.register("claude", ClaudeProvider)
+LLMProviderFactory.register("minimax", MiniMaxProvider)
+LLMProviderFactory.register("deepseek", DeepSeekProvider)
+LLMProviderFactory.register("siliconflow", SiliconFlowProvider)
+LLMProviderFactory.register("kimi", KimiProvider)
 
 __all__ = [
     "BaseLLMProvider",
@@ -52,4 +64,8 @@ __all__ = [
     "OpenAIProvider",
     "GeminiProvider",
     "ClaudeProvider",
+    "MiniMaxProvider",
+    "DeepSeekProvider",
+    "SiliconFlowProvider",
+    "KimiProvider",
 ]

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

@@ -59,6 +59,18 @@ class BaseLLMProvider(ABC):
         """
         pass
 
+    @abstractmethod
+    async def stream_generate(
+        self, messages: List[Message], max_tokens: int = 2000, temperature: float = 0.7
+    ):
+        """
+        Stream response tokens from LLM
+
+        Returns:
+            Async generator yielding string tokens
+        """
+        pass
+
     @abstractmethod
     async def plan(self, issue_description: str) -> str:
         """Generate implementation plan from issue"""

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

@@ -183,6 +183,52 @@ 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 Claude"""
+        import json as _json
+        try:
+            system_content = ""
+            user_messages = []
+            for msg in messages:
+                if msg.role == "system":
+                    system_content = msg.content
+                else:
+                    user_messages.append({"role": msg.role, "content": msg.content})
+
+            payload = {
+                "model": self.model,
+                "max_tokens": max_tokens,
+                "messages": user_messages,
+                "temperature": temperature,
+                "stream": True,
+            }
+            if system_content:
+                payload["system"] = system_content
+
+            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:]
+                        try:
+                            data = _json.loads(data_str)
+                            event_type = data.get("type", "")
+                            if event_type == "content_block_delta":
+                                delta = data.get("delta", {})
+                                if delta.get("type") == "text_delta" and "text" in delta:
+                                    yield delta["text"]
+                            elif event_type == "message_stop":
+                                break
+                        except Exception:
+                            continue
+        except Exception as e:
+            logger.error(f"Claude stream error: {e}")
+            raise
+
     async def close(self):
         """Close HTTP client"""
         await self.client.aclose()

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

@@ -0,0 +1,109 @@
+"""DeepSeek LLM Provider
+
+DeepSeek provides powerful code-focused 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 DeepSeekProvider(BaseLLMProvider):
+    """DeepSeek LLM Provider (OpenAI-compatible API)"""
+
+    API_ENDPOINT = "https://api.deepseek.com/v1/chat/completions"
+    DEFAULT_MODEL = "deepseek-chat"
+
+    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="DeepSeek")
+        except Exception as e:
+            logger.error(f"DeepSeek 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"DeepSeek 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": "DeepSeek", "tokens_used": response.tokens_used}
+
+    async def close(self):
+        await self.client.aclose()

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

@@ -143,6 +143,50 @@ 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 Gemini"""
+        import json as _json
+        try:
+            contents = []
+            for msg in messages:
+                contents.append({
+                    "role": "user" if msg.role == "user" else "model",
+                    "parts": [{"text": msg.content}],
+                })
+
+            payload = {
+                "contents": contents,
+                "generationConfig": {
+                    "maxOutputTokens": max_tokens,
+                    "temperature": temperature,
+                },
+            }
+
+            url = f"{self.API_ENDPOINT}/{self.model}:streamGenerateContent?key={self.api_key}&alt=sse"
+
+            async with self.client.stream("POST", url, 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:]
+                        try:
+                            data = _json.loads(data_str)
+                            candidates = data.get("candidates", [])
+                            if candidates:
+                                parts = candidates[0].get("content", {}).get("parts", [])
+                                for part in parts:
+                                    if "text" in part:
+                                        yield part["text"]
+                        except Exception:
+                            continue
+        except Exception as e:
+            logger.error(f"Gemini stream error: {e}")
+            raise
+
     async def close(self):
         """Close HTTP client"""
         await self.client.aclose()

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

@@ -0,0 +1,109 @@
+"""Kimi (Moonshot AI) LLM Provider
+
+Kimi provides large context window 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 KimiProvider(BaseLLMProvider):
+    """Kimi (Moonshot AI) LLM Provider (OpenAI-compatible API)"""
+
+    API_ENDPOINT = "https://api.moonshot.cn/v1/chat/completions"
+    DEFAULT_MODEL = "moonshot-v1-8k"
+
+    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="Kimi")
+        except Exception as e:
+            logger.error(f"Kimi 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"Kimi 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": "Kimi", "tokens_used": response.tokens_used}
+
+    async def close(self):
+        await self.client.aclose()