empathy-framework 5.3.0__py3-none-any.whl → 5.4.0__py3-none-any.whl

empathy_llm_toolkit/hooks/scripts/first_time_init.py

@@ -1,285 +0,0 @@
-"""First-Time Initialization Hook
-
-Checks if Empathy Framework is initialized in the current project.
-If not, prompts user with initialization dialog.
-
-Copyright 2025 Smart-AI-Memory
-Licensed under Fair Source License 0.9
-"""
-
-import json
-import logging
-from datetime import datetime
-from pathlib import Path
-from typing import Any
-
-logger = logging.getLogger(__name__)
-
-# Default configuration template
-DEFAULT_CONFIG = """# Empathy Framework Configuration
-# Generated: {timestamp}
-
-agent:
-  name: empathy-assistant
-  model_tier: capable
-  empathy_level: 3
-
-hooks:
-  enabled: true
-  log_executions: false
-
-learning:
-  enabled: true
-  auto_evaluate: true
-  quality_threshold: good
-  max_patterns_per_session: 10
-
-context:
-  auto_compact: true
-  token_threshold: 80
-"""
-
-# Directories to create
-INIT_DIRECTORIES = [
-    ".empathy",
-    ".empathy/compact_states",
-    ".empathy/learned_skills",
-    ".empathy/sessions",
-    ".empathy/patterns",
-]
-
-
-def get_project_root(**context: Any) -> Path:
-    """Get the project root directory.
-
-    Args:
-        **context: Hook context with project_path
-
-    Returns:
-        Project root path
-    """
-    project_path = context.get("project_path")
-    if project_path:
-        return Path(project_path)
-
-    # Fall back to current working directory
-    return Path.cwd()
-
-
-def is_initialized(project_root: Path) -> bool:
-    """Check if Empathy Framework is initialized in the project.
-
-    Args:
-        project_root: Project root directory
-
-    Returns:
-        True if .empathy directory exists with config
-    """
-    empathy_dir = project_root / ".empathy"
-    config_file = project_root / "empathy.config.yaml"
-
-    return empathy_dir.exists() or config_file.exists()
-
-
-def get_never_ask_file(project_root: Path) -> Path:
-    """Get path to the 'never ask' marker file."""
-    return project_root / ".empathy_never_init"
-
-
-def should_skip_init(project_root: Path) -> bool:
-    """Check if user previously said 'never ask again'."""
-    return get_never_ask_file(project_root).exists()
-
-
-def mark_never_ask(project_root: Path) -> None:
-    """Mark project to never ask about init again."""
-    marker = get_never_ask_file(project_root)
-    marker.write_text(f"Created: {datetime.now().isoformat()}\n")
-
-
-def initialize_project(project_root: Path) -> dict[str, Any]:
-    """Initialize Empathy Framework in the project.
-
-    Args:
-        project_root: Project root directory
-
-    Returns:
-        Initialization result
-    """
-    result = {
-        "success": True,
-        "created_directories": [],
-        "created_files": [],
-        "errors": [],
-    }
-
-    # Create directories
-    for dir_path in INIT_DIRECTORIES:
-        full_path = project_root / dir_path
-        try:
-            full_path.mkdir(parents=True, exist_ok=True)
-            result["created_directories"].append(str(dir_path))
-            logger.info("Created directory: %s", dir_path)
-        except OSError as e:
-            result["errors"].append(f"Failed to create {dir_path}: {e}")
-            logger.error("Failed to create directory %s: %s", dir_path, e)
-
-    # Create config file
-    config_path = project_root / "empathy.config.yaml"
-    if not config_path.exists():
-        try:
-            config_content = DEFAULT_CONFIG.format(timestamp=datetime.now().isoformat())
-            config_path.write_text(config_content)
-            result["created_files"].append("empathy.config.yaml")
-            logger.info("Created config file: empathy.config.yaml")
-        except OSError as e:
-            result["errors"].append(f"Failed to create config: {e}")
-            logger.error("Failed to create config file: %s", e)
-
-    # Create .gitignore entries file
-    gitignore_additions = project_root / ".empathy" / ".gitignore_additions"
-    try:
-        gitignore_content = """# Add these to your .gitignore:
-.empathy/compact_states/
-.empathy/sessions/
-.empathy/learned_skills/
-"""
-        gitignore_additions.write_text(gitignore_content)
-        result["created_files"].append(".empathy/.gitignore_additions")
-    except OSError:
-        pass  # Non-critical
-
-    if result["errors"]:
-        result["success"] = False
-
-    return result
-
-
-def check_init(**context: Any) -> dict[str, Any]:
-    """Check if initialization is needed and return appropriate response.
-
-    This is called on SessionStart to check if the project needs initialization.
-
-    Args:
-        **context: Hook context
-
-    Returns:
-        Dict with initialization status and prompt if needed
-    """
-    project_root = get_project_root(**context)
-
-    result = {
-        "checked": True,
-        "project_root": str(project_root),
-        "timestamp": datetime.now().isoformat(),
-        "needs_init": False,
-        "prompt_user": False,
-        "already_initialized": False,
-        "skipped": False,
-    }
-
-    # Check if already initialized
-    if is_initialized(project_root):
-        result["already_initialized"] = True
-        logger.debug("Project already initialized: %s", project_root)
-        return result
-
-    # Check if user said "never ask"
-    if should_skip_init(project_root):
-        result["skipped"] = True
-        logger.debug("Skipping init prompt (user preference): %s", project_root)
-        return result
-
-    # Need to prompt user
-    result["needs_init"] = True
-    result["prompt_user"] = True
-    result["prompt"] = {
-        "header": "Setup",
-        "question": "Welcome! Set up Empathy Framework for this project?",
-        "options": [
-            {
-                "label": "Yes, initialize now",
-                "description": "Create .empathy/ folder and default config",
-                "action": "init",
-            },
-            {
-                "label": "Not now",
-                "description": "Ask me again next session",
-                "action": "skip_once",
-            },
-            {
-                "label": "Never for this project",
-                "description": "Don't ask again for this project",
-                "action": "never",
-            },
-        ],
-    }
-
-    logger.info("Project needs initialization: %s", project_root)
-    return result
-
-
-def handle_init_response(action: str, **context: Any) -> dict[str, Any]:
-    """Handle user's response to the initialization prompt.
-
-    Args:
-        action: User's selected action (init, skip_once, never)
-        **context: Hook context
-
-    Returns:
-        Result of the action
-    """
-    project_root = get_project_root(**context)
-
-    if action == "init":
-        result = initialize_project(project_root)
-        if result["success"]:
-            result["message"] = "Empathy Framework initialized successfully!"
-        else:
-            result["message"] = "Initialization completed with errors."
-        return result
-
-    elif action == "never":
-        mark_never_ask(project_root)
-        return {
-            "success": True,
-            "action": "never",
-            "message": "Got it! Won't ask again for this project.",
-        }
-
-    else:  # skip_once
-        return {
-            "success": True,
-            "action": "skip_once",
-            "message": "No problem! I'll ask again next time.",
-        }
-
-
-def main(**context: Any) -> dict[str, Any]:
-    """Main hook entry point.
-
-    Called on SessionStart to check if initialization is needed.
-
-    Args:
-        **context: Hook context
-
-    Returns:
-        Initialization check result
-    """
-    return check_init(**context)
-
-
-if __name__ == "__main__":
-    # Allow running as a script for testing
-    import sys
-
-    logging.basicConfig(level=logging.INFO, format="%(message)s")
-
-    if len(sys.argv) > 1 and sys.argv[1] == "--init":
-        # Test initialization
-        result = initialize_project(Path.cwd())
-    else:
-        # Test check
-        result = main(project_path=str(Path.cwd()))
-
-    print(json.dumps(result, indent=2))

empathy_llm_toolkit/hooks/scripts/pre_compact.py

@@ -1,207 +0,0 @@
-"""Pre-Compact Hook Script
-
-Saves collaboration state before context compaction occurs.
-Ensures trust levels, patterns, and handoffs are preserved.
-
-Architectural patterns inspired by everything-claude-code by Affaan Mustafa.
-See: https://github.com/affaan-m/everything-claude-code (MIT License)
-See: ACKNOWLEDGMENTS.md for full attribution.
-
-Copyright 2025 Smart AI Memory, LLC
-Licensed under Fair Source 0.9
-"""
-
-from __future__ import annotations
-
-import logging
-from datetime import datetime
-from typing import Any
-
-logger = logging.getLogger(__name__)
-
-
-def run_pre_compact(context: dict[str, Any]) -> dict[str, Any]:
-    """Execute pre-compaction state preservation.
-
-    This hook is called before context compaction to save
-    the current collaboration state for restoration after
-    the context window resets.
-
-    Args:
-        context: Hook context containing:
-            - collaboration_state: Current CollaborationState
-            - context_manager: ContextManager instance
-            - session_id: Current session identifier
-            - current_phase: Current work phase (if any)
-            - pending_work: Description of pending work (if any)
-
-    Returns:
-        Dict with:
-            - state_saved: Whether state was successfully saved
-            - saved_path: Path to saved state file
-            - trust_level: Trust level that was preserved
-            - patterns_count: Number of patterns preserved
-            - has_handoff: Whether a handoff was saved
-            - restoration_available: Whether restoration will be available
-            - message: Human-readable summary
-    """
-    try:
-        # Get required components from context
-        collaboration_state = context.get("collaboration_state")
-        context_manager = context.get("context_manager")
-
-        if not collaboration_state:
-            logger.warning("Pre-compact: No collaboration state provided")
-            return {
-                "state_saved": False,
-                "saved_path": None,
-                "trust_level": None,
-                "patterns_count": 0,
-                "has_handoff": False,
-                "restoration_available": False,
-                "message": "No collaboration state available to save",
-            }
-
-        # Initialize context manager if not provided
-        if not context_manager:
-            from empathy_llm_toolkit.context import ContextManager
-
-            context_manager = ContextManager()
-
-        # Set session tracking if provided
-        if session_id := context.get("session_id"):
-            context_manager.session_id = session_id
-
-        if current_phase := context.get("current_phase"):
-            context_manager.current_phase = current_phase
-
-        # Create SBAR handoff for pending work if provided
-        pending_work = context.get("pending_work")
-        if pending_work:
-            context_manager.set_handoff(
-                situation=pending_work.get("situation", "Context compaction in progress"),
-                background=pending_work.get("background", "Session state being preserved"),
-                assessment=pending_work.get("assessment", "Work can continue after restoration"),
-                recommendation=pending_work.get("recommendation", "Restore state and continue"),
-                priority=pending_work.get("priority", "normal"),
-            )
-
-        # Save the state
-        saved_path = context_manager.save_for_compaction(collaboration_state)
-
-        # Extract the compact state for reporting
-        compact_state = context_manager.extract_compact_state(collaboration_state)
-
-        # Build success message
-        patterns_count = len(compact_state.detected_patterns)
-        message_parts = [
-            "State preserved successfully.",
-            f"Trust level: {compact_state.trust_level:.2f}",
-            f"Empathy level: {compact_state.empathy_level}",
-        ]
-
-        if patterns_count > 0:
-            message_parts.append(f"Patterns preserved: {patterns_count}")
-
-        if compact_state.pending_handoff:
-            message_parts.append(
-                f"Handoff recorded ({compact_state.pending_handoff.priority} priority)"
-            )
-
-        logger.info(f"Pre-compact: Saved state to {saved_path}")
-
-        return {
-            "state_saved": True,
-            "saved_path": str(saved_path),
-            "trust_level": compact_state.trust_level,
-            "empathy_level": compact_state.empathy_level,
-            "patterns_count": patterns_count,
-            "has_handoff": compact_state.pending_handoff is not None,
-            "restoration_available": True,
-            "saved_at": datetime.now().isoformat(),
-            "message": " | ".join(message_parts),
-        }
-
-    except Exception as e:
-        logger.exception(f"Pre-compact hook failed: {e}")
-        return {
-            "state_saved": False,
-            "saved_path": None,
-            "trust_level": None,
-            "patterns_count": 0,
-            "has_handoff": False,
-            "restoration_available": False,
-            "error": str(e),
-            "message": f"Failed to save state: {e}",
-        }
-
-
-def generate_compaction_summary(
-    collaboration_state: Any,
-    include_patterns: bool = True,
-    include_history: bool = False,
-) -> str:
-    """Generate a summary suitable for including in compacted context.
-
-    This can be used to create a brief summary that gets included
-    in the compacted context window.
-
-    Args:
-        collaboration_state: Current CollaborationState
-        include_patterns: Whether to include pattern summaries
-        include_history: Whether to include recent interaction summary
-
-    Returns:
-        Formatted summary string
-    """
-    lines = [
-        "## Session Context Summary",
-        "",
-        f"**User**: {collaboration_state.user_id}",
-        f"**Trust**: {collaboration_state.trust_level:.2f}",
-        f"**Empathy Level**: {collaboration_state.current_level}",
-        f"**Interactions**: {len(collaboration_state.interactions)}",
-        "",
-    ]
-
-    if include_patterns and collaboration_state.detected_patterns:
-        lines.append("### Known Patterns")
-        for pattern in collaboration_state.detected_patterns[:5]:
-            confidence_pct = int(pattern.confidence * 100)
-            lines.append(f"- {pattern.trigger} → {pattern.action} ({confidence_pct}%)")
-        lines.append("")
-
-    if include_history and collaboration_state.interactions:
-        lines.append("### Recent Context")
-        # Get last few exchanges
-        recent = collaboration_state.interactions[-6:]
-        for interaction in recent:
-            role = interaction.role.capitalize()
-            content = interaction.content[:100]
-            if len(interaction.content) > 100:
-                content += "..."
-            lines.append(f"- **{role}**: {content}")
-        lines.append("")
-
-    # Add preferences summary
-    if collaboration_state.preferences:
-        lines.append("### Preferences")
-        for key, value in list(collaboration_state.preferences.items())[:5]:
-            lines.append(f"- **{key}**: {value}")
-        lines.append("")
-
-    return "\n".join(lines)
-
-
-# Main entry point for hook execution
-if __name__ == "__main__":
-    # Example usage for testing
-    print("Pre-compact hook script")
-    print("This script is called before context compaction")
-    print()
-    print("Required context keys:")
-    print("  - collaboration_state: CollaborationState object")
-    print("  - context_manager: ContextManager instance (optional)")
-    print("  - session_id: Current session ID (optional)")
-    print("  - current_phase: Current work phase (optional)")
-    print("  - pending_work: Dict with SBAR fields (optional)")

empathy_llm_toolkit/hooks/scripts/session_end.py

@@ -1,183 +0,0 @@
-"""Session End Hook
-
-Persists session state and triggers pattern evaluation.
-Ported from everything-claude-code/scripts/hooks/session-end.js
-
-Copyright 2025 Smart-AI-Memory
-Licensed under Fair Source License 0.9
-"""
-
-import json
-import logging
-from datetime import datetime
-from pathlib import Path
-from typing import Any
-
-logger = logging.getLogger(__name__)
-
-
-def get_sessions_dir() -> Path:
-    """Get the sessions directory path."""
-    return Path.home() / ".empathy" / "sessions"
-
-
-def save_session_state(
-    session_id: str,
-    state: dict[str, Any],
-) -> Path:
-    """Save session state to a file.
-
-    Args:
-        session_id: Unique session identifier
-        state: Session state to save
-
-    Returns:
-        Path to saved file
-
-    """
-    sessions_dir = get_sessions_dir()
-    sessions_dir.mkdir(parents=True, exist_ok=True)
-
-    # Create filename with timestamp
-    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-    filename = f"session_{session_id}_{timestamp}.json"
-    file_path = sessions_dir / filename
-
-    # Add metadata
-    state_with_meta = {
-        **state,
-        "saved_at": datetime.now().isoformat(),
-        "session_id": session_id,
-    }
-
-    with open(file_path, "w") as f:
-        json.dump(state_with_meta, f, indent=2, default=str)
-
-    logger.info("Saved session state to %s", file_path)
-    return file_path
-
-
-def cleanup_old_sessions(max_sessions: int = 50) -> int:
-    """Remove old session files beyond max_sessions.
-
-    Args:
-        max_sessions: Maximum number of session files to keep
-
-    Returns:
-        Number of files removed
-
-    """
-    sessions_dir = get_sessions_dir()
-
-    if not sessions_dir.exists():
-        return 0
-
-    session_files = sorted(
-        sessions_dir.glob("session_*.json"),
-        key=lambda p: p.stat().st_mtime,
-        reverse=True,
-    )
-
-    removed = 0
-    for old_file in session_files[max_sessions:]:
-        try:
-            old_file.unlink()
-            removed += 1
-            logger.debug("Removed old session file: %s", old_file)
-        except OSError as e:
-            logger.warning("Failed to remove %s: %s", old_file, e)
-
-    return removed
-
-
-def main(**context: Any) -> dict[str, Any]:
-    """Session end hook main function.
-
-    Persists:
-    - Trust level and collaboration state
-    - Detected patterns and preferences
-    - Interaction statistics
-
-    Args:
-        **context: Hook context with session state
-
-    Returns:
-        Session end summary
-
-    """
-    session_id = context.get("session_id", datetime.now().strftime("%Y%m%d%H%M%S"))
-
-    # Extract state to persist
-    state_to_save = {
-        "trust_level": context.get("trust_level", 0.5),
-        "empathy_level": context.get("empathy_level", 4),
-        "interaction_count": context.get("interaction_count", 0),
-        "detected_patterns": context.get("detected_patterns", []),
-        "user_preferences": context.get("user_preferences", {}),
-        "completed_phases": context.get("completed_phases", []),
-        "pending_handoff": context.get("pending_handoff"),
-        "metrics": {
-            "success_rate": context.get("success_rate", 0),
-            "total_tokens": context.get("total_tokens", 0),
-            "total_cost": context.get("total_cost", 0),
-        },
-    }
-
-    result = {
-        "session_id": session_id,
-        "timestamp": datetime.now().isoformat(),
-        "state_saved": False,
-        "file_path": None,
-        "old_sessions_removed": 0,
-        "evaluate_for_learning": False,
-        "messages": [],
-    }
-
-    try:
-        # Save session state
-        file_path = save_session_state(session_id, state_to_save)
-        result["state_saved"] = True
-        result["file_path"] = str(file_path)
-        result["messages"].append(f"[SessionEnd] State saved to {file_path.name}")
-
-        # Cleanup old sessions
-        removed = cleanup_old_sessions()
-        result["old_sessions_removed"] = removed
-        if removed > 0:
-            result["messages"].append(f"[SessionEnd] Removed {removed} old session file(s)")
-
-        # Check if session should be evaluated for learning
-        min_interactions = context.get("min_learning_interactions", 10)
-        if state_to_save["interaction_count"] >= min_interactions:
-            result["evaluate_for_learning"] = True
-            result["messages"].append(
-                f"[SessionEnd] Session has {state_to_save['interaction_count']} "
-                f"interactions - evaluate for pattern extraction"
-            )
-
-    except Exception as e:
-        logger.error("Failed to save session state: %s", e)
-        result["messages"].append(f"[SessionEnd] Error: {e}")
-
-    # Log messages
-    for msg in result["messages"]:
-        logger.info(msg)
-
-    return result
-
-
-if __name__ == "__main__":
-    # Allow running as a script for testing
-
-    logging.basicConfig(level=logging.INFO, format="%(message)s")
-
-    # Simulate some context
-    test_context = {
-        "session_id": "test_session",
-        "trust_level": 0.75,
-        "interaction_count": 15,
-        "detected_patterns": [{"type": "preference", "value": "concise responses"}],
-    }
-
-    result = main(**test_context)
-    print(json.dumps(result, indent=2))