aline-ai 0.2.5__py3-none-any.whl → 0.3.0__py3-none-any.whl

realign/hooks.py

@@ -7,6 +7,7 @@ invoked directly from git hooks without copying any Python files to the target r
 """
 
 import os
+import re
 import sys
 import json
 import time
@@ -30,6 +31,53 @@ except ImportError:
 logger = setup_logger('realign.hooks', 'hooks.log')
 
 
+# ============================================================================
+# Message Cleaning Utilities
+# ============================================================================
+
+def clean_user_message(text: str) -> str:
+    """
+    Clean user message by removing IDE context tags and other system noise.
+
+    This function removes IDE-generated context that's not part of the actual
+    user intent, making commit messages and session logs cleaner.
+
+    Removes:
+    - <ide_opened_file>...</ide_opened_file> tags
+    - <ide_selection>...</ide_selection> tags
+    - System interrupt messages like "[Request interrupted by user for tool use]"
+    - Other system-generated context tags
+
+    Args:
+        text: Raw user message text
+
+    Returns:
+        Cleaned message text with system tags removed, or empty string if message is purely system-generated
+    """
+    if not text:
+        return text
+
+    # Check for system interrupt messages first (return empty for these)
+    # These are generated when user stops the AI mid-execution
+    if text.strip() == "[Request interrupted by user for tool use]":
+        return ""
+
+    # Remove IDE opened file tags
+    text = re.sub(r'<ide_opened_file>.*?</ide_opened_file>\s*', '', text, flags=re.DOTALL)
+
+    # Remove IDE selection tags
+    text = re.sub(r'<ide_selection>.*?</ide_selection>\s*', '', text, flags=re.DOTALL)
+
+    # Remove other common system tags if needed
+    # text = re.sub(r'<system_context>.*?</system_context>\s*', '', text, flags=re.DOTALL)
+
+    # Clean up extra whitespace
+    text = re.sub(r'\n\s*\n\s*\n+', '\n\n', text)  # Replace multiple blank lines with double newline
+    text = text.strip()
+
+    return text
+
+
 def get_new_content_from_git_diff(repo_root: Path, session_relpath: str) -> str:
     """
     Extract new content added in this commit by using git diff.
@@ -356,6 +404,115 @@ def find_latest_session(history_path: Path, explicit_path: Optional[str] = None)
     return max(session_files, key=lambda p: p.stat().st_mtime)
 
 
+def filter_session_content(content: str) -> Tuple[str, str, str]:
+    """
+    Filter session content to extract meaningful information for LLM summarization.
+
+    Filters out exploratory operations (Read, Grep, Glob) and technical details,
+    keeping only user requests, AI responses, and code changes.
+
+    Args:
+        content: Raw text content of new session additions
+
+    Returns:
+        Tuple of (user_messages, assistant_replies, code_changes)
+    """
+    if not content or not content.strip():
+        return "", "", ""
+
+    user_messages = []
+    assistant_replies = []
+    code_changes = []
+
+    lines = content.strip().split("\n")
+
+    for line in lines:
+        line = line.strip()
+        if not line:
+            continue
+
+        try:
+            obj = json.loads(line)
+
+            # Extract user messages and tool results
+            if obj.get("type") == "user":
+                msg = obj.get("message", {})
+                if isinstance(msg, dict):
+                    content_data = msg.get("content", "")
+                    if isinstance(content_data, str) and content_data.strip():
+                        user_messages.append(content_data.strip())
+                    elif isinstance(content_data, list):
+                        # Extract text from content list
+                        for item in content_data:
+                            if isinstance(item, dict):
+                                if item.get("type") == "text":
+                                    text = item.get("text", "").strip()
+                                    if text:
+                                        user_messages.append(text)
+                                # Extract code changes from tool results
+                                elif item.get("type") == "tool_result":
+                                    tool_use_result = obj.get("toolUseResult", {})
+                                    if "oldString" in tool_use_result and "newString" in tool_use_result:
+                                        # This is an Edit operation
+                                        new_string = tool_use_result.get("newString", "")
+                                        if new_string:
+                                            code_changes.append(f"Edit: {new_string[:300]}")
+                                    elif "content" in tool_use_result and "filePath" in tool_use_result:
+                                        # This is a Write operation
+                                        new_content = tool_use_result.get("content", "")
+                                        if new_content:
+                                            code_changes.append(f"Write: {new_content[:300]}")
+
+            # Extract assistant text replies (not tool use)
+            elif obj.get("type") == "assistant":
+                msg = obj.get("message", {})
+                if isinstance(msg, dict):
+                    content_data = msg.get("content", [])
+                    if isinstance(content_data, list):
+                        for item in content_data:
+                            if isinstance(item, dict):
+                                # Only extract text blocks, skip tool_use blocks
+                                if item.get("type") == "text":
+                                    text = item.get("text", "").strip()
+                                    if text:
+                                        assistant_replies.append(text)
+                                # Extract code changes from Edit/Write tool uses
+                                elif item.get("type") == "tool_use":
+                                    tool_name = item.get("name", "")
+                                    if tool_name in ("Edit", "Write"):
+                                        params = item.get("input", {})
+                                        if tool_name == "Edit":
+                                            new_string = params.get("new_string", "")
+                                            if new_string:
+                                                code_changes.append(f"Edit: {new_string[:200]}")
+                                        elif tool_name == "Write":
+                                            new_content = params.get("content", "")
+                                            if new_content:
+                                                code_changes.append(f"Write: {new_content[:200]}")
+
+            # Also handle simple role/content format (for compatibility)
+            elif obj.get("role") == "user":
+                content_text = obj.get("content", "")
+                if isinstance(content_text, str) and content_text.strip():
+                    user_messages.append(content_text.strip())
+
+            elif obj.get("role") == "assistant":
+                content_text = obj.get("content", "")
+                if isinstance(content_text, str) and content_text.strip():
+                    assistant_replies.append(content_text.strip())
+
+        except (json.JSONDecodeError, KeyError, TypeError):
+            # Not JSON or doesn't have expected structure, skip
+            continue
+
+    # Join with newlines for better readability
+    user_str = "\n".join(user_messages) if user_messages else ""
+    assistant_str = "\n".join(assistant_replies) if assistant_replies else ""
+    code_str = "\n".join(code_changes) if code_changes else ""
+
+    return user_str, assistant_str, code_str
+
+
 def simple_summarize(content: str, max_chars: int = 500) -> str:
     """
     Generate a simple summary from new session content.
@@ -445,34 +602,78 @@ def generate_summary_with_llm(
     content: str,
     max_chars: int = 500,
     provider: str = "auto"
-) -> Tuple[Optional[str], Optional[str]]:
+) -> Tuple[Optional[str], Optional[str], Optional[str]]:
     """
     Generate summary using LLM (Anthropic Claude or OpenAI) for NEW content only.
-    Returns (summary, model_name) tuple, or (None, None) if LLM is unavailable.
+    Returns (title, model_name, description) tuple, or (None, None, None) if LLM is unavailable.
 
     Args:
         content: Raw text content of new session additions
-        max_chars: Maximum characters in summary
+        max_chars: Maximum characters in summary (not used, kept for compatibility)
         provider: LLM provider to use - "auto" (try Claude then OpenAI), "claude", or "openai"
+
+    Returns:
+        Tuple of (title, model_name, description) where:
+        - title: One-line summary (max 150 chars)
+        - model_name: Name of the model used
+        - description: Detailed description of what happened (200-400 chars)
     """
-    logger.info(f"Attempting to generate LLM summary (provider: {provider}, max_chars: {max_chars})")
+    logger.info(f"Attempting to generate LLM summary (provider: {provider})")
 
     if not content or not content.strip():
         logger.debug("No content provided for summarization")
-        return "No new content in this session", None
-
-    # Truncate content for API (to avoid token limits)
-    # Approximately 4000 chars = ~1000 tokens
-    truncated_content = content[:4000]
-    if len(content) > 4000:
-        logger.debug(f"Content truncated from {len(content)} to 4000 chars for LLM API")
-
-    # System prompt for summarization
-    system_prompt = (
-        "You are a helpful assistant that summarizes NEW content added to AI agent chat sessions. "
-        "Provide a concise summary in English focusing on the main topics and actions in the NEW content."
-    )
-    user_prompt = f"Summarize this NEW content from an AI chat session in one or two sentences:\n\n{truncated_content}"
+        return "No new content in this session", None, ""
+
+    # Filter content to extract meaningful information
+    user_messages, assistant_replies, code_changes = filter_session_content(content)
+
+    # If no meaningful content after filtering, return early
+    if not user_messages and not assistant_replies and not code_changes:
+        logger.debug("No meaningful content after filtering")
+        return "Session update with no significant changes", None, "No significant changes detected in this session"
+
+    # System prompt for structured summarization
+    system_prompt = """You are a git commit message generator for AI chat sessions.
+Analyze the conversation and code changes, then generate a summary in JSON format:
+{
+  "title": "One-line summary (imperative mood, like 'Add feature X' or 'Fix bug in Y'. Aim for 80-120 chars, up to 150 max. Use complete words only - never truncate words. Omit articles like 'the', 'a' when possible to save space)",
+  "description": "Detailed description of what happened in this session. Aim for 300-600 words - be thorough and complete. Focus on key actions, decisions, and outcomes. Include specific details like function names, features discussed, bugs fixed, etc. NEVER truncate - write complete sentences."
+}
+
+IMPORTANT for title:
+- Keep it concise (80-120 chars ideal, 150 max) but COMPLETE - no truncated words
+- Use imperative mood (e.g., "Add", "Fix", "Refactor", "Implement")
+- If you can't fit everything, prioritize the most important change
+
+IMPORTANT for description:
+- Be thorough and complete (300-600 words)
+- Focus on WHAT was accomplished and WHY, not HOW
+- Include technical details: function names, module names, specific features
+- Mention key decisions or discussions
+- Write in clear, complete sentences - grammar matters for readability
+- NEVER truncate mid-sentence - always finish your thought
+- Avoid mentioning tool names like 'Edit', 'Write', 'Read'
+- For discussions without code: summarize the topics and conclusions
+- For code changes: describe what was changed and the purpose
+- If there were multiple related changes, group them logically
+
+Return JSON only, no other text."""
+
+    # Build user prompt with filtered content
+    user_prompt_parts = ["Summarize this AI chat session:\n"]
+
+    if user_messages:
+        user_prompt_parts.append(f"User requests:\n{user_messages[:1500]}\n")
+
+    if assistant_replies:
+        user_prompt_parts.append(f"AI responses:\n{assistant_replies[:1500]}\n")
+
+    if code_changes:
+        user_prompt_parts.append(f"Code changes:\n{code_changes[:1500]}\n")
+
+    user_prompt_parts.append("\nReturn JSON only, no other text.")
+
+    user_prompt = "\n".join(user_prompt_parts)
 
     # Determine which providers to try based on the provider parameter
     try_claude = provider in ("auto", "claude")
@@ -493,7 +694,7 @@ def generate_summary_with_llm(
 
             response = client.messages.create(
                 model="claude-3-5-haiku-20241022",  # Fast and cost-effective
-                max_tokens=150,
+                max_tokens=1000,  # Increased to allow complete descriptions (300-600 words)
                 temperature=0.7,
                 system=system_prompt,
                 messages=[
@@ -505,17 +706,57 @@ def generate_summary_with_llm(
             )
 
             elapsed = time.time() - start_time
-            summary = response.content[0].text.strip()
-            logger.info(f"Claude API success: {len(summary)} chars in {elapsed:.2f}s")
-            logger.debug(f"Claude response: {summary[:100]}...")
-            print("   ✅ Anthropic (Claude) summary successful", file=sys.stderr)
-            return summary[:max_chars], "claude-3-5-haiku-20241022"
+            response_text = response.content[0].text.strip()
+            logger.info(f"Claude API success: {len(response_text)} chars in {elapsed:.2f}s")
+            logger.debug(f"Claude response: {response_text[:200]}...")
+
+            # Parse JSON response
+            try:
+                # Try to extract JSON if wrapped in markdown code blocks
+                json_str = response_text
+                if "```json" in response_text:
+                    json_start = response_text.find("```json") + 7
+                    json_end = response_text.find("```", json_start)
+                    # Only extract if closing ``` was found
+                    if json_end != -1:
+                        json_str = response_text[json_start:json_end].strip()
+                elif "```" in response_text:
+                    json_start = response_text.find("```") + 3
+                    json_end = response_text.find("```", json_start)
+                    # Only extract if closing ``` was found
+                    if json_end != -1:
+                        json_str = response_text[json_start:json_end].strip()
+
+                summary_data = json.loads(json_str)
+                title = summary_data.get("title", "")
+                description = summary_data.get("description", "")
+
+                # Validate title is not just brackets or very short
+                if not title or len(title.strip()) < 2:
+                    logger.warning(f"Generated title is empty or too short: '{title}'")
+                    raise json.JSONDecodeError("Title validation failed", json_str, 0)
+
+                print("   ✅ Anthropic (Claude) summary successful", file=sys.stderr)
+                return title, "claude-3-5-haiku-20241022", description
+
+            except json.JSONDecodeError as e:
+                logger.warning(f"Failed to parse JSON from Claude response: {e}")
+                logger.debug(f"Raw response: {response_text}")
+                # Fallback: use first line as title, empty description
+                first_line = response_text.split("\n")[0][:150].strip()
+                # Validate fallback title is reasonable
+                if first_line and len(first_line) >= 2 and not first_line.startswith("{"):
+                    print("   ⚠️  Claude response was not valid JSON, using fallback", file=sys.stderr)
+                    return first_line, "claude-3-5-haiku-20241022", ""
+                else:
+                    logger.error(f"Claude fallback title validation failed: '{first_line}'")
+                    return None, None, None
 
         except ImportError:
             logger.warning("Anthropic package not installed")
             if provider == "claude":
                 print("   ❌ Anthropic package not installed", file=sys.stderr)
-                return None, None
+                return None, None, None
             else:
                 print("   ❌ Anthropic package not installed, trying OpenAI...", file=sys.stderr)
         except Exception as e:
@@ -531,7 +772,7 @@ def generate_summary_with_llm(
                     print(f"   ❌ Anthropic quota/credit issue", file=sys.stderr)
                 else:
                     print(f"   ❌ Anthropic API error: {e}", file=sys.stderr)
-                return None, None
+                return None, None, None
             else:
                 # Auto mode: try falling back to OpenAI
                 if "authentication" in error_msg.lower() or "invalid" in error_msg.lower():
@@ -547,7 +788,7 @@ def generate_summary_with_llm(
         logger.debug("ANTHROPIC_API_KEY not set")
         if provider == "claude":
             print("   ❌ ANTHROPIC_API_KEY not set", file=sys.stderr)
-            return None, None
+            return None, None, None
         else:
             print("   ⓘ ANTHROPIC_API_KEY not set, trying OpenAI...", file=sys.stderr)
 
@@ -576,21 +817,61 @@ def generate_summary_with_llm(
                         "content": user_prompt
                     }
                 ],
-                max_tokens=150,
+                max_tokens=1000,  # Increased to allow complete descriptions (300-600 words)
                 temperature=0.7,
             )
 
             elapsed = time.time() - start_time
-            summary = response.choices[0].message.content.strip()
-            logger.info(f"OpenAI API success: {len(summary)} chars in {elapsed:.2f}s")
-            logger.debug(f"OpenAI response: {summary[:100]}...")
-            print("   ✅ OpenAI (GPT) summary successful", file=sys.stderr)
-            return summary[:max_chars], "gpt-3.5-turbo"
+            response_text = response.choices[0].message.content.strip()
+            logger.info(f"OpenAI API success: {len(response_text)} chars in {elapsed:.2f}s")
+            logger.debug(f"OpenAI response: {response_text[:200]}...")
+
+            # Parse JSON response
+            try:
+                # Try to extract JSON if wrapped in markdown code blocks
+                json_str = response_text
+                if "```json" in response_text:
+                    json_start = response_text.find("```json") + 7
+                    json_end = response_text.find("```", json_start)
+                    # Only extract if closing ``` was found
+                    if json_end != -1:
+                        json_str = response_text[json_start:json_end].strip()
+                elif "```" in response_text:
+                    json_start = response_text.find("```") + 3
+                    json_end = response_text.find("```", json_start)
+                    # Only extract if closing ``` was found
+                    if json_end != -1:
+                        json_str = response_text[json_start:json_end].strip()
+
+                summary_data = json.loads(json_str)
+                title = summary_data.get("title", "")
+                description = summary_data.get("description", "")
+
+                # Validate title is not just brackets or very short
+                if not title or len(title.strip()) < 2:
+                    logger.warning(f"Generated title is empty or too short: '{title}'")
+                    raise json.JSONDecodeError("Title validation failed", json_str, 0)
+
+                print("   ✅ OpenAI (GPT) summary successful", file=sys.stderr)
+                return title, "gpt-3.5-turbo", description
+
+            except json.JSONDecodeError as e:
+                logger.warning(f"Failed to parse JSON from OpenAI response: {e}")
+                logger.debug(f"Raw response: {response_text}")
+                # Fallback: use first line as title, empty description
+                first_line = response_text.split("\n")[0][:150].strip()
+                # Validate fallback title is reasonable
+                if first_line and len(first_line) >= 2 and not first_line.startswith("{"):
+                    print("   ⚠️  OpenAI response was not valid JSON, using fallback", file=sys.stderr)
+                    return first_line, "gpt-3.5-turbo", ""
+                else:
+                    logger.error(f"OpenAI fallback title validation failed: '{first_line}'")
+                    return None, None, None
 
         except ImportError:
             logger.warning("OpenAI package not installed")
             print("   ❌ OpenAI package not installed", file=sys.stderr)
-            return None, None
+            return None, None, None
         except Exception as e:
             error_msg = str(e)
             logger.error(f"OpenAI API error: {error_msg}", exc_info=True)
@@ -602,17 +883,17 @@ def generate_summary_with_llm(
                 print(f"   ❌ OpenAI quota/billing issue", file=sys.stderr)
             else:
                 print(f"   ❌ OpenAI API error: {e}", file=sys.stderr)
-            return None, None
+            return None, None, None
     elif try_openai:
         logger.debug("OPENAI_API_KEY not set")
         print("   ❌ OPENAI_API_KEY not set", file=sys.stderr)
-        return None, None
+        return None, None, None
 
     # No API keys available or provider not configured
     logger.warning(f"No LLM API keys available (provider: {provider})")
     if provider == "auto":
         print("   ❌ No LLM API keys configured", file=sys.stderr)
-    return None, None
+    return None, None, None
 
 
 def generate_session_filename(user: str, agent: str = "claude") -> str:
@@ -694,6 +975,46 @@ def get_git_user() -> str:
         return os.getenv("USER", "unknown")
 
 
+def get_username(session_relpath: str = "") -> str:
+    """
+    Get username for commit message.
+
+    Tries to get from git config first, then falls back to extracting
+    from session filename.
+
+    Args:
+        session_relpath: Relative path to session file (used for fallback)
+
+    Returns:
+        Username string
+    """
+    # Try git config first
+    try:
+        result = subprocess.run(
+            ["git", "config", "user.name"],
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        username = result.stdout.strip()
+        if username:
+            return username
+    except subprocess.CalledProcessError:
+        pass
+
+    # Fallback: extract from session filename
+    # Format: username_agent_hash.jsonl
+    if session_relpath:
+        filename = Path(session_relpath).name
+        parts = filename.split("_")
+        if len(parts) >= 3:
+            # First part is username
+            return parts[0]
+
+    # Final fallback
+    return os.getenv("USER", "unknown")
+
+
 def copy_session_to_repo(
     session_file: Path,
     repo_root: Path,
@@ -701,7 +1022,7 @@ def copy_session_to_repo(
     config: Optional[ReAlignConfig] = None
 ) -> Tuple[Path, str, bool, int]:
     """
-    Copy session file to repository .realign/sessions/ directory.
+    Copy session file to repository sessions/ directory (in ~/.aline/{project_name}/).
     Optionally redacts sensitive information if configured.
     If the source filename is in UUID format, renames it to include username for better identification.
     Returns (absolute_path, relative_path, was_redacted, content_size).
@@ -709,7 +1030,9 @@ def copy_session_to_repo(
     logger.info(f"Copying session to repo: {session_file.name}")
     logger.debug(f"Source: {session_file}, Repo root: {repo_root}, User: {user}")
 
-    sessions_dir = repo_root / ".realign" / "sessions"
+    from realign import get_realign_dir
+    realign_dir = get_realign_dir(repo_root)
+    sessions_dir = realign_dir / "sessions"
     sessions_dir.mkdir(parents=True, exist_ok=True)
 
     original_filename = session_file.name
@@ -873,7 +1196,9 @@ def save_session_metadata(repo_root: Path, session_relpath: str, content_size: i
         session_relpath: Relative path to session file
         content_size: Size of session content when processed
     """
-    metadata_dir = repo_root / ".realign" / ".metadata"
+    from realign import get_realign_dir
+    realign_dir = get_realign_dir(repo_root)
+    metadata_dir = realign_dir / ".metadata"
     metadata_dir.mkdir(parents=True, exist_ok=True)
 
     # Use session filename as metadata key
@@ -905,7 +1230,9 @@ def get_session_metadata(repo_root: Path, session_relpath: str) -> Optional[Dict
     Returns:
         Metadata dictionary or None if not found
     """
-    metadata_dir = repo_root / ".realign" / ".metadata"
+    from realign import get_realign_dir
+    realign_dir = get_realign_dir(repo_root)
+    metadata_dir = realign_dir / ".metadata"
     session_name = Path(session_relpath).name
     metadata_file = metadata_dir / f"{session_name}.meta"
 
@@ -922,346 +1249,3 @@ def get_session_metadata(repo_root: Path, session_relpath: str) -> Optional[Dict
         return None
 
 
-def process_sessions(
-    pre_commit_mode: bool = False,
-    session_path: Optional[str] = None,
-    user: Optional[str] = None
-) -> Dict[str, Any]:
-    """
-    Core logic for processing agent sessions.
-    Used by both pre-commit and prepare-commit-msg hooks.
-
-    Args:
-        pre_commit_mode: If True, only return session paths without generating summaries
-        session_path: Explicit path to a session file (optional)
-        user: User name override (optional)
-
-    Returns:
-        Dictionary with keys: summary, session_relpaths, redacted, summary_entries, summary_model
-    """
-    import time
-    start_time = time.time()
-
-    hook_type = "pre-commit" if pre_commit_mode else "prepare-commit-msg"
-    logger.info(f"======== Hook started: {hook_type} ========")
-
-    # Load configuration
-    config = ReAlignConfig.load()
-    logger.debug(f"Config loaded: use_LLM={config.use_LLM}, redact_on_match={config.redact_on_match}")
-
-    # Find repository root
-    try:
-        result = subprocess.run(
-            ["git", "rev-parse", "--show-toplevel"],
-            capture_output=True,
-            text=True,
-            check=True,
-        )
-        repo_root = Path(result.stdout.strip())
-        logger.debug(f"Repository root: {repo_root}")
-    except subprocess.CalledProcessError as e:
-        logger.error(f"Not in a git repository: {e}")
-        print(json.dumps({"error": "Not in a git repository"}), file=sys.stderr)
-        sys.exit(1)
-
-    # Find all active session files
-    session_path_env = session_path or os.getenv("REALIGN_SESSION_PATH")
-
-    if session_path_env:
-        # Explicit session path provided
-        logger.info(f"Using explicit session path: {session_path_env}")
-        session_file = Path(session_path_env)
-        session_files = [session_file] if session_file.exists() else []
-        if not session_files:
-            logger.warning(f"Explicit session path not found: {session_path_env}")
-    else:
-        # Auto-detect all enabled sessions
-        session_files = find_all_active_sessions(config, repo_root)
-
-    if not session_files:
-        logger.info("No session files found, returning empty result")
-        # Return empty result (don't block commit)
-        return {"summary": "", "session_relpaths": [], "redacted": False}
-
-    # Get user
-    user = user or get_git_user()
-    logger.debug(f"Git user: {user}")
-
-    # Pre-commit mode: Copy sessions to repo (with optional redaction)
-    # Prepare-commit-msg mode: Reuse already copied sessions from .realign/sessions/
-    session_relpaths = []
-    session_metadata_map = {}  # Map session_relpath -> content_size
-    any_redacted = False
-
-    if pre_commit_mode:
-        # Pre-commit: Copy and redact sessions (heavy work done here)
-        logger.info("Pre-commit mode: Copying and processing sessions")
-        for session_file in session_files:
-            try:
-                _, session_relpath, was_redacted, content_size = copy_session_to_repo(
-                    session_file, repo_root, user, config
-                )
-                session_relpaths.append(session_relpath)
-                session_metadata_map[session_relpath] = content_size
-                if was_redacted:
-                    any_redacted = True
-            except Exception as e:
-                logger.error(f"Failed to copy session file {session_file}: {e}", exc_info=True)
-                print(f"Warning: Could not copy session file {session_file}: {e}", file=sys.stderr)
-                continue
-
-        if not session_relpaths:
-            logger.warning("No session files copied successfully")
-            return {
-                "summary": "",
-                "session_relpaths": [],
-                "redacted": False,
-                "summary_entries": [],
-                "summary_model": "",
-            }
-
-        logger.info(f"Copied {len(session_relpaths)} session(s): {session_relpaths}")
-    else:
-        # Prepare-commit-msg: Just find existing sessions in .realign/sessions/
-        # No need to copy again - pre-commit already did this
-        logger.info("Prepare-commit-msg mode: Using existing sessions from .realign/sessions/")
-        sessions_dir = repo_root / ".realign" / "sessions"
-
-        if sessions_dir.exists():
-            # Find all session files that were processed by pre-commit
-            for session_file in sessions_dir.glob("*.jsonl"):
-                # Skip agent sessions (these are sub-tasks)
-                if session_file.name.startswith("agent-"):
-                    continue
-
-                session_relpath = str(session_file.relative_to(repo_root))
-                session_relpaths.append(session_relpath)
-
-                # Get file size
-                try:
-                    content_size = session_file.stat().st_size
-                    session_metadata_map[session_relpath] = content_size
-                except Exception as e:
-                    logger.warning(f"Could not get size for {session_relpath}: {e}")
-                    session_metadata_map[session_relpath] = 0
-
-        if not session_relpaths:
-            logger.warning("No existing session files found in .realign/sessions/")
-            return {
-                "summary": "",
-                "session_relpaths": [],
-                "redacted": False,
-                "summary_entries": [],
-                "summary_model": "",
-            }
-
-        logger.info(f"Found {len(session_relpaths)} existing session(s): {session_relpaths}")
-
-    # If pre-commit mode, save metadata and return session paths (summary will be generated later)
-    if pre_commit_mode:
-        # Save metadata for each session to prevent reprocessing
-        for session_relpath, content_size in session_metadata_map.items():
-            save_session_metadata(repo_root, session_relpath, content_size)
-            logger.debug(f"Saved metadata for {session_relpath} in pre-commit")
-
-        elapsed = time.time() - start_time
-        logger.info(f"======== Hook completed: {hook_type} in {elapsed:.2f}s ========")
-        return {
-            "summary": "",
-            "session_relpaths": session_relpaths,
-            "redacted": any_redacted,
-            "summary_entries": [],
-            "summary_model": "",
-        }
-
-    # For prepare-commit-msg mode, we need to stage files first to get accurate diff
-    # This ensures git diff --cached works correctly
-    try:
-        for session_relpath in session_relpaths:
-            subprocess.run(
-                ["git", "add", session_relpath],
-                cwd=repo_root,
-                check=True,
-            )
-        logger.debug("Session files staged successfully")
-    except subprocess.CalledProcessError as e:
-        logger.error(f"Failed to stage session files: {e}", exc_info=True)
-        print(f"Warning: Could not stage session files: {e}", file=sys.stderr)
-
-    # For prepare-commit-msg mode, generate summary from all sessions
-    logger.info("Generating summaries for sessions")
-    summary_entries: List[Dict[str, str]] = []
-    legacy_summary_chunks: List[str] = []
-    summary_model_label: Optional[str] = None
-
-    for session_relpath in session_relpaths:
-        # Extract NEW content using git diff (compares staged content with HEAD)
-        # This correctly detects new content even if the file hasn't grown since pre-commit
-        # (which happens in auto-commit scenarios where the AI has finished responding)
-        current_size = session_metadata_map.get(session_relpath, 0)
-        new_content = get_new_content_from_git_diff(repo_root, session_relpath)
-
-        if not new_content or not new_content.strip():
-            logger.debug(f"No new content for {session_relpath}, skipping summary")
-            continue
-
-        # Generate summary for NEW content only
-        summary_text: Optional[str] = None
-        is_llm_summary = False
-        llm_model_name: Optional[str] = None
-        if config.use_LLM:
-            print(f"🤖 Attempting to generate LLM summary (provider: {config.llm_provider})...", file=sys.stderr)
-            summary_text, llm_model_name = generate_summary_with_llm(
-                new_content,
-                config.summary_max_chars,
-                config.llm_provider
-            )
-
-            if summary_text:
-                print("✅ LLM summary generated successfully", file=sys.stderr)
-                is_llm_summary = True
-                if summary_model_label is None:
-                    summary_model_label = llm_model_name or config.llm_provider
-            else:
-                print("⚠️  LLM summary failed - falling back to local summarization", file=sys.stderr)
-                print("   Check your API keys: ANTHROPIC_API_KEY or OPENAI_API_KEY", file=sys.stderr)
-
-        if not summary_text:
-            # Fallback to simple summarize
-            logger.info("Using local summarization (no LLM)")
-            print("📝 Using local summarization (no LLM)", file=sys.stderr)
-            summary_text = simple_summarize(new_content, config.summary_max_chars)
-
-        # Identify agent type from filename
-        agent_name = detect_agent_from_session_path(session_relpath)
-
-        summary_text = summary_text.strip()
-        logger.debug(f"Summary for {session_relpath} ({agent_name}): {summary_text[:100]}...")
-        summary_entries.append({
-            "agent": agent_name,
-            "text": summary_text,
-            "source": "llm" if is_llm_summary else "local",
-        })
-        legacy_summary_chunks.append(f"[{agent_name}] {summary_text}")
-
-        # Update metadata after successfully generating summary
-        save_session_metadata(repo_root, session_relpath, current_size)
-        logger.debug(f"Updated metadata for {session_relpath} in prepare-commit-msg")
-
-    # Combine all summaries
-    if summary_entries:
-        if summary_model_label is None:
-            summary_model_label = "Local summarizer"
-        combined_summary = " | ".join(legacy_summary_chunks)
-        logger.info(f"Generated {len(summary_entries)} summary(ies)")
-    else:
-        combined_summary = "No new content in sessions"
-        logger.info("No summaries generated (no new content)")
-
-    elapsed = time.time() - start_time
-    logger.info(f"======== Hook completed: {hook_type} in {elapsed:.2f}s ========")
-
-    return {
-        "summary": combined_summary,
-        "session_relpaths": session_relpaths,
-        "redacted": any_redacted,
-        "summary_entries": summary_entries,
-        "summary_model": summary_model_label or "",
-    }
-
-
-def pre_commit_hook():
-    """
-    Entry point for pre-commit hook.
-    Finds and stages session files.
-    """
-    result = process_sessions(pre_commit_mode=True)
-    print(json.dumps(result, ensure_ascii=False))
-
-    # Stage the session files
-    if result["session_relpaths"]:
-        try:
-            subprocess.run(
-                ["git", "rev-parse", "--show-toplevel"],
-                capture_output=True,
-                text=True,
-                check=True,
-            )
-            repo_root_result = subprocess.run(
-                ["git", "rev-parse", "--show-toplevel"],
-                capture_output=True,
-                text=True,
-                check=True,
-            )
-            repo_root = repo_root_result.stdout.strip()
-
-            for session_path in result["session_relpaths"]:
-                subprocess.run(
-                    ["git", "add", session_path],
-                    cwd=repo_root,
-                    check=True,
-                )
-        except subprocess.CalledProcessError as e:
-            print(f"Warning: Could not stage session files: {e}", file=sys.stderr)
-
-    sys.exit(0)
-
-
-def prepare_commit_msg_hook():
-    """
-    Entry point for prepare-commit-msg hook.
-    Generates session summary and appends to commit message.
-    """
-    # Get commit message file path from command line arguments
-    # When called via __main__ with --prepare-commit-msg flag, the file is at index 2
-    # When called directly as a hook entry point, the file is at index 1
-    if sys.argv[1] == "--prepare-commit-msg":
-        # Called via: python -m realign.hooks --prepare-commit-msg <msg-file> <source>
-        if len(sys.argv) < 3:
-            print("Error: Commit message file path not provided", file=sys.stderr)
-            sys.exit(1)
-        msg_file = sys.argv[2]
-    else:
-        # Called via: realign-hook-prepare-commit-msg <msg-file> <source>
-        msg_file = sys.argv[1]
-
-    # Process sessions and generate summary
-    result = process_sessions(pre_commit_mode=False)
-
-    # Append summary to commit message
-    summary_entries = result.get("summary_entries") or []
-    if summary_entries:
-        try:
-            with open(msg_file, "a", encoding="utf-8") as f:
-                summary_model = result.get("summary_model") or "Local summarizer"
-                f.write("\n\n")
-                f.write(f"--- LLM-Summary ({summary_model}) ---\n")
-                for entry in summary_entries:
-                    agent_label = entry.get("agent", "Agent")
-                    text = (entry.get("text") or "").strip()
-                    if not text:
-                        continue
-                    f.write(f"* [{agent_label}] {text}\n")
-                f.write("\n")
-                if result.get("redacted"):
-                    f.write("Agent-Redacted: true\n")
-        except Exception as e:
-            print(f"Warning: Could not append to commit message: {e}", file=sys.stderr)
-
-    sys.exit(0)
-
-
-if __name__ == "__main__":
-    # This allows the module to be run directly for testing
-    import sys
-    if len(sys.argv) > 1:
-        if sys.argv[1] == "--pre-commit":
-            pre_commit_hook()
-        elif sys.argv[1] == "--prepare-commit-msg":
-            prepare_commit_msg_hook()
-        else:
-            print("Usage: python -m realign.hooks [--pre-commit|--prepare-commit-msg]")
-            sys.exit(1)
-    else:
-        print("Usage: python -m realign.hooks [--pre-commit|--prepare-commit-msg]")
-        sys.exit(1)