jarviscore-framework 0.1.0__py3-none-any.whl

jarviscore/cli/smoketest.py

@@ -0,0 +1,371 @@
+"""
+JarvisCore Smoke Test CLI
+
+Quick validation that AutoAgent/Prompt-Dev workflow works end-to-end.
+Tests: LLM → Code Generation → Sandbox Execution → Result
+
+Usage:
+    python -m jarviscore.cli.smoketest              # Run basic smoke test
+    python -m jarviscore.cli.smoketest --verbose    # Show detailed output
+"""
+
+import sys
+import asyncio
+from pathlib import Path
+from datetime import datetime
+
+
+class SmokeTest:
+    """Smoke test runner for JarvisCore AutoAgent."""
+
+    def __init__(self, verbose: bool = False):
+        self.verbose = verbose
+        self.passed = []
+        self.failed = []
+        self.start_time = None
+        self.end_time = None
+
+    def print_header(self):
+        """Print test header."""
+        print("\n" + "="*70)
+        print("  JarvisCore Smoke Test")
+        print("  Validating AutoAgent: Prompt → Code → Result")
+        print("="*70 + "\n")
+
+    def print_test(self, name: str, status: bool, detail: str = "", duration: float = None):
+        """Print test result."""
+        symbol = "✓" if status else "✗"
+        duration_str = f" ({duration:.2f}s)" if duration else ""
+
+        print(f"{symbol} {name}{duration_str}")
+
+        if self.verbose or not status:
+            if detail:
+                for line in detail.split('\n'):
+                    print(f"  {line}")
+
+        if status:
+            self.passed.append(name)
+        else:
+            self.failed.append((name, detail))
+
+    async def test_imports(self) -> bool:
+        """Test that core framework modules load."""
+        test_start = asyncio.get_event_loop().time()
+
+        try:
+            from jarviscore import Mesh
+            from jarviscore.profiles import AutoAgent
+            from dotenv import load_dotenv
+
+            duration = asyncio.get_event_loop().time() - test_start
+            self.print_test("Import Framework", True, "Core modules loaded", duration)
+            return True
+
+        except Exception as e:
+            duration = asyncio.get_event_loop().time() - test_start
+            self.print_test("Import Framework", False, str(e), duration)
+            return False
+
+    async def test_env_config(self) -> bool:
+        """Test environment configuration."""
+        test_start = asyncio.get_event_loop().time()
+
+        try:
+            import os
+            from dotenv import load_dotenv
+
+            # Load .env
+            env_paths = [Path.cwd() / '.env', Path.cwd() / 'jarviscore' / '.env']
+            env_loaded = False
+
+            for env_path in env_paths:
+                if env_path.exists():
+                    load_dotenv(env_path)
+                    env_loaded = True
+                    break
+
+            # Check for at least one LLM configured
+            llm_providers = {
+                'CLAUDE_API_KEY': os.getenv('CLAUDE_API_KEY') or os.getenv('ANTHROPIC_API_KEY'),
+                'AZURE_API_KEY': os.getenv('AZURE_API_KEY') or os.getenv('AZURE_OPENAI_KEY'),
+                'GEMINI_API_KEY': os.getenv('GEMINI_API_KEY'),
+                'LLM_ENDPOINT': os.getenv('LLM_ENDPOINT'),
+            }
+
+            configured = [k for k, v in llm_providers.items() if v]
+
+            if not configured:
+                duration = asyncio.get_event_loop().time() - test_start
+                self.print_test(
+                    "Configuration",
+                    False,
+                    "No LLM provider configured. Add API key to .env file.",
+                    duration
+                )
+                return False
+
+            duration = asyncio.get_event_loop().time() - test_start
+            provider_str = configured[0].replace('_', ' ').title()
+            self.print_test("Configuration", True, f"Using {provider_str}", duration)
+            return True
+
+        except Exception as e:
+            duration = asyncio.get_event_loop().time() - test_start
+            self.print_test("Configuration", False, str(e), duration)
+            return False
+
+    async def test_mesh_creation(self) -> bool:
+        """Test mesh creation."""
+        test_start = asyncio.get_event_loop().time()
+
+        try:
+            from jarviscore import Mesh
+
+            mesh = Mesh(mode="autonomous")
+
+            duration = asyncio.get_event_loop().time() - test_start
+            self.print_test("Create Mesh", True, "Autonomous mode initialized", duration)
+            return True
+
+        except Exception as e:
+            duration = asyncio.get_event_loop().time() - test_start
+            self.print_test("Create Mesh", False, str(e), duration)
+            return False
+
+    async def test_agent_definition(self) -> bool:
+        """Test agent definition."""
+        test_start = asyncio.get_event_loop().time()
+
+        try:
+            from jarviscore.profiles import AutoAgent
+
+            class TestAgent(AutoAgent):
+                role = "calculator"
+                capabilities = ["math", "calculation"]
+                system_prompt = "You are a math expert. Generate Python code to solve problems."
+
+            agent = TestAgent()
+
+            duration = asyncio.get_event_loop().time() - test_start
+            self.print_test("Define Agent", True, "AutoAgent class created", duration)
+            return True
+
+        except Exception as e:
+            duration = asyncio.get_event_loop().time() - test_start
+            self.print_test("Define Agent", False, str(e), duration)
+            return False
+
+    async def test_end_to_end_execution(self) -> bool:
+        """Test full workflow: prompt → code → result."""
+        test_start = asyncio.get_event_loop().time()
+
+        max_retries = 3
+        retry_delay = 2  # seconds
+
+        for attempt in range(max_retries):
+            try:
+                from jarviscore import Mesh
+                from jarviscore.profiles import AutoAgent
+
+                # Define agent
+                class CalculatorAgent(AutoAgent):
+                    role = "calculator"
+                    capabilities = ["math"]
+                    system_prompt = "You are a math expert. Generate Python code. Store result in 'result' variable."
+
+                # Create mesh and add agent
+                mesh = Mesh(mode="autonomous")
+                mesh.add(CalculatorAgent)
+
+                # Start mesh
+                await mesh.start()
+
+                if self.verbose and attempt > 0:
+                    print(f"  Retry attempt {attempt + 1}/{max_retries}...")
+
+                # Execute simple task
+                task_start = asyncio.get_event_loop().time()
+                results = await mesh.workflow("smoke-test", [
+                    {
+                        "agent": "calculator",
+                        "task": "Calculate 2 + 2"
+                    }
+                ])
+
+                task_duration = asyncio.get_event_loop().time() - task_start
+
+                # Validate result
+                result = results[0]
+
+                # Check for success (status can be 'success' or 'completed')
+                if result.get('status') not in ['success', 'completed']:
+                    error_msg = result.get('error', 'Unknown error')
+
+                    # Check if it's a retryable error (rate limit, overloaded, timeout)
+                    if any(x in str(error_msg).lower() for x in ['overloaded', '529', 'rate limit', 'timeout']):
+                        if attempt < max_retries - 1:
+                            if self.verbose:
+                                print(f"  LLM temporarily unavailable, retrying in {retry_delay}s...")
+                            await asyncio.sleep(retry_delay)
+                            retry_delay *= 2  # Exponential backoff
+                            await mesh.stop()
+                            continue
+
+                    raise Exception(f"Task failed: {error_msg}")
+
+                output = result.get('output')
+                if output != 4:
+                    raise Exception(f"Expected 4, got {output}")
+
+                # Stop mesh
+                await mesh.stop()
+
+                duration = asyncio.get_event_loop().time() - test_start
+
+                detail = f"Task: '2 + 2' → Result: {output}\n"
+                detail += f"Execution time: {task_duration:.2f}s\n"
+                detail += f"Repairs: {result.get('repairs', 0)}"
+                if attempt > 0:
+                    detail += f"\nRetries: {attempt}"
+
+                self.print_test("End-to-End Workflow", True, detail, duration)
+                return True
+
+            except Exception as e:
+                # Check if this is the last attempt
+                if attempt == max_retries - 1:
+                    duration = asyncio.get_event_loop().time() - test_start
+
+                    error_detail = str(e)
+                    if self.verbose:
+                        import traceback
+                        error_detail = traceback.format_exc()
+
+                    self.print_test("End-to-End Workflow", False, error_detail, duration)
+                    return False
+
+                # Otherwise, retry if it's a retryable error
+                error_str = str(e).lower()
+                if any(x in error_str for x in ['overloaded', '529', 'rate limit', 'timeout']):
+                    if self.verbose:
+                        print(f"  LLM temporarily unavailable (attempt {attempt + 1}/{max_retries}), retrying in {retry_delay}s...")
+                    await asyncio.sleep(retry_delay)
+                    retry_delay *= 2
+                    continue
+
+                # Non-retryable error, fail immediately
+                duration = asyncio.get_event_loop().time() - test_start
+                error_detail = str(e)
+                if self.verbose:
+                    import traceback
+                    error_detail = traceback.format_exc()
+                self.print_test("End-to-End Workflow", False, error_detail, duration)
+                return False
+
+        return False
+
+    def print_summary(self):
+        """Print test summary."""
+        print("\n" + "="*70)
+        print("  Summary")
+        print("="*70 + "\n")
+
+        total = len(self.passed) + len(self.failed)
+        duration = self.end_time - self.start_time if self.start_time and self.end_time else 0
+
+        print(f"Tests run:  {total}")
+        print(f"Passed:     {len(self.passed)} ✓")
+        print(f"Failed:     {len(self.failed)} ✗")
+        print(f"Duration:   {duration:.2f}s")
+
+        if self.failed:
+            print("\n" + "="*70)
+            print("  Failed Tests")
+            print("="*70 + "\n")
+
+            for name, detail in self.failed:
+                print(f"✗ {name}")
+                if detail:
+                    print(f"  {detail}\n")
+
+            print("\n" + "="*70)
+            print("  Troubleshooting")
+            print("="*70)
+
+            if any("No LLM provider" in detail for _, detail in self.failed):
+                print("\nNo LLM configured:")
+                print("  1. Copy .env.example to .env")
+                print("  2. Add your API key (CLAUDE_API_KEY, AZURE_API_KEY, or GEMINI_API_KEY)")
+                print("  3. Run health check: python -m jarviscore.cli.check --validate-llm")
+
+            if any("Task failed" in detail or "error" in detail.lower() for _, detail in self.failed):
+                print("\nExecution failed:")
+                print("  1. Check LLM API key is valid")
+                print("  2. Test connectivity: python -m jarviscore.cli.check --validate-llm")
+                print("  3. Check logs: ls -la logs/")
+                print("  4. Run with verbose: python -m jarviscore.cli.smoketest --verbose")
+
+            print()
+            return False
+
+        print("\n✓ All smoke tests passed!")
+        print("\nJarvisCore is working correctly. Next steps:")
+        print("  1. Try examples: python examples/calculator_agent_example.py")
+        print("  2. Read user guide: docs/USER_GUIDE.md")
+        print("  3. Build your first agent: docs/GETTING_STARTED.md")
+        print()
+        return True
+
+    async def run(self) -> bool:
+        """Run all smoke tests."""
+        self.print_header()
+        self.start_time = asyncio.get_event_loop().time()
+
+        print("[Framework Tests]")
+        imports_ok = await self.test_imports()
+        if not imports_ok:
+            self.end_time = asyncio.get_event_loop().time()
+            self.print_summary()
+            return False
+
+        config_ok = await self.test_env_config()
+        if not config_ok:
+            self.end_time = asyncio.get_event_loop().time()
+            self.print_summary()
+            return False
+
+        mesh_ok = await self.test_mesh_creation()
+        agent_ok = await self.test_agent_definition()
+
+        print("\n[Integration Test]")
+        e2e_ok = await self.test_end_to_end_execution()
+
+        self.end_time = asyncio.get_event_loop().time()
+
+        return self.print_summary()
+
+
+def main():
+    """CLI entry point."""
+    import argparse
+
+    parser = argparse.ArgumentParser(
+        description='JarvisCore Smoke Test - Quick validation'
+    )
+    parser.add_argument(
+        '--verbose',
+        action='store_true',
+        help='Show detailed output and stack traces'
+    )
+
+    args = parser.parse_args()
+
+    smoke_test = SmokeTest(verbose=args.verbose)
+    success = asyncio.run(smoke_test.run())
+
+    sys.exit(0 if success else 1)
+
+
+if __name__ == '__main__':
+    main()

jarviscore/config/__init__.py

@@ -0,0 +1,7 @@
+"""
+Configuration module for JarvisCore Framework
+"""
+
+from .settings import Settings, settings, get_config_from_dict
+
+__all__ = ['Settings', 'settings', 'get_config_from_dict']

jarviscore/config/settings.py

@@ -0,0 +1,128 @@
+"""
+JarvisCore Framework Configuration
+
+Zero-config with standard environment variables (no prefix needed).
+
+Configuration can be provided via:
+1. Standard environment variables (CLAUDE_API_KEY, AZURE_OPENAI_KEY, etc.)
+2. .env file
+3. Direct config dictionary passed to Mesh
+
+Example:
+    # Via environment (standard names)
+    export CLAUDE_API_KEY="sk-..."
+    export AZURE_OPENAI_KEY="..."
+    export BIND_HOST="0.0.0.0"
+    export BIND_PORT=7946
+
+    # Via config dict
+    config = {
+        'bind_host': '0.0.0.0',
+        'bind_port': 7946,
+        'seed_nodes': '192.168.1.100:7946'
+    }
+    mesh = Mesh(mode="distributed", config=config)
+"""
+import os
+from typing import Optional
+from pydantic_settings import BaseSettings
+
+
+class Settings(BaseSettings):
+    """
+    Framework configuration with zero-config defaults.
+    Uses standard environment variable names (no JARVISCORE_ prefix).
+    """
+
+    # === P2P Settings ===
+    node_name: str = "jarviscore-node"
+    bind_host: str = "127.0.0.1"
+    bind_port: int = 7946
+    seed_nodes: str = ""  # Comma-separated "host:port,host:port"
+    p2p_enabled: bool = True
+    zmq_port_offset: int = 1000
+    transport_type: str = "hybrid"  # udp, tcp, or hybrid
+
+    # === Keepalive Settings ===
+    keepalive_enabled: bool = True
+    keepalive_interval: int = 90  # seconds
+    keepalive_timeout: int = 10
+    activity_suppress_window: int = 60
+
+    # === Execution Settings ===
+    max_retries: int = 3
+    max_repair_attempts: int = 3
+    execution_timeout: int = 300  # seconds
+
+    # === Sandbox Settings ===
+    sandbox_mode: str = "local"  # "local" or "remote"
+    sandbox_service_url: Optional[str] = None  # URL for remote sandbox
+
+    # === Storage Settings ===
+    log_directory: str = "./logs"
+
+    # === LLM Configuration ===
+    llm_timeout: float = 120.0
+    llm_temperature: float = 0.7
+
+    # Claude
+    claude_api_key: Optional[str] = None
+    claude_endpoint: Optional[str] = None
+    claude_model: str = "claude-sonnet-4"
+    anthropic_api_key: Optional[str] = None  # Alias for claude_api_key
+
+    # Azure OpenAI
+    azure_api_key: Optional[str] = None
+    azure_openai_key: Optional[str] = None  # Alias
+    azure_endpoint: Optional[str] = None
+    azure_openai_endpoint: Optional[str] = None  # Alias
+    azure_deployment: str = "gpt-4o"
+    azure_api_version: str = "2024-02-15-preview"
+
+    # Gemini
+    gemini_api_key: Optional[str] = None
+    gemini_model: str = "gemini-1.5-flash"
+    gemini_temperature: float = 0.1
+    gemini_timeout: float = 30.0
+
+    # vLLM
+    llm_endpoint: Optional[str] = None
+    vllm_endpoint: Optional[str] = None  # Alias
+    llm_model: str = "default"
+
+    # === Logging ===
+    log_level: str = "INFO"
+
+    class Config:
+        env_file = ".env"
+        env_file_encoding = "utf-8"
+        case_sensitive = False
+        extra = "ignore"
+
+
+def get_config_from_dict(config_dict: Optional[dict] = None) -> dict:
+    """
+    Get configuration from dictionary or environment.
+
+    Args:
+        config_dict: Optional configuration dictionary
+
+    Returns:
+        Configuration dictionary with defaults applied
+    """
+    # Load from environment first
+    try:
+        base_config = settings.model_dump()
+    except Exception:
+        # If pydantic fails, use manual defaults
+        base_config = {}
+
+    # Override with provided config
+    if config_dict:
+        base_config.update(config_dict)
+
+    return base_config
+
+
+# Global settings instance - loads from .env automatically
+settings = Settings()

jarviscore/core/__init__.py

@@ -0,0 +1,7 @@
+"""Core framework classes."""
+
+from .agent import Agent
+from .profile import Profile
+from .mesh import Mesh, MeshMode
+
+__all__ = ["Agent", "Profile", "Mesh", "MeshMode"]

jarviscore/core/agent.py

@@ -0,0 +1,163 @@
+"""
+Agent base class - defines WHAT an agent does (role, capabilities).
+
+This is the foundation of the JarvisCore framework. All agents inherit from this class.
+"""
+from abc import ABC, abstractmethod
+from typing import List, Dict, Any, Optional
+from uuid import uuid4
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class Agent(ABC):
+    """
+    Base class for all agents in JarvisCore framework.
+
+    Agents define WHAT they do via class attributes:
+    - role: The agent's role identifier
+    - capabilities: List of capabilities this agent provides
+
+    Subclasses (Profiles) define HOW they execute tasks.
+
+    Example:
+        class MyAgent(PromptDevAgent):
+            role = "scraper"
+            capabilities = ["web_scraping", "data_extraction"]
+            system_prompt = "You are an expert web scraper..."
+    """
+
+    # Class attributes - user must define these
+    role: str = None
+    capabilities: List[str] = []
+
+    def __init__(self, agent_id: Optional[str] = None):
+        """
+        Initialize agent with validation.
+
+        Args:
+            agent_id: Optional unique identifier (auto-generated if not provided)
+
+        Raises:
+            ValueError: If role or capabilities are not defined
+        """
+        # Validate required attributes
+        if not self.role:
+            raise ValueError(
+                f"{self.__class__.__name__} must define 'role' class attribute\n"
+                f"Example: role = 'scraper'"
+            )
+
+        if not self.capabilities:
+            raise ValueError(
+                f"{self.__class__.__name__} must define 'capabilities' class attribute\n"
+                f"Example: capabilities = ['web_scraping']"
+            )
+
+        # Initialize instance attributes
+        self.agent_id = agent_id or f"{self.role}-{uuid4().hex[:8]}"
+        self._mesh = None  # Set by Mesh when agent is added
+        self._logger = logging.getLogger(f"jarviscore.agent.{self.agent_id}")
+
+        self._logger.debug(f"Agent initialized: {self.agent_id}")
+
+    @abstractmethod
+    async def execute_task(self, task: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Execute a task (implemented by profile subclasses).
+
+        This defines HOW the agent executes tasks. Different profiles implement
+        this differently:
+        - PromptDevAgent: LLM code generation + sandbox execution
+        - MCPAgent: User-defined MCP tool calls
+
+        Args:
+            task: Task specification containing:
+                - task (str): Task description
+                - id (str): Task identifier
+                - params (dict, optional): Additional parameters
+
+        Returns:
+            Result dictionary containing:
+                - status (str): "success" or "failure"
+                - output (Any): Task output
+                - error (str, optional): Error message if failed
+                - tokens_used (int, optional): LLM tokens consumed
+                - cost_usd (float, optional): Cost in USD
+
+        Raises:
+            NotImplementedError: If subclass doesn't implement this method
+        """
+        raise NotImplementedError(
+            f"{self.__class__.__name__} must implement execute_task()"
+        )
+
+    async def setup(self):
+        """
+        Optional setup hook called when agent joins mesh.
+
+        Override this to perform initialization:
+        - Connect to external services
+        - Load models
+        - Setup resources
+
+        Example:
+            async def setup(self):
+                await super().setup()
+                self.db = await connect_to_database()
+        """
+        self._logger.info(f"Setting up agent: {self.agent_id}")
+
+    async def teardown(self):
+        """
+        Optional cleanup hook called when agent leaves mesh.
+
+        Override this to cleanup resources:
+        - Close connections
+        - Save state
+        - Release resources
+
+        Example:
+            async def teardown(self):
+                await self.db.close()
+                await super().teardown()
+        """
+        self._logger.info(f"Tearing down agent: {self.agent_id}")
+
+    def can_handle(self, task: Dict[str, Any]) -> bool:
+        """
+        Check if agent can handle a task based on capabilities.
+
+        Args:
+            task: Task specification with 'capability' or 'role' key
+
+        Returns:
+            True if agent has the required capability
+
+        Example:
+            task = {"task": "Scrape website", "role": "scraper"}
+            if agent.can_handle(task):
+                result = await agent.execute_task(task)
+        """
+        required = task.get("capability") or task.get("role")
+        can_handle = required in self.capabilities or required == self.role
+
+        self._logger.debug(
+            f"Can handle task requiring '{required}': {can_handle}"
+        )
+
+        return can_handle
+
+    def __repr__(self) -> str:
+        """String representation of agent."""
+        return (
+            f"<{self.__class__.__name__} "
+            f"id={self.agent_id} "
+            f"role={self.role} "
+            f"capabilities={self.capabilities}>"
+        )
+
+    def __str__(self) -> str:
+        """Human-readable string representation."""
+        return f"{self.role} ({self.agent_id})"