claude-self-reflect 6.0.5 → 7.1.8

package/src/runtime/hooks/session_start_hook.py

@@ -0,0 +1,259 @@
+#!/usr/bin/env python3
+"""
+Ralph SessionStart Hook - Searches CSR for relevant past sessions.
+
+Triggered at session start. Uses existing CSR infrastructure to search
+for relevant past Ralph sessions and injects context.
+
+Enhanced Features (v7.1+):
+- Error-centric search (find solutions to current blockers)
+- Anti-pattern injection (surface failed approaches first)
+- Winning strategy prioritization
+- Multi-signal search (task + errors + patterns)
+
+Input (stdin): JSON with session_id, transcript_path, source
+Output (stdout): Context message for Claude
+Exit code: 0 = success, 2 = blocking error
+
+Attribution:
+    Search patterns inspired by https://github.com/frankbria/ralph-claude-code
+"""
+
+import sys
+import json
+import logging
+from pathlib import Path
+from datetime import datetime
+
+# Add project root to path
+sys.path.insert(0, str(Path(__file__).parent.parent.parent.parent))
+
+from src.runtime.hooks.ralph_state import (
+    load_state,
+    save_state,
+    RalphState,
+    is_ralph_session,
+    load_ralph_session_state,
+)
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+def get_project_root() -> Path:
+    """Dynamically determine project root (works for any installation)."""
+    # This file is at: <project_root>/src/runtime/hooks/session_start_hook.py
+    return Path(__file__).parent.parent.parent.parent
+
+
+def _error_signature(error: str) -> str:
+    """Extract error signature for deduplication (matches RalphState method)."""
+    import re
+    sig = re.sub(r'line \d+', 'line N', error)
+    sig = re.sub(r'/[\w/.-]+/', '/.../', sig)
+    sig = re.sub(r'\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}', 'TIMESTAMP', sig)
+    return sig[:100]
+
+
+def search_past_sessions(task: str, errors: list = None, limit: int = 3) -> dict:
+    """Enhanced search: task + errors + anti-patterns."""
+    results = {
+        'similar_tasks': [],
+        'similar_errors': [],
+        'anti_patterns': [],
+        'winning_strategies': []
+    }
+
+    try:
+        # Import CSR standalone client (dynamic path for any installation)
+        project_root = get_project_root()
+        mcp_server_path = project_root / "mcp-server" / "src"
+        if str(mcp_server_path) not in sys.path:
+            sys.path.insert(0, str(mcp_server_path))
+        from standalone_client import CSRStandaloneClient
+        client = CSRStandaloneClient()
+
+        # 1. Task-based search (existing behavior)
+        task_results = client.search(
+            query=f"ralph session: {task}",
+            limit=2,
+            min_score=0.5
+        )
+        results['similar_tasks'] = task_results
+
+        # 2. NEW: Error-based search (if we have current errors)
+        if errors:
+            for error in errors[:2]:  # Top 2 errors only
+                sig = _error_signature(error)
+                error_results = client.search(
+                    query=f"error blocked solved: {sig}",
+                    limit=1,
+                    min_score=0.6
+                )
+                results['similar_errors'].extend(error_results)
+
+        # 3. NEW: Anti-patterns search (failed approaches from incomplete sessions)
+        anti_results = client.search(
+            query=f"failed approach don't retry: {task}",
+            limit=2,
+            min_score=0.5
+        )
+        # Filter for incomplete/abandoned sessions
+        results['anti_patterns'] = [
+            r for r in anti_results
+            if r.get('metadata', {}).get('outcome') in ('INCOMPLETE', 'ABANDONED')
+        ]
+
+        # 4. NEW: Winning strategies (successful sessions)
+        winners = client.search(
+            query=f"successful solution completed: {task}",
+            limit=1,
+            min_score=0.6
+        )
+        results['winning_strategies'] = [
+            r for r in winners
+            if r.get('metadata', {}).get('outcome') == 'COMPLETED'
+        ]
+
+        return results
+
+    except ImportError:
+        logger.warning("CSR standalone client not available, skipping memory search")
+        return results
+    except Exception as e:
+        logger.error(f"Error searching CSR: {e}")
+        return results
+
+
+def format_past_sessions(results: dict) -> str:
+    """Format search results with anti-patterns FIRST for fast loop efficiency."""
+    # Handle legacy list format
+    if isinstance(results, list):
+        results = {'similar_tasks': results}
+
+    has_content = any([
+        results.get('anti_patterns'),
+        results.get('winning_strategies'),
+        results.get('similar_errors'),
+        results.get('similar_tasks')
+    ])
+
+    if not has_content:
+        return ""
+
+    output = ["# Ralph Memory (from CSR)\n"]
+    output.append("Use these insights to avoid repeating mistakes.\n")
+
+    # 1. ANTI-PATTERNS FIRST (most important for fast loops)
+    if results.get('anti_patterns'):
+        output.append("## DON'T RETRY THESE")
+        for r in results['anti_patterns']:
+            # Extract failed approaches from metadata
+            failed = r.get('metadata', {}).get('failed_approaches', [])
+            if failed:
+                for f in failed[:3]:
+                    output.append(f"- {f}")
+            else:
+                # Fallback to content preview
+                content = r.get('content', r.get('preview', ''))[:150]
+                output.append(f"- {content}...")
+
+    # 2. WINNING STRATEGIES (proven approaches)
+    if results.get('winning_strategies'):
+        output.append("\n## PROVEN APPROACHES")
+        for r in results['winning_strategies']:
+            strategies = r.get('metadata', {}).get('successful_strategies', [])
+            if strategies:
+                for s in strategies[:3]:
+                    output.append(f"- {s}")
+            else:
+                content = r.get('content', r.get('preview', ''))[:150]
+                output.append(f"- {content}...")
+
+    # 3. PAST ERROR SOLUTIONS
+    if results.get('similar_errors'):
+        output.append("\n## PAST ERROR SOLUTIONS")
+        for r in results['similar_errors']:
+            score = r.get('score', 0)
+            content = r.get('content', r.get('preview', ''))[:200]
+            output.append(f"- (score: {score:.2f}) {content}...")
+
+    # 4. SIMILAR TASKS (context, less actionable)
+    if results.get('similar_tasks'):
+        output.append("\n## RELATED SESSIONS")
+        for i, r in enumerate(results['similar_tasks'][:2], 1):
+            score = r.get('score', 0)
+            outcome = r.get('metadata', {}).get('outcome', 'Unknown')
+            content = r.get('content', r.get('preview', ''))[:150]
+            output.append(f"- [{outcome}] (score: {score:.2f}) {content}...")
+
+            # Extract key learnings
+            if learnings := r.get('metadata', {}).get('learnings'):
+                for learning in learnings[:2]:
+                    output.append(f"  - Learning: {learning}")
+
+    return "\n".join(output)
+
+
+def main():
+    """Main hook entry point."""
+    # Read hook input from stdin (official protocol)
+    try:
+        input_data = json.load(sys.stdin)
+    except (json.JSONDecodeError, EOFError):
+        input_data = {}
+
+    session_id = input_data.get('session_id', '')
+    source = input_data.get('source', 'startup')
+
+    logger.info(f"SessionStart hook triggered: source={source}, session_id={session_id[:20] if session_id else 'none'}...")
+
+    # Check if this is a Ralph session
+    if not is_ralph_session():
+        logger.info("No Ralph session detected (checked .claude/ralph-loop.local.md and .ralph_state.md)")
+        sys.exit(0)
+
+    # Load current state (supports both ralph-wiggum and custom formats)
+    state = load_ralph_session_state()
+    if not state:
+        logger.warning("Could not load Ralph state")
+        sys.exit(0)
+
+    # Search for past sessions with similar task AND current errors
+    logger.info(f"Searching CSR for past sessions related to: {state.task[:50]}...")
+    results = search_past_sessions(
+        task=state.task,
+        errors=state.blocking_errors if hasattr(state, 'blocking_errors') else None
+    )
+
+    # Count total results
+    total_results = sum([
+        len(results.get('similar_tasks', [])),
+        len(results.get('similar_errors', [])),
+        len(results.get('anti_patterns', [])),
+        len(results.get('winning_strategies', []))
+    ])
+
+    if total_results > 0:
+        # Write context file for Claude to read
+        context = format_past_sessions(results)
+        past_sessions_path = Path('.ralph_past_sessions.md')
+        past_sessions_path.write_text(context)
+
+        # Log breakdown
+        logger.info(f"Found {total_results} relevant results:")
+        logger.info(f"  - Anti-patterns: {len(results.get('anti_patterns', []))}")
+        logger.info(f"  - Winning strategies: {len(results.get('winning_strategies', []))}")
+        logger.info(f"  - Error matches: {len(results.get('similar_errors', []))}")
+        logger.info(f"  - Similar tasks: {len(results.get('similar_tasks', []))}")
+
+        print(f"# Loaded {total_results} relevant past sessions")
+        print(f"# See .ralph_past_sessions.md for details")
+    else:
+        logger.info("No relevant past sessions found")
+
+    sys.exit(0)
+
+
+if __name__ == '__main__':
+    main()

package/src/runtime/precompact-hook.sh

@@ -2,9 +2,21 @@
 # PreCompact hook for Claude Self-Reflect
 # Place this in ~/.claude/hooks/precompact or source it from there
 
-# Configuration
-CLAUDE_REFLECT_DIR="${CLAUDE_REFLECT_DIR:-$HOME/claude-self-reflect}"
-VENV_PATH="${VENV_PATH:-$CLAUDE_REFLECT_DIR/.venv}"
+# Determine project root dynamically from this script's location
+# This file is at: <project_root>/src/runtime/precompact-hook.sh
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+DEFAULT_PROJECT_ROOT="$(cd "$SCRIPT_DIR/../.." && pwd)"
+
+# Configuration (allows override via environment)
+CLAUDE_REFLECT_DIR="${CLAUDE_REFLECT_DIR:-$DEFAULT_PROJECT_ROOT}"
+# Support both .venv and venv directories
+if [ -d "$CLAUDE_REFLECT_DIR/.venv" ]; then
+    VENV_PATH="${VENV_PATH:-$CLAUDE_REFLECT_DIR/.venv}"
+elif [ -d "$CLAUDE_REFLECT_DIR/venv" ]; then
+    VENV_PATH="${VENV_PATH:-$CLAUDE_REFLECT_DIR/venv}"
+else
+    VENV_PATH="${VENV_PATH:-$CLAUDE_REFLECT_DIR/.venv}"
+fi
 IMPORT_TIMEOUT="${IMPORT_TIMEOUT:-30}"
 
 # Check if Claude Self-Reflect is installed
@@ -29,5 +41,50 @@ timeout $IMPORT_TIMEOUT bash -c "
     echo "Quick import timed out after ${IMPORT_TIMEOUT}s" >&2
 }
 
+# ============================================================
+# RALPH MEMORY INTEGRATION (Added for Memory-Augmented Ralph)
+# ============================================================
+
+# If Ralph session, backup state to CSR before compaction
+# Check both ralph-wiggum format and custom format
+RALPH_STATE_FILE=""
+if [ -f ".claude/ralph-loop.local.md" ]; then
+    RALPH_STATE_FILE=".claude/ralph-loop.local.md"
+elif [ -f ".ralph_state.md" ]; then
+    RALPH_STATE_FILE=".ralph_state.md"
+fi
+
+if [ -n "$RALPH_STATE_FILE" ]; then
+    echo "📝 Backing up Ralph state to CSR..." >&2
+
+    RALPH_STATE_FILE="$RALPH_STATE_FILE" CLAUDE_REFLECT_DIR="$CLAUDE_REFLECT_DIR" python3 << 'PYTHON' 2>/dev/null || echo "Warning: Could not backup Ralph state" >&2
+import sys
+import os
+from pathlib import Path
+from datetime import datetime
+
+# Dynamic path resolution
+project_root = os.environ.get('CLAUDE_REFLECT_DIR', str(Path.home() / 'claude-self-reflect'))
+sys.path.insert(0, str(Path(project_root) / 'mcp-server' / 'src'))
+
+try:
+    from standalone_client import CSRStandaloneClient
+
+    ralph_state_file = os.environ.get('RALPH_STATE_FILE', '.ralph_state.md')
+    state_content = Path(ralph_state_file).read_text()
+    client = CSRStandaloneClient()
+
+    client.store_reflection(
+        content=f"Pre-compaction Ralph state backup ({datetime.now().isoformat()}):\n\n{state_content}",
+        tags=["ralph_state", "pre_compact_backup"]
+    )
+    print("✅ Ralph state backed up to CSR", file=sys.stderr)
+except ImportError:
+    print("CSR client not available, skipping backup", file=sys.stderr)
+except Exception as e:
+    print(f"Backup failed: {e}", file=sys.stderr)
+PYTHON
+fi
+
 # Always exit successfully to not block compacting
 exit 0

package/src/runtime/qdrant_connection.py

@@ -0,0 +1,73 @@
+"""
+Qdrant connection utilities with retry logic.
+"""
+
+import time
+import logging
+from typing import Optional
+from qdrant_client import QdrantClient
+
+logger = logging.getLogger(__name__)
+
+
+def connect_to_qdrant_with_retry(
+    url: str,
+    api_key: Optional[str] = None,
+    max_retries: int = 5,
+    initial_delay: float = 1.0
+) -> QdrantClient:
+    """
+    Connect to Qdrant with exponential backoff retry logic.
+
+    Args:
+        url: Qdrant URL
+        api_key: Optional API key for authentication
+        max_retries: Maximum number of retry attempts (default: 5)
+        initial_delay: Initial delay in seconds, doubles each retry (default: 1.0)
+
+    Returns:
+        Connected QdrantClient instance
+
+    Raises:
+        Exception: If all retries fail
+
+    Example:
+        >>> client = connect_to_qdrant_with_retry(
+        ...     url="http://localhost:6333",
+        ...     api_key="optional-api-key"
+        ... )
+        ✅ Connected to Qdrant at http://localhost:6333
+    """
+    delay = initial_delay
+
+    for attempt in range(max_retries):
+        try:
+            # Initialize client
+            if api_key:
+                client = QdrantClient(url=url, api_key=api_key)
+            else:
+                client = QdrantClient(url=url)
+
+            # Test connection by fetching collections
+            client.get_collections()
+
+        except Exception as e:
+            if attempt < max_retries - 1:
+                logger.warning(
+                    f"⚠️  Qdrant connection attempt {attempt + 1}/{max_retries} failed: {e}"
+                )
+                logger.info(f"   Retrying in {delay}s...")
+                time.sleep(delay)
+                delay *= 2  # Exponential backoff
+            else:
+                logger.exception(
+                    f"Failed to connect to Qdrant after {max_retries} attempts"
+                )
+                raise
+        else:
+            # Connection successful
+            logger.info(f"✅ Connected to Qdrant at {url}")
+            return client
+
+    # Should never reach here due to raise in except block
+    raise Exception(f"Failed to connect to Qdrant at {url} after {max_retries} attempts")

package/src/runtime/unified_state_manager.py

@@ -336,6 +336,10 @@ class UnifiedStateManager:
         except Exception as e:
             raise ValueError(f"Invalid path: {file_path}: {e}")
 
+        # Detect if running in Docker by checking for Docker-mounted paths
+        docker_paths = ["/logs", "/config", "/app/data"]
+        in_docker = any(Path(dp).exists() for dp in docker_paths)
+
         # Docker to local path mappings
         path_mappings = [
             ("/logs/", "/.claude/projects/"),
@@ -343,8 +347,15 @@ class UnifiedStateManager:
             ("/app/data/", "/.claude/projects/")
         ]
 
-        # Apply Docker mappings if needed
+        # In Docker: validate against Docker paths BEFORE transformation
+        # This ensures security validation uses paths that actually exist
         path_str = str(resolved)
+        original_path_str = path_str  # Keep original for Docker validation
+
+        # Check if this is a Docker path that we should validate directly
+        is_docker_path = in_docker and any(path_str.startswith(dp) for dp in docker_paths)
+
+        # Apply Docker mappings for storage consistency (not for validation)
         for docker_path, local_path in path_mappings:
             if path_str.startswith(docker_path):
                 home = str(Path.home())
@@ -359,21 +370,35 @@ class UnifiedStateManager:
         ]
 
         # Add Docker paths if they exist
-        for docker_path in ["/logs", "/config", "/app/data"]:
+        for docker_path in docker_paths:
             docker_base = Path(docker_path)
             if docker_base.exists():
                 allowed_bases.append(docker_base)
 
         # Check if path is within allowed directories
         path_allowed = False
-        for base in allowed_bases:
-            try:
-                if base.exists():
-                    resolved.relative_to(base)
-                    path_allowed = True
-                    break
-            except ValueError:
-                continue
+
+        # In Docker: validate original path against Docker mounts
+        if is_docker_path:
+            original_resolved = Path(original_path_str).resolve()
+            for base in allowed_bases:
+                try:
+                    if base.exists():
+                        original_resolved.relative_to(base)
+                        path_allowed = True
+                        break
+                except ValueError:
+                    continue
+        else:
+            # Local environment: validate transformed path
+            for base in allowed_bases:
+                try:
+                    if base.exists():
+                        resolved.relative_to(base)
+                        path_allowed = True
+                        break
+                except ValueError:
+                    continue
 
         # Allow test paths when running tests
         if not path_allowed: