jarviscore-framework 0.1.0__py3-none-any.whl

jarviscore/profiles/autoagent.py

@@ -0,0 +1,264 @@
+"""
+AutoAgent - Automated execution profile.
+
+Framework generates and executes code from natural language prompts.
+User writes just 3 attributes, framework handles everything.
+"""
+from typing import Dict, Any
+from jarviscore.core.profile import Profile
+
+
+class AutoAgent(Profile):
+    """
+    Automated execution profile.
+
+    User defines:
+    - role: str
+    - capabilities: List[str]
+    - system_prompt: str
+
+    Framework provides:
+    - LLM code generation from task descriptions
+    - Sandboxed code execution with resource limits
+    - Autonomous repair when execution fails
+    - Meta-cognition (detect spinning, paralysis)
+    - Token budget tracking
+    - Cost tracking per task
+
+    Example:
+        class ScraperAgent(AutoAgent):
+            role = "scraper"
+            capabilities = ["web_scraping", "data_extraction"]
+            system_prompt = '''
+            You are an expert web scraper. Use BeautifulSoup or Selenium
+            to extract structured data from websites. Return JSON results.
+            '''
+
+        # That's it! Framework handles execution automatically.
+    """
+
+    # Additional user-defined attribute (beyond Agent base class)
+    system_prompt: str = None
+
+    def __init__(self, agent_id=None):
+        super().__init__(agent_id)
+
+        if not self.system_prompt:
+            raise ValueError(
+                f"{self.__class__.__name__} must define 'system_prompt' class attribute\n"
+                f"Example: system_prompt = 'You are an expert...'"
+            )
+
+        # Execution components (initialized in setup() on Day 4)
+        self.llm = None
+        self.codegen = None
+        self.sandbox = None
+        self.repair = None
+
+    async def setup(self):
+        """
+        Initialize LLM and execution components with ZERO CONFIG.
+
+        Framework auto-detects available LLM providers and sets up:
+        - LLM client (tries vLLM → Azure → Gemini → Claude)
+        - Internet search (DuckDuckGo, no API key needed)
+        - Code generator with search injection
+        - Sandbox executor with timeout
+        - Autonomous repair system
+        """
+        await super().setup()
+
+        self._logger.info(f"AutoAgent setup: {self.agent_id}")
+        self._logger.info(f"  Role: {self.role}")
+        self._logger.info(f"  Capabilities: {self.capabilities}")
+        self._logger.info(f"  System Prompt: {self.system_prompt[:50]}...")
+
+        # Get config from mesh (or use empty dict)
+        config = self._mesh.config if self._mesh else {}
+
+        # Import execution components
+        from jarviscore.execution import (
+            create_llm_client,
+            create_search_client,
+            create_code_generator,
+            create_sandbox_executor,
+            create_autonomous_repair,
+            create_result_handler,
+            create_code_registry
+        )
+
+        # 1. Initialize LLM (auto-detects providers)
+        self._logger.info("Initializing LLM client...")
+        self.llm = create_llm_client(config)
+
+        # 2. Initialize search (zero-config)
+        self._logger.info("Initializing internet search...")
+        self.search = create_search_client()
+
+        # 3. Initialize code generator (with search injection)
+        self._logger.info("Initializing code generator...")
+        self.codegen = create_code_generator(self.llm, self.search)
+
+        # 4. Initialize sandbox executor (with search access)
+        timeout = config.get('execution_timeout', 300)
+        self._logger.info(f"Initializing sandbox executor ({timeout}s timeout)...")
+        self.sandbox = create_sandbox_executor(timeout, self.search, config)
+
+        # 5. Initialize autonomous repair
+        max_repairs = config.get('max_repair_attempts', 3)
+        self._logger.info(f"Initializing autonomous repair ({max_repairs} attempts)...")
+        self.repair = create_autonomous_repair(self.codegen, max_repairs)
+
+        # 6. Initialize result handler (file + in-memory storage)
+        log_dir = config.get('log_directory', './logs')
+        self._logger.info(f"Initializing result handler (dir: {log_dir})...")
+        self.result_handler = create_result_handler(log_dir)
+
+        # 7. Initialize code registry (reusable generated functions)
+        registry_dir = f"{log_dir}/code_registry"
+        self._logger.info(f"Initializing code registry (dir: {registry_dir})...")
+        self.code_registry = create_code_registry(registry_dir)
+
+        self._logger.info(f"✓ AutoAgent ready: {self.agent_id}")
+
+    async def execute_task(self, task: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Execute task via LLM code generation with automatic repair.
+
+        Pipeline:
+        1. Generate Python code from natural language task
+        2. Execute code in sandbox
+        3. If fails → autonomous repair (up to 3 attempts)
+        4. Return result with tokens/cost
+
+        Args:
+            task: Task specification with 'task' key (natural language)
+
+        Returns:
+            {
+                "status": "success" | "failure",
+                "output": Any,  # Task result
+                "error": str,   # Error if failed
+                "tokens": {...},  # Token usage
+                "cost_usd": float,
+                "code": str,    # Generated code
+                "repairs": int  # Number of repair attempts
+            }
+
+        Example:
+            result = await agent.execute_task({
+                "task": "Calculate factorial of 10"
+            })
+        """
+        task_desc = task.get('task', '')
+        self._logger.info(f"[AutoAgent] Executing: {task_desc[:80]}...")
+
+        total_tokens = {"input": 0, "output": 0, "total": 0}
+        total_cost = 0.0
+        repairs_attempted = 0
+
+        try:
+            # Step 1: Generate code from natural language
+            self._logger.info("Step 1: Generating code...")
+            code = await self.codegen.generate(
+                task=task,
+                system_prompt=self.system_prompt,
+                context=task.get('context'),  # Dependencies from previous steps
+                enable_search=True
+            )
+
+            # Track generation cost (from LLM response)
+            # Note: codegen now returns just code, cost tracked in llm
+            self._logger.debug(f"Generated {len(code)} characters of code")
+
+            # Step 2: Execute in sandbox
+            self._logger.info("Step 2: Executing code in sandbox...")
+            result = await self.sandbox.execute(code)
+
+            # Step 3: Handle execution failure with autonomous repair
+            if result['status'] == 'failure':
+                self._logger.warning(f"Execution failed: {result.get('error')}")
+                self._logger.info("Step 3: Attempting autonomous repair...")
+
+                # Use repair system with automatic retries
+                repair_result = await self.repair.repair_with_retries(
+                    code=code,
+                    error=Exception(result.get('error', 'Unknown error')),
+                    task=task,
+                    system_prompt=self.system_prompt,
+                    executor=self.sandbox
+                )
+
+                # Update result and track repairs
+                result = repair_result
+                repairs_attempted = len(repair_result.get('attempts', []))
+                self._logger.info(f"Repair attempts: {repairs_attempted}")
+
+            # Enrich result with metadata
+            result['code'] = code
+            result['repairs'] = repairs_attempted
+            result['agent_id'] = self.agent_id
+            result['role'] = self.role
+
+            # Add token/cost info if not already present
+            if 'tokens' not in result:
+                result['tokens'] = total_tokens
+            if 'cost_usd' not in result:
+                result['cost_usd'] = total_cost
+
+            # Store result to file system + in-memory cache
+            stored_result = self.result_handler.process_result(
+                agent_id=self.agent_id,
+                task=task_desc,
+                code=code,
+                output=result.get('output'),
+                status=result['status'],
+                error=result.get('error'),
+                execution_time=result.get('execution_time'),
+                tokens=result.get('tokens'),
+                cost_usd=result.get('cost_usd'),
+                repairs=repairs_attempted,
+                metadata={
+                    'role': self.role,
+                    'capabilities': self.capabilities,
+                    'system_prompt': self.system_prompt[:100]  # First 100 chars
+                }
+            )
+
+            # Add result_id to response
+            result['result_id'] = stored_result['result_id']
+
+            # Register successful code in registry for reuse
+            if result['status'] == 'success':
+                function_id = self.code_registry.register(
+                    code=code,
+                    agent_id=self.agent_id,
+                    task=task_desc,
+                    capabilities=self.capabilities,
+                    output=result.get('output'),
+                    result_id=result['result_id'],
+                    metadata={
+                        'role': self.role,
+                        'execution_time': result.get('execution_time'),
+                        'repairs': repairs_attempted
+                    }
+                )
+                result['function_id'] = function_id
+                self._logger.info(f"✓ Task completed successfully (result_id: {result['result_id']}, function_id: {function_id})")
+            else:
+                self._logger.error(f"✗ Task failed: {result.get('error')}")
+
+            return result
+
+        except Exception as e:
+            self._logger.error(f"Fatal error in execute_task: {e}", exc_info=True)
+            return {
+                "status": "failure",
+                "error": f"Fatal error: {str(e)}",
+                "error_type": type(e).__name__,
+                "agent_id": self.agent_id,
+                "role": self.role,
+                "repairs": repairs_attempted,
+                "tokens": total_tokens,
+                "cost_usd": total_cost
+            }

jarviscore/profiles/customagent.py

@@ -0,0 +1,137 @@
+"""
+CustomAgent - User-controlled execution profile.
+
+User provides their own implementation using any framework:
+- LangChain
+- MCP (Model Context Protocol)
+- CrewAI
+- Raw Python
+- Any other tool/framework
+"""
+from typing import Dict, Any
+from jarviscore.core.profile import Profile
+
+
+class CustomAgent(Profile):
+    """
+    Custom execution profile with full user control.
+
+    User defines:
+    - role: str
+    - capabilities: List[str]
+    - setup(): Initialize custom framework/tools
+    - execute_task(): Custom execution logic
+
+    Framework provides:
+    - Orchestration (task claiming, dependencies, nudging)
+    - P2P coordination (agent discovery, task routing)
+    - State management (crash recovery, HITL)
+    - Cost tracking (if user provides token counts)
+
+    Example with LangChain:
+        class APIAgent(CustomAgent):
+            role = "api_client"
+            capabilities = ["api_calls"]
+
+            async def setup(self):
+                await super().setup()
+                from langchain.agents import Agent
+                self.lc_agent = Agent(...)
+
+            async def execute_task(self, task):
+                result = await self.lc_agent.run(task["task"])
+                return {"status": "success", "output": result}
+
+    Example with MCP:
+        class MCPAgent(CustomAgent):
+            role = "tool_user"
+            capabilities = ["mcp_tools"]
+            mcp_server_url = "stdio://./server.py"
+
+            async def setup(self):
+                await super().setup()
+                from mcp import Client
+                self.mcp = Client(self.mcp_server_url)
+                await self.mcp.connect()
+
+            async def execute_task(self, task):
+                result = await self.mcp.call_tool("my_tool", task["params"])
+                return {"status": "success", "data": result}
+
+    Example with Raw Python:
+        class DataProcessor(CustomAgent):
+            role = "processor"
+            capabilities = ["data_processing"]
+
+            async def execute_task(self, task):
+                # Pure Python logic
+                data = task["params"]["data"]
+                processed = [x * 2 for x in data]
+                return {"status": "success", "output": processed}
+    """
+
+    def __init__(self, agent_id=None):
+        super().__init__(agent_id)
+
+        # User can add any custom attributes
+        # e.g., mcp_server_url, langchain_config, etc.
+
+    async def setup(self):
+        """
+        User implements this to initialize custom framework/tools.
+
+        DAY 1: Base implementation (user overrides)
+        DAY 5+: Full examples with LangChain, MCP, etc.
+
+        Example:
+            async def setup(self):
+                await super().setup()
+                # Initialize your framework
+                from langchain.agents import Agent
+                self.agent = Agent(...)
+        """
+        await super().setup()
+
+        self._logger.info(f"CustomAgent setup: {self.agent_id}")
+        self._logger.info(
+            f"  Note: Override setup() to initialize your custom framework"
+        )
+
+    async def execute_task(self, task: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        User implements this with custom execution logic.
+
+        DAY 1: Raises NotImplementedError (user must override)
+        DAY 5+: Full examples provided
+
+        Args:
+            task: Task specification
+
+        Returns:
+            Result dictionary with at least:
+            - status: "success" or "failure"
+            - output: Task result
+            - error (optional): Error message if failed
+            - tokens_used (optional): For cost tracking
+            - cost_usd (optional): For cost tracking
+
+        Raises:
+            NotImplementedError: User must override this method
+
+        Example:
+            async def execute_task(self, task):
+                result = await self.my_framework.run(task)
+                return {
+                    "status": "success",
+                    "output": result,
+                    "tokens_used": 1000,  # Optional
+                    "cost_usd": 0.002     # Optional
+                }
+        """
+        raise NotImplementedError(
+            f"{self.__class__.__name__} must implement execute_task()\n\n"
+            f"Example:\n"
+            f"    async def execute_task(self, task):\n"
+            f"        result = await self.my_framework.run(task['task'])\n"
+            f"        return {{'status': 'success', 'output': result}}\n"
+        )

jarviscore_framework-0.1.0.dist-info/METADATA

@@ -0,0 +1,136 @@
+Metadata-Version: 2.4
+Name: jarviscore-framework
+Version: 0.1.0
+Summary: P2P distributed agent framework with LLM code generation and event-sourced state management
+Author-email: Ruth Mutua <mutuandinda82@gmail.com>, Muyukani Kizito <muyukani@prescottdata.io>
+Maintainer-email: Prescott Data <info@prescottdata.io>
+License: MIT
+Project-URL: Homepage, https://github.com/yourusername/jarviscore
+Project-URL: Documentation, https://jarviscore.readthedocs.io
+Project-URL: Repository, https://github.com/yourusername/jarviscore
+Project-URL: Issues, https://github.com/yourusername/jarviscore/issues
+Keywords: agents,p2p,llm,distributed,workflow,orchestration
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: pydantic-settings>=2.0.0
+Requires-Dist: swim-p2p
+Requires-Dist: pyzmq
+Requires-Dist: python-dotenv>=1.0.0
+Requires-Dist: aiohttp>=3.9.0
+Requires-Dist: beautifulsoup4>=4.12.0
+Requires-Dist: anthropic>=0.18.0
+Requires-Dist: openai>=1.0.0
+Requires-Dist: google-generativeai>=0.3.0
+Requires-Dist: httpx>=0.25.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.4.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.1.0; extra == "dev"
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: mypy>=1.5.0; extra == "dev"
+Requires-Dist: ruff>=0.1.0; extra == "dev"
+Provides-Extra: all
+Requires-Dist: jarviscore[dev]; extra == "all"
+Dynamic: license-file
+
+# JarvisCore Framework
+
+**P2P distributed agent framework with LLM code generation and production-grade state management**
+
+## Features
+
+- ✅ **Simple Agent Definition** - Write just 3 attributes, framework handles everything
+- ✅ **P2P Mesh Architecture** - Automatic agent discovery and task routing via SWIM protocol
+- ✅ **Event-Sourced State** - Complete audit trail with crash recovery
+- ✅ **Autonomous Execution** - LLM code generation with automatic repair
+
+## Installation
+
+```bash
+pip install jarviscore
+```
+
+## Setup & Validation
+
+### 1. Configure LLM Provider
+
+Copy the example config and add your API key:
+
+```bash
+cp .env.example .env
+# Edit .env and add one of: CLAUDE_API_KEY, AZURE_API_KEY, GEMINI_API_KEY, or LLM_ENDPOINT
+```
+
+### 2. Validate Installation
+
+```bash
+# Check setup
+python -m jarviscore.cli.check
+
+# Test LLM connectivity
+python -m jarviscore.cli.check --validate-llm
+
+# Run smoke test (end-to-end validation)
+python -m jarviscore.cli.smoketest
+```
+
+✅ **All checks pass?** You're ready to build agents!
+
+## Quick Start
+
+```python
+from jarviscore import Mesh
+from jarviscore.profiles import PromptDevAgent
+
+# Define agent (3 lines)
+class ScraperAgent(PromptDevAgent):
+    role = "scraper"
+    capabilities = ["web_scraping"]
+    system_prompt = "You are an expert web scraper..."
+
+# Create mesh and run workflow
+mesh = Mesh(mode="autonomous")
+mesh.add(ScraperAgent)
+await mesh.start()
+
+results = await mesh.workflow(
+    workflow_id="wf-123",
+    steps=[
+        {"id": "scrape", "task": "Scrape example.com", "role": "scraper"}
+    ]
+)
+```
+
+## Architecture
+
+JarvisCore is built on three layers:
+
+1. **Execution Layer (20%)** - Profile-specific execution (Prompt-Dev, MCP)
+2. **Orchestration Layer (60%)** - Workflow engine, dependencies, state management
+3. **P2P Layer (20%)** - Agent discovery, task routing, mesh coordination
+
+## Documentation
+
+- [User Guide](jarviscore/docs/USER_GUIDE.md) - Complete guide for AutoAgent users
+- [API Reference](jarviscore/docs/API_REFERENCE.md) - Detailed API documentation
+- [Configuration Guide](jarviscore/docs/CONFIGURATION.md) - Settings and environment variables
+- [Troubleshooting](jarviscore/docs/TROUBLESHOOTING.md) - Common issues and solutions
+- [Examples](examples/) - Working code examples
+
+## Development Status
+
+**Version:** 0.1.0 (Alpha)
+**Day 1:** Core framework foundation ✅
+
+## License
+
+MIT License - see LICENSE file for details

jarviscore_framework-0.1.0.dist-info/RECORD

@@ -0,0 +1,55 @@
+examples/calculator_agent_example.py,sha256=x7TrzE45WT_1DqwEnw8U3Fw56WpR9jBe3SLZz5vsKWc,2276
+examples/multi_agent_workflow.py,sha256=Sygx3iEBM9WzorVMXqtiwn4rLYrW9BsxsiQSKceuzsE,4303
+examples/research_agent_example.py,sha256=phJ5AHNnZ_pxCfiKvHoTp_IFwOAW7VD1fRNHlXvfgj4,2287
+jarviscore/__init__.py,sha256=DKyYPM5AAcNcm6VnOJihC3sQRvkONgnYDupmQrmd3YQ,1380
+jarviscore/cli/__init__.py,sha256=OnpJ37xDcbh3jFhALLY1jimgp1mxlB1-VhsKhGS6TDY,123
+jarviscore/cli/__main__.py,sha256=GuIqW9NKJ3n70ei54ItzrBYEVaWG5dAWGxdu87w7YgI,829
+jarviscore/cli/check.py,sha256=1A7X_CjHd8rDQ4QNAzXWJgaYaxOMU5BcRlCuFuFyop8,13698
+jarviscore/cli/smoketest.py,sha256=1qek9Vb7DlX9YAtQwLg-L7Gr90q61oMy4elaF7rQA4I,13363
+jarviscore/config/__init__.py,sha256=ZLjbRHSi5azaDyoSOFr9cQ65J5Fvi56xI-WHdczc204,178
+jarviscore/config/settings.py,sha256=ueYpJAZxT1zoEPymzrn0OHAXZxQXBqSMs87VwolPdhg,3516
+jarviscore/core/__init__.py,sha256=30K2aqZckYTRZupn6X-mGV2QDSqWCgJ1cpN6Zk1gqlQ,177
+jarviscore/core/agent.py,sha256=qcqdhRVoYNxIhO_FYmttiDFA354EYtSaM2xp-TNDWGM,5402
+jarviscore/core/mesh.py,sha256=880H25tyteX7ppoI7KkTOnPQoCjoQ3_YdMPzWTb3Zzc,16380
+jarviscore/core/profile.py,sha256=sTrGTxV9mAqbt5l3z0-BSNOeWzq8YDLR3mlaPFSgt1c,2190
+jarviscore/docs/API_REFERENCE.md,sha256=26OhRSfX6n3eSSgvtQdoeITmjzDjl9qUOU4PuH1NqKM,20066
+jarviscore/docs/CONFIGURATION.md,sha256=xX7jSfIhCZ9mL-PK6QzRd9YIK7-WW4Hnkyw09NYn49A,14073
+jarviscore/docs/GETTING_STARTED.md,sha256=T8sCwjscFYlMkz2YBDEse8LEtyLlTcijKY5FOu7E7kk,13630
+jarviscore/docs/TROUBLESHOOTING.md,sha256=5sozZeJwTanFZ8-GctzgNN0R7ENM3CoS-Wu2Xt43oWk,8277
+jarviscore/docs/USER_GUIDE.md,sha256=f6zFDSIXejRanKp3WGOhm2GZ18tEG5NuVl8Bopi2St0,21179
+jarviscore/execution/__init__.py,sha256=yDAMehMO2dVvdKjxVx7zQV2AaxySmvymA24QF3O9tlY,1754
+jarviscore/execution/code_registry.py,sha256=C3_hAVXIeCG31qwSBUrmBBicmd2vnUrXJhJgj8MKlJw,9213
+jarviscore/execution/generator.py,sha256=zY7IxxDu4xoifeuCGZZN8_l8zQCsB5eUO9HGIiLIttw,8696
+jarviscore/execution/llm.py,sha256=3anWSfRlBPKf76b3SolyG78tT37461pT1uak1oqdscw,16476
+jarviscore/execution/repair.py,sha256=yy6GTX6nFoA38S9V1ZGvqOeH3iRThRkMI3GZ6F_2WrU,9092
+jarviscore/execution/result_handler.py,sha256=7SKr-teFksqNgejhnZNrjAzKbtDXbOSV3Tv7gfYsdig,10590
+jarviscore/execution/sandbox.py,sha256=IVkccce_WHDxXO6l8BCcuxAB5iueJfYtbryydoE972c,19981
+jarviscore/execution/search.py,sha256=JSoT8vb_yT6_EKaAgUQDS8ONgFeKf6s8YlEeTn6FaWQ,9923
+jarviscore/orchestration/__init__.py,sha256=Ia9GfEMWif0tN0Ju89q6M_x_BRw9FcQl5Rf99p8CIKU,386
+jarviscore/orchestration/claimer.py,sha256=ekhHqhtxpi_USnPsIioFK6bA2nhH6jalulBkptYubVU,3106
+jarviscore/orchestration/dependency.py,sha256=UtSSwSC2Ak5V5dYeZWJy3wZZuTE-Y-fcglkoIgNT_70,4377
+jarviscore/orchestration/engine.py,sha256=vviPOIYvhRqK5TbyS2epiRayhGe8fBg1j8N0VB6Vzyc,10455
+jarviscore/orchestration/status.py,sha256=XeKASMNQDwpJ6HpDw3m3eAAMNWsWCj4k9jrvMnLHPbo,2540
+jarviscore/p2p/__init__.py,sha256=EMggUUf7E0MGJlayy0GNGiFGnd0vr-PJ2T2suR_mwAI,632
+jarviscore/p2p/broadcaster.py,sha256=PQRBRfVQD1FNntnxi7H8VsOyYGk_63N-QtnRB4Dx_-I,14127
+jarviscore/p2p/coordinator.py,sha256=dqSyg2xUAlxuRIn121fY1246KqT1O8-bImjpH80WIC0,13397
+jarviscore/p2p/keepalive.py,sha256=Ml4TyXv2pzJ7UZl3uYVgMlHmpjxYV6fAebWLSEEXo5U,14079
+jarviscore/p2p/swim_manager.py,sha256=Mdr6D0uxJR0h1JMO_faAda2Ojv6gfjoY-ZOzD9q_DWo,10816
+jarviscore/profiles/__init__.py,sha256=vBV6W5vszx3px4UOZwCh2wsH-TYzIoPp4Zo_STT8pNo,154
+jarviscore/profiles/autoagent.py,sha256=1nJAVf1oU9lLO47BP1xFGBDZtypXXkwKy6kZjtpdlX0,10424
+jarviscore/profiles/customagent.py,sha256=GRauTYlWyYSgZrWyYZlAPNkJoVgjDHjfY_c0rdeoOgM,4618
+jarviscore_framework-0.1.0.dist-info/licenses/LICENSE,sha256=SjsXanvmQJFYz_SVFa17O85-bKIa_aG99wrkPpWtypo,1101
+tests/conftest.py,sha256=vK5f8DVxCkOGTz3K1835ru5vRgHnaDL_V9M5AUaJ2Zw,974
+tests/test_agent.py,sha256=qx9SFDTP4DlcQi6hV8y6LZyEYX6IB8D3VnM7fODnW9s,5182
+tests/test_autoagent.py,sha256=_mzinLdQwskOn6a-yGqdfoOsqw2f52XSyTCmj8hLqlg,4628
+tests/test_autoagent_day4.py,sha256=TTb0kSImF9stMsq4cMlkGahf9UBpYjoNXAkgnkKuuQA,4719
+tests/test_customagent.py,sha256=auxU6j3GVVT1r2kwoxarFUSCHtwSTjCrxBTqZzezqzw,8310
+tests/test_integration.py,sha256=X9TYRW2WKF1doLFARTEyCCYLFAnYsazsshDwBzQZcZE,9191
+tests/test_llm_fallback.py,sha256=CNajpKkQ6MO503dRbgaP2cz9kXHwUGKo5381tHKTe4c,5742
+tests/test_mesh.py,sha256=QD0qbVRms7__ox2Ye7Ps4tfuH63m3_EoJzikjHIHjbc,10902
+tests/test_p2p_integration.py,sha256=F9B21eWlwRzSRphm2Kacs9nM1FgSbSzi6RSLPDvvt2U,10995
+tests/test_remote_sandbox.py,sha256=80ebc0pWInauWnywsQ0VSzlk8OexSCgGL7BcJUCPkR8,3268
+jarviscore_framework-0.1.0.dist-info/METADATA,sha256=g-qil-HPVU4PZJub2x0eRsy8G0LPghls6Vbr_OvLtks,4250
+jarviscore_framework-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+jarviscore_framework-0.1.0.dist-info/top_level.txt,sha256=P1SVqN5qA97MpLqnuowxDioZ49zccGrx0tjKz-7wz5o,26
+jarviscore_framework-0.1.0.dist-info/RECORD,,

jarviscore_framework-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

jarviscore_framework-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 JarvisCore Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

jarviscore_framework-0.1.0.dist-info/top_level.txt

@@ -0,0 +1,3 @@
+examples
+jarviscore
+tests

tests/conftest.py

@@ -0,0 +1,44 @@
+"""
+Pytest configuration and fixtures for JarvisCore tests.
+"""
+import pytest
+import logging
+
+
+@pytest.fixture(autouse=True)
+def setup_logging():
+    """Setup logging for tests."""
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+    )
+
+
+@pytest.fixture
+def sample_task():
+    """Sample task for testing."""
+    return {
+        "task": "Test task description",
+        "params": {"key": "value"}
+    }
+
+
+@pytest.fixture
+def sample_workflow():
+    """Sample workflow for testing."""
+    return [
+        {
+            "agent": "agent1",
+            "task": "Step 1: Process data"
+        },
+        {
+            "agent": "agent2",
+            "task": "Step 2: Transform results",
+            "depends_on": [0]
+        },
+        {
+            "agent": "agent3",
+            "task": "Step 3: Save to storage",
+            "depends_on": [1]
+        }
+    ]