attune-ai 2.0.0__py3-none-any.whl

attune_llm/hooks/scripts/first_time_init.py

@@ -0,0 +1,285 @@
+"""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",
+    ".attune/compact_states",
+    ".attune/learned_skills",
+    ".attune/sessions",
+    ".attune/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 / "attune.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 / "attune.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("attune.config.yaml")
+            logger.info("Created config file: attune.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:
+.attune/compact_states/
+.attune/sessions/
+.attune/learned_skills/
+"""
+        gitignore_additions.write_text(gitignore_content)
+        result["created_files"].append(".attune/.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 .attune/ 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))

attune_llm/hooks/scripts/pre_compact.py

@@ -0,0 +1,207 @@
+"""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 attune_llm.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)")

attune_llm/hooks/scripts/session_end.py

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