jarviscore-framework 0.1.0__py3-none-any.whl

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())

examples/multi_agent_workflow.py

@@ -0,0 +1,132 @@
+"""
+Multi-Agent Workflow Example
+
+Demonstrates multiple AutoAgents collaborating on a workflow with dependencies.
+Shows how agents can pass data between steps automatically.
+
+Usage:
+    python examples/multi_agent_workflow.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 DataGeneratorAgent(AutoAgent):
+    """Generates sample data."""
+    role = "generator"
+    capabilities = ["data_generation", "random_data"]
+    system_prompt = """
+    You are a data generator. Create sample datasets based on specifications.
+    Use Python's random module or create structured data.
+    Store the generated data in a variable named 'result'.
+    """
+
+
+class DataAnalyzerAgent(AutoAgent):
+    """Analyzes data and computes statistics."""
+    role = "analyzer"
+    capabilities = ["data_analysis", "statistics"]
+    system_prompt = """
+    You are a data analyst. Analyze datasets and compute statistics.
+    Calculate mean, median, standard deviation, and find patterns.
+    Store your analysis results in a variable named 'result'.
+    """
+
+
+class ReportGeneratorAgent(AutoAgent):
+    """Creates formatted reports."""
+    role = "reporter"
+    capabilities = ["report_generation", "formatting"]
+    system_prompt = """
+    You are a report generator. Create well-formatted reports from data.
+    Generate markdown or plain text reports with clear sections.
+    Store the formatted report in a variable named 'result'.
+    """
+
+
+async def main():
+    """Run multi-agent workflow."""
+    print("\n" + "="*60)
+    print("JarvisCore: Multi-Agent Workflow Example")
+    print("="*60)
+
+    # Zero-config: Reads from .env automatically
+    # Framework tries: Claude → Azure → Gemini → vLLM
+
+    # Create mesh with all agents
+    mesh = Mesh(mode="autonomous")
+    mesh.add(DataGeneratorAgent)
+    mesh.add(DataAnalyzerAgent)
+    mesh.add(ReportGeneratorAgent)
+
+    try:
+        await mesh.start()
+        print(f"✓ Mesh started with {len(mesh.agents)} agents\n")
+
+        print("Workflow: Generate → Analyze → Report")
+        print("-" * 60)
+
+        # Execute 3-step workflow with dependencies
+        results = await mesh.workflow("data-pipeline", [
+            {
+                "id": "generate",
+                "agent": "generator",
+                "task": "Generate a list of 20 random numbers between 1 and 100"
+            },
+            {
+                "id": "analyze",
+                "agent": "analyzer",
+                "task": "Calculate mean, median, min, max, and standard deviation of the data",
+                "depends_on": ["generate"]  # Waits for generator to complete
+            },
+            {
+                "id": "report",
+                "agent": "reporter",
+                "task": "Create a formatted report with the statistics",
+                "depends_on": ["analyze"]  # Waits for analyzer to complete
+            }
+        ])
+
+        # Display results
+        print("\n" + "="*60)
+        print("RESULTS")
+        print("="*60)
+
+        print(f"\nStep 1 - Data Generation:")
+        print(f"  Status: {results[0]['status']}")
+        print(f"  Output: {results[0].get('output')}")
+
+        print(f"\nStep 2 - Data Analysis:")
+        print(f"  Status: {results[1]['status']}")
+        print(f"  Output: {results[1].get('output')}")
+
+        print(f"\nStep 3 - Report Generation:")
+        print(f"  Status: {results[2]['status']}")
+        print(f"  Report:\n{results[2].get('output')}")
+
+        print(f"\n" + "="*60)
+        print("WORKFLOW SUMMARY")
+        print("="*60)
+        total_repairs = sum(r.get('repairs', 0) for r in results)
+        print(f"Total steps: {len(results)}")
+        print(f"Successful: {sum(1 for r in results if r['status'] == 'success')}")
+        print(f"Total repairs: {total_repairs}")
+
+        await mesh.stop()
+        print("\n✓ Workflow completed\n")
+
+    except Exception as e:
+        print(f"\n✗ Error: {e}")
+        import traceback
+        traceback.print_exc()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

examples/research_agent_example.py

@@ -0,0 +1,76 @@
+"""
+Research Agent Example - Internet Search & Data Extraction
+
+Demonstrates AutoAgent with internet search capabilities.
+Agent automatically gets access to web search tools (DuckDuckGo).
+
+Usage:
+    python examples/research_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 ResearchAgent(AutoAgent):
+    """Research assistant with internet access."""
+    role = "researcher"
+    capabilities = ["research", "web_search", "information_gathering"]
+    system_prompt = """
+    You are a research assistant with internet access.
+    Search the web for information and provide concise summaries.
+    Use the 'search' object available in your code:
+    - await search.search(query, max_results=5)
+    - await search.extract_content(url)
+    - await search.search_and_extract(query, num_results=3)
+    Store your findings in a variable named 'result'.
+    """
+
+
+async def main():
+    """Run research agent example."""
+    print("\n" + "="*60)
+    print("JarvisCore: Research Agent Example")
+    print("="*60)
+
+    # Zero-config: Reads from .env automatically
+    # Framework auto-detects: Claude → Azure → Gemini → vLLM
+    mesh = Mesh(mode="autonomous")
+    mesh.add(ResearchAgent)
+
+    try:
+        await mesh.start()
+        print("✓ Mesh started with internet search enabled\n")
+
+        print("Example: Research Python asyncio")
+        print("-" * 60)
+
+        results = await mesh.workflow("research-asyncio", [
+            {
+                "agent": "researcher",
+                "task": "Search for 'Python asyncio tutorial' and summarize the top 2 results"
+            }
+        ])
+
+        result = results[0]
+        print(f"Status: {result['status']}")
+        print(f"Summary:\n{result.get('output')}")
+        print(f"\nRepairs needed: {result.get('repairs', 0)}")
+
+        await mesh.stop()
+        print("\n✓ Research completed\n")
+
+    except Exception as e:
+        print(f"\n✗ Error: {e}")
+        import traceback
+        traceback.print_exc()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

jarviscore/__init__.py

@@ -0,0 +1,54 @@
+"""
+JarvisCore - P2P Distributed Agent Framework
+
+A production-grade framework for building autonomous agent systems with:
+- Event-sourced state management (crash recovery, HITL support)
+- P2P coordination via SWIM protocol
+- Two execution profiles:
+  * AutoAgent: LLM code generation (3 lines of user code)
+  * CustomAgent: Framework-agnostic (LangChain, MCP, raw Python)
+
+Quick Start:
+    from jarviscore import Mesh, AutoAgent
+
+    class ScraperAgent(AutoAgent):
+        role = "scraper"
+        capabilities = ["web_scraping"]
+        system_prompt = "You are an expert web scraper..."
+
+    mesh = Mesh(mode="autonomous")
+    mesh.add(ScraperAgent)
+    await mesh.start()
+
+    results = await mesh.workflow("my-workflow", [
+        {"agent": "scraper", "task": "Scrape example.com"}
+    ])
+"""
+
+__version__ = "0.1.0"
+__author__ = "JarvisCore Contributors"
+__license__ = "MIT"
+
+# Core classes
+from jarviscore.core.agent import Agent
+from jarviscore.core.profile import Profile
+from jarviscore.core.mesh import Mesh, MeshMode
+
+# Execution profiles
+from jarviscore.profiles.autoagent import AutoAgent
+from jarviscore.profiles.customagent import CustomAgent
+
+__all__ = [
+    # Version
+    "__version__",
+
+    # Core
+    "Agent",
+    "Profile",
+    "Mesh",
+    "MeshMode",
+
+    # Profiles
+    "AutoAgent",
+    "CustomAgent",
+]

jarviscore/cli/__init__.py

@@ -0,0 +1,7 @@
+"""
+JarvisCore CLI Tools
+
+Command-line utilities for setup, validation, and testing.
+"""
+
+__all__ = ['check', 'smoketest']

jarviscore/cli/__main__.py

@@ -0,0 +1,33 @@
+"""
+CLI entry point for JarvisCore commands.
+
+Usage:
+    python -m jarviscore.cli.check
+    python -m jarviscore.cli.smoketest
+"""
+
+import sys
+
+def main():
+    if len(sys.argv) < 2:
+        print("Usage: python -m jarviscore.cli <command>")
+        print("\nAvailable commands:")
+        print("  check      - Health check and validation")
+        print("  smoketest  - Quick smoke test")
+        sys.exit(1)
+
+    command = sys.argv[1]
+    sys.argv = [sys.argv[0]] + sys.argv[2:]  # Remove command from argv
+
+    if command == 'check':
+        from .check import main as check_main
+        check_main()
+    elif command == 'smoketest':
+        from .smoketest import main as smoketest_main
+        smoketest_main()
+    else:
+        print(f"Unknown command: {command}")
+        sys.exit(1)
+
+if __name__ == '__main__':
+    main()