aline-ai 0.2.6__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.
@@ -588,19 +636,26 @@ def generate_summary_with_llm(
     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 (max 150 chars, imperative mood, like 'Add feature X' or 'Fix bug in Y'. NEVER truncate words - keep whole words only. Omit articles like 'the', 'a' when possible to save space)",
-  "description": "Detailed description of what happened in this session (200-400 chars). Focus on key actions, decisions, and outcomes. Don't worry about perfect grammar - clarity and completeness matter more. Include specific details like function names, features discussed, bugs fixed, etc."
+  "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 specific and informative (200-400 characters)
+- 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
-- Don't worry about perfect grammar - focus on conveying the right meaning clearly
+- 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."""
 
@@ -639,7 +694,7 @@ Return JSON only, no other text."""
 
             response = client.messages.create(
                 model="claude-3-5-haiku-20241022",  # Fast and cost-effective
-                max_tokens=300,  # Increased for keywords
+                max_tokens=1000,  # Increased to allow complete descriptions (300-600 words)
                 temperature=0.7,
                 system=system_prompt,
                 messages=[
@@ -658,20 +713,28 @@ Return JSON only, no other text."""
             # 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)
-                    json_str = response_text[json_start:json_end].strip()
+                    # 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)
-                    json_str = response_text[json_start:json_end].strip()
-                else:
-                    json_str = response_text
+                    # 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", "")[:150]  # Enforce 150 char limit
-                description = summary_data.get("description", "")[:400]  # Enforce 400 char limit
+                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
@@ -680,9 +743,14 @@ Return JSON only, no other text."""
                 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]
-                print("   ⚠️  Claude response was not valid JSON, using fallback", file=sys.stderr)
-                return first_line, "claude-3-5-haiku-20241022", ""
+                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")
@@ -749,7 +817,7 @@ Return JSON only, no other text."""
                         "content": user_prompt
                     }
                 ],
-                max_tokens=300,  # Increased for keywords
+                max_tokens=1000,  # Increased to allow complete descriptions (300-600 words)
                 temperature=0.7,
             )
 
@@ -761,20 +829,28 @@ Return JSON only, no other text."""
             # 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)
-                    json_str = response_text[json_start:json_end].strip()
+                    # 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)
-                    json_str = response_text[json_start:json_end].strip()
-                else:
-                    json_str = response_text
+                    # 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", "")[:150]  # Enforce 150 char limit
-                description = summary_data.get("description", "")[:400]  # Enforce 400 char limit
+                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
@@ -783,9 +859,14 @@ Return JSON only, no other text."""
                 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]
-                print("   ⚠️  OpenAI response was not valid JSON, using fallback", file=sys.stderr)
-                return first_line, "gpt-3.5-turbo", ""
+                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")
@@ -941,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).
@@ -949,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
@@ -1113,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
@@ -1145,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"
 
@@ -1162,386 +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_title: Optional[str] = None
-        summary_description: str = ""
-        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_title, llm_model_name, summary_description = generate_summary_with_llm(
-                new_content,
-                config.summary_max_chars,
-                config.llm_provider
-            )
-
-            if summary_title:
-                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_title:
-            # Fallback to simple summarize
-            logger.info("Using local summarization (no LLM)")
-            print("📝 Using local summarization (no LLM)", file=sys.stderr)
-            summary_title = simple_summarize(new_content, config.summary_max_chars)
-            summary_description = ""
-
-        # Identify agent type from filename
-        agent_name = detect_agent_from_session_path(session_relpath)
-
-        summary_title = summary_title.strip()
-        logger.debug(f"Summary for {session_relpath} ({agent_name}): {summary_title[:100]}...")
-        logger.debug(f"Description: {summary_description[:100]}...")
-        summary_entries.append({
-            "agent": agent_name,
-            "title": summary_title,
-            "description": summary_description,
-            "source": "llm" if is_llm_summary else "local",
-        })
-        legacy_summary_chunks.append(f"[{agent_name}] {summary_title}")
-
-        # 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 []
-    session_relpaths = result.get("session_relpaths") or []
-
-    if summary_entries:
-        try:
-            # Read existing commit message to check if user provided one
-            with open(msg_file, "r", encoding="utf-8") as f:
-                existing_msg = f.read().strip()
-
-            # Check if this is an auto-commit (empty message or only comments)
-            is_auto_commit = not existing_msg or all(
-                line.startswith("#") for line in existing_msg.split("\n") if line.strip()
-            )
-
-            # Get username from first session path
-            username = get_username(session_relpaths[0] if session_relpaths else "")
-
-            # Get timestamp
-            from datetime import datetime
-            timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-
-            with open(msg_file, "a", encoding="utf-8") as f:
-                # Combine all summaries
-                first_entry = summary_entries[0]
-                title = first_entry.get("title", "Session update").strip()
-                agent_label = first_entry.get("agent", "Unknown")
-                description = first_entry.get("description", "").strip()
-
-                if is_auto_commit:
-                    # Auto-commit format: use aline summary as the main message
-                    f.write(f"aline: {title}\n\n")
-                    if description:
-                        f.write(f"{description}\n\n")
-                    f.write(f"Agent: {agent_label}\n")
-                    f.write(f"User: {username}\n")
-                    f.write(f"Timestamp: {timestamp}\n")
-                else:
-                    # User-provided commit message format: append aline summary after separator
-                    f.write("\n\n---\n")
-                    f.write(f"aline: {title}\n\n")
-                    if description:
-                        f.write(f"{description}\n\n")
-                    f.write(f"Agent: {agent_label}\n")
-                    f.write(f"User: {username}\n")
-                    f.write(f"Timestamp: {timestamp}\n")
-
-                # Add redaction marker if applicable
-                if result.get("redacted"):
-                    f.write("Redacted: true\n")
-
-        except Exception as e:
-            print(f"Warning: Could not append to commit message: {e}", file=sys.stderr)
-            import traceback
-            logger.error(f"Commit message formatting error: {traceback.format_exc()}")
-
-    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)

realign/logging_config.py

@@ -40,7 +40,7 @@ def get_log_directory() -> Path:
     """
     Get the log directory path.
 
-    Default: ~/.realign/.logs/
+    Default: ~/.aline/.logs/
     Can be overridden with REALIGN_LOG_DIR environment variable.
 
     Returns:
@@ -51,7 +51,7 @@ def get_log_directory() -> Path:
     if log_dir_str:
         log_dir = Path(log_dir_str).expanduser()
     else:
-        log_dir = Path.home() / '.realign' / '.logs'
+        log_dir = Path.home() / '.aline' / '.logs'
 
     # Create directory if it doesn't exist
     log_dir.mkdir(parents=True, exist_ok=True)