netra-zen 1.0.1__py3-none-any.whl → 1.0.3__py3-none-any.whl

{netra_zen-1.0.1.dist-info → netra_zen-1.0.3.dist-info}/RECORD

@@ -1,15 +1,15 @@
-zen_orchestrator.py,sha256=QApF_yEo7C8CUq_p8GGYJT2gPwMCLIMLSNIdFZFuxcI,144907
+zen_orchestrator.py,sha256=eUiA8T08QYMfx5kM84LUloDUxscCUzv_k3O0WN3nFpo,148941
 agent_interface/__init__.py,sha256=OsbOKzElHsxhVgak87oOx_u46QNgKmz-Reis-plAMwk,525
 agent_interface/base_agent.py,sha256=GNskG9VaZgno7X24lQTpFdxUoQE0yJHLh0UPFJvOPn4,11098
-netra_zen-1.0.1.dist-info/licenses/LICENSE.md,sha256=PZrP0UDn58i4LjV4zijIQTnsQPvWm4zq9Fet9i7qgwI,80
+netra_zen-1.0.3.dist-info/licenses/LICENSE.md,sha256=t6LtOzAE2hgIIv5WbaN0wOcU3QCnGtAkMGNclHrKTOs,79
 token_budget/__init__.py,sha256=_2tmi72DGNtbYcZ-rGIxVKMytdkHFjzJaWz8bDhYACc,33
 token_budget/budget_manager.py,sha256=VRWxKcGDtgJfIRh-ztYQ4-wuhBvddVJJnyoGfxCBlv0,9567
 token_budget/models.py,sha256=14xFTk2-R1Ql0F9WLDof7vADrKC_5Fj7EE7UmZdoG00,2384
 token_budget/visualization.py,sha256=SaNnZ15edHXtjDCA5Yfu7w3AztCZRYsYCPGBqzapupY,719
 token_transparency/__init__.py,sha256=go86Rg4_VYAPLw3myVpLe1s1PbMu1llDTw1wfomP1lA,453
 token_transparency/claude_pricing_engine.py,sha256=9zWQJS3HJEs_lljil-xT1cUvG-Jf3ykNAninJFyfNSM,12630
-netra_zen-1.0.1.dist-info/METADATA,sha256=ixxjb8v_zQKUIIoMXOPhfSXdrawdMMPWsOxAUBu_xCE,30220
-netra_zen-1.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-netra_zen-1.0.1.dist-info/entry_points.txt,sha256=oDehCnPGZezG0m9ZWspxjHLHyQ3eERX87eojR4ljaRo,45
-netra_zen-1.0.1.dist-info/top_level.txt,sha256=dHz-hgh_dfiiOUrPf8wW80fA31rfEYDFmA6fpu67Yjk,65
-netra_zen-1.0.1.dist-info/RECORD,,
+netra_zen-1.0.3.dist-info/METADATA,sha256=WQb-6CiZG9JqJrkW8fuGc5UmejBT4-ZimVnNVH6ehLw,29442
+netra_zen-1.0.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+netra_zen-1.0.3.dist-info/entry_points.txt,sha256=oDehCnPGZezG0m9ZWspxjHLHyQ3eERX87eojR4ljaRo,45
+netra_zen-1.0.3.dist-info/top_level.txt,sha256=dHz-hgh_dfiiOUrPf8wW80fA31rfEYDFmA6fpu67Yjk,65
+netra_zen-1.0.3.dist-info/RECORD,,

{netra_zen-1.0.1.dist-info → netra_zen-1.0.3.dist-info}/licenses/LICENSE.md

@@ -1 +1 @@
-© Netra Inc. All rights reserved. Use is subject to Netra's Terms of Service.
+© Netra Inc. All rights reserved. Use is subject to Netra's Terms of Service.

zen_orchestrator.py

@@ -60,6 +60,11 @@ import re
 from uuid import uuid4, UUID
 from enum import Enum
 
+try:
+    from zen.telemetry import telemetry_manager
+except Exception:  # pragma: no cover - telemetry optional
+    telemetry_manager = None
+
 # Add token budget imports with proper path handling
 sys.path.insert(0, str(Path(__file__).parent))
 try:
@@ -79,6 +84,7 @@ except ImportError as e:
     ClaudePricingEngine = None
     TokenUsageData = None
 
+
 # Setup logging
 logging.basicConfig(
     level=logging.INFO,
@@ -107,7 +113,8 @@ def determine_log_level(args) -> LogLevel:
 @dataclass
 class InstanceConfig:
     """Configuration for a Claude Code instance"""
-    command: str
+    command: Optional[str] = None  # For slash commands like /help
+    prompt: Optional[str] = None   # For raw prompts like "What are the available commands?"
     name: Optional[str] = None
     description: Optional[str] = None
     allowed_tools: List[str] = None
@@ -121,10 +128,35 @@ class InstanceConfig:
 
     def __post_init__(self):
         """Set defaults after initialization"""
+        # Validate that either command or prompt is provided
+        if not self.command and not self.prompt:
+            raise ValueError("Either 'command' or 'prompt' must be provided")
+
+        # If both are provided, prioritize command over prompt
+        if self.command and self.prompt:
+            # Use command, but log that prompt is being ignored
+            pass  # This is valid - command takes precedence
+
+        # If only prompt is provided, treat it as the command for execution
+        elif self.prompt and not self.command:
+            self.command = self.prompt
+
+        # Set default name
         if self.name is None:
-            self.name = self.command
+            if self.command and self.command.startswith('/'):
+                self.name = self.command
+            else:
+                # For prompts, create a shorter name
+                display_text = self.prompt or self.command
+                self.name = display_text[:30] + "..." if len(display_text) > 30 else display_text
+
+        # Set default description
         if self.description is None:
-            self.description = f"Execute {self.command}"
+            if self.command and self.command.startswith('/'):
+                self.description = f"Execute {self.command}"
+            else:
+                self.description = f"Execute prompt: {(self.prompt or self.command)[:50]}..."
+
         # Set permission mode if not explicitly set
         if self.permission_mode is None:
             # Default to bypassPermissions for all platforms to avoid approval prompts
@@ -163,6 +195,7 @@ class InstanceStatus:
     tool_details: Dict[str, int] = None  # Tool name -> usage count
     tool_tokens: Dict[str, int] = None   # Tool name -> token usage
     tool_id_mapping: Dict[str, str] = field(default_factory=dict)  # tool_use_id -> tool name mapping
+    telemetry_recorded: bool = False
 
     def __post_init__(self):
         """Initialize fields that need special handling"""
@@ -202,6 +235,7 @@ class ClaudeInstanceOrchestrator:
         self.quiet = quiet
         self.log_level = log_level
         self.batch_id = str(uuid4())  # Generate batch ID for this orchestration run
+        
         self.optimizer = None
 
         # Initialize budget manager if any budget settings are provided
@@ -257,10 +291,17 @@ class ClaudeInstanceOrchestrator:
 
     def add_instance(self, config: InstanceConfig):
         """Add a new instance configuration"""
-        # Validate slash command exists
-        if not self.validate_command(config.command):
-            logger.warning(f"Command '{config.command}' not found in available commands")
-            logger.info(f"Available commands: {', '.join(self.discover_available_commands())}")
+        # Determine if this is a slash command or raw prompt
+        is_slash_command = config.command and config.command.startswith('/')
+        is_raw_prompt = config.prompt and not is_slash_command
+
+        if is_slash_command:
+            # Validate slash command exists
+            if not self.validate_command(config.command):
+                logger.warning(f"Command '{config.command}' not found in available commands")
+                logger.info(f"Available commands: {', '.join(self.discover_available_commands())}")
+        elif is_raw_prompt:
+            logger.info(f"Using raw prompt: {config.prompt[:50]}{'...' if len(config.prompt) > 50 else ''}")
 
         self.instances[config.name] = config
         self.statuses[config.name] = InstanceStatus(name=config.name)
@@ -289,36 +330,36 @@ class ClaudeInstanceOrchestrator:
         command_string = "; ".join(full_command)
 
         # Find the claude executable with Mac-specific paths
-        claude_cmd = shutil.which("claude")
+        # IMPORTANT: Use direct paths to avoid shell functions that may have database dependencies
+        possible_paths = [
+            "/opt/homebrew/bin/claude",  # Mac Homebrew ARM - prefer direct path
+            "/usr/local/bin/claude",     # Mac Homebrew Intel
+            "~/.local/bin/claude",       # User local install
+            "/usr/bin/claude",           # System install
+            "claude.cmd",                # Windows
+            "claude.exe",                # Windows
+        ]
+
+        claude_cmd = None
+        for path in possible_paths:
+            # Expand user path if needed
+            expanded_path = Path(path).expanduser()
+            if expanded_path.exists() and expanded_path.is_file():
+                claude_cmd = str(expanded_path)
+                logger.info(f"Found Claude executable at: {claude_cmd}")
+                break
+
+        # Only use shutil.which as fallback if no direct path found
         if not claude_cmd:
-            # Try common paths on different platforms
-            possible_paths = [
-                "claude.cmd",  # Windows
-                "claude.exe",  # Windows
-                "/opt/homebrew/bin/claude",  # Mac Homebrew ARM
-                "/usr/local/bin/claude",     # Mac Homebrew Intel
-                "~/.local/bin/claude",       # User local install
-                "/usr/bin/claude",           # System install
-                "claude"                     # Final fallback
-            ]
-            
-            for path in possible_paths:
-                # Expand user path if needed
-                expanded_path = Path(path).expanduser()
-                if expanded_path.exists():
-                    claude_cmd = str(expanded_path)
-                    logger.info(f"Found Claude executable at: {claude_cmd}")
-                    break
-                elif shutil.which(path):
-                    claude_cmd = path
-                    logger.info(f"Found Claude executable via which: {claude_cmd}")
-                    break
+            claude_cmd = shutil.which("claude")
+            if claude_cmd:
+                logger.info(f"Found Claude executable via which: {claude_cmd}")
 
-            if not claude_cmd or claude_cmd == "claude":
-                logger.warning("Claude command not found in PATH or common locations")
-                logger.warning("Please ensure Claude Code is installed and in your PATH")
-                logger.warning("Install with: npm install -g @anthropic/claude-code")
-                claude_cmd = "claude"  # Fallback
+        if not claude_cmd:
+            logger.warning("Claude command not found in PATH or common locations")
+            logger.warning("Please ensure Claude Code is installed and in your PATH")
+            logger.warning("Install with: npm install -g @anthropic/claude-code")
+            claude_cmd = "/opt/homebrew/bin/claude"  # Default fallback to most likely location
 
         # New approach: slash commands can be included directly in prompt
         cmd = [
@@ -445,6 +486,11 @@ class ClaudeInstanceOrchestrator:
                     logger.error(f"🚫 BLOCK MODE: {message}")
                     status.status = "failed"
                     status.error = f"Blocked by budget limit - {reason}"
+                    timestamp = time.time()
+                    if status.start_time is None:
+                        status.start_time = timestamp
+                    status.end_time = timestamp
+                    self._emit_instance_telemetry(name, config, status)
                     return False
                 else:  # warn mode
                     logger.warning(f"⚠️  WARN MODE: {message}")
@@ -522,18 +568,22 @@ class ClaudeInstanceOrchestrator:
             if returncode == 0:
                 status.status = "completed"
                 logger.info(f"Instance {name} completed successfully")
+                self._emit_instance_telemetry(name, config, status)
                 return True
             else:
                 status.status = "failed"
                 logger.error(f"Instance {name} failed with return code {returncode}")
                 if status.error:
                     logger.error(f"Error output: {status.error}")
+                self._emit_instance_telemetry(name, config, status)
                 return False
 
         except Exception as e:
             status.status = "failed"
             status.error = str(e)
             logger.error(f"Exception running instance {name}: {e}")
+            status.end_time = status.end_time or time.time()
+            self._emit_instance_telemetry(name, config, status)
             return False
 
     async def _save_metrics_to_database(self, name: str, config: InstanceConfig, status: InstanceStatus):
@@ -586,6 +636,38 @@ class ClaudeInstanceOrchestrator:
 
         return input_cost + output_cost + cache_read_cost + cache_creation_cost + tool_cost
 
+    def _emit_instance_telemetry(self, name: str, config: InstanceConfig, status: InstanceStatus) -> None:
+        """Send telemetry span with token usage and cost metadata."""
+
+        if telemetry_manager is None or not hasattr(telemetry_manager, "is_enabled"):
+            return
+
+        if getattr(status, "telemetry_recorded", False):
+            return
+
+        if not telemetry_manager.is_enabled():
+            return
+
+        cost_usd: Optional[float]
+        try:
+            cost_usd = self._calculate_cost(status)
+        except Exception as exc:  # pragma: no cover - defensive guard
+            logger.debug(f"Cost calculation failed for telemetry span ({name}): {exc}")
+            cost_usd = None
+
+        try:
+            telemetry_manager.record_instance_span(
+                batch_id=self.batch_id,
+                instance_name=name,
+                status=status,
+                config=config,
+                cost_usd=cost_usd,
+                workspace=str(self.workspace_dir),
+            )
+            status.telemetry_recorded = True
+        except Exception as exc:  # pragma: no cover - Network/export errors
+            logger.debug(f"Telemetry emission failed for {name}: {exc}")
+
     async def _stream_output(self, name: str, process):
         """Stream output in real-time for stream-json format (DEPRECATED - use _stream_output_parallel)"""
         status = self.statuses[name]
@@ -761,13 +843,19 @@ class ClaudeInstanceOrchestrator:
         for name, result in zip(self.instances.keys(), results):
             if isinstance(result, asyncio.TimeoutError):
                 logger.error(f"Instance {name} timed out after {timeout}s")
-                self.statuses[name].status = "failed"
-                self.statuses[name].error = f"Timeout after {timeout}s"
+                status = self.statuses[name]
+                status.status = "failed"
+                status.error = f"Timeout after {timeout}s"
+                status.end_time = time.time()
+                self._emit_instance_telemetry(name, self.instances[name], status)
                 final_results[name] = False
             elif isinstance(result, Exception):
                 logger.error(f"Instance {name} failed with exception: {result}")
-                self.statuses[name].status = "failed"
-                self.statuses[name].error = str(result)
+                status = self.statuses[name]
+                status.status = "failed"
+                status.error = str(result)
+                status.end_time = time.time()
+                self._emit_instance_telemetry(name, self.instances[name], status)
                 final_results[name] = False
             else:
                 final_results[name] = result
@@ -2322,7 +2410,6 @@ async def main():
     parser.add_argument("--start-at", type=str, default=None,
                        help="Schedule orchestration to start at specific time. Examples: '2h' (2 hours from now), '30m' (30 minutes), '14:30' (2:30 PM today), '1am' (1 AM today/tomorrow)")
 
-
     # Direct command options
     parser.add_argument("--instance-name", type=str, help="Instance name for direct command execution")
     parser.add_argument("--instance-description", type=str, help="Instance description for direct command execution")
@@ -2404,6 +2491,7 @@ async def main():
     
     logger.info(f"Using workspace: {workspace}")
 
+
     # Load instance configurations with direct command precedence
     direct_instance = create_direct_instance(args, workspace)
 
@@ -2857,6 +2945,11 @@ async def main():
     print("🌐 Learn more: https://netrasystems.ai/")
     print("="*80)
 
+
+    # Flush telemetry before exit
+    if telemetry_manager is not None and hasattr(telemetry_manager, "shutdown"):
+        telemetry_manager.shutdown()
+
     # Exit with appropriate code
     sys.exit(0 if summary['failed'] == 0 else 1)
 
@@ -2865,4 +2958,4 @@ def run():
     asyncio.run(main())
 
 if __name__ == "__main__":
-    run()
+    run()