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

realign/commands/init.py

@@ -1,23 +1,20 @@
-"""ReAlign init command - Initialize ReAlign in a git repository."""
+"""Aline init command - Initialize Aline tracking system."""
 
 import os
 import subprocess
-import yaml
 from pathlib import Path
-from typing import Optional, Dict, Any
+from typing import Dict, Any
 import typer
 from rich.console import Console
-from rich.prompt import Confirm
 
 from ..config import ReAlignConfig, get_default_config_content
+from realign import get_realign_dir
 
 console = Console()
 
 
 def init_repository(
     repo_path: str = ".",
-    auto_init_git: bool = True,
-    skip_commit: bool = False,
     force: bool = False,
 ) -> Dict[str, Any]:
     """
@@ -25,9 +22,7 @@ def init_repository(
 
     Args:
         repo_path: Path to the repository to initialize
-        auto_init_git: Automatically initialize git repo if not exists
-        skip_commit: Skip auto-commit of hooks
-        force: Force re-initialization and update all hooks even if they exist
+        force: Force re-initialization even if .aline already exists
 
     Returns:
         Dictionary with initialization results and metadata
@@ -37,10 +32,9 @@ def init_repository(
         "repo_path": None,
         "repo_root": None,
         "realign_dir": None,
-        "hooks_created": [],
         "config_path": None,
         "history_dir": None,
-        "git_initialized": False,
+        "realign_git_initialized": False,
         "message": "",
         "errors": [],
     }
@@ -54,77 +48,38 @@ def init_repository(
         result["errors"].append(f"Failed to change to directory {repo_path}: {e}")
         result["message"] = "Failed to access target directory"
         return result
+
     try:
-        # Check if we're in a git repository
-        is_git_repo = True
-        try:
-            subprocess.run(
-                ["git", "rev-parse", "--git-dir"],
-                check=True,
-                capture_output=True,
-                text=True,
-            )
-        except subprocess.CalledProcessError:
-            is_git_repo = False
-
-        # If not a git repo, auto-initialize if allowed
-        if not is_git_repo:
-            if auto_init_git:
-                try:
-                    subprocess.run(["git", "init"], check=True, capture_output=True)
-                    result["git_initialized"] = True
-                except subprocess.CalledProcessError as e:
-                    result["errors"].append(f"Failed to initialize git repository: {e}")
-                    result["message"] = "Git initialization failed"
-                    return result
-            else:
-                result["errors"].append("Not in a git repository and auto_init_git=False")
-                result["message"] = "Not a git repository"
-                return result
-
-        repo_root = Path(
-            subprocess.run(
-                ["git", "rev-parse", "--show-toplevel"],
-                check=True,
-                capture_output=True,
-                text=True,
-            ).stdout.strip()
-        )
+        # Use current directory as repo_root (no git dependency)
+        repo_root = Path(os.getcwd()).resolve()
         result["repo_root"] = str(repo_root)
 
-        # Create directory structure
-        realign_dir = repo_root / ".realign"
-        hooks_dir = realign_dir / "hooks"
+        # Create directory structure in ~/.aline/{project_name}/
+        realign_dir = get_realign_dir(repo_root)
         sessions_dir = realign_dir / "sessions"
         result["realign_dir"] = str(realign_dir)
 
-        for directory in [realign_dir, hooks_dir, sessions_dir]:
+        # Check if already initialized (unless --force)
+        if realign_dir.exists() and not force:
+            result["errors"].append("Aline already initialized in this project")
+            result["message"] = "Already initialized. Use --force to reinitialize."
+            return result
+
+        # If force and exists, remove existing directory
+        if force and realign_dir.exists():
+            import shutil
+            console.print(f"[yellow]Removing existing Aline directory: {realign_dir}[/yellow]")
+            shutil.rmtree(realign_dir)
+            result["message"] = "Re-initialized existing Aline directory"
+
+        # Create directories (no hooks needed)
+        for directory in [realign_dir, sessions_dir]:
             directory.mkdir(parents=True, exist_ok=True)
 
-        # Install pre-commit hook
-        pre_commit_path = hooks_dir / "pre-commit"
-        if force or not pre_commit_path.exists():
-            action = "updated" if pre_commit_path.exists() else "created"
-            pre_commit_content = get_pre_commit_hook()
-            pre_commit_path.write_text(pre_commit_content, encoding="utf-8")
-            pre_commit_path.chmod(0o755)
-            result["hooks_created"].append(f"pre-commit ({action})")
-
-        # Install prepare-commit-msg hook
-        hook_path = hooks_dir / "prepare-commit-msg"
-        if force or not hook_path.exists():
-            action = "updated" if hook_path.exists() else "created"
-            hook_content = get_prepare_commit_msg_hook()
-            hook_path.write_text(hook_content, encoding="utf-8")
-            hook_path.chmod(0o755)
-            result["hooks_created"].append(f"prepare-commit-msg ({action})")
-
         # Create .gitignore for sessions and metadata
         gitignore_path = realign_dir / ".gitignore"
         if not gitignore_path.exists():
             gitignore_content = (
-                "# Uncomment to ignore session files\n"
-                "# sessions/\n\n"
                 "# Ignore metadata files (used internally to prevent duplicate processing)\n"
                 ".metadata/\n\n"
                 "# Ignore original sessions (contains potential secrets before redaction)\n"
@@ -132,37 +87,24 @@ def init_repository(
             )
             gitignore_path.write_text(gitignore_content, encoding="utf-8")
 
-        # Backup and set core.hooksPath
-        backup_file = realign_dir / "backup_hook_config.yaml"
-        current_hooks_path = subprocess.run(
-            ["git", "config", "--local", "core.hooksPath"],
-            capture_output=True,
-            text=True,
-            check=False,
-        ).stdout.strip()
-
-        if current_hooks_path and current_hooks_path != ".realign/hooks":
-            # Backup old configuration
-            backup_data = {
-                "original_hooks_path": current_hooks_path,
-                "backup_timestamp": subprocess.run(
-                    ["date", "+%Y-%m-%d %H:%M:%S"],
-                    capture_output=True,
-                    text=True,
-                    check=False,
-                ).stdout.strip(),
-            }
-            with open(backup_file, "w", encoding="utf-8") as f:
-                yaml.dump(backup_data, f)
-
-        # Set new hooks path
-        subprocess.run(
-            ["git", "config", "--local", "core.hooksPath", ".realign/hooks"],
-            check=True,
-        )
+        # Initialize .aline/.git if it doesn't exist
+        # NOTE: We only create the git repo here, the initial commit happens after mirroring
+        realign_git = realign_dir / ".git"
+        if not realign_git.exists():
+            try:
+                subprocess.run(
+                    ["git", "init"],
+                    cwd=realign_dir,
+                    check=True,
+                    capture_output=True
+                )
+                result["realign_git_initialized"] = True
+            except subprocess.CalledProcessError as e:
+                result["errors"].append(f"Failed to initialize .aline/.git: {e}")
+                # Continue anyway, this is not critical for basic functionality
 
         # Initialize global config if not exists
-        global_config_path = Path.home() / ".config" / "realign" / "config.yaml"
+        global_config_path = Path.home() / ".config" / "aline" / "config.yaml"
         if not global_config_path.exists():
             global_config_path.parent.mkdir(parents=True, exist_ok=True)
             global_config_path.write_text(get_default_config_content(), encoding="utf-8")
@@ -174,23 +116,26 @@ def init_repository(
         history_dir.mkdir(parents=True, exist_ok=True)
         result["history_dir"] = str(history_dir)
 
-        # Add hooks to git (optional commit)
-        if not skip_commit:
-            try:
-                subprocess.run(["git", "add", ".realign/hooks/prepare-commit-msg"], check=True)
-                # Try to commit (may fail if no changes, which is fine)
-                commit_result = subprocess.run(
-                    ["git", "commit", "-m", "chore(realign): add prepare-commit-msg hook", "--no-verify"],
-                    capture_output=True,
-                    text=True,
-                    check=False,
-                )
-                result["committed"] = commit_result.returncode == 0
-            except subprocess.CalledProcessError:
-                result["committed"] = False
+        # Create a .aline-config file in project root to store realign_dir location
+        config_marker = repo_root / ".aline-config"
+        config_marker.write_text(str(realign_dir), encoding="utf-8")
+
+        # Update project .gitignore to ignore .aline-config
+        project_gitignore = repo_root / ".gitignore"
+        if project_gitignore.exists():
+            gitignore_content = project_gitignore.read_text(encoding="utf-8")
+            if ".aline-config" not in gitignore_content:
+                # Add .aline-config to .gitignore
+                if not gitignore_content.endswith('\n'):
+                    gitignore_content += '\n'
+                gitignore_content += '\n# Aline config file\n.aline-config\n'
+                project_gitignore.write_text(gitignore_content, encoding="utf-8")
+        else:
+            # Create new .gitignore with .aline-config
+            project_gitignore.write_text('# Aline config file\n.aline-config\n', encoding="utf-8")
 
         result["success"] = True
-        result["message"] = "ReAlign initialized successfully"
+        result["message"] = "Aline initialized successfully"
 
     except Exception as e:
         result["errors"].append(f"Initialization failed: {e}")
@@ -203,24 +148,22 @@ def init_repository(
 
 
 def init_command(
-    yes: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation prompts (deprecated, now default)"),
-    skip_commit: bool = typer.Option(False, "--skip-commit", help="Skip auto-commit of hooks"),
-    force: bool = typer.Option(False, "--force", "-f", help="Force re-initialization and update hooks even if they exist"),
+    force: bool = typer.Option(False, "--force", "-f", help="Force re-initialization even if .aline exists"),
 ):
-    """Initialize ReAlign in the current git repository.
+    """Initialize Aline tracking system in the current directory.
 
-    Use --force to re-initialize and update hooks to the latest version.
+    Creates .aline directory structure and initializes the shadow git repository.
+    Works with or without an existing git repository in the project.
     """
+    # Standard initialization
     # Call the core function
     result = init_repository(
         repo_path=".",
-        auto_init_git=True,
-        skip_commit=skip_commit,
         force=force,
     )
 
     # Print detailed results
-    console.print("\n[bold blue]═══ ReAlign Initialization ═══[/bold blue]\n")
+    console.print("\n[bold blue]═══ Aline Initialization ═══[/bold blue]\n")
 
     if result["success"]:
         console.print("[bold green]✓ Status: SUCCESS[/bold green]\n")
@@ -228,17 +171,12 @@ def init_command(
         console.print("[bold red]✗ Status: FAILED[/bold red]\n")
 
     # Print all parameters and results
-    console.print("[bold]Parameters:[/bold]")
-    console.print(f"  Repository Path: [cyan]{result.get('repo_path', 'N/A')}[/cyan]")
-    console.print(f"  Repository Root: [cyan]{result.get('repo_root', 'N/A')}[/cyan]")
-    console.print(f"  ReAlign Directory: [cyan]{result.get('realign_dir', 'N/A')}[/cyan]")
-    console.print(f"  Config Path: [cyan]{result.get('config_path', 'N/A')}[/cyan]")
+    console.print("[bold]Configuration:[/bold]")
+    console.print(f"  Project Root: [cyan]{result.get('repo_root', 'N/A')}[/cyan]")
+    console.print(f"  Aline Directory: [cyan]{result.get('realign_dir', 'N/A')}[/cyan]")
+    console.print(f"  Global Config: [cyan]{result.get('config_path', 'N/A')}[/cyan]")
     console.print(f"  History Directory: [cyan]{result.get('history_dir', 'N/A')}[/cyan]")
-    console.print(f"  Git Initialized: [cyan]{result.get('git_initialized', False)}[/cyan]")
-    console.print(f"  Force Reinit: [cyan]{force}[/cyan]")
-    console.print(f"  Skip Commit: [cyan]{skip_commit}[/cyan]")
-    console.print(f"  Hooks: [cyan]{', '.join(result.get('hooks_created', [])) or 'None'}[/cyan]")
-    console.print(f"  Auto-committed: [cyan]{result.get('committed', False)}[/cyan]")
+    console.print(f"  Shadow Git Initialized: [cyan]{result.get('realign_git_initialized', False)}[/cyan]")
 
     if result.get("errors"):
         console.print("\n[bold red]Errors:[/bold red]")
@@ -248,95 +186,44 @@ def init_command(
     console.print(f"\n[bold]Result:[/bold] {result['message']}\n")
 
     if result["success"]:
+        # Mirror project files after successful initialization
+        console.print("[bold]Mirroring project files...[/bold]")
+        from .mirror import mirror_project
+        mirror_success = mirror_project(project_path=Path(result["repo_root"]), verbose=False)
+
+        if mirror_success:
+            console.print("[green]✓ Project files mirrored successfully[/green]\n")
+
+            # Create initial commit with mirrored files
+            realign_dir = Path(result["realign_dir"])
+            try:
+                subprocess.run(
+                    ["git", "add", "-A"],
+                    cwd=realign_dir,
+                    check=True,
+                    capture_output=True
+                )
+                subprocess.run(
+                    ["git", "commit", "-m", "Initial commit: Mirror project files"],
+                    cwd=realign_dir,
+                    check=True,
+                    capture_output=True
+                )
+                console.print("[green]✓ Created initial commit in shadow git[/green]\n")
+            except subprocess.CalledProcessError as e:
+                console.print(f"[yellow]⚠ Warning: Failed to create initial commit: {e}[/yellow]\n")
+        else:
+            console.print("[yellow]⚠ Warning: Failed to mirror project files[/yellow]")
+            console.print("[dim]You can manually run 'aline mirror' later[/dim]\n")
+
         console.print("[bold]Next steps:[/bold]")
-        console.print("  1. Ensure your agent saves chat histories to:", style="dim")
-        console.print(f"     {result['history_dir']}", style="cyan")
-        console.print("  2. Make commits as usual - ReAlign will automatically track sessions", style="dim")
-        console.print("  3. Search sessions with: [cyan]realign search <keyword>[/cyan]", style="dim")
-        console.print("  4. View sessions with: [cyan]realign show <commit>[/cyan]", style="dim")
+        console.print("  1. Start Claude Code or Codex - the MCP server will auto-start", style="dim")
+        console.print("  2. Sessions are automatically tracked to .aline/.git", style="dim")
+        console.print("  3. Review commits with: [cyan]aline review[/cyan]", style="dim")
+        console.print("  4. Hide sensitive commits with: [cyan]aline hide <indices>[/cyan]", style="dim")
     else:
         raise typer.Exit(1)
 
 
-def get_pre_commit_hook() -> str:
-    """Get the pre-commit hook script content."""
-    return '''#!/bin/bash
-# ReAlign pre-commit hook
-# Finds and stages agent session files before commit
-
-# 1. Try direct Python execution first (development mode - highest priority for dev machines)
-# Check if realign module is importable (e.g., installed in editable mode or in PYTHONPATH)
-if python -c "import realign.hooks" 2>/dev/null; then
-    echo "Aline pre-commit hook (dev-mode)" >&2
-    exec python -m realign.hooks --pre-commit "$@"
-fi
-
-# 2. Try to find aline-hook-pre-commit in PATH (pipx/pip installations)
-if command -v aline-hook-pre-commit >/dev/null 2>&1; then
-    VERSION=$(aline version 2>/dev/null | grep -oE '[0-9]+\\.[0-9]+\\.[0-9]+' || echo "unknown")
-    echo "Aline pre-commit hook (cli-$VERSION)" >&2
-    exec aline-hook-pre-commit "$@"
-fi
-
-# 3. Try using uvx (for MCP installations where command is in uvx cache)
-if command -v uvx >/dev/null 2>&1; then
-    VERSION=$(uvx --from aline-ai aline version 2>/dev/null | grep -oE '[0-9]+\\.[0-9]+\\.[0-9]+' || echo "unknown")
-    echo "Aline pre-commit hook (mcp-$VERSION)" >&2
-    exec uvx --from aline-ai aline-hook-pre-commit "$@"
-fi
-
-# If all else fails, print an error
-echo "Error: Cannot find aline. Please ensure it's installed:" >&2
-echo "  - For dev: Ensure 'python -m realign.hooks' works (editable install or PYTHONPATH)" >&2
-echo "  - For CLI: pipx install aline-ai" >&2
-echo "  - For MCP: Ensure uvx is available" >&2
-exit 1
-'''
-
-
-def get_prepare_commit_msg_hook() -> str:
-    """Get the prepare-commit-msg hook script content."""
-    return '''#!/bin/bash
-# ReAlign prepare-commit-msg hook
-# Adds agent session metadata to commit messages
-
-COMMIT_MSG_FILE="$1"
-COMMIT_SOURCE="$2"
-
-# Skip for merge, squash, and commit --amend (but allow message and template)
-if [ "$COMMIT_SOURCE" = "merge" ] || [ "$COMMIT_SOURCE" = "squash" ] || [ "$COMMIT_SOURCE" = "commit" ]; then
-    exit 0
-fi
-
-# 1. Try direct Python execution first (development mode - highest priority for dev machines)
-# Check if realign module is importable (e.g., installed in editable mode or in PYTHONPATH)
-if python -c "import realign.hooks" 2>/dev/null; then
-    echo "Aline prepare-commit-msg hook (dev-mode)" >&2
-    exec python -m realign.hooks --prepare-commit-msg "$@"
-fi
-
-# 2. Try to find aline-hook-prepare-commit-msg in PATH (pipx/pip installations)
-if command -v aline-hook-prepare-commit-msg >/dev/null 2>&1; then
-    VERSION=$(aline version 2>/dev/null | grep -oE '[0-9]+\\.[0-9]+\\.[0-9]+' || echo "unknown")
-    echo "Aline prepare-commit-msg hook (cli-$VERSION)" >&2
-    exec aline-hook-prepare-commit-msg "$@"
-fi
-
-# 3. Try using uvx (for MCP installations where command is in uvx cache)
-if command -v uvx >/dev/null 2>&1; then
-    VERSION=$(uvx --from aline-ai aline version 2>/dev/null | grep -oE '[0-9]+\\.[0-9]+\\.[0-9]+' || echo "unknown")
-    echo "Aline prepare-commit-msg hook (mcp-$VERSION)" >&2
-    exec uvx --from aline-ai aline-hook-prepare-commit-msg "$@"
-fi
-
-# If all else fails, print an error
-echo "Error: Cannot find aline. Please ensure it's installed:" >&2
-echo "  - For dev: Ensure 'python -m realign.hooks' works (editable install or PYTHONPATH)" >&2
-echo "  - For CLI: pipx install aline-ai" >&2
-echo "  - For MCP: Ensure uvx is available" >&2
-exit 1
-'''
-
-
 if __name__ == "__main__":
     typer.run(init_command)

realign/commands/mirror.py

@@ -0,0 +1,131 @@
+"""ReAlign mirror command - Mirror project files to shadow git repository."""
+
+from pathlib import Path
+from typing import Optional
+import typer
+from rich.console import Console
+from rich.progress import Progress, SpinnerColumn, TextColumn
+
+from ..tracker.git_tracker import ReAlignGitTracker
+from ..mirror_utils import collect_project_files
+from realign import get_realign_dir
+
+console = Console()
+
+
+def mirror_project(
+    project_path: Optional[Path] = None,
+    verbose: bool = False
+) -> bool:
+    """
+    Mirror all project files to the shadow git repository.
+
+    Args:
+        project_path: Path to project directory (defaults to current directory)
+        verbose: Print detailed progress information
+
+    Returns:
+        True if successful, False otherwise
+    """
+    # Use current directory if not specified
+    if project_path is None:
+        project_path = Path.cwd()
+    else:
+        project_path = Path(project_path).resolve()
+
+    # Check if project exists
+    if not project_path.exists():
+        console.print(f"[red]Error: Project directory does not exist: {project_path}[/red]")
+        return False
+
+    # Check if ReAlign is initialized
+    realign_dir = get_realign_dir(project_path)
+    if not realign_dir.exists():
+        console.print(f"[red]Error: ReAlign not initialized in {project_path}[/red]")
+        console.print(f"[dim]Run 'realign init' first[/dim]")
+        return False
+
+    try:
+        # Initialize git tracker
+        tracker = ReAlignGitTracker(project_path)
+        if not tracker.is_initialized():
+            console.print("[yellow]Shadow git not initialized, initializing now...[/yellow]")
+            if not tracker.init_repo():
+                console.print("[red]Failed to initialize shadow git[/red]")
+                return False
+
+        # Collect all project files
+        if verbose:
+            console.print(f"[dim]Scanning project files in {project_path}...[/dim]")
+
+        all_files = collect_project_files(project_path)
+
+        if not all_files:
+            console.print("[yellow]No files to mirror[/yellow]")
+            return True
+
+        # Mirror files with progress
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            console=console
+        ) as progress:
+            task = progress.add_task(
+                f"Mirroring {len(all_files)} file(s)...",
+                total=None
+            )
+
+            mirrored_files = tracker.mirror_files(all_files)
+            progress.update(task, completed=True)
+
+        # Report results
+        if mirrored_files:
+            console.print(f"[green]✓ Mirrored {len(mirrored_files)} file(s) to {realign_dir / 'mirror'}[/green]")
+            if verbose:
+                console.print("\n[bold]Mirrored files:[/bold]")
+                for file_path in mirrored_files[:10]:  # Show first 10
+                    rel_path = file_path.relative_to(realign_dir / "mirror")
+                    console.print(f"  • {rel_path}")
+                if len(mirrored_files) > 10:
+                    console.print(f"  ... and {len(mirrored_files) - 10} more")
+        else:
+            console.print("[dim]No files needed to be copied (all up to date)[/dim]")
+
+        return True
+
+    except Exception as e:
+        console.print(f"[red]Error mirroring project: {e}[/red]")
+        if verbose:
+            import traceback
+            console.print(f"[dim]{traceback.format_exc()}[/dim]")
+        return False
+
+
+def mirror_command(
+    verbose: bool = typer.Option(False, "--verbose", "-v", help="Show detailed progress"),
+    path: Optional[str] = typer.Argument(None, help="Project path (defaults to current directory)"),
+):
+    """Mirror all project files to the shadow git repository.
+
+    This command copies all project files (respecting .gitignore) to the
+    ~/.aline/{project_name}/mirror/ directory in the shadow git repository.
+
+    The mirror is automatically updated when watcher detects session changes,
+    but this command can be used to manually sync files at any time.
+    """
+    project_path = Path(path) if path else None
+
+    if verbose:
+        if project_path:
+            console.print(f"[bold blue]Mirroring project: {project_path}[/bold blue]\n")
+        else:
+            console.print(f"[bold blue]Mirroring project: {Path.cwd()}[/bold blue]\n")
+
+    success = mirror_project(project_path=project_path, verbose=verbose)
+
+    if not success:
+        raise typer.Exit(1)
+
+
+if __name__ == "__main__":
+    typer.run(mirror_command)

realign/commands/pull.py

@@ -0,0 +1,101 @@
+"""Pull command - Pull session updates from remote repository."""
+
+import os
+import subprocess
+from pathlib import Path
+from typing import Optional
+
+from ..tracker.git_tracker import ReAlignGitTracker
+from ..logging_config import setup_logger
+
+logger = setup_logger('realign.commands.pull', 'pull.log')
+
+
+def pull_command(repo_root: Optional[Path] = None) -> int:
+    """
+    Pull session updates from remote repository.
+
+    This command fetches and merges session commits from the
+    remote repository, bringing in updates from your teammates.
+
+    Args:
+        repo_root: Path to repository root (uses cwd if not provided)
+
+    Returns:
+        Exit code (0 for success, 1 for error)
+    """
+    # Get project root
+    if repo_root is None:
+        repo_root = Path(os.getcwd()).resolve()
+
+    # Initialize tracker
+    tracker = ReAlignGitTracker(repo_root)
+
+    # Check if repository is initialized
+    if not tracker.is_initialized():
+        print("❌ Repository not initialized")
+        print("Run 'aline init' first")
+        return 1
+
+    # Check if remote is configured
+    if not tracker.has_remote():
+        print("❌ No remote configured")
+        print("\nTo join a shared repository:")
+        print("  aline init --join <repo>")
+        print("\nOr to set up sharing:")
+        print("  aline init --share")
+        return 1
+
+    # Check for unpushed commits
+    unpushed = tracker.get_unpushed_commits()
+
+    if unpushed:
+        print(f"⚠️  Warning: You have {len(unpushed)} unpushed commit(s)")
+        print("These will be merged with remote changes")
+        print()
+
+        confirm = input("Continue with pull? [Y/n]: ").strip().lower()
+        if confirm == 'n':
+            print("Cancelled")
+            return 0
+
+    # Perform pull
+    print("Pulling from remote...")
+
+    remote_url = tracker.get_remote_url()
+    print(f"Remote: {remote_url}")
+    print()
+
+    success = tracker.safe_pull()
+
+    if success:
+        print("✓ Successfully pulled updates from remote")
+
+        # Try to get some stats about what was pulled
+        try:
+            # Get log of recent commits
+            result = subprocess.run(
+                ["git", "log", "--oneline", "-5"],
+                cwd=tracker.realign_dir,
+                capture_output=True,
+                text=True,
+                check=False
+            )
+
+            if result.returncode == 0 and result.stdout.strip():
+                print("\nRecent commits:")
+                for line in result.stdout.strip().split('\n'):
+                    print(f"  {line}")
+
+        except Exception as e:
+            logger.debug(f"Failed to get commit stats: {e}")
+
+        return 0
+    else:
+        print("❌ Pull failed")
+        print("\nPossible issues:")
+        print("  - Conflicts requiring manual resolution")
+        print("  - Network connection problems")
+        print("  - Repository access issues")
+        print("\nCheck logs: .realign/logs/pull.log")
+        return 1