zenus-core 0.6.1__tar.gz

zenus_core-0.6.1/PKG-INFO

@@ -0,0 +1,46 @@
+Metadata-Version: 2.4
+Name: zenus-core
+Version: 0.6.1
+Summary: Zenus Core - Intent Execution Engine
+License: MIT
+Author: Zenus Team
+Requires-Python: >=3.10,<4.0
+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
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Provides-Extra: all
+Provides-Extra: browser
+Requires-Dist: anthropic (>=0.47.0,<0.48.0)
+Requires-Dist: matplotlib (>=3.8.0,<4.0.0)
+Requires-Dist: numpy (>=1.24.0,<2.0.0)
+Requires-Dist: openai (>=1.0.0,<2.0.0)
+Requires-Dist: pillow (>=12.1.1,<13.0.0)
+Requires-Dist: playwright (>=1.40.0,<2.0.0) ; extra == "browser" or extra == "all"
+Requires-Dist: prompt-toolkit (>=3.0.52,<4.0.0)
+Requires-Dist: psutil (>=5.9.0,<6.0.0)
+Requires-Dist: pyautogui (>=0.9.54,<0.10.0)
+Requires-Dist: pydantic (>=2.0.0,<3.0.0)
+Requires-Dist: python-dotenv (>=1.0.0,<2.0.0)
+Requires-Dist: pyyaml (>=6.0.0,<7.0.0)
+Requires-Dist: requests (>=2.31.0,<3.0.0)
+Requires-Dist: rich (>=13.7.0,<14.0.0)
+Requires-Dist: watchdog (>=3.0.0,<4.0.0)
+Requires-Dist: zenus-visualization (>=0.6.1,<0.7.0)
+Description-Content-Type: text/markdown
+
+# Zenus Core
+
+The brain of Zenus - intelligent intent execution engine.
+
+## Installation
+
+```bash
+pip install zenus-core
+```
+
+See main [Zenus documentation](../../README.md) for details.
+

zenus_core-0.6.1/README.md

@@ -0,0 +1,11 @@
+# Zenus Core
+
+The brain of Zenus - intelligent intent execution engine.
+
+## Installation
+
+```bash
+pip install zenus-core
+```
+
+See main [Zenus documentation](../../README.md) for details.

zenus_core-0.6.1/pyproject.toml

@@ -0,0 +1,40 @@
+[tool.poetry]
+name = "zenus-core"
+version = "0.6.1"
+description = "Zenus Core - Intent Execution Engine"
+authors = ["Zenus Team"]
+readme = "README.md"
+license = "MIT"
+packages = [{include = "zenus_core", from = "src"}]
+
+[tool.poetry.dependencies]
+python = "^3.10"
+pydantic = "^2.0.0"
+python-dotenv = "^1.0.0"
+pyyaml = "^6.0.0"
+watchdog = "^3.0.0"
+requests = "^2.31.0"
+openai = "^1.0.0"
+anthropic = "^0.47.0"
+rich = "^13.7.0"
+psutil = "^5.9.0"
+playwright = {version = "^1.40.0", optional = true}
+prompt-toolkit = "^3.0.52"
+pyautogui = "^0.9.54"
+pillow = "^12.1.1"
+matplotlib = "^3.8.0"
+numpy = "^1.24.0"
+zenus-visualization = "^0.6.1"
+
+[tool.poetry.extras]
+browser = ["playwright"]
+all = ["playwright"]
+
+[tool.poetry.group.dev.dependencies]
+pytest = "^8.0.0"
+pytest-cov = "^4.1.0"
+pytest-asyncio = "^0.23.0"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"

zenus_core-0.6.1/src/zenus_core/__init__.py

@@ -0,0 +1,12 @@
+"""
+Zenus Core - Intent Execution Engine
+
+The brain of Zenus: translates intent into validated system operations.
+"""
+
+__version__ = "0.3.0"
+
+from zenus_core.orchestrator import Orchestrator, OrchestratorError
+from zenus_core.brain.llm.schemas import IntentIR, Step
+
+__all__ = ["Orchestrator", "OrchestratorError", "IntentIR", "Step", "__version__"]

zenus_core-0.6.1/src/zenus_core/audit/logger.py

@@ -0,0 +1,116 @@
+"""
+Audit Logger
+
+Records all intent translation and execution flows for review and debugging.
+"""
+
+import json
+import os
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+from zenus_core.brain.llm.schemas import IntentIR
+
+
+class AuditLogger:
+    """Logs all operations to structured audit files"""
+
+    def __init__(self, log_dir: Optional[str] = None):
+        if log_dir is None:
+            log_dir = os.path.expanduser("~/.zenus/logs")
+        
+        self.log_dir = Path(log_dir)
+        self.log_dir.mkdir(parents=True, exist_ok=True)
+        
+        # Current session log file
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        self.session_file = self.log_dir / f"session_{timestamp}.jsonl"
+
+    def log_intent(self, user_input: str, intent: IntentIR, mode: str = "execution"):
+        """Log intent translation"""
+        entry = {
+            "timestamp": datetime.now().isoformat(),
+            "type": "intent",
+            "mode": mode,
+            "user_input": user_input,
+            "goal": intent.goal,
+            "requires_confirmation": intent.requires_confirmation,
+            "steps": [
+                {
+                    "tool": step.tool,
+                    "action": step.action,
+                    "args": step.args,
+                    "risk": step.risk
+                }
+                for step in intent.steps
+            ]
+        }
+        self._write(entry)
+
+    def log_execution_start(self, intent: IntentIR):
+        """Log execution start"""
+        entry = {
+            "timestamp": datetime.now().isoformat(),
+            "type": "execution_start",
+            "goal": intent.goal
+        }
+        self._write(entry)
+
+    def log_step_result(self, tool: str, action: str, result: str, success: bool):
+        """Log individual step result"""
+        entry = {
+            "timestamp": datetime.now().isoformat(),
+            "type": "step_result",
+            "tool": tool,
+            "action": action,
+            "result": result,
+            "success": success
+        }
+        self._write(entry)
+
+    def log_execution_end(self, success: bool, message: Optional[str] = None):
+        """Log execution completion"""
+        entry = {
+            "timestamp": datetime.now().isoformat(),
+            "type": "execution_end",
+            "success": success,
+            "message": message
+        }
+        self._write(entry)
+
+    def log_error(self, error: str, context: Optional[dict] = None):
+        """Log error"""
+        entry = {
+            "timestamp": datetime.now().isoformat(),
+            "type": "error",
+            "error": error,
+            "context": context or {}
+        }
+        self._write(entry)
+    
+    def log_info(self, event_type: str, data: Optional[dict] = None):
+        """Log informational event"""
+        entry = {
+            "timestamp": datetime.now().isoformat(),
+            "type": "info",
+            "event": event_type,
+            "data": data or {}
+        }
+        self._write(entry)
+
+    def _write(self, entry: dict):
+        """Write entry to log file"""
+        with open(self.session_file, "a") as f:
+            f.write(json.dumps(entry) + "\n")
+
+
+# Global logger instance
+_logger: Optional[AuditLogger] = None
+
+
+def get_logger() -> AuditLogger:
+    """Get or create global logger"""
+    global _logger
+    if _logger is None:
+        _logger = AuditLogger()
+    return _logger

zenus_core-0.6.1/src/zenus_core/brain/adaptive_planner.py

@@ -0,0 +1,207 @@
+"""
+Adaptive Planner
+
+Executes plans with observation and adaptation.
+Key difference from basic planner: can observe failures and replan.
+"""
+
+from typing import Optional, Callable
+from zenus_core.brain.llm.schemas import IntentIR, Step
+from zenus_core.brain.llm.factory import get_llm
+from zenus_core.tools.registry import TOOLS
+from zenus_core.safety.policy import check_step, SafetyError
+
+
+class ExecutionResult:
+    """Result of a single step execution"""
+    def __init__(self, success: bool, output: str, error: Optional[str] = None):
+        self.success = success
+        self.output = output
+        self.error = error
+
+
+class AdaptivePlanner:
+    """
+    Executes plans with observation and adaptation
+    
+    Unlike basic execution, this planner:
+    - Observes each step result
+    - Detects failures
+    - Can request corrective actions
+    - Maintains execution context
+    """
+    
+    def __init__(self, logger=None):
+        self.logger = logger
+        self.llm = get_llm()
+        self.execution_history = []
+    
+    def execute_adaptive(
+        self, 
+        intent: IntentIR,
+        max_retries: int = 2,
+        on_failure: Callable = None
+    ) -> bool:
+        """
+        Execute plan with adaptive retry on failure
+        
+        Args:
+            intent: The validated IntentIR to execute
+            max_retries: Maximum retry attempts per step
+            on_failure: Optional callback for failure handling
+        
+        Returns:
+            True if all steps succeeded, False otherwise
+        """
+        
+        # CRITICAL: Clear execution history at the start of each execution
+        # to prevent caching results from previous commands
+        self.execution_history = []
+        
+        if self.logger:
+            self.logger.log_execution_start(intent)
+        
+        for step_idx, step in enumerate(intent.steps):
+            attempt = 0
+            step_succeeded = False
+            
+            while attempt <= max_retries and not step_succeeded:
+                if attempt > 0:
+                    print(f"\n  Retry attempt {attempt} for step {step_idx + 1}...")
+                
+                result = self._execute_single_step(step, step_idx + 1)
+                
+                if result.success:
+                    step_succeeded = True
+                    self.execution_history.append({
+                        "step": step,
+                        "result": result,
+                        "attempt": attempt
+                    })
+                else:
+                    attempt += 1
+                    
+                    if attempt <= max_retries:
+                        # Try to adapt the step based on failure
+                        adapted_step = self._adapt_on_failure(
+                            step, 
+                            result,
+                            self.execution_history
+                        )
+                        
+                        if adapted_step:
+                            print(f"  Adapting: {adapted_step.action} with {adapted_step.args}")
+                            step = adapted_step
+                        else:
+                            # No adaptation possible, fail
+                            break
+                    
+                    if on_failure:
+                        on_failure(step, result)
+            
+            if not step_succeeded:
+                error_msg = f"Step {step_idx + 1} failed after {attempt} attempts"
+                if self.logger:
+                    self.logger.log_execution_end(False, error_msg)
+                return False
+        
+        if self.logger:
+            self.logger.log_execution_end(True)
+        
+        return True
+    
+    def _execute_single_step(self, step: Step, step_num: int) -> ExecutionResult:
+        """Execute a single step and capture result"""
+        
+        try:
+            # Safety check
+            check_step(step)
+            
+            # Get tool
+            tool = TOOLS.get(step.tool)
+            if not tool:
+                return ExecutionResult(
+                    False, 
+                    "", 
+                    f"Tool not found: {step.tool}"
+                )
+            
+            # Get action
+            action = getattr(tool, step.action, None)
+            if not action:
+                return ExecutionResult(
+                    False,
+                    "",
+                    f"Action not found: {step.tool}.{step.action}"
+                )
+            
+            # Execute
+            output = action(**step.args)
+            # Note: Result display handled by orchestrator via print_step()
+            
+            if self.logger:
+                self.logger.log_step_result(
+                    step.tool, 
+                    step.action, 
+                    str(output), 
+                    True
+                )
+            
+            return ExecutionResult(True, str(output))
+            
+        except SafetyError as e:
+            error_msg = f"Safety check failed: {e}"
+            if self.logger:
+                self.logger.log_step_result(
+                    step.tool, 
+                    step.action, 
+                    error_msg, 
+                    False
+                )
+            return ExecutionResult(False, "", error_msg)
+            
+        except Exception as e:
+            error_msg = f"Execution failed: {e}"
+            if self.logger:
+                self.logger.log_step_result(
+                    step.tool,
+                    step.action,
+                    error_msg,
+                    False
+                )
+            return ExecutionResult(False, "", error_msg)
+    
+    def _adapt_on_failure(
+        self, 
+        failed_step: Step, 
+        result: ExecutionResult,
+        history: list
+    ) -> Optional[Step]:
+        """
+        Attempt to adapt a failed step
+        
+        Uses LLM to suggest corrective action based on:
+        - The failed step
+        - The error
+        - Execution history
+        
+        Returns adapted step or None if no adaptation possible
+        """
+        
+        # For now, return None (no LLM-based adaptation yet)
+        # This will be enhanced in future iterations
+        return None
+    
+    def get_execution_summary(self) -> dict:
+        """Get summary of execution for reporting"""
+        
+        total_steps = len(self.execution_history)
+        retried_steps = sum(
+            1 for entry in self.execution_history if entry["attempt"] > 0
+        )
+        
+        return {
+            "total_steps": total_steps,
+            "retried_steps": retried_steps,
+            "success_rate": 1.0 if total_steps > 0 else 0.0
+        }