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

test_logs/code_registry/functions/report_generator-37552117_e711c2b9.py

@@ -0,0 +1,35 @@
+async def main():
+    try:
+        # Create invoice header with company name and date
+        company_name = "Acme Corp"
+        date = "Jan 2024"
+        
+        # Create formatted header
+        width = 50
+        border = "=" * width
+        
+        header_lines = [
+            border,
+            "",
+            company_name.center(width),
+            "",
+            "INVOICE".center(width),
+            "",
+            f"Date: {date}".center(width),
+            "",
+            border
+        ]
+        
+        report = "\n".join(header_lines)
+        
+        result = {
+            'report': report
+        }
+        
+        return result
+        
+    except Exception as e:
+        result = {
+            'report': f"Error generating invoice header: {str(e)}"
+        }
+        return result

test_logs/code_registry/functions/report_generator-bc662768_e711c2b9.py

@@ -0,0 +1,35 @@
+async def main():
+    try:
+        # Create invoice header with company name and date
+        company_name = "Acme Corp"
+        date = "Jan 2024"
+        
+        # Create formatted header
+        width = 50
+        border = "=" * width
+        
+        header_lines = [
+            border,
+            "",
+            company_name.center(width),
+            "",
+            "INVOICE".center(width),
+            "",
+            f"Date: {date}".center(width),
+            "",
+            border
+        ]
+        
+        report = "\n".join(header_lines)
+        
+        result = {
+            'report': report
+        }
+        
+        return result
+        
+    except Exception as e:
+        result = {
+            'report': f"Error generating invoice header: {str(e)}"
+        }
+        return result

test_logs/code_registry/functions/report_generator-d6c0e76b_5e7722ec.py

@@ -0,0 +1,44 @@
+async def main():
+    try:
+        # Get data from previous step if available, otherwise use provided data
+        previous_data = {'name': 'John', 'age': 30, 'city': 'NYC'}
+        
+        # Check if we have previous step results
+        try:
+            if 'step0' in previous_step_results:
+                previous_data = previous_step_results['step0']
+        except NameError:
+            pass
+        
+        name = previous_data.get('name', 'John')
+        age = previous_data.get('age', 30)
+        city = previous_data.get('city', 'NYC')
+        
+        # Create formatted text report
+        report_lines = [
+            "=" * 40,
+            "PERSON INFORMATION REPORT",
+            "=" * 40,
+            "",
+            f"{'Name:':<15} {name}",
+            f"{'Age:':<15} {age}",
+            f"{'City:':<15} {city}",
+            "",
+            "-" * 40,
+            f"Report generated successfully",
+            "=" * 40
+        ]
+        
+        report = "\n".join(report_lines)
+        
+        result = {
+            'report': report
+        }
+        
+        return result
+        
+    except Exception as e:
+        result = {
+            'report': f"Error generating report: {str(e)}"
+        }
+        return result

test_logs/code_registry/functions/report_generator-f270fb02_680529c3.py

@@ -0,0 +1,44 @@
+async def main():
+    try:
+        # Get data from previous step if available, otherwise use provided defaults
+        previous_data = {'name': 'John', 'age': 30, 'city': 'NYC'}
+        
+        # Check if we have previous step results
+        try:
+            if 'step0' in globals().get('previous_step_results', {}):
+                previous_data = previous_step_results['step0']
+        except:
+            pass
+        
+        # Extract person data
+        name = previous_data.get('name', 'John')
+        age = previous_data.get('age', 30)
+        city = previous_data.get('city', 'NYC')
+        
+        # Create formatted text report
+        report_lines = [
+            "=" * 40,
+            "PERSON INFORMATION REPORT",
+            "=" * 40,
+            "",
+            f"Name:     {name}",
+            f"Age:      {age}",
+            f"City:     {city}",
+            "",
+            "-" * 40,
+            f"Generated for: {name}",
+            "=" * 40
+        ]
+        
+        report = "\n".join(report_lines)
+        
+        result = {
+            'report': report
+        }
+        
+        return result
+        
+    except Exception as e:
+        return {
+            'report': f"Error generating report: {str(e)}"
+        }

test_logs/code_registry/functions/text_processor-11393b14_4370d3ed.py

@@ -0,0 +1,40 @@
+def main():
+    # Input product list
+    product_string = "Widget=$10, Gadget=$25, Tool=$15"
+    
+    try:
+        # Split the string by comma and strip whitespace
+        products = [item.strip() for item in product_string.split(',')]
+        
+        # Create bulleted list
+        bulleted_items = []
+        for product in products:
+            # Split by '=' to separate name and price
+            parts = product.split('=')
+            if len(parts) == 2:
+                name = parts[0].strip()
+                price = parts[1].strip()
+                bulleted_items.append(f"• {name}: {price}")
+            else:
+                bulleted_items.append(f"• {product}")
+        
+        # Join into final bulleted text
+        bulleted_text = '\n'.join(bulleted_items)
+        
+        result = {
+            'original': product_string,
+            'bulleted_list': bulleted_text,
+            'item_count': len(bulleted_items),
+            'items': bulleted_items
+        }
+        
+        return result
+        
+    except Exception as e:
+        return {
+            'error': str(e),
+            'original': product_string,
+            'bulleted_list': None
+        }
+
+result = main()

test_logs/code_registry/functions/text_processor-7d02dfc3_d3b569be.py

@@ -0,0 +1,37 @@
+async def main():
+    try:
+        # Input product list
+        product_string = "Widget=$10, Gadget=$25, Tool=$15"
+        
+        # Parse the product list
+        products = product_string.split(", ")
+        
+        # Format as bulleted list
+        bulleted_lines = []
+        for product in products:
+            # Split by = to get name and price
+            parts = product.split("=")
+            if len(parts) == 2:
+                name = parts[0].strip()
+                price = parts[1].strip()
+                bulleted_lines.append(f"• {name}: {price}")
+        
+        # Join into final bulleted text
+        bulleted_text = "\n".join(bulleted_lines)
+        
+        result = {
+            "original": product_string,
+            "bulleted_list": bulleted_text,
+            "item_count": len(bulleted_lines),
+            "items": [{"name": p.split("=")[0].strip(), "price": p.split("=")[1].strip()} for p in products]
+        }
+        
+        return result
+        
+    except Exception as e:
+        result = {
+            "error": str(e),
+            "bulleted_list": "",
+            "item_count": 0
+        }
+        return result

test_logs/code_registry/functions/text_processor-8adb5e32_9168c5fe.py

@@ -0,0 +1,13 @@
+async def main():
+    words = ["apple", "banana", "cherry", "date", "elderberry"]
+    
+    word_lengths = {word: len(word) for word in words}
+    total_characters = sum(word_lengths.values())
+    
+    result = {
+        "words": words,
+        "individual_lengths": word_lengths,
+        "total_characters": total_characters
+    }
+    
+    return result

test_logs/code_registry/functions/text_processor-c58ffc19_78b4ceac.py

@@ -0,0 +1,42 @@
+def main():
+    # Input product list
+    product_string = "Widget=$10, Gadget=$25, Tool=$15"
+    
+    try:
+        # Split the string by comma and strip whitespace
+        products = [item.strip() for item in product_string.split(",")]
+        
+        # Create bulleted list
+        bulleted_items = []
+        for product in products:
+            # Split by = to get name and price
+            parts = product.split("=")
+            if len(parts) == 2:
+                name = parts[0].strip()
+                price = parts[1].strip()
+                bulleted_items.append(f"• {name}: {price}")
+            else:
+                bulleted_items.append(f"• {product}")
+        
+        # Join into final bulleted text
+        bulleted_text = "\n".join(bulleted_items)
+        
+        result = {
+            "original": product_string,
+            "bulleted_list": bulleted_text,
+            "item_count": len(bulleted_items),
+            "items": bulleted_items
+        }
+        
+        return result
+        
+    except Exception as e:
+        return {
+            "error": str(e),
+            "original": product_string,
+            "bulleted_list": "",
+            "item_count": 0,
+            "items": []
+        }
+
+result = main()

test_logs/code_registry/functions/text_processor-cd5977b1_9168c5fe.py

@@ -0,0 +1,13 @@
+async def main():
+    words = ["apple", "banana", "cherry", "date", "elderberry"]
+    
+    word_lengths = {word: len(word) for word in words}
+    total_characters = sum(word_lengths.values())
+    
+    result = {
+        "words": words,
+        "individual_lengths": word_lengths,
+        "total_characters": total_characters
+    }
+    
+    return result

test_logs/code_registry/functions/text_processor-ec1c8773_9168c5fe.py

@@ -0,0 +1,13 @@
+async def main():
+    words = ["apple", "banana", "cherry", "date", "elderberry"]
+    
+    word_lengths = {word: len(word) for word in words}
+    total_characters = sum(word_lengths.values())
+    
+    result = {
+        "words": words,
+        "individual_lengths": word_lengths,
+        "total_characters": total_characters
+    }
+    
+    return result

tests/test_01_analyst_standalone.py

@@ -0,0 +1,124 @@
+"""
+Test 1: Standalone Analyst
+
+The Analyst agent working alone - no framework.
+Can analyze data, but cannot receive requests from other agents.
+"""
+
+
+class Analyst:
+    """
+    Standalone Analyst agent.
+
+    Capabilities:
+    - Analyze data
+    - Generate reports
+    - Provide recommendations
+    """
+
+    def __init__(self):
+        self.name = "analyst"
+        self.analyses_count = 0
+
+    def analyze(self, data: str) -> dict:
+        """Analyze data and return insights."""
+        self.analyses_count += 1
+        return {
+            "id": self.analyses_count,
+            "input": data,
+            "summary": f"Analysis of '{data}' shows positive trends",
+            "confidence": 0.85,
+            "recommendation": "Proceed with caution"
+        }
+
+    def generate_report(self, analysis: dict) -> str:
+        """Generate a text report from analysis."""
+        return (
+            f"Report #{analysis['id']}\n"
+            f"Summary: {analysis['summary']}\n"
+            f"Confidence: {analysis['confidence']}\n"
+            f"Recommendation: {analysis['recommendation']}"
+        )
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# TESTS
+# ═══════════════════════════════════════════════════════════════════════════════
+
+def test_analyst_init():
+    """Analyst initializes correctly."""
+    analyst = Analyst()
+    assert analyst.name == "analyst"
+    assert analyst.analyses_count == 0
+    print("✓ Analyst initialized")
+
+
+def test_analyst_analyze():
+    """Analyst can analyze data."""
+    analyst = Analyst()
+    result = analyst.analyze("Q4 sales data")
+
+    assert result["id"] == 1
+    assert result["confidence"] == 0.85
+    assert "Q4 sales data" in result["summary"]
+    print(f"✓ Analysis: {result['summary']}")
+
+
+def test_analyst_multiple_analyses():
+    """Analyst tracks analysis count."""
+    analyst = Analyst()
+
+    analyst.analyze("data 1")
+    analyst.analyze("data 2")
+    result = analyst.analyze("data 3")
+
+    assert analyst.analyses_count == 3
+    assert result["id"] == 3
+    print(f"✓ Multiple analyses: count = {analyst.analyses_count}")
+
+
+def test_analyst_generate_report():
+    """Analyst can generate reports."""
+    analyst = Analyst()
+    analysis = analyst.analyze("market trends")
+    report = analyst.generate_report(analysis)
+
+    assert "Report #1" in report
+    assert "market trends" in report
+    print(f"✓ Report generated:\n{report}")
+
+
+def test_analyst_cannot_receive_requests():
+    """Analyst has NO way to receive external requests."""
+    analyst = Analyst()
+
+    # No peers
+    assert not hasattr(analyst, 'peers')
+
+    # No receive method
+    assert not hasattr(analyst, 'receive')
+
+    # No way to listen for incoming messages
+    assert not hasattr(analyst, 'run')
+
+    print("✓ Analyst CANNOT receive external requests (limitation)")
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# RUN
+# ═══════════════════════════════════════════════════════════════════════════════
+
+if __name__ == "__main__":
+    print("\n" + "="*60)
+    print("TEST 1: STANDALONE ANALYST")
+    print("="*60 + "\n")
+
+    test_analyst_init()
+    test_analyst_analyze()
+    test_analyst_multiple_analyses()
+    test_analyst_generate_report()
+    test_analyst_cannot_receive_requests()
+
+    print("\n" + "-"*60)
+    print("Analyst works, but cannot receive requests from others.")
+    print("-"*60 + "\n")

tests/test_02_assistant_standalone.py

@@ -0,0 +1,164 @@
+"""
+Test 2: Standalone Assistant
+
+The Assistant agent working alone - no framework.
+Has local tools (search, calculate) but cannot talk to other agents.
+"""
+
+
+class Assistant:
+    """
+    Standalone Assistant agent.
+
+    Capabilities:
+    - Search the web
+    - Calculate expressions
+    - Chat with user
+
+    Tools available to LLM:
+    - search
+    - calculate
+    """
+
+    def __init__(self):
+        self.name = "assistant"
+
+    def search(self, query: str) -> str:
+        """Search the web for information."""
+        # Simulated search
+        return f"Search results for '{query}': Found 10 relevant articles."
+
+    def calculate(self, expression: str) -> str:
+        """Calculate a math expression."""
+        try:
+            result = eval(expression)
+            return f"Result: {result}"
+        except Exception as e:
+            return f"Error: {e}"
+
+    def get_tools(self) -> list:
+        """Return tool definitions for LLM."""
+        return [
+            {
+                "name": "search",
+                "description": "Search the web for information",
+                "parameters": {"query": "string"}
+            },
+            {
+                "name": "calculate",
+                "description": "Calculate a math expression",
+                "parameters": {"expression": "string"}
+            }
+        ]
+
+    def execute_tool(self, tool_name: str, args: dict) -> str:
+        """Execute a tool by name."""
+        if tool_name == "search":
+            return self.search(args.get("query", ""))
+        elif tool_name == "calculate":
+            return self.calculate(args.get("expression", ""))
+        else:
+            return f"Unknown tool: {tool_name}"
+
+    def chat(self, message: str) -> str:
+        """Simple chat response."""
+        return f"I received: {message}"
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# TESTS
+# ═══════════════════════════════════════════════════════════════════════════════
+
+def test_assistant_init():
+    """Assistant initializes correctly."""
+    assistant = Assistant()
+    assert assistant.name == "assistant"
+    print("✓ Assistant initialized")
+
+
+def test_assistant_search():
+    """Assistant can search."""
+    assistant = Assistant()
+    result = assistant.search("market trends 2024")
+
+    assert "Search results" in result
+    assert "market trends" in result
+    print(f"✓ Search: {result}")
+
+
+def test_assistant_calculate():
+    """Assistant can calculate."""
+    assistant = Assistant()
+
+    result1 = assistant.calculate("2 + 2")
+    assert "4" in result1
+    print(f"✓ Calculate 2+2: {result1}")
+
+    result2 = assistant.calculate("100 * 0.15")
+    assert "15" in result2
+    print(f"✓ Calculate 100*0.15: {result2}")
+
+
+def test_assistant_get_tools():
+    """Assistant returns tool definitions."""
+    assistant = Assistant()
+    tools = assistant.get_tools()
+    tool_names = [t["name"] for t in tools]
+
+    assert "search" in tool_names
+    assert "calculate" in tool_names
+    assert len(tools) == 2
+    print(f"✓ Tools: {tool_names}")
+
+
+def test_assistant_execute_tool():
+    """Assistant can execute tools by name."""
+    assistant = Assistant()
+
+    result = assistant.execute_tool("search", {"query": "python tutorials"})
+    assert "python tutorials" in result
+    print(f"✓ Execute search: {result}")
+
+    result = assistant.execute_tool("calculate", {"expression": "10 / 2"})
+    assert "5" in result
+    print(f"✓ Execute calculate: {result}")
+
+
+def test_assistant_cannot_talk_to_peers():
+    """Assistant has NO way to talk to other agents."""
+    assistant = Assistant()
+    tools = assistant.get_tools()
+    tool_names = [t["name"] for t in tools]
+
+    # No peer communication tools
+    assert "ask_peer" not in tool_names
+    assert "broadcast_update" not in tool_names
+    assert "list_peers" not in tool_names
+
+    # No peers attribute
+    assert not hasattr(assistant, 'peers')
+
+    print("✓ Assistant CANNOT talk to peers (limitation)")
+    print(f"  Available tools: {tool_names}")
+    print(f"  Missing: ask_peer, broadcast_update, list_peers")
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# RUN
+# ═══════════════════════════════════════════════════════════════════════════════
+
+if __name__ == "__main__":
+    print("\n" + "="*60)
+    print("TEST 2: STANDALONE ASSISTANT")
+    print("="*60 + "\n")
+
+    test_assistant_init()
+    test_assistant_search()
+    test_assistant_calculate()
+    test_assistant_get_tools()
+    test_assistant_execute_tool()
+    test_assistant_cannot_talk_to_peers()
+
+    print("\n" + "-"*60)
+    print("Assistant works, but cannot talk to other agents.")
+    print("-"*60 + "\n")