claude-mpm 3.9.9__py3-none-any.whl → 4.0.3__py3-none-any.whl

claude_mpm/services/project/registry.py

@@ -17,44 +17,46 @@ to provide complete project lifecycle tracking.
 """
 
 import os
-import sys
-import uuid
-import subprocess
 import platform
 import shutil
-from datetime import datetime, timezone, timedelta
+import subprocess
+import sys
+import uuid
+from datetime import datetime, timedelta, timezone
 from pathlib import Path
-from typing import Dict, Any, Optional, List
+from typing import Any, Dict, List, Optional
+
 import yaml
 
 from claude_mpm.core.logger import get_logger
-from claude_mpm.deployment_paths import get_project_root
+from claude_mpm.core.unified_paths import get_project_root
 
 
 class ProjectRegistryError(Exception):
     """Base exception for project registry operations."""
+
     pass
 
 
 class ProjectRegistry:
     """
     Manages the project registry for claude-mpm installations.
-    
+
     WHY: The project registry provides persistent project tracking across sessions,
     enabling project identification, metadata collection, and usage analytics.
     This is crucial for multi-project environments where users switch between
     different codebases.
-    
+
     DESIGN DECISION: Registry files are stored in ~/.claude-mpm/registry/
     with UUID-based filenames to ensure uniqueness and avoid conflicts. The registry
     uses YAML for human readability and ease of manual inspection/editing.
     Registry is stored in the user's home directory for persistence across projects.
     """
-    
+
     def __init__(self):
         """
         Initialize the project registry.
-        
+
         WHY: Sets up the registry directory and logger. The registry directory
         is created in the user's home directory to keep registry data user-specific
         and persistent across different projects and sessions.
@@ -65,189 +67,189 @@ class ProjectRegistry:
         user_home = Path.home()
         self.registry_dir = user_home / ".claude-mpm" / "registry"
         self.current_project_path = Path.cwd().resolve()
-        
+
         # Ensure registry directory exists
         try:
             self.registry_dir.mkdir(parents=True, exist_ok=True)
         except Exception as e:
             self.logger.error(f"Failed to create registry directory: {e}")
             raise ProjectRegistryError(f"Cannot create registry directory: {e}")
-    
+
     def get_or_create_project_entry(self) -> Dict[str, Any]:
         """
         Get existing project registry entry or create a new one.
-        
+
         WHY: This is the main entry point for project registration. It handles
         both new project registration and existing project updates, ensuring
         that every claude-mpm session is properly tracked.
-        
+
         DESIGN DECISION: Matching is done by normalized absolute path to handle
         symbolic links and different path representations consistently.
-        
+
         Returns:
             Dictionary containing the project registry data
-            
+
         Raises:
             ProjectRegistryError: If registry operations fail
         """
         try:
             # Look for existing registry entry
             existing_entry = self._find_existing_entry()
-            
+
             if existing_entry:
-                self.logger.debug(f"Found existing project entry: {existing_entry['project_id']}")
+                self.logger.debug(
+                    f"Found existing project entry: {existing_entry['project_id']}"
+                )
                 # Update existing entry with current session info
                 return self._update_existing_entry(existing_entry)
             else:
                 self.logger.debug("Creating new project registry entry")
                 # Create new entry
                 return self._create_new_entry()
-                
+
         except Exception as e:
             self.logger.error(f"Failed to get or create project entry: {e}")
             raise ProjectRegistryError(f"Registry operation failed: {e}")
-    
+
     def _find_existing_entry(self) -> Optional[Dict[str, Any]]:
         """
         Search for existing registry entry matching current project path.
-        
+
         WHY: We need to match projects by their absolute path to avoid creating
         duplicate entries when the same project is accessed from different
         working directories or via different path representations.
-        
+
         Returns:
             Existing registry data if found, None otherwise
         """
         try:
             # Normalize current path for consistent matching
             current_path_str = str(self.current_project_path)
-            
+
             # Search all registry files
             for registry_file in self.registry_dir.glob("*.yaml"):
                 try:
-                    with open(registry_file, 'r', encoding='utf-8') as f:
+                    with open(registry_file, "r", encoding="utf-8") as f:
                         data = yaml.safe_load(f) or {}
-                    
+
                     # Check if project_path matches
-                    if data.get('project_path') == current_path_str:
-                        data['_registry_file'] = registry_file  # Add file reference
+                    if data.get("project_path") == current_path_str:
+                        data["_registry_file"] = registry_file  # Add file reference
                         return data
-                        
+
                 except Exception as e:
-                    self.logger.warning(f"Failed to read registry file {registry_file}: {e}")
+                    self.logger.warning(
+                        f"Failed to read registry file {registry_file}: {e}"
+                    )
                     continue
-            
+
             return None
-            
+
         except Exception as e:
             self.logger.error(f"Error searching for existing entry: {e}")
             return None
-    
+
     def _create_new_entry(self) -> Dict[str, Any]:
         """
         Create a new project registry entry.
-        
+
         WHY: New projects need to be registered with comprehensive metadata
         including project information, environment details, and initial runtime
         data. This creates a complete snapshot of the project at first access.
-        
+
         Returns:
             Newly created registry data
         """
         project_id = str(uuid.uuid4())
         registry_file = self.registry_dir / f"{project_id}.yaml"
-        
+
         # Build comprehensive project data
         project_data = {
-            'project_id': project_id,
-            'project_path': str(self.current_project_path),
-            'project_name': self.current_project_path.name,
-            'metadata': self._build_metadata(is_new=True),
-            'runtime': self._build_runtime_info(),
-            'environment': self._build_environment_info(),
-            'git': self._build_git_info(),
-            'session': self._build_session_info(),
-            'project_info': self._build_project_info()
+            "project_id": project_id,
+            "project_path": str(self.current_project_path),
+            "project_name": self.current_project_path.name,
+            "metadata": self._build_metadata(is_new=True),
+            "runtime": self._build_runtime_info(),
+            "environment": self._build_environment_info(),
+            "git": self._build_git_info(),
+            "session": self._build_session_info(),
+            "project_info": self._build_project_info(),
         }
-        
+
         # Save to registry file
         self._save_registry_data(registry_file, project_data)
-        project_data['_registry_file'] = registry_file
-        
+        project_data["_registry_file"] = registry_file
+
         self.logger.info(f"Created new project registry entry: {project_id}")
         return project_data
-    
+
     def _update_existing_entry(self, existing_data: Dict[str, Any]) -> Dict[str, Any]:
         """
         Update existing project registry entry with current session information.
-        
+
         WHY: Existing projects need their metadata updated to reflect current
         access patterns, runtime information, and any changes in project state.
         This maintains accurate usage tracking and project state history.
-        
+
         Args:
             existing_data: The existing registry data to update
-            
+
         Returns:
             Updated registry data
         """
-        registry_file = existing_data.get('_registry_file')
+        registry_file = existing_data.get("_registry_file")
         if not registry_file:
-            raise ProjectRegistryError("Registry file reference missing from existing data")
-        
+            raise ProjectRegistryError(
+                "Registry file reference missing from existing data"
+            )
+
         # Update timestamps and counters
-        metadata = existing_data.get('metadata', {})
-        access_count = metadata.get('access_count', 0) + 1
+        metadata = existing_data.get("metadata", {})
+        access_count = metadata.get("access_count", 0) + 1
         now = datetime.now(timezone.utc).isoformat()
-        
-        existing_data['metadata'].update({
-            'updated_at': now,
-            'last_accessed': now,
-            'access_count': access_count
-        })
-        
+
+        existing_data["metadata"].update(
+            {"updated_at": now, "last_accessed": now, "access_count": access_count}
+        )
+
         # Update runtime information
-        existing_data['runtime'] = self._build_runtime_info()
-        
+        existing_data["runtime"] = self._build_runtime_info()
+
         # Update session information
-        existing_data['session'] = self._build_session_info()
-        
+        existing_data["session"] = self._build_session_info()
+
         # Update git information (may have changed)
-        existing_data['git'] = self._build_git_info()
-        
+        existing_data["git"] = self._build_git_info()
+
         # Update project info (may have changed)
-        existing_data['project_info'] = self._build_project_info()
-        
+        existing_data["project_info"] = self._build_project_info()
+
         # Save updated data
         self._save_registry_data(registry_file, existing_data)
-        
+
         self.logger.debug(f"Updated project registry entry (access #{access_count})")
         return existing_data
-    
+
     def _build_metadata(self, is_new: bool = False) -> Dict[str, Any]:
         """
         Build metadata section for registry entry.
-        
+
         WHY: Metadata tracks creation, modification, and access patterns for
         analytics and project lifecycle management.
         """
         now = datetime.now(timezone.utc).isoformat()
-        
-        metadata = {
-            'updated_at': now,
-            'last_accessed': now,
-            'access_count': 1
-        }
-        
+
+        metadata = {"updated_at": now, "last_accessed": now, "access_count": 1}
+
         if is_new:
-            metadata['created_at'] = now
-        
+            metadata["created_at"] = now
+
         return metadata
-    
+
     def _build_runtime_info(self) -> Dict[str, Any]:
         """
         Build runtime information section.
-        
+
         WHY: Runtime information helps track session lifecycle, process management,
         and system state. This is valuable for debugging session issues and
         understanding usage patterns.
@@ -257,128 +259,128 @@ class ProjectRegistry:
             from claude_mpm import __version__ as claude_mpm_version
         except ImportError:
             claude_mpm_version = "unknown"
-        
+
         return {
-            'startup_time': datetime.now(timezone.utc).isoformat(),
-            'pid': os.getpid(),
-            'python_version': f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}",
-            'claude_mpm_version': claude_mpm_version,
-            'command_line': ' '.join(sys.argv),
-            'launch_method': 'subprocess'  # Default, could be detected based on parent process
+            "startup_time": datetime.now(timezone.utc).isoformat(),
+            "pid": os.getpid(),
+            "python_version": f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}",
+            "claude_mpm_version": claude_mpm_version,
+            "command_line": " ".join(sys.argv),
+            "launch_method": "subprocess",  # Default, could be detected based on parent process
         }
-    
+
     def _build_environment_info(self) -> Dict[str, Any]:
         """
         Build environment information section.
-        
+
         WHY: Environment information helps with debugging, platform-specific
         behavior analysis, and provides context for project usage patterns
         across different systems and user setups.
         """
         return {
-            'user': os.getenv('USER') or os.getenv('USERNAME', 'unknown'),
-            'hostname': platform.node(),
-            'os': platform.system(),
-            'os_version': platform.release(),
-            'shell': os.getenv('SHELL', 'unknown'),
-            'terminal': os.getenv('TERM', 'unknown'),
-            'cwd': str(Path.cwd())
+            "user": os.getenv("USER") or os.getenv("USERNAME", "unknown"),
+            "hostname": platform.node(),
+            "os": platform.system(),
+            "os_version": platform.release(),
+            "shell": os.getenv("SHELL", "unknown"),
+            "terminal": os.getenv("TERM", "unknown"),
+            "cwd": str(Path.cwd()),
         }
-    
+
     def _build_git_info(self) -> Dict[str, Any]:
         """
         Build git repository information.
-        
+
         WHY: Git information is crucial for project identification and tracking
         changes across different branches and commits. This helps understand
         project state and enables better project management features.
         """
         git_info = {
-            'is_repo': False,
-            'branch': None,
-            'remote_url': None,
-            'last_commit': None,
-            'has_uncommitted': False
+            "is_repo": False,
+            "branch": None,
+            "remote_url": None,
+            "last_commit": None,
+            "has_uncommitted": False,
         }
-        
+
         try:
             # Check if we're in a git repository
             result = subprocess.run(
-                ['git', 'rev-parse', '--git-dir'],
+                ["git", "rev-parse", "--git-dir"],
                 cwd=self.current_project_path,
                 capture_output=True,
                 text=True,
-                timeout=5
+                timeout=5,
             )
-            
+
             if result.returncode == 0:
-                git_info['is_repo'] = True
-                
+                git_info["is_repo"] = True
+
                 # Get current branch
                 try:
                     result = subprocess.run(
-                        ['git', 'branch', '--show-current'],
+                        ["git", "branch", "--show-current"],
                         cwd=self.current_project_path,
                         capture_output=True,
                         text=True,
-                        timeout=5
+                        timeout=5,
                     )
                     if result.returncode == 0:
-                        git_info['branch'] = result.stdout.strip()
+                        git_info["branch"] = result.stdout.strip()
                 except Exception:
                     pass
-                
+
                 # Get remote URL
                 try:
                     result = subprocess.run(
-                        ['git', 'remote', 'get-url', 'origin'],
+                        ["git", "remote", "get-url", "origin"],
                         cwd=self.current_project_path,
                         capture_output=True,
                         text=True,
-                        timeout=5
+                        timeout=5,
                     )
                     if result.returncode == 0:
-                        git_info['remote_url'] = result.stdout.strip()
+                        git_info["remote_url"] = result.stdout.strip()
                 except Exception:
                     pass
-                
+
                 # Get last commit
                 try:
                     result = subprocess.run(
-                        ['git', 'rev-parse', 'HEAD'],
+                        ["git", "rev-parse", "HEAD"],
                         cwd=self.current_project_path,
                         capture_output=True,
                         text=True,
-                        timeout=5
+                        timeout=5,
                     )
                     if result.returncode == 0:
-                        git_info['last_commit'] = result.stdout.strip()
+                        git_info["last_commit"] = result.stdout.strip()
                 except Exception:
                     pass
-                
+
                 # Check for uncommitted changes
                 try:
                     result = subprocess.run(
-                        ['git', 'status', '--porcelain'],
+                        ["git", "status", "--porcelain"],
                         cwd=self.current_project_path,
                         capture_output=True,
                         text=True,
-                        timeout=5
+                        timeout=5,
                     )
                     if result.returncode == 0:
-                        git_info['has_uncommitted'] = bool(result.stdout.strip())
+                        git_info["has_uncommitted"] = bool(result.stdout.strip())
                 except Exception:
                     pass
-        
+
         except Exception as e:
             self.logger.debug(f"Failed to get git info: {e}")
-        
+
         return git_info
-    
+
     def _build_session_info(self) -> Dict[str, Any]:
         """
         Build session information.
-        
+
         WHY: Session information tracks the current claude-mpm session state,
         including active components and configuration. This helps with session
         management and debugging.
@@ -386,223 +388,243 @@ class ProjectRegistry:
         # These would be populated by the actual session manager
         # For now, we provide placeholders that can be updated by the caller
         return {
-            'session_id': None,  # Could be set by session manager
-            'ticket_count': 0,   # Could be updated by ticket manager
-            'agent_count': 0,    # Could be updated by agent manager
-            'hooks_enabled': False,  # Could be detected from configuration
-            'monitor_enabled': False  # Could be detected from process state
+            "session_id": None,  # Could be set by session manager
+            "ticket_count": 0,  # Could be updated by ticket manager
+            "agent_count": 0,  # Could be updated by agent manager
+            "hooks_enabled": False,  # Could be detected from configuration
+            "monitor_enabled": False,  # Could be detected from process state
         }
-    
+
     def _build_project_info(self) -> Dict[str, Any]:
         """
         Build project information section.
-        
+
         WHY: Project information helps identify the type of project and its
         characteristics, enabling better tool selection and project-specific
         optimizations.
         """
         project_info = {
-            'has_claude_config': False,
-            'has_claude_md': False,
-            'has_pyproject': False,
-            'has_package_json': False,
-            'project_type': 'unknown'
+            "has_claude_config": False,
+            "has_claude_md": False,
+            "has_pyproject": False,
+            "has_package_json": False,
+            "project_type": "unknown",
         }
-        
+
         # Check for various project files
-        claude_files = ['.claude', 'claude.toml', '.claude.toml']
+        claude_files = [".claude", "claude.toml", ".claude.toml"]
         for claude_file in claude_files:
             if (self.current_project_path / claude_file).exists():
-                project_info['has_claude_config'] = True
+                project_info["has_claude_config"] = True
                 break
-        
-        claude_md_files = ['CLAUDE.md', 'claude.md', '.claude.md']
+
+        claude_md_files = ["CLAUDE.md", "claude.md", ".claude.md"]
         for claude_md in claude_md_files:
             if (self.current_project_path / claude_md).exists():
-                project_info['has_claude_md'] = True
+                project_info["has_claude_md"] = True
                 break
-        
-        if (self.current_project_path / 'pyproject.toml').exists():
-            project_info['has_pyproject'] = True
-        
-        if (self.current_project_path / 'package.json').exists():
-            project_info['has_package_json'] = True
-        
+
+        if (self.current_project_path / "pyproject.toml").exists():
+            project_info["has_pyproject"] = True
+
+        if (self.current_project_path / "package.json").exists():
+            project_info["has_package_json"] = True
+
         # Determine project type
-        if project_info['has_pyproject'] or (self.current_project_path / 'setup.py').exists():
-            project_info['project_type'] = 'python'
-        elif project_info['has_package_json']:
-            project_info['project_type'] = 'javascript'
-        elif (self.current_project_path / 'Cargo.toml').exists():
-            project_info['project_type'] = 'rust'
-        elif (self.current_project_path / 'go.mod').exists():
-            project_info['project_type'] = 'go'
-        elif (self.current_project_path / 'pom.xml').exists():
-            project_info['project_type'] = 'java'
-        elif any((self.current_project_path / ext).exists() for ext in ['*.c', '*.cpp', '*.h', '*.hpp']):
-            project_info['project_type'] = 'c/cpp'
-        elif project_info['has_claude_config'] or project_info['has_claude_md']:
-            project_info['project_type'] = 'claude'
+        if (
+            project_info["has_pyproject"]
+            or (self.current_project_path / "setup.py").exists()
+        ):
+            project_info["project_type"] = "python"
+        elif project_info["has_package_json"]:
+            project_info["project_type"] = "javascript"
+        elif (self.current_project_path / "Cargo.toml").exists():
+            project_info["project_type"] = "rust"
+        elif (self.current_project_path / "go.mod").exists():
+            project_info["project_type"] = "go"
+        elif (self.current_project_path / "pom.xml").exists():
+            project_info["project_type"] = "java"
+        elif any(
+            (self.current_project_path / ext).exists()
+            for ext in ["*.c", "*.cpp", "*.h", "*.hpp"]
+        ):
+            project_info["project_type"] = "c/cpp"
+        elif project_info["has_claude_config"] or project_info["has_claude_md"]:
+            project_info["project_type"] = "claude"
         else:
             # Try to detect by file extensions
-            common_files = list(self.current_project_path.iterdir())[:20]  # Check first 20 files
+            common_files = list(self.current_project_path.iterdir())[
+                :20
+            ]  # Check first 20 files
             extensions = {f.suffix.lower() for f in common_files if f.is_file()}
-            
-            if '.py' in extensions:
-                project_info['project_type'] = 'python'
-            elif any(ext in extensions for ext in ['.js', '.ts', '.jsx', '.tsx']):
-                project_info['project_type'] = 'javascript'
-            elif any(ext in extensions for ext in ['.rs']):
-                project_info['project_type'] = 'rust'
-            elif any(ext in extensions for ext in ['.go']):
-                project_info['project_type'] = 'go'
-            elif any(ext in extensions for ext in ['.java', '.scala', '.kt']):
-                project_info['project_type'] = 'jvm'
-            elif any(ext in extensions for ext in ['.c', '.cpp', '.cc', '.h', '.hpp']):
-                project_info['project_type'] = 'c/cpp'
-            elif any(ext in extensions for ext in ['.md', '.txt', '.rst']):
-                project_info['project_type'] = 'documentation'
-        
+
+            if ".py" in extensions:
+                project_info["project_type"] = "python"
+            elif any(ext in extensions for ext in [".js", ".ts", ".jsx", ".tsx"]):
+                project_info["project_type"] = "javascript"
+            elif any(ext in extensions for ext in [".rs"]):
+                project_info["project_type"] = "rust"
+            elif any(ext in extensions for ext in [".go"]):
+                project_info["project_type"] = "go"
+            elif any(ext in extensions for ext in [".java", ".scala", ".kt"]):
+                project_info["project_type"] = "jvm"
+            elif any(ext in extensions for ext in [".c", ".cpp", ".cc", ".h", ".hpp"]):
+                project_info["project_type"] = "c/cpp"
+            elif any(ext in extensions for ext in [".md", ".txt", ".rst"]):
+                project_info["project_type"] = "documentation"
+
         return project_info
-    
+
     def _save_registry_data(self, registry_file: Path, data: Dict[str, Any]) -> None:
         """
         Save registry data to YAML file.
-        
+
         WHY: Centralized saving logic ensures consistent formatting and error
         handling across all registry operations. YAML format provides human
         readability for debugging and manual inspection.
-        
+
         Args:
             registry_file: Path to the registry file
             data: Registry data to save
         """
         try:
             # Remove internal fields before saving
-            save_data = {k: v for k, v in data.items() if not k.startswith('_')}
-            
-            with open(registry_file, 'w', encoding='utf-8') as f:
-                yaml.dump(save_data, f, default_flow_style=False, sort_keys=False, indent=2)
-                
+            save_data = {k: v for k, v in data.items() if not k.startswith("_")}
+
+            with open(registry_file, "w", encoding="utf-8") as f:
+                yaml.dump(
+                    save_data, f, default_flow_style=False, sort_keys=False, indent=2
+                )
+
             self.logger.debug(f"Saved registry data to {registry_file}")
-            
+
         except Exception as e:
             self.logger.error(f"Failed to save registry data: {e}")
             raise ProjectRegistryError(f"Failed to save registry: {e}")
-    
+
     def list_projects(self) -> List[Dict[str, Any]]:
         """
         List all registered projects.
-        
+
         WHY: Provides visibility into all projects managed by claude-mpm,
         useful for project management and analytics.
-        
+
         Returns:
             List of project registry data dictionaries
         """
         projects = []
-        
+
         try:
             for registry_file in self.registry_dir.glob("*.yaml"):
                 try:
-                    with open(registry_file, 'r', encoding='utf-8') as f:
+                    with open(registry_file, "r", encoding="utf-8") as f:
                         data = yaml.safe_load(f) or {}
                     projects.append(data)
                 except Exception as e:
-                    self.logger.warning(f"Failed to read registry file {registry_file}: {e}")
+                    self.logger.warning(
+                        f"Failed to read registry file {registry_file}: {e}"
+                    )
                     continue
-        
+
         except Exception as e:
             self.logger.error(f"Failed to list projects: {e}")
-        
+
         return projects
-    
+
     def cleanup_old_entries(self, max_age_days: int = 90) -> int:
         """
         Clean up old registry entries that haven't been accessed recently.
-        
+
         WHY: Prevents registry directory from growing indefinitely with old
         project entries. Keeps the registry focused on active projects.
-        
+
         Args:
             max_age_days: Maximum age in days for keeping entries
-            
+
         Returns:
             Number of entries cleaned up
         """
         if max_age_days <= 0:
             return 0
-        
+
         cleaned_count = 0
         cutoff_date = datetime.now(timezone.utc) - timedelta(days=max_age_days)
-        
+
         try:
             for registry_file in self.registry_dir.glob("*.yaml"):
                 try:
-                    with open(registry_file, 'r', encoding='utf-8') as f:
+                    with open(registry_file, "r", encoding="utf-8") as f:
                         data = yaml.safe_load(f) or {}
-                    
+
                     # Check last accessed time
-                    last_accessed_str = data.get('metadata', {}).get('last_accessed')
+                    last_accessed_str = data.get("metadata", {}).get("last_accessed")
                     if last_accessed_str:
-                        last_accessed = datetime.fromisoformat(last_accessed_str.replace('Z', '+00:00'))
+                        last_accessed = datetime.fromisoformat(
+                            last_accessed_str.replace("Z", "+00:00")
+                        )
                         if last_accessed < cutoff_date:
                             registry_file.unlink()
                             cleaned_count += 1
-                            self.logger.debug(f"Cleaned up old registry entry: {registry_file}")
-                    
+                            self.logger.debug(
+                                f"Cleaned up old registry entry: {registry_file}"
+                            )
+
                 except Exception as e:
-                    self.logger.warning(f"Failed to process registry file {registry_file}: {e}")
+                    self.logger.warning(
+                        f"Failed to process registry file {registry_file}: {e}"
+                    )
                     continue
-        
+
         except Exception as e:
             self.logger.error(f"Failed to cleanup old entries: {e}")
-        
+
         if cleaned_count > 0:
             self.logger.info(f"Cleaned up {cleaned_count} old registry entries")
-        
+
         return cleaned_count
-    
+
     def update_session_info(self, session_updates: Dict[str, Any]) -> bool:
         """
         Update session information for the current project.
-        
+
         WHY: Allows other components (session manager, ticket manager, etc.)
         to update the registry with current session state information.
-        
+
         Args:
             session_updates: Dictionary of session updates to apply
-            
+
         Returns:
             True if update was successful, False otherwise
         """
         try:
             existing_entry = self._find_existing_entry()
             if not existing_entry:
-                self.logger.warning("No existing registry entry found for session update")
+                self.logger.warning(
+                    "No existing registry entry found for session update"
+                )
                 return False
-            
-            registry_file = existing_entry.get('_registry_file')
+
+            registry_file = existing_entry.get("_registry_file")
             if not registry_file:
                 self.logger.error("Registry file reference missing")
                 return False
-            
+
             # Update session information
-            if 'session' not in existing_entry:
-                existing_entry['session'] = {}
-            
-            existing_entry['session'].update(session_updates)
-            
+            if "session" not in existing_entry:
+                existing_entry["session"] = {}
+
+            existing_entry["session"].update(session_updates)
+
             # Update metadata timestamp
             now = datetime.now(timezone.utc).isoformat()
-            existing_entry['metadata']['updated_at'] = now
-            
+            existing_entry["metadata"]["updated_at"] = now
+
             # Save updated data
             self._save_registry_data(registry_file, existing_entry)
-            
+
             self.logger.debug(f"Updated session info: {session_updates}")
             return True
-            
+
         except Exception as e:
             self.logger.error(f"Failed to update session info: {e}")
-            return False
+            return False