aline-ai 0.2.4__py3-none-any.whl → 0.2.6__py3-none-any.whl

{aline_ai-0.2.4.dist-info → aline_ai-0.2.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aline-ai
-Version: 0.2.4
+Version: 0.2.6
 Summary: Shared AI memory; everyone knows everything in teams
 Author: Sharemind
 License: MIT

{aline_ai-0.2.4.dist-info → aline_ai-0.2.6.dist-info}/RECORD

@@ -1,27 +1,28 @@
-aline_ai-0.2.4.dist-info/licenses/LICENSE,sha256=H8wTqV5IF1oHw_HbBtS1PSDU8G_q81yblEIL_JfV8Vo,1077
-realign/__init__.py,sha256=DWRnxKpLy7YmDatlK_Q7QaCcwo6p-FhjIz_gNyJ0o4o,68
+aline_ai-0.2.6.dist-info/licenses/LICENSE,sha256=H8wTqV5IF1oHw_HbBtS1PSDU8G_q81yblEIL_JfV8Vo,1077
+realign/__init__.py,sha256=kYl1kB-KlgNv4t7nc-BFE8PSabtXYIzbte8yU4ZaTvY,68
 realign/claude_detector.py,sha256=NLxI0zJWcqNxNha9jAy9AslTMwHKakCc9yPGdkrbiFE,3028
-realign/cli.py,sha256=OC5KWJ__7_MXbFRlacVxE-rkylBcDIYxdhVbfwsDbY0,1936
+realign/cli.py,sha256=WSdT9zpHLswBeDPjb5M_U2cvhIm7yrgnXPDyb7vD-jg,2798
 realign/codex_detector.py,sha256=RI3JbZgebrhoqpRfTBMfclYCAISN7hZAHVW3bgftJpU,4428
 realign/config.py,sha256=jarinbr0mA6e5DmgY19b_VpMnxk6SOYTwyvB9luq0ww,7207
 realign/file_lock.py,sha256=-9c3tMdMj_ZxmasK5y6hV9Gfo6KDsSO3Q7PXiTBhsu4,3369
-realign/hooks.py,sha256=GzkEbW35-ifwAilYbVxDpNURZ_7XrF68DTqDSQ8v7fE,50670
+realign/hooks.py,sha256=ZckwB_W7nx5WO_JfyqXP78peL-HDiefoZWE43yBhRtI,63854
 realign/logging_config.py,sha256=KvkKktF-bkUu031y9vgUoHpsbnOw7ud25jhpzliNZwA,4929
-realign/mcp_server.py,sha256=dntFatMpozI80K5hHrIiQ9sviC6ARKTP89goULhi1T4,16477
-realign/mcp_watcher.py,sha256=ffYOXDLuf9T6Kab3CdGNAOY3DBlAbjZrVrSjM5RdYGU,26828
+realign/mcp_server.py,sha256=Q82nuEm6LF17eKUZfHHt6exQjzOWbbBmGXLYwNIGnoo,21002
+realign/mcp_watcher.py,sha256=XmpaX5X8Dm91RCZKC5PoGPNaF1ssUcpRKOe4zWPJ-0A,26751
 realign/redactor.py,sha256=FizaGSdW-QTBAQl4h-gtmMpx2mFrfd2a5DoPEPyLfRg,9989
-realign/commands/__init__.py,sha256=m4bAl1uQoPN6QQV7JUCD0zaLBMXFAXP0Kd4-Vpq9i8g,199
-realign/commands/auto_commit.py,sha256=jgjAYZHqN34NmQkncZg3Vtwsl3MyAlsvucxEBwUj7ko,7450
+realign/commands/__init__.py,sha256=caHulsUeguKyy2ZIIa9hVwzGwNHfIbeHwZIC67C8gnI,213
+realign/commands/auto_commit.py,sha256=3QMlUerXlIJgiwN1BKH6U--qwEqZupzoLPgyAivLr1A,7899
 realign/commands/commit.py,sha256=mlwrv5nfTRY17WlcAdiJKKGh5uM7dGvT7sMxhdbsfkw,12605
 realign/commands/config.py,sha256=iiu7usqw00djKZja5bx0iDH8DB0vU2maUPMkXLdgXwI,6609
 realign/commands/hide.py,sha256=i_XLsmsB4duLKNIA-eRAUvniS4N6GdQUyfN92CGndEA,34138
 realign/commands/init.py,sha256=vOXSAveWgP8TWp0rgqZO8zNRKZMPiaxWsg4PeDZ9RVs,13586
+realign/commands/push.py,sha256=77GXeKggzzc-100JN1PSgDFcDhSaB4kv2jN24h5YM6I,10249
 realign/commands/review.py,sha256=3TY6F87RGNEbutxvUr_konr24-gCyj5fmD9usd3n4-U,15570
 realign/commands/search.py,sha256=xTWuX0lpjQPX8cen0ewl-BNF0FeWgjMwN06bdeesED8,18770
 realign/commands/session_utils.py,sha256=L1DwZIGCOBirp6tkAswACJEeDa6i9aAAfsialAs4rRY,864
 realign/commands/show.py,sha256=A9LvhOBcY6_HoI76irPB2rBOSgdftBuX2uZiO8IwNoU,16338
-aline_ai-0.2.4.dist-info/METADATA,sha256=Hgg_pnm9t39cmHHrFRMllNsfASfBgHWbdEc8AtY8GZ0,1437
-aline_ai-0.2.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-aline_ai-0.2.4.dist-info/entry_points.txt,sha256=h-NocHDzSueXfsepHTIdRPNQzhNZQPAztJfldd-mQTE,202
-aline_ai-0.2.4.dist-info/top_level.txt,sha256=yIL3s2xv9nf1GwD5n71Aq_JEIV4AfzCIDNKBzewuRm4,8
-aline_ai-0.2.4.dist-info/RECORD,,
+aline_ai-0.2.6.dist-info/METADATA,sha256=UqZkpvO5NlU8KpL2KN7DezSmaWMTiS_Lrbcs-_xHmtg,1437
+aline_ai-0.2.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+aline_ai-0.2.6.dist-info/entry_points.txt,sha256=h-NocHDzSueXfsepHTIdRPNQzhNZQPAztJfldd-mQTE,202
+aline_ai-0.2.6.dist-info/top_level.txt,sha256=yIL3s2xv9nf1GwD5n71Aq_JEIV4AfzCIDNKBzewuRm4,8
+aline_ai-0.2.6.dist-info/RECORD,,

realign/__init__.py

@@ -1,3 +1,3 @@
 """Aline - AI Agent Chat Session Tracker."""
 
-__version__ = "0.2.4"
+__version__ = "0.2.6"

realign/cli.py

@@ -7,7 +7,7 @@ from typing import Optional
 from rich.console import Console
 from rich.syntax import Syntax
 
-from .commands import init, search, show, config, commit, auto_commit, review, hide
+from .commands import init, search, show, config, commit, auto_commit, review, hide, push
 
 app = typer.Typer(
     name="realign",
@@ -48,6 +48,29 @@ def hide_cli(
     raise typer.Exit(code=exit_code)
 
 
+@app.command(name="push")
+def push_cli(
+    remote: str = typer.Option("origin", "--remote", "-r", help="Git remote name"),
+    branch: Optional[str] = typer.Option(None, "--branch", "-b", help="Branch to push (default: current branch)"),
+    force: bool = typer.Option(False, "--force", "-f", help="Skip all confirmation prompts"),
+    dry_run: bool = typer.Option(False, "--dry-run", help="Show what would be pushed without actually pushing"),
+):
+    """Interactive push workflow with review and hide options.
+
+    This command provides an interactive workflow:
+    1. Review unpushed commits
+    2. Optionally hide sensitive commits
+    3. Final confirmation before pushing
+    """
+    exit_code = push.push_command(
+        remote=remote,
+        branch=branch,
+        force=force,
+        dry_run=dry_run
+    )
+    raise typer.Exit(code=exit_code)
+
+
 @app.command()
 def version():
     """Show ReAlign version."""

realign/commands/__init__.py

@@ -1,5 +1,5 @@
 """ReAlign commands module."""
 
-from . import init, search, show, config, commit, auto_commit, review, hide
+from . import init, search, show, config, commit, auto_commit, review, hide, push
 
-__all__ = ["init", "search", "show", "config", "commit", "auto_commit", "review", "hide"]
+__all__ = ["init", "search", "show", "config", "commit", "auto_commit", "review", "hide", "push"]

realign/commands/auto_commit.py

@@ -85,10 +85,16 @@ def get_session_mtimes(repo_root: Path) -> dict:
 
 
 def generate_commit_message() -> str:
-    """Generate an automatic commit message."""
-    from datetime import datetime
-    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-    return f"chore: Auto-commit MCP session ({timestamp})"
+    """
+    Generate an automatic commit message.
+
+    DEPRECATED: This function is no longer used for auto-commits.
+    The commit message is now generated by the prepare-commit-msg hook
+    with LLM-based summaries and keywords.
+
+    Returns empty string to let the hook generate the message.
+    """
+    return ""
 
 
 def auto_commit_once(repo_root: Path, message: Optional[str] = None, silent: bool = False) -> bool:
@@ -97,12 +103,13 @@ def auto_commit_once(repo_root: Path, message: Optional[str] = None, silent: boo
 
     Args:
         repo_root: Path to the repository root
-        message: Custom commit message (auto-generated if not provided)
+        message: Custom commit message (if provided, will be used as-is and aline summary appended)
         silent: If True, suppress console output (for watcher mode)
 
     Returns:
         True if commit was successful, False otherwise
     """
+    # If user provided a custom message, use it; otherwise let the hook generate it
     commit_message = message or generate_commit_message()
 
     try:
@@ -124,7 +131,11 @@ def auto_commit_once(repo_root: Path, message: Optional[str] = None, silent: boo
 
         if result.returncode == 0:
             if not silent:
-                console.print(f"[green]✓[/green] Auto-committed: {commit_message}")
+                # If message was provided by user, show it; otherwise indicate auto-commit
+                if message:
+                    console.print(f"[green]✓[/green] Auto-committed: {message}")
+                else:
+                    console.print("[green]✓[/green] Auto-committed successfully")
             return True
         else:
             # Check if it's just "no changes" error

realign/commands/push.py

@@ -0,0 +1,290 @@
+#!/usr/bin/env python3
+"""
+Push command - Interactive workflow for reviewing and pushing commits.
+
+This command provides an interactive workflow:
+1. Run aline review to show unpushed commits
+2. Ask user if they want to hide any commits
+3. If yes, allow interactive hiding
+4. Ask for final confirmation before pushing
+"""
+
+import subprocess
+import sys
+from pathlib import Path
+from typing import Optional
+
+from .review import review_command, get_unpushed_commits
+from .hide import hide_command, parse_commit_indices
+from ..logging_config import setup_logger
+
+logger = setup_logger('realign.commands.push', 'push.log')
+
+
+def prompt_yes_no(question: str, default: bool = False) -> bool:
+    """
+    Prompt user for yes/no confirmation.
+
+    Args:
+        question: Question to ask
+        default: Default answer if user just presses Enter
+
+    Returns:
+        True for yes, False for no
+    """
+    default_str = "Y/n" if default else "y/N"
+    prompt = f"{question} [{default_str}] "
+
+    while True:
+        response = input(prompt).strip().lower()
+
+        if not response:
+            return default
+
+        if response in ('y', 'yes'):
+            return True
+        elif response in ('n', 'no'):
+            return False
+        else:
+            print("Please answer 'y' or 'n'")
+
+
+def push_command(
+    repo_root: Optional[Path] = None,
+    remote: str = "origin",
+    branch: Optional[str] = None,
+    force: bool = False,
+    dry_run: bool = False
+) -> int:
+    """
+    Interactive push workflow with review and hide options.
+
+    Workflow:
+    1. Review unpushed commits
+    2. Ask if user wants to hide any commits
+    3. Interactive hiding loop (if requested)
+    4. Final confirmation
+    5. Execute git push
+
+    Args:
+        repo_root: Path to repository root (auto-detected if None)
+        remote: Git remote name (default: origin)
+        branch: Branch to push (default: current branch)
+        force: Skip all confirmation prompts
+        dry_run: Don't actually push, just show what would happen
+
+    Returns:
+        0 on success, 1 on error, 2 if cancelled by user
+    """
+    logger.info("======== Push command started ========")
+
+    # Auto-detect repo root if not provided
+    if repo_root is None:
+        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"Detected repo root: {repo_root}")
+        except subprocess.CalledProcessError:
+            print("Error: Not in a git repository", file=sys.stderr)
+            logger.error("Not in a git repository")
+            return 1
+
+    # Detect current branch if not provided
+    if branch is None:
+        try:
+            result = subprocess.run(
+                ["git", "rev-parse", "--abbrev-ref", "HEAD"],
+                cwd=repo_root,
+                capture_output=True,
+                text=True,
+                check=True
+            )
+            branch = result.stdout.strip()
+            logger.debug(f"Detected current branch: {branch}")
+        except subprocess.CalledProcessError:
+            print("Error: Failed to detect current branch", file=sys.stderr)
+            logger.error("Failed to detect current branch")
+            return 1
+
+    # Step 1: Review unpushed commits
+    print("\n" + "=" * 60)
+    print("STEP 1: Review unpushed commits")
+    print("=" * 60 + "\n")
+
+    try:
+        commits = get_unpushed_commits(repo_root)
+    except Exception as e:
+        print(f"Error: Failed to get unpushed commits: {e}", file=sys.stderr)
+        logger.error(f"Failed to get unpushed commits: {e}", exc_info=True)
+        return 1
+
+    if not commits:
+        print("✓ No unpushed commits found. Nothing to push.\n")
+        logger.info("No unpushed commits found")
+        return 0
+
+    # Run review command to display commits
+    exit_code = review_command(repo_root=repo_root, verbose=False, detect_secrets=False)
+    if exit_code != 0:
+        logger.error("Review command failed")
+        return 1
+
+    # Step 2: Ask if user wants to hide any commits
+    if not force:
+        print("\n" + "=" * 60)
+        print("STEP 2: Hide sensitive commits (optional)")
+        print("=" * 60 + "\n")
+
+        want_to_hide = prompt_yes_no(
+            "Do you want to hide any commits before pushing?",
+            default=False
+        )
+
+        if want_to_hide:
+            # Interactive hiding loop
+            while True:
+                print("\nEnter commit indices to hide (e.g., '1', '1,3,5', '2-4', or 'done'):")
+                print("  Type 'done' when finished hiding commits")
+                print("  Type 'review' to see the current list of commits")
+                print("  Type 'cancel' to abort the push operation")
+
+                user_input = input("\n> ").strip()
+
+                if not user_input:
+                    continue
+
+                if user_input.lower() == 'done':
+                    break
+                elif user_input.lower() == 'cancel':
+                    print("\n❌ Push cancelled by user.\n")
+                    logger.info("Push cancelled by user during hide phase")
+                    return 2
+                elif user_input.lower() == 'review':
+                    print("\n" + "-" * 60)
+                    review_command(repo_root=repo_root, verbose=False, detect_secrets=False)
+                    print("-" * 60)
+                    continue
+
+                # Try to parse and hide the commits
+                try:
+                    # Validate indices first
+                    indices_list = parse_commit_indices(user_input)
+
+                    # Refresh commit list
+                    commits = get_unpushed_commits(repo_root)
+                    if not commits:
+                        print("\n✓ No more unpushed commits to hide.\n")
+                        break
+
+                    max_index = len(commits)
+                    invalid_indices = [i for i in indices_list if i < 1 or i > max_index]
+                    if invalid_indices:
+                        print(f"❌ Invalid indices (out of range 1-{max_index}): {invalid_indices}")
+                        continue
+
+                    # Execute hide command
+                    print()
+                    exit_code = hide_command(
+                        indices=user_input,
+                        repo_root=repo_root,
+                        force=False  # Always ask for confirmation
+                    )
+
+                    if exit_code == 0:
+                        print("\n✅ Commits hidden successfully.\n")
+                        logger.info(f"Successfully hidden commits: {user_input}")
+
+                        # Refresh and show updated commit list
+                        commits = get_unpushed_commits(repo_root)
+                        if not commits:
+                            print("✓ No more unpushed commits.\n")
+                            logger.info("No commits left after hiding")
+                            return 0
+                        else:
+                            print("\n📋 Updated commit list:\n")
+                            review_command(repo_root=repo_root, verbose=False, detect_secrets=False)
+                    else:
+                        print(f"\n❌ Failed to hide commits.\n")
+                        logger.error(f"Hide command failed for indices: {user_input}")
+
+                        # Ask if user wants to continue
+                        if not prompt_yes_no("Continue with push workflow?", default=True):
+                            print("\n❌ Push cancelled.\n")
+                            return 2
+
+                except ValueError as e:
+                    print(f"❌ Invalid input: {e}")
+                    print("   Examples: '1', '1,3,5', '2-4'")
+                    continue
+                except Exception as e:
+                    print(f"❌ Error during hide: {e}", file=sys.stderr)
+                    logger.error(f"Error during hide: {e}", exc_info=True)
+
+                    # Ask if user wants to continue
+                    if not prompt_yes_no("Continue with push workflow?", default=True):
+                        print("\n❌ Push cancelled.\n")
+                        return 2
+
+    # Step 3: Final confirmation
+    if not force:
+        print("\n" + "=" * 60)
+        print("STEP 3: Final confirmation")
+        print("=" * 60 + "\n")
+
+        # Refresh commit list one more time
+        try:
+            commits = get_unpushed_commits(repo_root)
+        except Exception as e:
+            print(f"Error: Failed to refresh commits: {e}", file=sys.stderr)
+            return 1
+
+        if not commits:
+            print("✓ No unpushed commits. Nothing to push.\n")
+            return 0
+
+        print(f"Ready to push {len(commits)} commit(s) to {remote}/{branch}\n")
+
+        if not prompt_yes_no("Proceed with git push?", default=True):
+            print("\n❌ Push cancelled by user.\n")
+            logger.info("Push cancelled by user at final confirmation")
+            return 2
+
+    # Step 4: Execute git push
+    print("\n" + "=" * 60)
+    print("STEP 4: Pushing to remote")
+    print("=" * 60 + "\n")
+
+    if dry_run:
+        print(f"🔍 DRY RUN: Would execute: git push {remote} {branch}\n")
+        logger.info(f"Dry run: would push to {remote}/{branch}")
+        return 0
+
+    try:
+        print(f"🚀 Pushing to {remote}/{branch}...")
+
+        result = subprocess.run(
+            ["git", "push", remote, branch],
+            cwd=repo_root,
+            capture_output=True,
+            text=True
+        )
+
+        if result.returncode == 0:
+            print("\n✅ Successfully pushed to remote!\n")
+            print(result.stdout)
+            logger.info(f"Successfully pushed to {remote}/{branch}")
+            return 0
+        else:
+            print(f"\n❌ Push failed:\n{result.stderr}\n", file=sys.stderr)
+            logger.error(f"Git push failed: {result.stderr}")
+            return 1
+
+    except Exception as e:
+        print(f"\n❌ Error during push: {e}\n", file=sys.stderr)
+        logger.error(f"Error during push: {e}", exc_info=True)
+        return 1

realign/hooks.py

@@ -356,6 +356,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 +554,71 @@ 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 (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."
+}
+
+IMPORTANT for description:
+- Be specific and informative (200-400 characters)
+- 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
+- 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
+
+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 +639,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=300,  # Increased for keywords
                 temperature=0.7,
                 system=system_prompt,
                 messages=[
@@ -505,17 +651,44 @@ 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
+                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()
+                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
+
+                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
+
+                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]
+                print("   ⚠️  Claude response was not valid JSON, using fallback", file=sys.stderr)
+                return first_line, "claude-3-5-haiku-20241022", ""
 
         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 +704,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 +720,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 +749,48 @@ def generate_summary_with_llm(
                         "content": user_prompt
                     }
                 ],
-                max_tokens=150,
+                max_tokens=300,  # Increased for keywords
                 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
+                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()
+                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
+
+                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
+
+                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]
+                print("   ⚠️  OpenAI response was not valid JSON, using fallback", file=sys.stderr)
+                return first_line, "gpt-3.5-turbo", ""
 
         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 +802,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 +894,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,
@@ -1106,18 +1346,19 @@ def process_sessions(
             continue
 
         # Generate summary for NEW content only
-        summary_text: Optional[str] = None
+        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_text, llm_model_name = generate_summary_with_llm(
+            summary_title, llm_model_name, summary_description = generate_summary_with_llm(
                 new_content,
                 config.summary_max_chars,
                 config.llm_provider
             )
 
-            if summary_text:
+            if summary_title:
                 print("✅ LLM summary generated successfully", file=sys.stderr)
                 is_llm_summary = True
                 if summary_model_label is None:
@@ -1126,23 +1367,26 @@ def process_sessions(
                 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:
+        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_text = simple_summarize(new_content, config.summary_max_chars)
+            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_text = summary_text.strip()
-        logger.debug(f"Summary for {session_relpath} ({agent_name}): {summary_text[:100]}...")
+        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,
-            "text": summary_text,
+            "title": summary_title,
+            "description": summary_description,
             "source": "llm" if is_llm_summary else "local",
         })
-        legacy_summary_chunks.append(f"[{agent_name}] {summary_text}")
+        legacy_summary_chunks.append(f"[{agent_name}] {summary_title}")
 
         # Update metadata after successfully generating summary
         save_session_metadata(repo_root, session_relpath, current_size)
@@ -1230,23 +1474,59 @@ def prepare_commit_msg_hook():
 
     # 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:
-                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")
+                # 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("Agent-Redacted: true\n")
+                    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)
 

realign/mcp_server.py

@@ -170,6 +170,63 @@ async def list_tools() -> list[Tool]:
                 "properties": {},
             },
         ),
+        Tool(
+            name="aline_review",
+            description=(
+                "Review unpushed commits before pushing. "
+                "Shows commit messages, LLM summaries, session files modified, and line counts. "
+                "Helps identify what content will be made public when you push."
+            ),
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "repo_path": {
+                        "type": "string",
+                        "description": "Path to repository root (default: current directory)",
+                    },
+                    "verbose": {
+                        "type": "boolean",
+                        "description": "Show detailed information",
+                        "default": False,
+                    },
+                    "detect_secrets": {
+                        "type": "boolean",
+                        "description": "Run sensitive content detection",
+                        "default": False,
+                    },
+                },
+            },
+        ),
+        Tool(
+            name="aline_hide",
+            description=(
+                "Hide (redact) specific unpushed commits by rewriting git history. "
+                "This redacts commit messages and session content. "
+                "WARNING: This rewrites git history. Use with caution."
+            ),
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "indices": {
+                        "type": "string",
+                        "description": (
+                            "Commit indices to hide (e.g., '1', '1,3,5', '2-4', or '--all'). "
+                            "Use aline_review first to see the commit indices."
+                        ),
+                    },
+                    "repo_path": {
+                        "type": "string",
+                        "description": "Path to repository root (default: current directory)",
+                    },
+                    "force": {
+                        "type": "boolean",
+                        "description": "Skip confirmation prompt",
+                        "default": False,
+                    },
+                },
+                "required": ["indices"],
+            },
+        ),
     ]
 
 
@@ -189,6 +246,10 @@ async def call_tool(name: str, arguments: Any) -> list[TextContent]:
             result = await handle_get_latest_session(arguments)
         elif name == "aline_version":
             result = await handle_version(arguments)
+        elif name == "aline_review":
+            result = await handle_review(arguments)
+        elif name == "aline_hide":
+            result = await handle_hide(arguments)
         else:
             return [TextContent(type="text", text=f"Unknown tool: {name}")]
 
@@ -395,6 +456,78 @@ async def handle_version(args: dict) -> list[TextContent]:
     )]
 
 
+async def handle_review(args: dict) -> list[TextContent]:
+    """Handle aline_review tool."""
+    from .commands.review import review_command
+    from io import StringIO
+    import sys
+
+    repo_path = args.get("repo_path")
+    verbose = args.get("verbose", False)
+    detect_secrets = args.get("detect_secrets", False)
+
+    # Convert repo_path to Path if provided
+    repo_root = Path(repo_path) if repo_path else None
+
+    # Capture stdout
+    old_stdout = sys.stdout
+    sys.stdout = captured_output = StringIO()
+
+    try:
+        # Call the review command
+        exit_code = review_command(
+            repo_root=repo_root,
+            verbose=verbose,
+            detect_secrets=detect_secrets
+        )
+
+        # Get the output
+        output = captured_output.getvalue()
+
+        if exit_code == 0:
+            return [TextContent(type="text", text=output or "No unpushed commits found.")]
+        else:
+            return [TextContent(type="text", text=f"Error: Review failed\n{output}")]
+    finally:
+        sys.stdout = old_stdout
+
+
+async def handle_hide(args: dict) -> list[TextContent]:
+    """Handle aline_hide tool."""
+    from .commands.hide import hide_command
+    from io import StringIO
+    import sys
+
+    indices = args["indices"]
+    repo_path = args.get("repo_path")
+    force = args.get("force", False)
+
+    # Convert repo_path to Path if provided
+    repo_root = Path(repo_path) if repo_path else None
+
+    # Capture stdout
+    old_stdout = sys.stdout
+    sys.stdout = captured_output = StringIO()
+
+    try:
+        # Call the hide command
+        exit_code = hide_command(
+            indices=indices,
+            repo_root=repo_root,
+            force=force
+        )
+
+        # Get the output
+        output = captured_output.getvalue()
+
+        if exit_code == 0:
+            return [TextContent(type="text", text=output or "Hide operation completed.")]
+        else:
+            return [TextContent(type="text", text=f"Error: Hide failed\n{output}")]
+    finally:
+        sys.stdout = old_stdout
+
+
 def _server_log(msg: str):
     """Log MCP server messages to both stderr and file."""
     from datetime import datetime

realign/mcp_watcher.py

@@ -442,9 +442,8 @@ class DialogueWatcher:
             session_file: Session file that triggered the commit
         """
         try:
-            # Generate commit message
-            timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-            message = f"chore: Auto-commit MCP session ({timestamp})"
+            # Use empty message to let prepare-commit-msg hook generate it with LLM summary
+            message = ""
 
             # Use realign commit command
             result = await asyncio.get_event_loop().run_in_executor(
@@ -455,8 +454,8 @@ class DialogueWatcher:
             )
 
             if result:
-                logger.info(f"✓ Committed to {project_path.name}: {message}")
-                print(f"[MCP Watcher] ✓ Committed to {project_path.name}: {message}", file=sys.stderr)
+                logger.info(f"✓ Committed to {project_path.name}")
+                print(f"[MCP Watcher] ✓ Auto-committed to {project_path.name}", file=sys.stderr)
                 # Update last commit time for this project
                 self.last_commit_times[str(project_path)] = time.time()
                 # Baseline counts already updated in _check_if_turn_complete()