session-buddy 0.10.0__py3-none-any.whl

session_buddy/__init__.py

@@ -0,0 +1,32 @@
+"""Session Management MCP Server.
+
+Provides comprehensive session management, conversation memory,
+and quality monitoring for Claude Code projects.
+"""
+
+from contextlib import suppress
+
+# Phase 2 Decomposition: New modular architecture
+# These imports expose the decomposed server components
+with suppress(ImportError):
+    from .advanced_features import (
+        AdvancedFeaturesHub,
+    )
+    from .core.permissions import (
+        SessionPermissionsManager,
+    )
+    # QualityScoreResult is not directly exposed from quality_engine as it doesn't exist
+    # MCPServerCore does not exist in server_core
+from .utils.logging import SessionLogger
+
+__version__ = "0.7.4"
+
+__all__ = [
+    # Advanced features
+    "AdvancedFeaturesHub",
+    # Core components are not directly exposed
+    "SessionLogger",
+    "SessionPermissionsManager",
+    # Package metadata
+    "__version__",
+]

session_buddy/__main__.py

@@ -0,0 +1,23 @@
+#!/usr/bin/env python3
+"""Session Management MCP Server - Module Entry Point.
+
+Provides CLI interface matching crackerjack's server management pattern.
+
+Usage:
+    python -m session_buddy --start-mcp-server       # Start server
+    python -m session_buddy --stop-mcp-server        # Stop server
+    python -m session_buddy --restart-mcp-server     # Restart server
+    python -m session_buddy --status                 # Show status
+    python -m session_buddy --version                # Show version
+"""
+
+
+def main() -> None:
+    """Main entry point for the session management MCP server."""
+    from .cli import app
+
+    app()
+
+
+if __name__ == "__main__":
+    main()

session_buddy/acb_cache_adapter.py

@@ -0,0 +1,282 @@
+"""Async-native, ACB-backed cache adapters for session-mgmt-mcp.
+
+This module provides fully asynchronous cache adapters using aiocache,
+leveraging ACB's underlying cache for optimized serialization and
+lifecycle management.
+"""
+
+import hashlib
+import typing as t
+from dataclasses import dataclass
+
+from aiocache import SimpleMemoryCache
+from aiocache.serializers import PickleSerializer
+
+
+@dataclass
+class CacheStats:
+    """Cache statistics for monitoring."""
+
+    hits: int = 0
+    misses: int = 0
+    evictions: int = 0
+    total_entries: int = 0
+
+    @property
+    def hit_rate(self) -> float:
+        """Calculate cache hit rate percentage."""
+        total = self.hits + self.misses
+        return (self.hits / total * 100) if total > 0 else 0.0
+
+    def to_dict(self) -> dict[str, t.Any]:
+        """Convert stats to dictionary for reporting."""
+        return {
+            "hits": self.hits,
+            "misses": self.misses,
+            "evictions": self.evictions,
+            "total_entries": self.total_entries,
+            "hit_rate_percent": round(self.hit_rate, 2),
+        }
+
+
+class ACBChunkCache:
+    """Async-native, ACB-backed chunk cache for the token optimizer."""
+
+    def __init__(self, ttl: int = 3600) -> None:
+        """Initialize chunk cache.
+
+        Args:
+            ttl: Default time-to-live in seconds (default: 1 hour)
+
+        """
+        self._cache = SimpleMemoryCache(
+            serializer=PickleSerializer(),
+            namespace="session_mgmt:chunks:",
+        )
+        self._cache.timeout = 0.0  # No operation timeout
+        self._ttl = ttl
+        self.stats = CacheStats()
+
+    async def set(self, key: str, value: t.Any, ttl: int | None = None) -> None:
+        """Store chunk data in cache asynchronously.
+
+        Args:
+            key: Cache key
+            value: Value to cache (ChunkResult)
+            ttl: Optional TTL override in seconds
+
+        """
+        effective_ttl = ttl or self._ttl
+        await self._cache.set(key, value, ttl=effective_ttl)
+        self.stats.total_entries += 1
+
+    async def get(self, key: str) -> t.Any | None:
+        """Retrieve chunk data from cache asynchronously.
+
+        Args:
+            key: Cache key
+
+        Returns:
+            Cached value or None if not found/expired
+
+        """
+        result = await self._cache.get(key)
+        if result is None:
+            self.stats.misses += 1
+        else:
+            self.stats.hits += 1
+        return result
+
+    async def delete(self, key: str) -> None:
+        """Delete chunk data from cache asynchronously.
+
+        Args:
+            key: Cache key to delete
+
+        """
+        await self._cache.delete(key)
+        self.stats.evictions += 1
+
+    async def clear(self) -> None:
+        """Clear all cached chunk data asynchronously."""
+        await self._cache.clear()
+        self.stats = CacheStats()
+
+    async def __contains__(self, key: str) -> bool:
+        """Check if key exists in cache asynchronously.
+
+        Args:
+            key: Cache key to check
+
+        Returns:
+            True if key exists and is not expired
+
+        """
+        result = await self._cache.exists(key)
+        return bool(result)
+
+    async def __getitem__(self, key: str) -> t.Any:
+        """Get item using dict syntax asynchronously.
+
+        Args:
+            key: Cache key
+
+        Returns:
+            Cached value
+
+        Raises:
+            KeyError: If key not found in cache
+
+        """
+        result = await self.get(key)
+        if result is None:
+            raise KeyError(key)
+        return result
+
+    async def __setitem__(self, key: str, value: t.Any) -> None:
+        """Set item using dict syntax asynchronously.
+
+        Args:
+            key: Cache key
+            value: Value to cache
+
+        """
+        await self.set(key, value)
+
+    async def __delitem__(self, key: str) -> None:
+        """Delete item using dict syntax asynchronously.
+
+        Args:
+            key: Cache key to delete
+
+        """
+        await self.delete(key)
+
+    async def keys(self) -> list[str]:
+        """Get all cache keys (not efficiently supported by SimpleMemoryCache)."""
+        return []
+
+    def get_stats(self) -> dict[str, t.Any]:
+        """Get cache statistics."""
+        return {"chunk_cache": self.stats.to_dict()}
+
+
+class ACBHistoryCache:
+    """Async-native, ACB-backed history cache for analysis results."""
+
+    def __init__(self, ttl: float = 300.0) -> None:
+        """Initialize history cache.
+
+        Args:
+            ttl: Time-to-live in seconds (default: 5 minutes)
+
+        """
+        self._cache = SimpleMemoryCache(
+            serializer=PickleSerializer(),
+            namespace="session_mgmt:history:",
+        )
+        self._cache.timeout = 0.0
+        self._ttl = int(ttl)
+        self.stats = CacheStats()
+
+    def _generate_key(self, project: str, days: int) -> str:
+        """Generate cache key from parameters."""
+        params = f"{project}:{days}"
+        return hashlib.md5(params.encode(), usedforsecurity=False).hexdigest()
+
+    async def get(self, project: str, days: int) -> dict[str, t.Any] | None:
+        """Retrieve cached analysis result asynchronously.
+
+        Args:
+            project: Project name
+            days: Number of days analyzed
+
+        Returns:
+            Cached analysis dict or None if not found/expired
+
+        """
+        key = self._generate_key(project, days)
+        result: dict[str, t.Any] | None = await self._cache.get(key)
+        if result is None:
+            self.stats.misses += 1
+        else:
+            self.stats.hits += 1
+        return result
+
+    async def set(self, project: str, days: int, data: dict[str, t.Any]) -> None:
+        """Store analysis result in cache asynchronously.
+
+        Args:
+            project: Project name
+            days: Number of days analyzed
+            data: Analysis result dictionary
+
+        """
+        key = self._generate_key(project, days)
+        await self._cache.set(key, data, ttl=self._ttl)
+        self.stats.total_entries += 1
+
+    async def invalidate(self, project: str | None = None) -> None:
+        """Invalidate cache entries asynchronously.
+
+        Args:
+            project: Optional project name (if None, clears entire cache)
+
+        """
+        if project is None:
+            await self._cache.clear()
+            self.stats = CacheStats()
+        else:
+            import warnings
+
+            warnings.warn(
+                "ACB cache doesn't support selective invalidation by project. "
+                "Use invalidate(None) to clear all cached data.",
+                stacklevel=2,
+            )
+
+    async def size(self) -> int:
+        """Get number of cached entries (approximate)."""
+        return self.stats.total_entries
+
+    def get_stats(self) -> dict[str, int]:
+        """Get cache statistics."""
+        return {
+            "total_entries": self.stats.total_entries,
+            "hits": self.stats.hits,
+            "misses": self.stats.misses,
+            "expired_entries": 0,
+            "active_entries": self.stats.total_entries,
+        }
+
+
+# Global cache instances
+_chunk_cache: ACBChunkCache | None = None
+_history_cache: ACBHistoryCache | None = None
+
+
+def get_chunk_cache(ttl: int = 3600) -> ACBChunkCache:
+    """Get or create global async chunk cache instance."""
+    global _chunk_cache
+    if _chunk_cache is None:
+        _chunk_cache = ACBChunkCache(ttl=ttl)
+    return _chunk_cache
+
+
+def get_history_cache(ttl: float = 300.0) -> ACBHistoryCache:
+    """Get or create global async history cache instance."""
+    global _history_cache
+    if _history_cache is None:
+        _history_cache = ACBHistoryCache(ttl=ttl)
+    return _history_cache
+
+
+async def reset_caches() -> None:
+    """Reset global cache instances asynchronously."""
+    global _chunk_cache, _history_cache
+    if _chunk_cache:
+        await _chunk_cache.clear()
+    if _history_cache:
+        await _history_cache.invalidate()
+    _chunk_cache = None
+    _history_cache = None

session_buddy/adapters/__init__.py

@@ -0,0 +1,38 @@
+"""ACB adapter compatibility wrappers for session management.
+
+This module provides compatibility wrappers that maintain the existing ReflectionDatabase
+and KnowledgeGraphDatabase APIs while using ACB adapters under the hood.
+
+Phase 1: Storage adapter integration for session state persistence
+Phase 2.7 (Week 7 Day 1-5): Migration to ACB dependency injection
+"""
+
+from __future__ import annotations
+
+from .session_storage_adapter import (
+    DEFAULT_SESSION_BUCKET,
+    SessionStorageAdapter,
+    get_default_storage_adapter,
+)
+from .storage_registry import (
+    SUPPORTED_BACKENDS,
+    configure_storage_buckets,
+    get_default_session_buckets,
+    get_storage_adapter,
+    register_storage_adapter,
+)
+
+__all__ = [
+    "DEFAULT_SESSION_BUCKET",
+    "SUPPORTED_BACKENDS",
+    # Reflection adapter (Phase 2.7)
+    "ReflectionDatabaseAdapter",
+    # Storage adapters (Phase 1)
+    "SessionStorageAdapter",
+    "configure_storage_buckets",
+    "get_default_session_buckets",
+    "get_default_storage_adapter",
+    "get_storage_adapter",
+    # Storage registry
+    "register_storage_adapter",
+]