netra-zen 1.0.7__py3-none-any.whl → 1.0.9__py3-none-any.whl

scripts/agent_logs.py

@@ -4,6 +4,7 @@ Agent Logs Collection Helper
 Collects recent JSONL logs from .claude/Projects for agent CLI integration
 """
 
+import hashlib
 import json
 import logging
 import os
@@ -127,7 +128,7 @@ def _find_most_recent_project(projects_root: Path) -> Optional[Path]:
         return None
 
 
-def _collect_jsonl_files(project_path: Path, limit: int) -> List[Dict[str, Any]]:
+def _collect_jsonl_files(project_path: Path, limit: int) -> tuple[List[Dict[str, Any]], int, List[Dict[str, str]]]:
     """
     Collect and parse JSONL files from project directory.
 
@@ -136,11 +137,11 @@ def _collect_jsonl_files(project_path: Path, limit: int) -> List[Dict[str, Any]]
         limit: Maximum number of log files to read
 
     Returns:
-        List of parsed log entries (dicts)
+        Tuple of (list of parsed log entries, number of files read, list of file info dicts)
     """
     if not project_path.exists() or not project_path.is_dir():
         logger.warning(f"Project path does not exist: {project_path}")
-        return []
+        return [], 0, []
 
     try:
         # Find all .jsonl files
@@ -148,18 +149,32 @@ def _collect_jsonl_files(project_path: Path, limit: int) -> List[Dict[str, Any]]
 
         if not jsonl_files:
             logger.info(f"No .jsonl files found in {project_path}")
-            return []
+            return [], 0, []
 
         # Sort by modification time, most recent first
         jsonl_files.sort(key=lambda p: p.stat().st_mtime, reverse=True)
 
         # Limit number of files to read
         jsonl_files = jsonl_files[:limit]
+        files_read = len(jsonl_files)
 
         all_logs = []
+        file_info = []
 
         for jsonl_file in jsonl_files:
             try:
+                # Calculate file hash for tracking
+                hasher = hashlib.sha256()
+                entry_count = 0
+
+                with open(jsonl_file, 'rb') as f:
+                    # Read in chunks for efficient hashing
+                    for chunk in iter(lambda: f.read(4096), b''):
+                        hasher.update(chunk)
+
+                file_hash = hasher.hexdigest()[:8]  # First 8 chars of hash
+
+                # Now read and parse the file
                 with open(jsonl_file, 'r', encoding='utf-8') as f:
                     for line_num, line in enumerate(f, 1):
                         line = line.strip()
@@ -169,43 +184,50 @@ def _collect_jsonl_files(project_path: Path, limit: int) -> List[Dict[str, Any]]
                         try:
                             log_entry = json.loads(line)
                             all_logs.append(log_entry)
+                            entry_count += 1
                         except json.JSONDecodeError as e:
                             logger.debug(
                                 f"Skipping malformed JSON in {jsonl_file.name}:{line_num}: {e}"
                             )
                             continue
 
+                file_info.append({
+                    'name': jsonl_file.name,
+                    'hash': file_hash,
+                    'entries': entry_count
+                })
+
             except Exception as e:
                 logger.warning(f"Error reading {jsonl_file.name}: {e}")
                 continue
 
-        logger.info(f"Collected {len(all_logs)} log entries from {len(jsonl_files)} files")
-        return all_logs
+        logger.info(f"Collected {len(all_logs)} log entries from {files_read} files")
+        return all_logs, files_read, file_info
 
     except Exception as e:
         logger.error(f"Error collecting JSONL files: {e}")
-        return []
+        return [], 0, []
 
 
 def collect_recent_logs(
-    limit: int = 5,
+    limit: int = 3,
     project_name: Optional[str] = None,
     base_path: Optional[str] = None,
     username: Optional[str] = None,
     platform_name: Optional[str] = None
-) -> Optional[List[Dict[str, Any]]]:
+) -> Optional[tuple[List[Dict[str, Any]], int, List[Dict[str, str]]]]:
     """
     Collect recent JSONL logs from .claude/Projects directory.
 
     Args:
-        limit: Maximum number of log files to read (default: 5)
+        limit: Maximum number of log files to read (default: 3)
         project_name: Specific project name or None for most recent
-        base_path: Direct path override to logs directory
+        base_path: Direct path override to logs directory OR a specific .jsonl file
         username: Windows username override
         platform_name: Platform override for testing ('Darwin', 'Windows', 'Linux')
 
     Returns:
-        List of log entry dicts or None if no logs found
+        Tuple of (list of log entry dicts, number of files read, list of file info) or None if no logs found
 
     Raises:
         ValueError: If limit is not positive or project_name is invalid
@@ -214,7 +236,63 @@ def collect_recent_logs(
         raise ValueError(f"Limit must be positive, got {limit}")
 
     try:
-        # Resolve projects root
+        # Check if base_path points to a specific .jsonl file
+        if base_path:
+            base_path_obj = Path(base_path)
+            if base_path_obj.is_file() and base_path_obj.suffix == '.jsonl':
+                # Handle direct file path
+                logger.info(f"Reading specific log file: {base_path_obj}")
+
+                if not base_path_obj.exists():
+                    logger.warning(f"Specified log file does not exist: {base_path_obj}")
+                    return None
+
+                # Read the single file
+                all_logs = []
+                file_info = []
+
+                try:
+                    # Calculate file hash
+                    hasher = hashlib.sha256()
+                    entry_count = 0
+
+                    with open(base_path_obj, 'rb') as f:
+                        for chunk in iter(lambda: f.read(4096), b''):
+                            hasher.update(chunk)
+
+                    file_hash = hasher.hexdigest()[:8]
+
+                    # Read and parse the file
+                    with open(base_path_obj, 'r', encoding='utf-8') as f:
+                        for line_num, line in enumerate(f, 1):
+                            line = line.strip()
+                            if not line:
+                                continue
+
+                            try:
+                                log_entry = json.loads(line)
+                                all_logs.append(log_entry)
+                                entry_count += 1
+                            except json.JSONDecodeError as e:
+                                logger.debug(
+                                    f"Skipping malformed JSON in {base_path_obj.name}:{line_num}: {e}"
+                                )
+                                continue
+
+                    file_info.append({
+                        'name': base_path_obj.name,
+                        'hash': file_hash,
+                        'entries': entry_count
+                    })
+
+                    logger.info(f"Collected {len(all_logs)} log entries from {base_path_obj.name}")
+                    return all_logs, 1, file_info
+
+                except Exception as e:
+                    logger.error(f"Error reading log file {base_path_obj}: {e}")
+                    return None
+
+        # Original directory-based logic
         base = Path(base_path) if base_path else None
         projects_root = _resolve_projects_root(
             platform_name=platform_name,
@@ -237,12 +315,12 @@ def collect_recent_logs(
                 return None
 
         # Collect logs
-        logs = _collect_jsonl_files(project_path, limit)
+        logs, files_read, file_info = _collect_jsonl_files(project_path, limit)
 
         if not logs:
             return None
 
-        return logs
+        return logs, files_read, file_info
 
     except Exception as e:
         logger.error(f"Failed to collect logs: {e}")

scripts/bump_version.py

@@ -1,138 +1,138 @@
-#!/usr/bin/env python3
-"""
-Version bump utility for Zen Orchestrator.
-Updates version in all relevant files.
-
-Usage:
-    python scripts/bump_version.py patch  # 1.0.0 -> 1.0.1
-    python scripts/bump_version.py minor  # 1.0.0 -> 1.1.0
-    python scripts/bump_version.py major  # 1.0.0 -> 2.0.0
-    python scripts/bump_version.py 1.2.3  # Set specific version
-"""
-
-import re
-import sys
-from pathlib import Path
-from typing import Tuple
-
-
-def parse_version(version_str: str) -> Tuple[int, int, int]:
-    """Parse version string to tuple of integers."""
-    match = re.match(r'^(\d+)\.(\d+)\.(\d+)$', version_str)
-    if not match:
-        raise ValueError(f"Invalid version format: {version_str}")
-    return tuple(map(int, match.groups()))
-
-
-def format_version(version_tuple: Tuple[int, int, int]) -> str:
-    """Format version tuple to string."""
-    return '.'.join(map(str, version_tuple))
-
-
-def get_current_version() -> str:
-    """Get current version from __init__.py."""
-    init_file = Path(__file__).parent.parent / "__init__.py"
-    content = init_file.read_text()
-    match = re.search(r'__version__\s*=\s*["\']([^"\']+)["\']', content)
-    if not match:
-        raise ValueError("Could not find version in __init__.py")
-    return match.group(1)
-
-
-def bump_version(current: str, bump_type: str) -> str:
-    """Bump version based on type."""
-    if re.match(r'^\d+\.\d+\.\d+$', bump_type):
-        # Specific version provided
-        return bump_type
-    
-    major, minor, patch = parse_version(current)
-    
-    if bump_type == 'major':
-        return format_version((major + 1, 0, 0))
-    elif bump_type == 'minor':
-        return format_version((major, minor + 1, 0))
-    elif bump_type == 'patch':
-        return format_version((major, minor, patch + 1))
-    else:
-        raise ValueError(f"Invalid bump type: {bump_type}")
-
-
-def update_file(file_path: Path, old_version: str, new_version: str, patterns: list):
-    """Update version in a file using specified patterns."""
-    if not file_path.exists():
-        print(f"  ⚠️  {file_path} does not exist, skipping...")
-        return
-    
-    content = file_path.read_text()
-    original_content = content
-    
-    for pattern in patterns:
-        old_pattern = pattern.format(version=old_version)
-        new_pattern = pattern.format(version=new_version)
-        content = content.replace(old_pattern, new_pattern)
-    
-    if content != original_content:
-        file_path.write_text(content)
-        print(f"  ✅ Updated {file_path}")
-    else:
-        print(f"  ℹ️  No changes in {file_path}")
-
-
-def main():
-    """Main function."""
-    if len(sys.argv) != 2:
-        print(__doc__)
-        sys.exit(1)
-    
-    bump_type = sys.argv[1]
-    
-    # Get current version
-    try:
-        current = get_current_version()
-        print(f"Current version: {current}")
-    except Exception as e:
-        print(f"Error getting current version: {e}")
-        sys.exit(1)
-    
-    # Calculate new version
-    try:
-        new = bump_version(current, bump_type)
-        print(f"New version: {new}")
-    except Exception as e:
-        print(f"Error calculating new version: {e}")
-        sys.exit(1)
-    
-    # Update files
-    base_path = Path(__file__).parent.parent
-    
-    files_to_update = [
-        (
-            base_path / "__init__.py",
-            ['__version__ = "{version}"']
-        ),
-        (
-            base_path / "setup.py",
-            ['version="{version}"']
-        ),
-        (
-            base_path / "pyproject.toml",
-            ['version = "{version}"']
-        ),
-    ]
-    
-    print("\nUpdating files:")
-    for file_path, patterns in files_to_update:
-        update_file(file_path, current, new, patterns)
-    
-    print(f"\n✨ Version bumped from {current} to {new}")
-    print("\nNext steps:")
-    print(f"  1. Update CHANGELOG.md with changes for v{new}")
-    print(f"  2. Commit: git commit -am 'Bump version to {new}'")
-    print(f"  3. Tag: git tag -a v{new} -m 'Release version {new}'")
-    print(f"  4. Push: git push origin main --tags")
-    print(f"  5. Build: python -m build")
-    print(f"  6. Upload: python -m twine upload dist/*")
-
-
-if __name__ == "__main__":
+#!/usr/bin/env python3
+"""
+Version bump utility for Zen Orchestrator.
+Updates version in all relevant files.
+
+Usage:
+    python scripts/bump_version.py patch  # 1.0.0 -> 1.0.1
+    python scripts/bump_version.py minor  # 1.0.0 -> 1.1.0
+    python scripts/bump_version.py major  # 1.0.0 -> 2.0.0
+    python scripts/bump_version.py 1.2.3  # Set specific version
+"""
+
+import re
+import sys
+from pathlib import Path
+from typing import Tuple
+
+
+def parse_version(version_str: str) -> Tuple[int, int, int]:
+    """Parse version string to tuple of integers."""
+    match = re.match(r'^(\d+)\.(\d+)\.(\d+)$', version_str)
+    if not match:
+        raise ValueError(f"Invalid version format: {version_str}")
+    return tuple(map(int, match.groups()))
+
+
+def format_version(version_tuple: Tuple[int, int, int]) -> str:
+    """Format version tuple to string."""
+    return '.'.join(map(str, version_tuple))
+
+
+def get_current_version() -> str:
+    """Get current version from __init__.py."""
+    init_file = Path(__file__).parent.parent / "__init__.py"
+    content = init_file.read_text()
+    match = re.search(r'__version__\s*=\s*["\']([^"\']+)["\']', content)
+    if not match:
+        raise ValueError("Could not find version in __init__.py")
+    return match.group(1)
+
+
+def bump_version(current: str, bump_type: str) -> str:
+    """Bump version based on type."""
+    if re.match(r'^\d+\.\d+\.\d+$', bump_type):
+        # Specific version provided
+        return bump_type
+    
+    major, minor, patch = parse_version(current)
+    
+    if bump_type == 'major':
+        return format_version((major + 1, 0, 0))
+    elif bump_type == 'minor':
+        return format_version((major, minor + 1, 0))
+    elif bump_type == 'patch':
+        return format_version((major, minor, patch + 1))
+    else:
+        raise ValueError(f"Invalid bump type: {bump_type}")
+
+
+def update_file(file_path: Path, old_version: str, new_version: str, patterns: list):
+    """Update version in a file using specified patterns."""
+    if not file_path.exists():
+        print(f"  ⚠️  {file_path} does not exist, skipping...")
+        return
+    
+    content = file_path.read_text()
+    original_content = content
+    
+    for pattern in patterns:
+        old_pattern = pattern.format(version=old_version)
+        new_pattern = pattern.format(version=new_version)
+        content = content.replace(old_pattern, new_pattern)
+    
+    if content != original_content:
+        file_path.write_text(content)
+        print(f"  ✅ Updated {file_path}")
+    else:
+        print(f"  ℹ️  No changes in {file_path}")
+
+
+def main():
+    """Main function."""
+    if len(sys.argv) != 2:
+        print(__doc__)
+        sys.exit(1)
+    
+    bump_type = sys.argv[1]
+    
+    # Get current version
+    try:
+        current = get_current_version()
+        print(f"Current version: {current}")
+    except Exception as e:
+        print(f"Error getting current version: {e}")
+        sys.exit(1)
+    
+    # Calculate new version
+    try:
+        new = bump_version(current, bump_type)
+        print(f"New version: {new}")
+    except Exception as e:
+        print(f"Error calculating new version: {e}")
+        sys.exit(1)
+    
+    # Update files
+    base_path = Path(__file__).parent.parent
+    
+    files_to_update = [
+        (
+            base_path / "__init__.py",
+            ['__version__ = "{version}"']
+        ),
+        (
+            base_path / "setup.py",
+            ['version="{version}"']
+        ),
+        (
+            base_path / "pyproject.toml",
+            ['version = "{version}"']
+        ),
+    ]
+    
+    print("\nUpdating files:")
+    for file_path, patterns in files_to_update:
+        update_file(file_path, current, new, patterns)
+    
+    print(f"\n✨ Version bumped from {current} to {new}")
+    print("\nNext steps:")
+    print(f"  1. Update CHANGELOG.md with changes for v{new}")
+    print(f"  2. Commit: git commit -am 'Bump version to {new}'")
+    print(f"  3. Tag: git tag -a v{new} -m 'Release version {new}'")
+    print(f"  4. Push: git push origin main --tags")
+    print(f"  5. Build: python -m build")
+    print(f"  6. Upload: python -m twine upload dist/*")
+
+
+if __name__ == "__main__":
     main()

scripts/verify_log_transmission.py

@@ -0,0 +1,140 @@
+#!/usr/bin/env python3
+"""
+Verification script to prove JSONL logs are bundled in payload
+"""
+
+import json
+import sys
+from pathlib import Path
+
+# Add parent directory to path
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from scripts.agent_logs import collect_recent_logs
+
+
+def verify_log_bundling(log_path: str):
+    """
+    Verify that logs are properly collected and bundled
+
+    Args:
+        log_path: Path to JSONL file or directory
+    """
+    print("=" * 70)
+    print("JSONL LOG TRANSMISSION VERIFICATION")
+    print("=" * 70)
+    print()
+
+    # Step 1: Collect logs
+    print("Step 1: Collecting logs from file...")
+    result = collect_recent_logs(limit=1, base_path=log_path)
+
+    if not result:
+        print("❌ FAILED: No logs collected")
+        return False
+
+    logs, files_read, file_info = result
+    print(f"✓ Successfully collected {len(logs)} log entries from {files_read} file(s)")
+    print()
+
+    # Step 2: Show file details
+    print("Step 2: File details...")
+    for info in file_info:
+        print(f"  File: {info['name']}")
+        print(f"  Hash: {info['hash']}")
+        print(f"  Entries: {info['entries']}")
+    print()
+
+    # Step 3: Simulate payload creation
+    print("Step 3: Simulating WebSocket payload creation...")
+    payload = {
+        "type": "message_create",
+        "run_id": "test-run-id",
+        "payload": {
+            "message": "Test message with logs",
+            "jsonl_logs": logs  # This is where logs are added
+        }
+    }
+
+    print(f"✓ Payload created with 'jsonl_logs' key")
+    print(f"  Payload keys: {list(payload['payload'].keys())}")
+    print()
+
+    # Step 4: Verify payload size
+    print("Step 4: Calculating payload size...")
+    payload_json = json.dumps(payload)
+    payload_size_bytes = len(payload_json.encode('utf-8'))
+    payload_size_kb = payload_size_bytes / 1024
+    payload_size_mb = payload_size_kb / 1024
+
+    if payload_size_mb >= 1:
+        size_str = f"{payload_size_mb:.2f} MB"
+    elif payload_size_kb >= 1:
+        size_str = f"{payload_size_kb:.2f} KB"
+    else:
+        size_str = f"{payload_size_bytes} bytes"
+
+    print(f"✓ Total payload size: {size_str}")
+    print()
+
+    # Step 5: Show sample log entries
+    print("Step 5: Sample log entries in payload...")
+    if logs:
+        print(f"  First entry keys: {list(logs[0].keys())}")
+        print(f"  First entry timestamp: {logs[0].get('timestamp', 'N/A')}")
+        print(f"  Last entry timestamp: {logs[-1].get('timestamp', 'N/A')}")
+    print()
+
+    # Step 6: Verify transmission-ready
+    print("Step 6: Transmission verification...")
+    print(f"✓ Payload is valid JSON: {payload_json is not None}")
+    print(f"✓ Payload contains 'jsonl_logs': {'jsonl_logs' in payload['payload']}")
+    print(f"✓ Log count in payload: {len(payload['payload']['jsonl_logs'])}")
+    print()
+
+    print("=" * 70)
+    print("✅ VERIFICATION COMPLETE")
+    print("=" * 70)
+    print()
+    print("PROOF OF TRANSMISSION:")
+    print(f"  • {len(logs)} JSONL log entries are bundled in the payload")
+    print(f"  • Payload size: {size_str}")
+    print(f"  • Ready for WebSocket transmission to backend")
+    print()
+
+    # Optional: Save proof file
+    proof_file = Path("/tmp/zen_transmission_proof.json")
+    proof_payload = {
+        "verification_timestamp": "verification_run",
+        "log_count": len(logs),
+        "files_read": files_read,
+        "file_info": file_info,
+        "payload_size": size_str,
+        "sample_first_entry": logs[0] if logs else None,
+        "sample_last_entry": logs[-1] if logs else None,
+        "payload_structure": {
+            "type": payload["type"],
+            "run_id": payload["run_id"],
+            "payload_keys": list(payload["payload"].keys()),
+            "jsonl_logs_present": "jsonl_logs" in payload["payload"],
+            "jsonl_logs_count": len(payload["payload"]["jsonl_logs"])
+        }
+    }
+
+    with open(proof_file, 'w') as f:
+        json.dump(proof_payload, f, indent=2)
+
+    print(f"📝 Detailed proof saved to: {proof_file}")
+    print()
+
+    return True
+
+
+if __name__ == "__main__":
+    if len(sys.argv) < 2:
+        print("Usage: python verify_log_transmission.py <path-to-jsonl-file>")
+        sys.exit(1)
+
+    log_path = sys.argv[1]
+    success = verify_log_bundling(log_path)
+    sys.exit(0 if success else 1)