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

{netra_zen-1.0.2.dist-info → netra_zen-1.0.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: netra-zen
-Version: 1.0.2
+Version: 1.0.3
 Summary: Multi-instance Claude orchestrator for parallel task execution
 Home-page: https://github.com/netra-systems/zen
 Author:  Systems

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

@@ -1,15 +1,15 @@
-zen_orchestrator.py,sha256=Q4bEnsyMYPJV6R9PutC6vrfxGiaOizlFjSW6qJDLrDI,148686
+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.2.dist-info/licenses/LICENSE.md,sha256=t6LtOzAE2hgIIv5WbaN0wOcU3QCnGtAkMGNclHrKTOs,79
+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.2.dist-info/METADATA,sha256=3iv4Hq5DNLRAMivXVCwx_jieqevK_G3d1OU0Tbksl-g,29442
-netra_zen-1.0.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-netra_zen-1.0.2.dist-info/entry_points.txt,sha256=oDehCnPGZezG0m9ZWspxjHLHyQ3eERX87eojR4ljaRo,45
-netra_zen-1.0.2.dist-info/top_level.txt,sha256=dHz-hgh_dfiiOUrPf8wW80fA31rfEYDFmA6fpu67Yjk,65
-netra_zen-1.0.2.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,,

zen_orchestrator.py

@@ -2,41 +2,43 @@
 """
 Usage Examples:
 
+  zen -h  # Help
+
 Direct Command Execution:
-  python zen_orchestrator.py "/help"  # Execute single command directly
-  python zen_orchestrator.py "/analyze-code" --workspace ~/my-project
-  python zen_orchestrator.py "/debug-issue" --instance-name "debug-session"
-  python zen_orchestrator.py "/optimize-performance" --session-id "perf-1"
-  python zen_orchestrator.py "/generate-docs" --clear-history --compact-history
+  zen "/single-command-in-claude-commands"  # Execute single command directly
+  zen "/analyze-code" --workspace ~/my-project
+  zen "/debug-issue" --instance-name "debug-session"
+  zen "/optimize-performance" --session-id "perf-1"
+  zen "/generate-docs" --clear-history --compact-history
 
 Configuration File Mode:
-  python zen_orchestrator.py --config config.json
-  python zen_orchestrator.py --config config.json --workspace ~/my-project
+  zen --config config.json
+  zen --config config.json --workspace ~/my-project
 
 Default Instances Mode:
-  python zen_orchestrator.py --dry-run  # Auto-detects workspace from project root
-  python zen_orchestrator.py --workspace ~/my-project --dry-run  # Override workspace
-  python zen_orchestrator.py --startup-delay 2.0  # 2 second delay between launches
-  python zen_orchestrator.py --startup-delay 0.5  # 0.5 second delay between launches
-  python zen_orchestrator.py --max-line-length 1000  # Longer output lines
-  python zen_orchestrator.py --status-report-interval 60  # Status reports every 60s
-  python zen_orchestrator.py --quiet  # Minimal output, errors only
+  zen --dry-run  # Auto-detects workspace from project root
+  zen --workspace ~/my-project --dry-run  # Override workspace
+  zen --startup-delay 2.0  # 2 second delay between launches
+  zen --startup-delay 0.5  # 0.5 second delay between launches
+  zen --max-line-length 1000  # Longer output lines
+  zen --status-report-interval 60  # Status reports every 60s
+  zen --quiet  # Minimal output, errors only
 
 Command Discovery:
-  python zen_orchestrator.py --list-commands  # Show all available commands
-  python zen_orchestrator.py --inspect-command "/analyze-code"  # Inspect specific command
+  zen --list-commands  # Show all available commands
+  zen --inspect-command "/analyze-code"  # Inspect specific command
 
 Scheduling:
-  python zen_orchestrator.py "/analyze-code" --start-at "2h"  # Start 2 hours from now
-  python zen_orchestrator.py "/debug-issue" --start-at "30m"  # Start in 30 minutes
-  python zen_orchestrator.py "/optimize" --start-at "1am"  # Start at 1 AM (today or tomorrow)
-  python zen_orchestrator.py "/review-code" --start-at "14:30"  # Start at 2:30 PM (today or tomorrow)
-  python zen_orchestrator.py "/generate-docs" --start-at "10:30pm"  # Start at 10:30 PM (today or tomorrow)
+  zen "/analyze-code" --start-at "2h"  # Start 2 hours from now
+  zen "/debug-issue" --start-at "30m"  # Start in 30 minutes
+  zen "/optimize" --start-at "1am"  # Start at 1 AM (today or tomorrow)
+  zen "/review-code" --start-at "14:30"  # Start at 2:30 PM (today or tomorrow)
+  zen "/generate-docs" --start-at "10:30pm"  # Start at 10:30 PM (today or tomorrow)
 
 Precedence Rules:
-  1. Direct command (highest) - python zen_orchestrator.py "/command"
-  2. Config file (medium) - python zen_orchestrator.py --config file.json
-  3. Default instances (lowest) - python zen_orchestrator.py
+  1. Direct command (highest) - zen "/command"
+  2. Config file (medium) - zen --config file.json    # expected default usage pattern
+  3. Default instances (lowest) - zen
 """
 
 import asyncio
@@ -58,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:
@@ -77,15 +84,6 @@ except ImportError as e:
     ClaudePricingEngine = None
     TokenUsageData = None
 
-# Add CLI extensions imports
-try:
-    from cli_extensions import handle_example_commands
-except ImportError as e:
-    # Graceful fallback if CLI extensions are not available
-    handle_example_commands = None
-
-# NetraOptimizer database functionality has been removed for security
-# Local token metrics are preserved without database persistence
 
 # Setup logging
 logging.basicConfig(
@@ -197,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"""
@@ -214,7 +213,7 @@ class ClaudeInstanceOrchestrator:
 
     def __init__(self, workspace_dir: Path, max_console_lines: int = 5, startup_delay: float = 1.0,
                  max_line_length: int = 500, status_report_interval: int = 30,
-                 use_cloud_sql: bool = False, quiet: bool = False,
+                 quiet: bool = False,
                  overall_token_budget: Optional[int] = None,
                  overall_cost_budget: Optional[float] = None,
                  budget_type: str = "tokens",
@@ -233,11 +232,10 @@ class ClaudeInstanceOrchestrator:
         self.status_report_interval = status_report_interval  # Seconds between status reports
         self.last_status_report = time.time()
         self.status_report_task = None  # For the rolling status report task
-        self.use_cloud_sql = use_cloud_sql
         self.quiet = quiet
         self.log_level = log_level
         self.batch_id = str(uuid4())  # Generate batch ID for this orchestration run
-        # Database client removed for security - local metrics only
+        
         self.optimizer = None
 
         # Initialize budget manager if any budget settings are provided
@@ -278,12 +276,6 @@ class ClaudeInstanceOrchestrator:
         else:
             logger.debug("Token budget tracking disabled (no budget specified)")
 
-        # Configure CloudSQL if requested
-        # CloudSQL functionality available with Netra Apex
-        # Token metrics are now handled locally without database persistence
-        if use_cloud_sql:
-            logger.warning("CloudSQL functionality has been disabled. Token metrics will be displayed locally only.")
-            logger.info("For data persistence, consider upgrading to Netra Apex.")
 
     def log_at_level(self, level: LogLevel, message: str, log_func=None):
         """Log message only if current log level permits."""
@@ -338,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 = [
@@ -494,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}")
@@ -571,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):
@@ -635,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]
@@ -810,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
@@ -2370,8 +2409,6 @@ async def main():
                        help="Seconds between rolling status reports (default: 5)")
     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)")
-    parser.add_argument("--use-cloud-sql", action="store_true",
-                       help="Save metrics to CloudSQL database (NetraOptimizer integration)")
 
     # Direct command options
     parser.add_argument("--instance-name", type=str, help="Instance name for direct command execution")
@@ -2454,10 +2491,6 @@ async def main():
     
     logger.info(f"Using workspace: {workspace}")
 
-    # Handle CLI extension commands
-    if handle_example_commands and handle_example_commands(args):
-        return
-
 
     # Load instance configurations with direct command precedence
     direct_instance = create_direct_instance(args, workspace)
@@ -2547,7 +2580,6 @@ async def main():
         startup_delay=args.startup_delay,
         max_line_length=args.max_line_length,
         status_report_interval=args.status_report_interval,
-        use_cloud_sql=args.use_cloud_sql,
         quiet=args.quiet,
         overall_token_budget=final_overall_budget,
         overall_cost_budget=final_overall_cost_budget,
@@ -2775,9 +2807,6 @@ async def main():
 
     # Run all instances
     logger.info("Starting Claude Code instance orchestration")
-    if args.use_cloud_sql:
-        logger.info(f"Batch ID: {orchestrator.batch_id}")
-        logger.info("Metrics will be saved to CloudSQL")
     start_time = time.time()
 
     results = await orchestrator.run_all_instances(args.timeout)
@@ -2909,19 +2938,17 @@ async def main():
 
     # For detailed data access
     print("\n" + "="*80)
-    print("🚀 NEED DETAILED TOKEN ANALYTICS & DATA ACCESS?")
+    print("🚀 Looking for more?")
     print("="*80)
-    print("For comprehensive token usage analytics, historical data,")
-    print("and advanced reporting features, upgrade to Netra Apex.")
+    print("Explore Zen with Apex for the most effective AI Ops value for production AI.")
     print("")
     print("🌐 Learn more: https://netrasystems.ai/")
     print("="*80)
 
-    # Show CloudSQL info if enabled
-    if args.use_cloud_sql:
-        print(f"\n📊 Local metrics displayed above")
-        print(f"   Batch ID: {orchestrator.batch_id}")
-        print(f"   Database persistence disabled for security")
+
+    # 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)
@@ -2931,4 +2958,4 @@ def run():
     asyncio.run(main())
 
 if __name__ == "__main__":
-    run()
+    run()