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

scripts/agent_logs.py

@@ -0,0 +1,249 @@
+#!/usr/bin/env python3
+"""
+Agent Logs Collection Helper
+Collects recent JSONL logs from .claude/Projects for agent CLI integration
+"""
+
+import json
+import logging
+import os
+import platform
+from pathlib import Path
+from typing import Optional, List, Dict, Any
+
+# Configure module logger
+logger = logging.getLogger(__name__)
+
+
+def _get_default_user() -> Optional[str]:
+    """
+    Get default username for Windows path resolution.
+
+    Returns:
+        Username from environment or None if not available
+    """
+    return os.environ.get('USERNAME') or os.environ.get('USER')
+
+
+def _resolve_projects_root(
+    platform_name: Optional[str] = None,
+    username: Optional[str] = None,
+    base_path: Optional[Path] = None
+) -> Path:
+    """
+    Resolve the .claude/Projects root directory based on platform.
+
+    Args:
+        platform_name: Platform identifier ('Darwin', 'Windows', 'Linux') or None for auto-detect
+        username: Windows username override
+        base_path: Direct path override (bypasses platform resolution)
+
+    Returns:
+        Path to .claude/Projects directory
+
+    Raises:
+        ValueError: If path cannot be resolved
+    """
+    if base_path:
+        return Path(base_path).resolve()
+
+    platform_name = platform_name or platform.system()
+
+    if platform_name == 'Windows':
+        # Windows: C:\Users\<username>\.claude\Projects
+        if username:
+            user_home = Path(f"C:/Users/{username}")
+        else:
+            user_home = Path(os.environ.get('USERPROFILE', Path.home()))
+    else:
+        # macOS/Linux: ~/.claude/Projects
+        user_home = Path.home()
+
+    projects_root = user_home / ".claude" / "Projects"
+
+    return projects_root.resolve()
+
+
+def _sanitize_project_name(project_name: str) -> str:
+    """
+    Sanitize project name to prevent directory traversal attacks.
+
+    Args:
+        project_name: Raw project name
+
+    Returns:
+        Sanitized project name safe for path construction
+
+    Raises:
+        ValueError: If project name contains dangerous patterns
+    """
+    if not project_name:
+        raise ValueError("Project name cannot be empty")
+
+    # Remove path separators and parent directory references
+    dangerous_patterns = ['..', '/', '\\', '\0']
+    for pattern in dangerous_patterns:
+        if pattern in project_name:
+            raise ValueError(f"Project name contains invalid pattern: {pattern}")
+
+    # Remove leading/trailing whitespace and dots
+    sanitized = project_name.strip().strip('.')
+
+    if not sanitized:
+        raise ValueError("Project name invalid after sanitization")
+
+    return sanitized
+
+
+def _find_most_recent_project(projects_root: Path) -> Optional[Path]:
+    """
+    Find the most recently modified project directory.
+
+    Args:
+        projects_root: Path to .claude/Projects directory
+
+    Returns:
+        Path to most recent project directory or None if no projects found
+    """
+    if not projects_root.exists() or not projects_root.is_dir():
+        logger.warning(f"Projects root does not exist: {projects_root}")
+        return None
+
+    try:
+        # Get all subdirectories
+        project_dirs = [p for p in projects_root.iterdir() if p.is_dir()]
+
+        if not project_dirs:
+            logger.warning(f"No project directories found in {projects_root}")
+            return None
+
+        # Sort by modification time, most recent first
+        project_dirs.sort(key=lambda p: p.stat().st_mtime, reverse=True)
+
+        return project_dirs[0]
+
+    except Exception as e:
+        logger.error(f"Error finding most recent project: {e}")
+        return None
+
+
+def _collect_jsonl_files(project_path: Path, limit: int) -> List[Dict[str, Any]]:
+    """
+    Collect and parse JSONL files from project directory.
+
+    Args:
+        project_path: Path to project directory
+        limit: Maximum number of log files to read
+
+    Returns:
+        List of parsed log entries (dicts)
+    """
+    if not project_path.exists() or not project_path.is_dir():
+        logger.warning(f"Project path does not exist: {project_path}")
+        return []
+
+    try:
+        # Find all .jsonl files
+        jsonl_files = list(project_path.glob("*.jsonl"))
+
+        if not jsonl_files:
+            logger.info(f"No .jsonl files found in {project_path}")
+            return []
+
+        # 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]
+
+        all_logs = []
+
+        for jsonl_file in jsonl_files:
+            try:
+                with open(jsonl_file, '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)
+                        except json.JSONDecodeError as e:
+                            logger.debug(
+                                f"Skipping malformed JSON in {jsonl_file.name}:{line_num}: {e}"
+                            )
+                            continue
+
+            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
+
+    except Exception as e:
+        logger.error(f"Error collecting JSONL files: {e}")
+        return []
+
+
+def collect_recent_logs(
+    limit: int = 5,
+    project_name: Optional[str] = None,
+    base_path: Optional[str] = None,
+    username: Optional[str] = None,
+    platform_name: Optional[str] = None
+) -> Optional[List[Dict[str, Any]]]:
+    """
+    Collect recent JSONL logs from .claude/Projects directory.
+
+    Args:
+        limit: Maximum number of log files to read (default: 5)
+        project_name: Specific project name or None for most recent
+        base_path: Direct path override to logs directory
+        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
+
+    Raises:
+        ValueError: If limit is not positive or project_name is invalid
+    """
+    if limit < 1:
+        raise ValueError(f"Limit must be positive, got {limit}")
+
+    try:
+        # Resolve projects root
+        base = Path(base_path) if base_path else None
+        projects_root = _resolve_projects_root(
+            platform_name=platform_name,
+            username=username,
+            base_path=base
+        )
+
+        # Determine target project
+        if project_name:
+            sanitized_name = _sanitize_project_name(project_name)
+            project_path = projects_root / sanitized_name
+
+            if not project_path.exists():
+                logger.warning(f"Specified project does not exist: {project_path}")
+                return None
+        else:
+            # Auto-detect most recent project
+            project_path = _find_most_recent_project(projects_root)
+            if not project_path:
+                return None
+
+        # Collect logs
+        logs = _collect_jsonl_files(project_path, limit)
+
+        if not logs:
+            return None
+
+        return logs
+
+    except Exception as e:
+        logger.error(f"Failed to collect logs: {e}")
+        return None

scripts/bump_version.py

@@ -0,0 +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__":
+    main()

scripts/demo_log_collection.py

@@ -0,0 +1,144 @@
+#!/usr/bin/env python3
+"""
+Demonstration of log collection from .claude/Projects
+
+This script shows how the zen --apex --send-logs functionality works
+"""
+import sys
+from pathlib import Path
+import json
+
+# Add parent to path for imports
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from scripts.agent_logs import collect_recent_logs
+
+
+def demo_log_collection():
+    """Demonstrate log collection with various scenarios"""
+
+    print("=" * 60)
+    print("Zen Apex Log Collection Demo")
+    print("=" * 60)
+    print()
+
+    # Check if .claude/Projects exists
+    claude_path = Path.home() / ".claude" / "Projects"
+
+    if not claude_path.exists():
+        print("❌ .claude/Projects does not exist")
+        print(f"   Expected location: {claude_path}")
+        print()
+        print("Creating test directory...")
+        claude_path.mkdir(parents=True, exist_ok=True)
+        test_project = claude_path / "demo-project"
+        test_project.mkdir(exist_ok=True)
+
+        # Create sample log
+        sample_log = {
+            "type": "demo_event",
+            "timestamp": "2025-01-08T12:00:00",
+            "message": "This is a demo log entry",
+            "data": {"key": "value"}
+        }
+        (test_project / "demo-session.jsonl").write_text(json.dumps(sample_log) + "\n")
+        print(f"✅ Created demo project at {test_project}")
+        print()
+
+    # Scenario 1: Collect with defaults
+    print("Scenario 1: Collect logs with defaults (limit=5, auto-detect project)")
+    print("-" * 60)
+    logs = collect_recent_logs(limit=5)
+
+    if logs:
+        print(f"✅ Collected {len(logs)} log entries")
+        print(f"   Total entries: {len(logs)}")
+        print()
+        print("   Sample entry (first):")
+        print(f"   {json.dumps(logs[0], indent=4)}")
+    else:
+        print("⚠️  No logs found")
+        print("   Tip: Run Claude Code with some commands to generate logs")
+    print()
+
+    # Scenario 2: List available projects
+    print("Scenario 2: List available projects")
+    print("-" * 60)
+    if claude_path.exists():
+        projects = [p for p in claude_path.iterdir() if p.is_dir()]
+        if projects:
+            print(f"Found {len(projects)} project(s):")
+            for proj in sorted(projects, key=lambda p: p.stat().st_mtime, reverse=True):
+                jsonl_count = len(list(proj.glob("*.jsonl")))
+                mtime = proj.stat().st_mtime
+                from datetime import datetime
+                mtime_str = datetime.fromtimestamp(mtime).strftime("%Y-%m-%d %H:%M:%S")
+                marker = "  ← most recent" if proj == projects[0] else ""
+                print(f"  • {proj.name}: {jsonl_count} .jsonl files (modified: {mtime_str}){marker}")
+        else:
+            print("  No projects found")
+    print()
+
+    # Scenario 3: Collect from specific project
+    if claude_path.exists():
+        projects = [p for p in claude_path.iterdir() if p.is_dir()]
+        if projects:
+            specific_project = projects[0].name
+            print(f"Scenario 3: Collect from specific project '{specific_project}'")
+            print("-" * 60)
+            logs = collect_recent_logs(limit=3, project_name=specific_project)
+            if logs:
+                print(f"✅ Collected {len(logs)} entries from '{specific_project}'")
+                print(f"   Entry types: {[log.get('type', 'unknown') for log in logs[:3]]}")
+            else:
+                print(f"⚠️  No logs in '{specific_project}'")
+            print()
+
+    # Scenario 4: Show what would be sent with --send-logs
+    print("Scenario 4: What gets sent with 'zen --apex --send-logs --message \"..\"'")
+    print("-" * 60)
+    logs = collect_recent_logs(limit=5)
+    if logs:
+        payload_preview = {
+            "type": "user_message",
+            "payload": {
+                "content": "your message here",
+                "run_id": "cli_20250108_120000_12345",
+                "thread_id": "cli_thread_abc123def456",
+                "timestamp": "2025-01-08T12:00:00",
+                "jsonl_logs": logs  # This is what gets attached
+            }
+        }
+        print("Payload structure:")
+        print(json.dumps(payload_preview, indent=2)[:500] + "...")
+        print()
+        print(f"✅ {len(logs)} log entries would be attached to the message")
+    else:
+        print("⚠️  No logs would be attached (none found)")
+    print()
+
+    # Summary
+    print("=" * 60)
+    print("Summary")
+    print("=" * 60)
+    print()
+    print("To use log forwarding with zen --apex:")
+    print()
+    print("  # Basic usage (attaches last 5 log files)")
+    print("  zen --apex --send-logs --message \"analyze these sessions\"")
+    print()
+    print("  # Custom number of logs")
+    print("  zen --apex --send-logs --logs-count 10 --message \"review last 10\"")
+    print()
+    print("  # Specific project")
+    if claude_path.exists() and list(claude_path.iterdir()):
+        first_project = list(p for p in claude_path.iterdir() if p.is_dir())[0].name
+        print(f"  zen --apex --send-logs --logs-project {first_project} --message \"...\"")
+    else:
+        print("  zen --apex --send-logs --logs-project PROJECT_NAME --message \"...\"")
+    print()
+    print("=" * 60)
+
+
+if __name__ == "__main__":
+    demo_log_collection()

scripts/embed_release_credentials.py

@@ -0,0 +1,75 @@
+#!/usr/bin/env python3
+"""Embed telemetry credentials for release builds.
+
+Usage:
+    COMMUNITY_CREDENTIALS="<base64-json>" python scripts/embed_release_credentials.py
+"""
+
+from __future__ import annotations
+
+import base64
+import json
+import os
+import sys
+from pathlib import Path
+
+
+PROJECT_ROOT = Path(__file__).resolve().parents[1]
+TARGET_FILE = PROJECT_ROOT / "zen" / "telemetry" / "embedded_credentials.py"
+
+
+def main() -> int:
+    encoded = os.getenv("COMMUNITY_CREDENTIALS", "").strip()
+    if not encoded:
+        print(
+            "COMMUNITY_CREDENTIALS is not set. Set the base64-encoded "
+            "service-account JSON before running this script.",
+            file=sys.stderr,
+        )
+        return 1
+
+    try:
+        decoded = base64.b64decode(encoded)
+        info = json.loads(decoded)
+    except Exception as exc:  # pragma: no cover - defensive guard
+        print(f"Failed to decode telemetry credentials: {exc}", file=sys.stderr)
+        return 2
+
+    project_id = info.get("project_id", "netra-telemetry-public")
+    encoded_literal = repr(encoded)
+
+    generated = f'''"""Embedded telemetry credentials. AUTO-GENERATED - DO NOT COMMIT."""
+
+import base64
+import json
+from google.oauth2 import service_account
+
+_EMBEDDED_CREDENTIALS_B64 = {encoded_literal}
+_CREDENTIALS_DICT = json.loads(
+    base64.b64decode(_EMBEDDED_CREDENTIALS_B64.encode("utf-8"))
+)
+
+
+def get_embedded_credentials():
+    """Return service account credentials."""
+    try:
+        return service_account.Credentials.from_service_account_info(
+            _CREDENTIALS_DICT,
+            scopes=["https://www.googleapis.com/auth/trace.append"],
+        )
+    except Exception:
+        return None
+
+
+def get_project_id() -> str:
+    """Return GCP project ID."""
+    return _CREDENTIALS_DICT.get("project_id", {project_id!r})
+'''
+
+    TARGET_FILE.write_text(generated)
+    print(f"Embedded release credentials written to {TARGET_FILE.relative_to(PROJECT_ROOT)}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

zen/__main__.py

@@ -0,0 +1,11 @@
+"""Module entry point to support `python -m zen` invocation."""
+
+from zen_orchestrator import run
+
+
+def main() -> None:
+    run()
+
+
+if __name__ == "__main__":
+    main()

zen/telemetry/embedded_credentials.py

@@ -1,20 +1,50 @@
-"""Embedded telemetry credentials. AUTO-GENERATED - DO NOT COMMIT."""
+"""Runtime loader for telemetry credentials from environment variables."""
+
+from __future__ import annotations
 
 import base64
 import json
+import os
+from pathlib import Path
+from typing import Optional
+
 from google.oauth2 import service_account
 
-_EMBEDDED_CREDENTIALS_B64 = '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'
-_CREDENTIALS_DICT = json.loads(
-    base64.b64decode(_EMBEDDED_CREDENTIALS_B64.encode("utf-8"))
-)
+_ENV_B64 = "COMMUNITY_CREDENTIALS"
+_ENV_PATH = "ZEN_COMMUNITY_TELEMETRY_FILE"
+_ENV_PROJECT = "ZEN_COMMUNITY_TELEMETRY_PROJECT"
+_DEFAULT_PROJECT = "netra-telemetry-public"
+
+
+def _load_service_account_dict() -> Optional[dict]:
+    """Load service account JSON from environment variables."""
+    encoded = os.getenv(_ENV_B64)
+    if encoded:
+        try:
+            raw = base64.b64decode(encoded)
+            return json.loads(raw)
+        except (ValueError, json.JSONDecodeError):
+            return None
+
+    path = os.getenv(_ENV_PATH)
+    if path:
+        candidate = Path(path).expanduser()
+        if candidate.exists():
+            try:
+                return json.loads(candidate.read_text())
+            except json.JSONDecodeError:
+                return None
+    return None
 
 
 def get_embedded_credentials():
-    """Return service account credentials."""
+    """Return service account credentials or None."""
+    info = _load_service_account_dict()
+    if not info:
+        return None
     try:
         return service_account.Credentials.from_service_account_info(
-            _CREDENTIALS_DICT,
+            info,
             scopes=["https://www.googleapis.com/auth/trace.append"],
         )
     except Exception:
@@ -22,5 +52,8 @@ def get_embedded_credentials():
 
 
 def get_project_id() -> str:
-    """Return GCP project ID."""
-    return _CREDENTIALS_DICT.get("project_id", 'netra-telemetry-public')
+    """Return GCP project ID for telemetry."""
+    info = _load_service_account_dict()
+    if info and "project_id" in info:
+        return info["project_id"]
+    return os.getenv(_ENV_PROJECT, _DEFAULT_PROJECT)