empathy-framework 4.6.6__py3-none-any.whl → 4.7.1__py3-none-any.whl

empathy_llm_toolkit/hooks/scripts/session_start.py

@@ -0,0 +1,163 @@
+"""Session Start Hook
+
+Loads previous context and patterns on new session start.
+Ported from everything-claude-code/scripts/hooks/session-start.js
+
+Copyright 2025 Smart-AI-Memory
+Licensed under Fair Source License 0.9
+"""
+
+import json
+import logging
+from datetime import datetime, timedelta
+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 get_patterns_dir() -> Path:
+    """Get the patterns directory path."""
+    return Path.home() / ".empathy" / "patterns"
+
+
+def get_learned_skills_dir() -> Path:
+    """Get the learned skills directory path."""
+    return Path.home() / ".empathy" / "skills" / "learned"
+
+
+def find_recent_files(
+    directory: Path,
+    pattern: str = "*.json",
+    max_age_days: int = 7,
+) -> list[Path]:
+    """Find files matching pattern modified within max_age_days.
+
+    Args:
+        directory: Directory to search
+        pattern: Glob pattern for files
+        max_age_days: Maximum file age in days
+
+    Returns:
+        List of matching file paths, sorted by modification time (newest first)
+
+    """
+    if not directory.exists():
+        return []
+
+    cutoff = datetime.now() - timedelta(days=max_age_days)
+    matching = []
+
+    for file_path in directory.glob(pattern):
+        if file_path.is_file():
+            mtime = datetime.fromtimestamp(file_path.stat().st_mtime)
+            if mtime >= cutoff:
+                matching.append((file_path, mtime))
+
+    # Sort by modification time, newest first
+    matching.sort(key=lambda x: x[1], reverse=True)
+    return [path for path, _ in matching]
+
+
+def load_session_state(session_file: Path) -> dict[str, Any] | None:
+    """Load session state from a file.
+
+    Args:
+        session_file: Path to session state file
+
+    Returns:
+        Session state dict or None if failed
+
+    """
+    try:
+        with open(session_file) as f:
+            return json.load(f)
+    except (json.JSONDecodeError, OSError) as e:
+        logger.warning("Failed to load session state from %s: %s", session_file, e)
+        return None
+
+
+def main(**context: Any) -> dict[str, Any]:
+    """Session start hook main function.
+
+    Loads:
+    - Previous session state (trust level, patterns, preferences)
+    - Learned skills from previous sessions
+    - Project-specific patterns
+
+    Args:
+        **context: Hook context (session_id, project_path, etc.)
+
+    Returns:
+        Session initialization data
+
+    """
+    sessions_dir = get_sessions_dir()
+    patterns_dir = get_patterns_dir()
+    learned_dir = get_learned_skills_dir()
+
+    # Ensure directories exist
+    sessions_dir.mkdir(parents=True, exist_ok=True)
+    patterns_dir.mkdir(parents=True, exist_ok=True)
+    learned_dir.mkdir(parents=True, exist_ok=True)
+
+    result = {
+        "initialized": True,
+        "timestamp": datetime.now().isoformat(),
+        "loaded_state": None,
+        "learned_skills_count": 0,
+        "patterns_count": 0,
+        "messages": [],
+    }
+
+    # Find and load recent session state
+    recent_sessions = find_recent_files(sessions_dir, "*.json", max_age_days=7)
+
+    if recent_sessions:
+        latest = recent_sessions[0]
+        state = load_session_state(latest)
+
+        if state:
+            result["loaded_state"] = {
+                "file": str(latest),
+                "trust_level": state.get("trust_level"),
+                "interaction_count": state.get("interaction_count", 0),
+                "patterns_detected": len(state.get("detected_patterns", [])),
+            }
+            result["messages"].append(f"[SessionStart] Restored state from {latest.name}")
+            logger.info("Loaded session state from %s", latest)
+
+    # Count learned skills
+    learned_skills = list(learned_dir.glob("*.md"))
+    result["learned_skills_count"] = len(learned_skills)
+
+    if learned_skills:
+        result["messages"].append(
+            f"[SessionStart] {len(learned_skills)} learned skill(s) available"
+        )
+
+    # Count patterns
+    pattern_files = list(patterns_dir.glob("*.json"))
+    result["patterns_count"] = len(pattern_files)
+
+    if pattern_files:
+        result["messages"].append(f"[SessionStart] {len(pattern_files)} pattern file(s) loaded")
+
+    # Log summary
+    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")
+    result = main()
+    print(json.dumps(result, indent=2))

empathy_llm_toolkit/hooks/scripts/suggest_compact.py

@@ -0,0 +1,225 @@
+"""Suggest Compact Hook
+
+Suggests strategic compaction at logical breakpoints to manage context window.
+Ported from everything-claude-code/scripts/hooks/suggest-compact.js
+
+Copyright 2025 Smart-AI-Memory
+Licensed under Fair Source License 0.9
+"""
+
+import json
+import logging
+import os
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+# Configuration
+DEFAULT_COMPACT_THRESHOLD = 50  # Tool calls before first suggestion
+DEFAULT_REMINDER_INTERVAL = 25  # Interval between reminders
+
+
+def get_compaction_state_file() -> Path:
+    """Get the compaction state file path."""
+    return Path.home() / ".empathy" / "compaction_state.json"
+
+
+def load_compaction_state() -> dict[str, Any]:
+    """Load compaction tracking state.
+
+    Returns:
+        Current compaction state
+
+    """
+    state_file = get_compaction_state_file()
+
+    if state_file.exists():
+        try:
+            with open(state_file) as f:
+                return json.load(f)
+        except (json.JSONDecodeError, OSError):
+            pass
+
+    return {
+        "tool_call_count": 0,
+        "last_suggestion": None,
+        "last_compaction": None,
+        "suggestion_count": 0,
+    }
+
+
+def save_compaction_state(state: dict[str, Any]) -> None:
+    """Save compaction tracking state.
+
+    Args:
+        state: State to save
+
+    """
+    state_file = get_compaction_state_file()
+    state_file.parent.mkdir(parents=True, exist_ok=True)
+
+    with open(state_file, "w") as f:
+        json.dump(state, f, indent=2)
+
+
+def should_suggest_compaction(
+    state: dict[str, Any],
+    threshold: int = DEFAULT_COMPACT_THRESHOLD,
+    interval: int = DEFAULT_REMINDER_INTERVAL,
+) -> tuple[bool, str]:
+    """Determine if compaction should be suggested.
+
+    Args:
+        state: Current compaction state
+        threshold: Tool calls before first suggestion
+        interval: Interval between reminders
+
+    Returns:
+        Tuple of (should_suggest, reason)
+
+    """
+    count = state.get("tool_call_count", 0)
+
+    # First threshold
+    if count == threshold:
+        return True, f"Reached {threshold} tool calls - good time to compact"
+
+    # Periodic reminders after threshold
+    if count > threshold and (count - threshold) % interval == 0:
+        return True, f"At {count} tool calls - consider compacting"
+
+    return False, ""
+
+
+def get_compaction_recommendations(context: dict[str, Any]) -> list[str]:
+    """Get recommendations for what to compact.
+
+    Args:
+        context: Current session context
+
+    Returns:
+        List of recommendations
+
+    """
+    recommendations = []
+
+    # Check completed phases
+    completed_phases = context.get("completed_phases", [])
+
+    if completed_phases:
+        recommendations.append(
+            f"Completed phases ({', '.join(completed_phases)}) can be summarized"
+        )
+
+    # Check for exploration context
+    if context.get("exploration_complete", False):
+        recommendations.append("Exploration context can be compacted to findings only")
+
+    # Check for research context
+    if context.get("research_complete", False):
+        recommendations.append("Research context can be compacted to conclusions")
+
+    # General recommendations
+    if not recommendations:
+        recommendations = [
+            "Summarize completed work before starting new tasks",
+            "Keep implementation plan, compact exploration details",
+            "Preserve critical decisions and constraints",
+        ]
+
+    return recommendations
+
+
+def main(**context: Any) -> dict[str, Any]:
+    """Suggest compact hook main function.
+
+    Tracks tool usage and suggests compaction at strategic points.
+
+    Args:
+        **context: Hook context (tool name, current phase, etc.)
+
+    Returns:
+        Compaction suggestion result
+
+    """
+    threshold = int(os.environ.get("COMPACT_THRESHOLD", DEFAULT_COMPACT_THRESHOLD))
+    interval = int(os.environ.get("COMPACT_INTERVAL", DEFAULT_REMINDER_INTERVAL))
+
+    # Load and update state
+    state = load_compaction_state()
+    state["tool_call_count"] = state.get("tool_call_count", 0) + 1
+
+    result = {
+        "tool_call_count": state["tool_call_count"],
+        "suggest_compaction": False,
+        "reason": "",
+        "recommendations": [],
+        "messages": [],
+    }
+
+    # Check if we should suggest compaction
+    should_suggest, reason = should_suggest_compaction(state, threshold, interval)
+
+    if should_suggest:
+        result["suggest_compaction"] = True
+        result["reason"] = reason
+        result["recommendations"] = get_compaction_recommendations(context)
+
+        state["last_suggestion"] = datetime.now().isoformat()
+        state["suggestion_count"] = state.get("suggestion_count", 0) + 1
+
+        result["messages"].append(f"[SuggestCompact] {reason}")
+        for rec in result["recommendations"]:
+            result["messages"].append(f"[SuggestCompact] - {rec}")
+
+    # Save updated state
+    save_compaction_state(state)
+
+    # Log messages
+    for msg in result["messages"]:
+        logger.info(msg)
+
+    return result
+
+
+def reset_on_compaction(**context: Any) -> dict[str, Any]:
+    """Reset compaction state after a compaction event.
+
+    Called by PreCompact hook.
+
+    Args:
+        **context: Hook context
+
+    Returns:
+        Reset confirmation
+
+    """
+    state = load_compaction_state()
+    state["tool_call_count"] = 0
+    state["last_compaction"] = datetime.now().isoformat()
+    save_compaction_state(state)
+
+    logger.info("[SuggestCompact] Reset after compaction")
+
+    return {
+        "reset": True,
+        "timestamp": datetime.now().isoformat(),
+    }
+
+
+if __name__ == "__main__":
+    # Allow running as a script for testing
+
+    logging.basicConfig(level=logging.INFO, format="%(message)s")
+
+    # Simulate tool calls
+    for i in range(60):
+        result = main(current_phase="implementation")
+        if result["suggest_compaction"]:
+            print(f"\nCall {i + 1}: SUGGEST COMPACTION")
+            print(f"  Reason: {result['reason']}")
+            for rec in result["recommendations"]:
+                print(f"  - {rec}")

empathy_llm_toolkit/learning/__init__.py

@@ -0,0 +1,30 @@
+"""Continuous Learning Module for Empathy Framework
+
+Automatic pattern extraction from sessions to enable learning and improvement.
+Identifies valuable patterns from user interactions for future application.
+
+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 empathy_llm_toolkit.learning.evaluator import SessionEvaluator, SessionQuality
+from empathy_llm_toolkit.learning.extractor import (
+                                                    ExtractedPattern,
+                                                    PatternCategory,
+                                                    PatternExtractor,
+)
+from empathy_llm_toolkit.learning.storage import LearnedSkill, LearnedSkillsStorage
+
+__all__ = [
+    "ExtractedPattern",
+    "LearnedSkill",
+    "LearnedSkillsStorage",
+    "PatternCategory",
+    "PatternExtractor",
+    "SessionEvaluator",
+    "SessionQuality",
+]