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

empathy_llm_toolkit/hooks/scripts/session_start.py

@@ -1,163 +0,0 @@
-"""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

@@ -1,225 +0,0 @@
-"""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

@@ -1,30 +0,0 @@
-"""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",
-]