claude-self-reflect 4.0.3 → 5.0.4

package/mcp-server/src/safe_getters.py

@@ -0,0 +1,217 @@
+"""Safe getter utilities for handling None values consistently."""
+
+import logging
+from typing import Any, Dict, List, Optional, Set, Union
+
+logger = logging.getLogger(__name__)
+
+
+def safe_get_list(
+    data: Optional[Dict[str, Any]],
+    key: str,
+    default: Optional[List] = None
+) -> List[Any]:
+    """
+    Safely get a list field from a dictionary, handling None and non-list values.
+
+    Args:
+        data: Dictionary to get value from (can be None)
+        key: Key to retrieve
+        default: Default value if key not found or value is None
+
+    Returns:
+        A list, either the value, converted value, or default/empty list
+    """
+    if data is None:
+        return default if default is not None else []
+
+    value = data.get(key)
+
+    if value is None:
+        return default if default is not None else []
+
+    # Handle sets and tuples by converting to list
+    if isinstance(value, (set, tuple)):
+        return list(value)
+
+    # If it's already a list, return it
+    if isinstance(value, list):
+        return value
+
+    # If it's not a list-like type, log warning and return empty list
+    logger.warning(
+        f"Expected list-like type for key '{key}', got {type(value).__name__}. "
+        f"Value: {repr(value)[:100]}"
+    )
+    return default if default is not None else []
+
+
+def safe_get_str(
+    data: Optional[Dict[str, Any]],
+    key: str,
+    default: str = ""
+) -> str:
+    """
+    Safely get a string field from a dictionary.
+
+    Args:
+        data: Dictionary to get value from (can be None)
+        key: Key to retrieve
+        default: Default value if key not found or value is None
+
+    Returns:
+        A string, either the value or the default
+    """
+    if data is None:
+        return default
+
+    value = data.get(key)
+
+    if value is None:
+        return default
+
+    # Convert to string if needed
+    return str(value)
+
+
+def safe_get_dict(
+    data: Optional[Dict[str, Any]],
+    key: str,
+    default: Optional[Dict] = None
+) -> Dict[str, Any]:
+    """
+    Safely get a dictionary field from another dictionary.
+
+    Args:
+        data: Dictionary to get value from (can be None)
+        key: Key to retrieve
+        default: Default value if key not found or value is None
+
+    Returns:
+        A dictionary, either the value or the default/empty dict
+    """
+    if data is None:
+        return default if default is not None else {}
+
+    value = data.get(key)
+
+    if value is None:
+        return default if default is not None else {}
+
+    if isinstance(value, dict):
+        return value
+
+    logger.warning(
+        f"Expected dict for key '{key}', got {type(value).__name__}. "
+        f"Value: {repr(value)[:100]}"
+    )
+    return default if default is not None else {}
+
+
+def safe_get_float(
+    data: Optional[Dict[str, Any]],
+    key: str,
+    default: float = 0.0
+) -> float:
+    """
+    Safely get a float field from a dictionary.
+
+    Args:
+        data: Dictionary to get value from (can be None)
+        key: Key to retrieve
+        default: Default value if key not found or value is None/non-numeric
+
+    Returns:
+        A float, either the converted value or the default
+    """
+    if data is None:
+        return default
+
+    value = data.get(key)
+
+    if value is None:
+        return default
+
+    try:
+        return float(value)
+    except (TypeError, ValueError) as e:
+        logger.warning(
+            f"Could not convert key '{key}' value to float: {repr(value)[:100]}. "
+            f"Error: {e}"
+        )
+        return default
+
+
+def safe_get_int(
+    data: Optional[Dict[str, Any]],
+    key: str,
+    default: int = 0
+) -> int:
+    """
+    Safely get an integer field from a dictionary.
+
+    Args:
+        data: Dictionary to get value from (can be None)
+        key: Key to retrieve
+        default: Default value if key not found or value is None/non-numeric
+
+    Returns:
+        An integer, either the converted value or the default
+    """
+    if data is None:
+        return default
+
+    value = data.get(key)
+
+    if value is None:
+        return default
+
+    try:
+        return int(value)
+    except (TypeError, ValueError) as e:
+        logger.warning(
+            f"Could not convert key '{key}' value to int: {repr(value)[:100]}. "
+            f"Error: {e}"
+        )
+        return default
+
+
+def safe_get_bool(
+    data: Optional[Dict[str, Any]],
+    key: str,
+    default: bool = False
+) -> bool:
+    """
+    Safely get a boolean field from a dictionary.
+
+    Args:
+        data: Dictionary to get value from (can be None)
+        key: Key to retrieve
+        default: Default value if key not found or value is None
+
+    Returns:
+        A boolean, either the value or the default
+    """
+    if data is None:
+        return default
+
+    value = data.get(key)
+
+    if value is None:
+        return default
+
+    if isinstance(value, bool):
+        return value
+
+    # Handle string booleans
+    if isinstance(value, str):
+        return value.lower() in ('true', '1', 'yes', 'on')
+
+    # Handle numeric booleans
+    try:
+        return bool(int(value))
+    except (TypeError, ValueError):
+        logger.warning(
+            f"Could not convert key '{key}' value to bool: {repr(value)[:100]}"
+        )
+        return default

package/mcp-server/src/search_tools.py

@@ -20,6 +20,26 @@ from .rich_formatting import format_search_results_rich
 logger = logging.getLogger(__name__)
 
 
+def is_searchable_collection(name: str) -> bool:
+    """
+    Check if collection name matches searchable patterns.
+    Supports both v3 and v4 collection naming conventions.
+    """
+    return (
+        # v3 patterns
+        name.endswith('_local')
+        or name.endswith('_voyage')
+        # v4 patterns
+        or name.endswith('_384d')  # Local v4 collections
+        or name.endswith('_1024d')  # Cloud v4 collections
+        or '_cloud_' in name  # Cloud v4 intermediate naming
+        # Reflections
+        or name.startswith('reflections')
+        # CSR prefixed collections
+        or name.startswith('csr_')
+    )
+
+
 class SearchTools:
     """Handles all search operations for the MCP server."""
     
@@ -114,6 +134,11 @@ class SearchTools:
             # Convert results to dict format
             results = []
             for result in search_results:
+                # Guard against None payload
+                if result.payload is None:
+                    logger.warning(f"Result in {collection_name} has None payload, skipping")
+                    continue
+
                 results.append({
                     'conversation_id': result.payload.get('conversation_id'),
                     'timestamp': result.payload.get('timestamp'),
@@ -274,10 +299,10 @@ class SearchTools:
                     return "<search_results><message>No collections available</message></search_results>"
 
                 # Include both conversation collections and reflection collections
+                # Use module-level function for consistency
                 filtered_collections = [
                     c for c in collections
-                    if (c.name.endswith('_local') or c.name.endswith('_voyage') or
-                        c.name.startswith('reflections'))
+                    if is_searchable_collection(c.name)
                 ]
                 await ctx.debug(f"Searching across {len(filtered_collections)} collections")
             
@@ -403,8 +428,7 @@ class SearchTools:
                 # Include both conversation collections and reflection collections
                 filtered_collections = [
                     c for c in collections
-                    if (c.name.endswith('_local') or c.name.endswith('_voyage') or
-                        c.name.startswith('reflections'))
+                    if is_searchable_collection(c.name)
                 ]
             
             # Quick PARALLEL count across collections
@@ -493,8 +517,7 @@ class SearchTools:
                 # Include both conversation collections and reflection collections
                 filtered_collections = [
                     c for c in collections
-                    if (c.name.endswith('_local') or c.name.endswith('_voyage') or
-                        c.name.startswith('reflections'))
+                    if is_searchable_collection(c.name)
                 ]
             
             # Gather results for summary using PARALLEL search
@@ -590,8 +613,7 @@ class SearchTools:
                 # Include both conversation collections and reflection collections
                 filtered_collections = [
                     c for c in collections
-                    if (c.name.endswith('_local') or c.name.endswith('_voyage') or
-                        c.name.startswith('reflections'))
+                    if is_searchable_collection(c.name)
                 ]
             
             # Gather all results using PARALLEL search

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-self-reflect",
-  "version": "4.0.3",
+  "version": "5.0.4",
   "description": "Give Claude perfect memory of all your conversations - Installation wizard for Python MCP server",
   "keywords": [
     "claude",

package/scripts/ast_grep_final_analyzer.py

@@ -257,15 +257,18 @@ class FinalASTGrepAnalyzer:
         return '\n'.join(report)
 
 
-def run_final_analysis():
+def run_final_analysis(file_path=None):
     """Run final AST-GREP analysis with unified registry."""
     print("🚀 FINAL AST-GREP Analysis with Unified Registry")
     print("=" * 60)
 
     analyzer = FinalASTGrepAnalyzer()
 
-    # Analyze server.py
-    server_path = "/Users/ramakrishnanannaswamy/projects/claude-self-reflect/mcp-server/src/server.py"
+    # Use provided path or default
+    # Use relative path from script location
+    script_dir = Path(__file__).parent
+    default_path = script_dir.parent / "mcp-server" / "src" / "server.py"
+    server_path = file_path if file_path else str(default_path)
 
     print(f"\nAnalyzing: {server_path}")
     print("-" * 40)
@@ -299,14 +302,14 @@ def run_final_analysis():
 
         # Generate and save report
         report = analyzer.generate_report(result)
-        report_path = "/Users/ramakrishnanannaswamy/projects/claude-self-reflect/scripts/final_analysis_report.md"
+        report_path = script_dir / "final_analysis_report.md"
         with open(report_path, 'w') as f:
             f.write(report)
 
         print(f"\n📝 Full report saved to: {report_path}")
 
         # Save JSON results
-        json_path = "/Users/ramakrishnanannaswamy/projects/claude-self-reflect/scripts/final_analysis_result.json"
+        json_path = script_dir / "final_analysis_result.json"
         with open(json_path, 'w') as f:
             json.dump(result, f, indent=2)
 
@@ -325,4 +328,11 @@ def run_final_analysis():
 
 
 if __name__ == "__main__":
-    run_final_analysis()
+    import sys
+    if len(sys.argv) > 1:
+        # Use provided file path
+        file_path = sys.argv[1]
+    else:
+        # Default to server.py
+        file_path = str(default_path)  # Use the same default path from above
+    run_final_analysis(file_path)

package/scripts/csr-status

@@ -6,6 +6,7 @@ Standalone script that doesn't require venv activation.
 
 import json
 import time
+import os
 from pathlib import Path
 from datetime import datetime, timedelta
 import sys
@@ -147,6 +148,51 @@ def format_statusline_quality(critical=0, medium=0, low=0):
 
 def get_session_health():
     """Get cached session health with icon-based quality display."""
+    # Get project-specific cache based on current directory
+    project_dir = os.getcwd()
+    project_name = os.path.basename(project_dir) if project_dir else "default"
+
+    # Check project-specific realtime cache first
+    quality_dir = Path.home() / ".claude-self-reflect" / "quality_by_project"
+    realtime_cache = quality_dir / f"{project_name}.json"
+
+    # Fallback to global cache if project-specific doesn't exist
+    if not realtime_cache.exists():
+        realtime_cache = Path.home() / ".claude-self-reflect" / "realtime_quality.json"
+
+    if realtime_cache.exists():
+        try:
+            # Check realtime cache age
+            mtime = datetime.fromtimestamp(realtime_cache.stat().st_mtime)
+            age = datetime.now() - mtime
+
+            if age < timedelta(minutes=5):  # Fresh realtime data
+                with open(realtime_cache, 'r') as f:
+                    realtime_data = json.load(f)
+
+                if "session_aggregate" in realtime_data:
+                    agg = realtime_data["session_aggregate"]
+                    issues = agg.get("total_issues", {})
+                    critical = issues.get("critical", 0)
+                    medium = issues.get("medium", 0)
+                    low = issues.get("low", 0)
+
+                    # Include score in display if significantly below threshold
+                    score = agg.get("average_score", 100)
+                    if critical > 0 or medium > 0 or low > 0:
+                        # Show issue counts when there are any issues
+                        return format_statusline_quality(critical, medium, low)
+                    elif score < 70:
+                        # Use red icon for scores below threshold (no issues but poor score)
+                        icon = "🔴"
+                        return f"{icon} {score:.0f}%"
+                    else:
+                        # Good quality, no issues
+                        return format_statusline_quality(critical, medium, low)
+        except Exception:
+            pass  # Fall back to old cache system
+
+    # Fall back to old cache system
     # Check for session edit tracker to show appropriate label
     tracker_file = Path.home() / ".claude-self-reflect" / "current_session_edits.json"
 
@@ -363,8 +409,63 @@ def get_compact_status():
             except:
                 pass
 
-    # Get quality grade - PER PROJECT cache
-    # BUG FIX: Cache must be per-project, not global!
+    # Get project-specific cache based on current directory
+    project_name = os.path.basename(os.getcwd()) if os.getcwd() else "default"
+
+    # Check project-specific realtime cache first
+    quality_dir = Path.home() / ".claude-self-reflect" / "quality_by_project"
+    realtime_cache = quality_dir / f"{project_name}.json"
+
+    # Fallback to global cache if project-specific doesn't exist
+    if not realtime_cache.exists():
+        realtime_cache = Path.home() / ".claude-self-reflect" / "realtime_quality.json"
+
+    grade_str = ""
+    quality_valid = False
+
+    if realtime_cache.exists():
+        try:
+            mtime = datetime.fromtimestamp(realtime_cache.stat().st_mtime)
+            age = datetime.now() - mtime
+            if age < timedelta(minutes=5):  # Fresh realtime data
+                with open(realtime_cache, 'r') as f:
+                    realtime_data = json.load(f)
+
+                if "session_aggregate" in realtime_data:
+                    agg = realtime_data["session_aggregate"]
+                    issues = agg.get("total_issues", {})
+                    critical = issues.get("critical", 0)
+                    medium = issues.get("medium", 0)
+                    low = issues.get("low", 0)
+                    score = agg.get("average_score", 100)
+
+                    # Get icon based on score and issues
+                    if score < 70:
+                        icon = "🔴"  # Red for below threshold
+                    else:
+                        icon = get_quality_icon(critical, medium, low)
+
+                    # Build compact display
+                    if critical > 0 or medium > 0 or low > 0:
+                        # Show issue counts when there are any issues
+                        colored_parts = []
+                        if critical > 0:
+                            colored_parts.append(f"C:{critical}")
+                        if medium > 0:
+                            colored_parts.append(f"M:{medium}")
+                        if low > 0:
+                            colored_parts.append(f"L:{low}")
+                        grade_str = f"[{icon}:{'·'.join(colored_parts)}]"
+                    elif score < 70:
+                        # Show score when below threshold but no specific issues
+                        grade_str = f"[{icon}:{score:.0f}%]"
+                    else:
+                        grade_str = f"[{icon}]"
+                    quality_valid = True
+        except:
+            pass
+
+    # Setup cache file path for fallback
     project_name = os.path.basename(os.getcwd())
     # Secure sanitization with whitelist approach
     import re
@@ -372,21 +473,23 @@ def get_compact_status():
     cache_dir = Path.home() / ".claude-self-reflect" / "quality_cache"
     cache_file = cache_dir / f"{safe_project_name}.json"
 
-    # If the exact cache file doesn't exist, try to find one that ends with this project name
-    # This handles cases like "metafora-Atlas-gold.json" for project "Atlas-gold"
-    if not cache_file.exists():
-        # Look for files ending with the project name
-        possible_files = list(cache_dir.glob(f"*-{safe_project_name}.json"))
-        if possible_files:
-            cache_file = possible_files[0]  # Use the first match
-
-    # Validate cache file path stays within cache directory
-    if cache_file.exists() and not str(cache_file.resolve()).startswith(str(cache_dir.resolve())):
-        # Security issue - return placeholder
-        grade_str = "[...]"
-    else:
-        cache_file.parent.mkdir(exist_ok=True, parents=True)
-    grade_str = ""
+    # Fall back to old cache if no realtime data
+    if not quality_valid:
+
+        # If the exact cache file doesn't exist, try to find one that ends with this project name
+        # This handles cases like "metafora-Atlas-gold.json" for project "Atlas-gold"
+        if not cache_file.exists():
+            # Look for files ending with the project name
+            possible_files = list(cache_dir.glob(f"*-{safe_project_name}.json"))
+            if possible_files:
+                cache_file = possible_files[0]  # Use the first match
+
+        # Validate cache file path stays within cache directory
+        if cache_file.exists() and not str(cache_file.resolve()).startswith(str(cache_dir.resolve())):
+            # Security issue - return placeholder
+            grade_str = "[...]"
+        else:
+            cache_file.parent.mkdir(exist_ok=True, parents=True)
 
     # Try to get quality data (regenerate if too old or missing)
     quality_valid = False

package/scripts/debug-august-parsing.py

@@ -59,7 +59,11 @@ def parse_jsonl_file(file_path):
     return messages
 
 if __name__ == "__main__":
-    file_path = "/Users/ramakrishnanannaswamy/.claude/projects/-Users-ramakrishnanannaswamy-projects-claude-self-reflect/7b3354ed-d6d2-4eab-b328-1fced4bb63bb.jsonl"
+    # Use home directory path
+    from pathlib import Path
+    home = Path.home()
+    file_path = home / ".claude" / "projects" / f"-{home}-projects-claude-self-reflect" / "7b3354ed-d6d2-4eab-b328-1fced4bb63bb.jsonl"
+    file_path = str(file_path)
     
     print(f"Parsing: {file_path}")
     print("=" * 60)

package/scripts/debug-project-resolver.py

@@ -48,9 +48,9 @@ from shared.normalization import normalize_project_name
 import hashlib
 
 test_paths = [
-    "/Users/ramakrishnanannaswamy/projects/claude-self-reflect",
-    "/Users/ramakrishnanannaswamy/projects/memento",
-    "/Users/ramakrishnanannaswamy/projects/cc-enhance"
+    str(Path.home() / "projects" / "claude-self-reflect"),
+    str(Path.home() / "projects" / "memento"),
+    str(Path.home() / "projects" / "cc-enhance")
 ]
 
 for path in test_paths: