jarviscore-framework 0.1.0__py3-none-any.whl → 0.2.0__py3-none-any.whl

jarviscore/data/.env.example

@@ -0,0 +1,146 @@
+# =============================================================================
+# JARVISCORE FRAMEWORK CONFIGURATION
+# =============================================================================
+# Copy this file to .env and fill in your values
+# All settings are optional - framework provides sensible defaults
+# Standard environment variable names (no JARVISCORE_ prefix)
+
+# =============================================================================
+# LLM CONFIGURATION (Zero-Config with Automatic Fallback)
+# =============================================================================
+# Framework tries providers in order: Claude → vLLM → Azure → Gemini
+# At least ONE provider must be configured for AutoAgent to work
+
+# --- Anthropic Claude ---
+# Standard: CLAUDE_API_KEY or ANTHROPIC_API_KEY
+# CLAUDE_API_KEY=your-anthropic-api-key
+# CLAUDE_ENDPOINT=https://api.anthropic.com  # Optional: custom endpoint
+# CLAUDE_MODEL=claude-sonnet-4
+
+# --- vLLM (Local/Self-Hosted) ---
+# Recommended for development and cost-effective production
+# LLM_ENDPOINT=http://localhost:8000
+# LLM_MODEL=Qwen/Qwen2.5-Coder-32B-Instruct
+
+# --- Azure OpenAI ---
+# Standard: AZURE_API_KEY or AZURE_OPENAI_KEY
+# AZURE_API_KEY=your-azure-openai-key
+# AZURE_ENDPOINT=https://your-resource.openai.azure.com
+# AZURE_DEPLOYMENT=gpt-4o
+# AZURE_API_VERSION=2024-02-15-preview
+
+# --- Google Gemini ---
+# GEMINI_API_KEY=your-gemini-api-key
+# GEMINI_MODEL=gemini-1.5-flash
+# GEMINI_TEMPERATURE=0.1
+# GEMINI_TIMEOUT=30.0
+
+# Common LLM Settings
+# LLM_TIMEOUT=120.0
+# LLM_TEMPERATURE=0.7
+
+# =============================================================================
+# EXECUTION SETTINGS
+# =============================================================================
+# Sandbox execution and code generation limits
+
+# Maximum execution time for generated code (seconds)
+EXECUTION_TIMEOUT=300
+
+# Maximum number of autonomous repair attempts
+MAX_REPAIR_ATTEMPTS=3
+
+# Maximum retries for failed operations
+MAX_RETRIES=3
+
+# =============================================================================
+# SANDBOX CONFIGURATION (Phase 2)
+# =============================================================================
+# Sandbox execution mode: "local" (in-process) or "remote" (service)
+# Default: local (for development)
+# Production: remote (uses JarvisCore's Azure Container Apps sandbox)
+SANDBOX_MODE=local
+
+# Remote sandbox service URL (provided by JarvisCore)
+# Azure Container Apps sandbox service - no setup required!
+# Uncomment and set SANDBOX_MODE=remote to use it
+# SANDBOX_SERVICE_URL=https://browser-task-executor.bravesea-3f5f7e75.eastus.azurecontainerapps.io
+
+# =============================================================================
+# STORAGE CONFIGURATION (Phase 1)
+# =============================================================================
+# Directory for result storage and code registry
+LOG_DIRECTORY=./logs
+
+# =============================================================================
+# P2P CONFIGURATION (For Distributed Mode)
+# =============================================================================
+# Required only if using mesh in distributed mode
+# Autonomous mode works without P2P
+
+# Enable P2P mesh networking
+P2P_ENABLED=true
+
+# Node identification
+NODE_NAME=jarviscore-node-1
+
+# Bind address and port for P2P communication
+BIND_HOST=127.0.0.1
+BIND_PORT=7946
+
+# Seed nodes to join existing mesh (comma-separated)
+# Example: 192.168.1.100:7946,192.168.1.101:7946
+# SEED_NODES=
+
+# ZeroMQ port offset (P2P messaging)
+ZMQ_PORT_OFFSET=1000
+
+# Transport type: udp, tcp, or hybrid
+TRANSPORT_TYPE=hybrid
+
+# =============================================================================
+# KEEPALIVE SETTINGS (P2P Health Monitoring)
+# =============================================================================
+
+# Enable smart keepalive (suppresses when active)
+KEEPALIVE_ENABLED=true
+
+# Keepalive interval (seconds)
+KEEPALIVE_INTERVAL=90
+
+# Keepalive timeout (seconds)
+KEEPALIVE_TIMEOUT=10
+
+# Activity suppression window (seconds)
+# If agent is actively working, suppress keepalive for this duration
+ACTIVITY_SUPPRESS_WINDOW=60
+
+# =============================================================================
+# LOGGING
+# =============================================================================
+# Log level: DEBUG, INFO, WARNING, ERROR, CRITICAL
+LOG_LEVEL=INFO
+
+# =============================================================================
+# EXAMPLES
+# =============================================================================
+
+# Example 1: Local development with vLLM
+# LLM_ENDPOINT=http://localhost:8000
+# LLM_MODEL=Qwen/Qwen2.5-Coder-32B-Instruct
+# P2P_ENABLED=false
+
+# Example 2: Production with Azure OpenAI + P2P mesh
+# AZURE_API_KEY=sk-...
+# AZURE_ENDPOINT=https://my-resource.openai.azure.com
+# AZURE_DEPLOYMENT=gpt-4o
+# P2P_ENABLED=true
+# BIND_HOST=0.0.0.0
+# BIND_PORT=7946
+# SEED_NODES=192.168.1.100:7946
+
+# Example 3: Zero-config (use defaults)
+# Just don't set any variables and framework will:
+# - Try to detect available LLM providers
+# - Use sensible defaults for all settings
+# - Work in autonomous mode (no P2P)

jarviscore/data/__init__.py

@@ -0,0 +1,7 @@
+"""
+Data files for JarvisCore scaffolding.
+
+Contains:
+- .env.example: Example environment configuration
+- examples/: Example agent implementations
+"""

jarviscore/data/examples/autoagent_distributed_example.py

@@ -0,0 +1,211 @@
+"""
+AutoAgent Distributed Mode Example
+
+Demonstrates AutoAgent in distributed mode, which combines:
+- P2P network layer (SWIM protocol, ZMQ messaging)
+- Workflow orchestration (step execution, dependencies)
+
+This is ideal for multi-node deployments where agents can:
+- Execute on different machines
+- Discover each other via SWIM
+- Run orchestrated workflows across the network
+
+Usage:
+    python examples/autoagent_distributed_example.py
+
+Prerequisites:
+    - .env file with LLM API key (CLAUDE_API_KEY, etc.)
+"""
+import asyncio
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from jarviscore import Mesh
+from jarviscore.profiles import AutoAgent
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# AUTOAGENT DEFINITIONS
+# ═══════════════════════════════════════════════════════════════════════════════
+
+class DataCollectorAgent(AutoAgent):
+    """Collects and generates data."""
+    role = "collector"
+    capabilities = ["data_collection", "sampling"]
+    system_prompt = """
+    You are a data collection specialist. Generate sample datasets
+    based on specifications. Use Python's standard library only.
+    Store results in a variable named 'result' as a dictionary.
+    """
+
+
+class DataProcessorAgent(AutoAgent):
+    """Processes and transforms data."""
+    role = "processor"
+    capabilities = ["data_processing", "transformation"]
+    system_prompt = """
+    You are a data processing expert. Transform and clean datasets.
+    Apply filters, aggregations, and transformations as needed.
+    Use Python's standard library only. Store results in 'result'.
+    """
+
+
+class ReportWriterAgent(AutoAgent):
+    """Generates reports from processed data."""
+    role = "reporter"
+    capabilities = ["reporting", "documentation"]
+    system_prompt = """
+    You are a technical writer. Create clear, well-formatted reports
+    from data. Use markdown formatting. Store the report in 'result'.
+    """
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# MAIN EXAMPLE
+# ═══════════════════════════════════════════════════════════════════════════════
+
+async def main():
+    """Run AutoAgent distributed mode example."""
+    print("\n" + "="*70)
+    print("JarvisCore: AutoAgent in Distributed Mode")
+    print("="*70)
+
+    # ─────────────────────────────────────────────────────────────────────────
+    # KEY DIFFERENCE: mode="distributed" with P2P configuration
+    # ─────────────────────────────────────────────────────────────────────────
+    mesh = Mesh(
+        mode="distributed",  # Enables P2P + Workflow Engine
+        config={
+            # P2P Network Configuration
+            'bind_host': '127.0.0.1',    # Interface to bind to
+            'bind_port': 7950,            # SWIM protocol port (ZMQ uses +1000)
+            'node_name': 'autoagent-node',
+
+            # For multi-node: uncomment to join existing cluster
+            # 'seed_nodes': '192.168.1.10:7950,192.168.1.11:7950',
+
+            # AutoAgent Configuration
+            'execution_timeout': 60,      # Max seconds per task
+            'max_repair_attempts': 2,     # Auto-repair on failure
+            'log_directory': './logs',    # Result storage
+        }
+    )
+
+    # Add agents - same as autonomous mode
+    mesh.add(DataCollectorAgent)
+    mesh.add(DataProcessorAgent)
+    mesh.add(ReportWriterAgent)
+
+    try:
+        await mesh.start()
+
+        print("\n[INFO] Mesh started in DISTRIBUTED mode")
+        print(f"  - P2P Coordinator: Active (port {mesh.config.get('bind_port', 7950)})")
+        print(f"  - Workflow Engine: Active")
+        print(f"  - Agents: {len(mesh.agents)}")
+
+        # ─────────────────────────────────────────────────────────────────────
+        # WORKFLOW EXECUTION - Same API as autonomous mode
+        # ─────────────────────────────────────────────────────────────────────
+        print("\n" + "-"*70)
+        print("Executing Pipeline: Collect → Process → Report")
+        print("-"*70)
+
+        results = await mesh.workflow("distributed-pipeline", [
+            {
+                "id": "collect",
+                "agent": "collector",
+                "task": "Generate a dataset of 10 products with name, price, and category"
+            },
+            {
+                "id": "process",
+                "agent": "processor",
+                "task": "Calculate total value, average price, and count by category",
+                "depends_on": ["collect"]
+            },
+            {
+                "id": "report",
+                "agent": "reporter",
+                "task": "Create a summary report with the statistics",
+                "depends_on": ["process"]
+            }
+        ])
+
+        # Display results
+        print("\n" + "="*70)
+        print("RESULTS")
+        print("="*70)
+
+        for i, result in enumerate(results):
+            step_names = ["Data Collection", "Data Processing", "Report Generation"]
+            print(f"\n{step_names[i]}:")
+            print(f"  Status: {result['status']}")
+            if result['status'] == 'success':
+                output = str(result.get('output', ''))[:200]
+                print(f"  Output: {output}...")
+            else:
+                print(f"  Error: {result.get('error')}")
+
+        # Summary
+        successes = sum(1 for r in results if r['status'] == 'success')
+        print(f"\n{'='*70}")
+        print(f"Pipeline Complete: {successes}/{len(results)} steps successful")
+        print(f"{'='*70}")
+
+        await mesh.stop()
+
+    except Exception as e:
+        print(f"\nError: {e}")
+        import traceback
+        traceback.print_exc()
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# MULTI-NODE EXAMPLE (Reference)
+# ═══════════════════════════════════════════════════════════════════════════════
+
+async def multi_node_example():
+    """
+    Example: Running agents across multiple machines.
+
+    Node 1 (seed node):
+        mesh = Mesh(mode="distributed", config={
+            'bind_host': '0.0.0.0',
+            'bind_port': 7950,
+            'node_name': 'node-1',
+        })
+        mesh.add(DataCollectorAgent)
+        await mesh.start()
+        await mesh.serve_forever()  # Keep running
+
+    Node 2 (joins cluster):
+        mesh = Mesh(mode="distributed", config={
+            'bind_host': '0.0.0.0',
+            'bind_port': 7950,
+            'node_name': 'node-2',
+            'seed_nodes': '192.168.1.10:7950',  # Node 1's address
+        })
+        mesh.add(DataProcessorAgent)
+        await mesh.start()
+        await mesh.serve_forever()
+
+    Node 3 (joins cluster):
+        mesh = Mesh(mode="distributed", config={
+            'bind_host': '0.0.0.0',
+            'bind_port': 7950,
+            'node_name': 'node-3',
+            'seed_nodes': '192.168.1.10:7950',
+        })
+        mesh.add(ReportWriterAgent)
+        await mesh.start()
+        await mesh.serve_forever()
+
+    Any node can now execute workflows that span all three!
+    """
+    pass
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

jarviscore/data/examples/calculator_agent_example.py

@@ -0,0 +1,77 @@
+"""
+Calculator Agent Example - Simple Math Operations
+
+Demonstrates AutoAgent with code generation for mathematical tasks.
+Zero configuration required - just define the agent and run.
+
+Usage:
+    python examples/calculator_agent_example.py
+"""
+import asyncio
+import sys
+from pathlib import Path
+
+# Add parent directory to path
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from jarviscore import Mesh
+from jarviscore.profiles import AutoAgent
+
+
+class CalculatorAgent(AutoAgent):
+    """Math expert agent that generates code to solve problems."""
+    role = "calculator"
+    capabilities = ["math", "calculation", "arithmetic"]
+    system_prompt = """
+    You are a math expert. Generate Python code to solve mathematical problems.
+    Store the final answer in a variable named 'result'.
+    Use standard math operations and the math module when needed.
+    """
+
+
+async def main():
+    """Run calculator agent examples."""
+    print("\n" + "="*60)
+    print("JarvisCore: Calculator Agent Example")
+    print("="*60)
+
+    # Zero-config: Framework auto-detects LLM from .env
+    # Tries: Claude → Azure → Gemini → vLLM (based on .env)
+    # Or pass custom config dict to override
+
+    # Create mesh and add agent (reads from .env automatically)
+    mesh = Mesh(mode="autonomous")
+    mesh.add(CalculatorAgent)
+
+    try:
+        await mesh.start()
+        print("✓ Mesh started successfully\n")
+
+        # Example 1: Simple calculation
+        print("Example 1: Calculate factorial of 10")
+        print("-" * 60)
+
+        results = await mesh.workflow("factorial", [
+            {
+                "agent": "calculator",
+                "task": "Calculate the factorial of 10"
+            }
+        ])
+
+        result = results[0]
+        print(f"Status: {result['status']}")
+        print(f"Result: {result.get('output')}")
+        print(f"Repairs needed: {result.get('repairs', 0)}")
+        print(f"Generated code:\n{result.get('code', 'N/A')}\n")
+
+        await mesh.stop()
+        print("✓ Mesh stopped\n")
+
+    except Exception as e:
+        print(f"\n✗ Error: {e}")
+        import traceback
+        traceback.print_exc()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())