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

realign/commands/review.py

@@ -15,6 +15,22 @@ from typing import List, Dict, Tuple, Optional
 
 from ..logging_config import setup_logger
 
+# ANSI color codes for terminal output
+class Colors:
+    RESET = '\033[0m'
+    BOLD = '\033[1m'
+    DIM = '\033[2m'
+
+    # Foreground colors
+    RED = '\033[91m'
+    GREEN = '\033[92m'
+    YELLOW = '\033[93m'
+    BLUE = '\033[94m'
+    MAGENTA = '\033[95m'
+    CYAN = '\033[96m'
+    WHITE = '\033[97m'
+    GRAY = '\033[90m'
+
 logger = setup_logger('realign.commands.review', 'review.log')
 
 
@@ -27,6 +43,7 @@ class UnpushedCommit:
     message: str                                     # First line of commit message
     timestamp: datetime                              # Commit timestamp
     llm_summary: str                                 # Extracted LLM summary
+    user_request: Optional[str]                      # User's request text
     session_files: List[str]                         # Session files modified
     session_additions: Dict[str, List[Tuple[int, int]]]  # {file: [(start, end), ...]}
     has_sensitive: bool = False                      # Whether sensitive content detected
@@ -36,10 +53,14 @@ def get_unpushed_commits(repo_root: Path) -> List[UnpushedCommit]:
     """
     Get all unpushed commits from the current branch.
 
-    Strategy (方案 C):
-    1. Try to use upstream branch (@{u})
-    2. Fallback to origin/main or origin/master
-    3. If no remote exists, show all commits on current branch
+    Strategy (Updated):
+    1. Get current branch name
+    2. If on main/master branch:
+       - Use upstream (@{u}) if exists, otherwise origin/main
+    3. If on feature branch:
+       - Always compare against origin/main or origin/master
+       - This shows all commits that will be in the PR
+    4. If no remote exists, show all commits on current branch
 
     Args:
         repo_root: Path to repository root
@@ -49,35 +70,58 @@ def get_unpushed_commits(repo_root: Path) -> List[UnpushedCommit]:
     """
     logger.info("Getting unpushed commits")
 
-    # Try to get upstream branch
-    upstream_result = subprocess.run(
-        ["git", "rev-parse", "--abbrev-ref", "@{u}"],
+    # Get current branch name
+    current_branch_result = subprocess.run(
+        ["git", "rev-parse", "--abbrev-ref", "HEAD"],
         cwd=repo_root,
         capture_output=True,
         text=True
     )
 
-    if upstream_result.returncode == 0:
-        base = "@{u}"
-        logger.debug(f"Using upstream branch: {upstream_result.stdout.strip()}")
-    else:
-        # Fallback to origin/main or origin/master
-        main_branch = detect_main_branch(repo_root)
-        base = f"origin/{main_branch}"
-        logger.debug(f"No upstream found, using fallback: {base}")
+    if current_branch_result.returncode != 0:
+        logger.error("Failed to get current branch name")
+        return []
+
+    current_branch = current_branch_result.stdout.strip()
+    logger.debug(f"Current branch: {current_branch}")
 
-        # Verify that the remote branch exists
-        verify_result = subprocess.run(
-            ["git", "rev-parse", "--verify", base],
+    # Detect main branch name
+    main_branch = detect_main_branch(repo_root)
+
+    # Determine base branch based on current branch
+    if current_branch in ['main', 'master']:
+        # On main branch: show commits not pushed to upstream
+        upstream_result = subprocess.run(
+            ["git", "rev-parse", "--abbrev-ref", "@{u}"],
             cwd=repo_root,
             capture_output=True,
             text=True
         )
 
-        if verify_result.returncode != 0:
-            # Remote branch doesn't exist, show all commits on current branch
-            base = None
-            logger.info("No remote branch found, will show all commits on current branch")
+        if upstream_result.returncode == 0:
+            base = "@{u}"
+            logger.debug(f"On main branch, using upstream: {upstream_result.stdout.strip()}")
+        else:
+            base = f"origin/{main_branch}"
+            logger.debug(f"On main branch but no upstream, using: {base}")
+    else:
+        # On feature branch: show all commits relative to main
+        # This shows what would be in a PR
+        base = f"origin/{main_branch}"
+        logger.debug(f"On feature branch '{current_branch}', comparing against: {base}")
+
+    # Verify that the base branch exists
+    verify_result = subprocess.run(
+        ["git", "rev-parse", "--verify", base],
+        cwd=repo_root,
+        capture_output=True,
+        text=True
+    )
+
+    if verify_result.returncode != 0:
+        # Remote branch doesn't exist, show all commits on current branch
+        base = None
+        logger.info(f"Base branch '{base}' not found, will show all commits on current branch")
 
     # Get commit list
     # Format: full_hash|short_hash|subject|timestamp
@@ -125,8 +169,9 @@ def get_unpushed_commits(repo_root: Path) -> List[UnpushedCommit]:
             text=True
         ).stdout
 
-        # Extract LLM summary
+        # Extract LLM summary and user request
         llm_summary = extract_llm_summary(full_message)
+        user_request = extract_user_request(full_message)
 
         # Get session file additions
         session_files, session_additions = get_session_additions(full_hash, repo_root)
@@ -138,6 +183,7 @@ def get_unpushed_commits(repo_root: Path) -> List[UnpushedCommit]:
             message=subject,
             timestamp=timestamp,
             llm_summary=llm_summary,
+            user_request=user_request,
             session_files=session_files,
             session_additions=session_additions,
             has_sensitive=False  # Will be set by --detect-secrets flag
@@ -199,27 +245,85 @@ def detect_main_branch(repo_root: Path) -> str:
     return "main"
 
 
+def extract_user_request(commit_message: str) -> Optional[str]:
+    """
+    Extract user request from commit message.
+
+    New format (v0.3+):
+        ---
+        Session: ... | Turn: ... | Model: ...
+        Request: {user_message}
+
+    Args:
+        commit_message: Full commit message
+
+    Returns:
+        User request text, or None if not found
+    """
+    lines = commit_message.split('\n')
+
+    # Look for "Request:" line
+    for i, line in enumerate(lines):
+        if line.strip().startswith('Request:'):
+            # Extract text after "Request:"
+            request = line.strip()[8:].strip()  # Remove "Request:" prefix
+            # Filter out placeholder messages
+            if request and request != "No user message found":
+                return request
+
+    return None
+
+
 def extract_llm_summary(commit_message: str) -> str:
     """
     Extract LLM summary from commit message.
 
-    Expected format:
+    Supports two formats:
+
+    New format (v0.3+):
+        {llm_title}
+
+        {llm_description}
+
+        ---
+        Turn: #{turn_number} | Model: {model_name}
+        Request: {user_message}
+
+    Legacy format:
         chore: Auto-commit MCP session (2025-11-22 19:24:29)
 
         --- LLM-Summary (claude-3-5-haiku) ---
         * [Claude] Discussed implementing JWT authentication
-        * [Codex] Fixed bug in payment module
-
-        Agent-Redacted: false
 
     Args:
         commit_message: Full commit message
 
     Returns:
-        Extracted summary text (without * and [Agent] prefix), or "(No summary)"
+        Extracted summary text, or "(No summary)"
     """
     lines = commit_message.split('\n')
 
+    # Try new format first: title is first line, description is in the middle
+    if lines and not lines[0].startswith('chore:') and '---' in commit_message:
+        # New format: {title}\n\n{description}\n\n---
+        title = lines[0].strip()
+
+        # Find description (between title and ---)
+        description_lines = []
+        for i, line in enumerate(lines[1:], start=1):
+            if line.strip() == '---':
+                break
+            if line.strip():  # Skip empty lines
+                description_lines.append(line.strip())
+
+        if title:
+            summary = title
+            if description_lines:
+                # Use first line of description if available
+                summary += f": {description_lines[0]}"
+            return summary
+
+    # Try legacy format
     in_summary = False
     summary_lines = []
 
@@ -282,9 +386,11 @@ def get_session_additions(commit_hash: str, repo_root: Path) -> Tuple[List[str],
     all_files = files_result.stdout.strip().split('\n')
 
     # Filter session files
+    # Note: In shadow git, session files are in 'sessions/' directory
+    # In user project, they would be in '.realign/sessions/' directory
     session_files = [
         f for f in all_files
-        if f.startswith('.realign/sessions/') and f.endswith('.jsonl')
+        if (f.startswith('sessions/') or f.startswith('.realign/sessions/')) and f.endswith('.jsonl')
     ]
 
     if not session_files:
@@ -388,32 +494,61 @@ def display_unpushed_commits(commits: List[UnpushedCommit], verbose: bool = Fals
         verbose: Whether to show detailed information
     """
     if not commits:
-        print("\n✓ No unpushed commits found.\n")
+        print(f"\n{Colors.GREEN}✓ No unpushed commits found.{Colors.RESET}\n")
         return
 
-    print(f"\n📋 Unpushed commits ({len(commits)}):\n")
+    # Header
+    print(f"\n{Colors.BOLD}{Colors.CYAN}📋 Unpushed commits ({len(commits)}){Colors.RESET}\n")
 
     for commit in commits:
-        # Basic info
-        print(f"  [{commit.index}] {commit.hash} - {commit.message}")
-        print(f"      Time: {commit.timestamp.strftime('%Y-%m-%d %H:%M:%S')}")
-
-        # LLM Summary
-        if commit.llm_summary and commit.llm_summary != "(No summary)":
-            print(f"      Summary: {commit.llm_summary}")
-
-        # Session files
-        if commit.session_files:
-            for session_file in commit.session_files:
-                additions = commit.session_additions.get(session_file, [])
-                total_lines = sum(end - start + 1 for start, end in additions)
-                print(f"      Session: {session_file} (+{total_lines} lines)")
-
-        # Sensitive content warning
-        if commit.has_sensitive:
-            print(f"      ⚠️  WARNING: Potential sensitive content detected")
-
-        print()  # Blank line separator
+        # Index and hash in gray
+        index_str = f"{Colors.GRAY}[{commit.index}]{Colors.RESET}"
+        hash_str = f"{Colors.YELLOW}{commit.hash}{Colors.RESET}"
+
+        # Commit message (first line only) in bold white
+        message_str = f"{Colors.BOLD}{commit.message}{Colors.RESET}"
+
+        print(f"{index_str} {hash_str} {message_str}")
+
+        # User request (first 50 characters) in cyan
+        if commit.user_request:
+            # Truncate to 50 characters
+            request_display = commit.user_request[:50]
+            if len(commit.user_request) > 50:
+                request_display += "..."
+            print(f"    {Colors.CYAN}└─ {request_display}{Colors.RESET}")
+
+        # Verbose mode: show additional details
+        if verbose:
+            # Timestamp in dim gray
+            time_str = commit.timestamp.strftime('%Y-%m-%d %H:%M:%S')
+            print(f"    {Colors.DIM}Time: {time_str}{Colors.RESET}")
+
+            # LLM Summary
+            if commit.llm_summary and commit.llm_summary != "(No summary)":
+                print(f"    {Colors.DIM}Summary: {commit.llm_summary}{Colors.RESET}")
+
+            # Session files (only show files with additions)
+            if commit.session_files:
+                files_with_additions = [
+                    (f, commit.session_additions.get(f, []))
+                    for f in commit.session_files
+                ]
+                # Filter to only files with actual additions
+                files_with_additions = [
+                    (f, ranges) for f, ranges in files_with_additions
+                    if ranges  # Only show files with non-empty additions
+                ]
+
+                for session_file, additions in files_with_additions:
+                    total_lines = sum(end - start + 1 for start, end in additions)
+                    print(f"    {Colors.DIM}Session: {session_file} (+{total_lines} lines){Colors.RESET}")
+
+            # Sensitive content warning
+            if commit.has_sensitive:
+                print(f"    {Colors.RED}⚠️  WARNING: Potential sensitive content detected{Colors.RESET}")
+
+            print()  # Blank line separator in verbose mode
 
 
 def review_command(
@@ -424,8 +559,11 @@ def review_command(
     """
     Main entry point for review command.
 
+    Reviews commits in the shadow git repository (~/.aline/{project}/.git)
+    rather than the user's project repository.
+
     Args:
-        repo_root: Path to repository root (auto-detected if None)
+        repo_root: Path to user's project root (auto-detected if None)
         verbose: Show detailed information
         detect_secrets: Run sensitive content detection
 
@@ -434,7 +572,7 @@ def review_command(
     """
     logger.info("======== Review command started ========")
 
-    # Auto-detect repo root if not provided
+    # Auto-detect user project root if not provided
     if repo_root is None:
         try:
             result = subprocess.run(
@@ -444,12 +582,36 @@ def review_command(
                 check=True
             )
             repo_root = Path(result.stdout.strip())
-            logger.debug(f"Detected repo root: {repo_root}")
+            logger.debug(f"Detected user project 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
 
+    # Get shadow git repository path
+    from .. import get_realign_dir
+    shadow_dir = get_realign_dir(repo_root)
+    shadow_git = shadow_dir
+
+    # Verify shadow git exists
+    if not shadow_git.exists():
+        print(f"Error: Shadow git repository not found at {shadow_git}", file=sys.stderr)
+        print("Run 'aline init' first to initialize the repository.", file=sys.stderr)
+        logger.error(f"Shadow git not found at {shadow_git}")
+        return 1
+
+    # Check if it's a git repository
+    git_dir = shadow_git / '.git'
+    if not git_dir.exists():
+        print(f"Error: {shadow_git} is not a git repository", file=sys.stderr)
+        print("Run 'aline init' first to initialize the repository.", file=sys.stderr)
+        logger.error(f"No .git found in {shadow_git}")
+        return 1
+
+    logger.info(f"Using shadow git repository: {shadow_git}")
+    # Override repo_root to point to shadow git
+    repo_root = shadow_git
+
     # Get unpushed commits
     try:
         commits = get_unpushed_commits(repo_root)

realign/commands/session_utils.py

@@ -7,15 +7,26 @@ from pathlib import Path
 from typing import List
 
 
-def find_session_paths_for_commit(repo_root: Path, commit_hash: str) -> List[str]:
-    """Return relative session file paths tracked in a given commit."""
+def find_session_paths_for_commit(repo_root: Path, commit_hash: str, git_dir: Path = None) -> List[str]:
+    """
+    Return relative session file paths tracked in a given commit.
+
+    Args:
+        repo_root: Root directory (used if git_dir not provided)
+        commit_hash: Commit hash to query
+        git_dir: Optional git directory to use (for .aline repos)
+
+    Returns:
+        List of relative session file paths
+    """
     try:
+        cwd = git_dir if git_dir else repo_root
         result = subprocess.run(
             ["git", "show", "--pretty=format:", "--name-only", commit_hash],
             capture_output=True,
             text=True,
             check=True,
-            cwd=repo_root,
+            cwd=cwd,
         )
     except subprocess.CalledProcessError:
         return []
@@ -23,6 +34,130 @@ def find_session_paths_for_commit(repo_root: Path, commit_hash: str) -> List[str
     paths = []
     for line in result.stdout.splitlines():
         candidate = line.strip()
-        if candidate.startswith(".realign/sessions/") and candidate.endswith(".jsonl"):
+        # Support both .realign/sessions/ and sessions/ patterns
+        if (candidate.startswith(".realign/sessions/") or candidate.startswith("sessions/")) and candidate.endswith(".jsonl"):
             paths.append(candidate)
     return paths
+
+
+def detect_original_session_location(session_filename: str, project_root: Path, commit_timestamp: int) -> Path:
+    """
+    Detect the original location where a session file should be restored.
+
+    Args:
+        session_filename: Name of session file (e.g., "huminhao_claude_637f35af.jsonl" or "uuid.jsonl")
+        project_root: Root directory of the user's project
+        commit_timestamp: Unix timestamp of the commit
+
+    Returns:
+        Path where session should be restored, or None if cannot detect
+    """
+    from datetime import datetime
+    import re
+
+    # Check if this is a UUID format (Claude Code original format)
+    # UUID pattern: 8-4-4-4-12 hex digits
+    uuid_pattern = r'^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\.jsonl$'
+    if re.match(uuid_pattern, session_filename, re.IGNORECASE):
+        # This is a UUID format session file, likely from Claude Code
+        try:
+            from ..claude_detector import find_claude_sessions_dir
+            claude_dir = find_claude_sessions_dir(project_root)
+            if claude_dir and claude_dir.exists():
+                return claude_dir / session_filename
+        except Exception:
+            pass
+        # Fall through to return None if Claude dir not found
+
+    else:
+        # Parse filename to extract agent type
+        # Expected format: {user}_{agent}_{hash}.jsonl
+        parts = session_filename.replace('.jsonl', '').split('_')
+
+        if len(parts) >= 3:
+            agent_type = parts[1].lower()  # e.g., "claude", "codex"
+
+            if agent_type == "claude":
+                # Try to find Claude sessions directory
+                try:
+                    from ..claude_detector import find_claude_sessions_dir
+                    claude_dir = find_claude_sessions_dir(project_root)
+                    if claude_dir and claude_dir.exists():
+                        return claude_dir / session_filename
+                except Exception:
+                    pass
+
+            elif agent_type == "codex":
+                # Construct Codex path from timestamp
+                try:
+                    dt = datetime.fromtimestamp(int(commit_timestamp))
+                    codex_dir = Path.home() / ".codex" / "sessions" / dt.strftime("%Y") / dt.strftime("%m") / dt.strftime("%d")
+                    if codex_dir.exists():
+                        # Codex uses rollout-* naming, but we'll use our renamed format
+                        return codex_dir / session_filename
+                except Exception:
+                    pass
+
+    # Fall back to None if cannot detect
+    return None
+
+
+def restore_session_from_commit(tracker, commit_hash: str, session_rel_path: str, dest_path: Path) -> bool:
+    """
+    Restore a session file from a commit to its original location.
+
+    Args:
+        tracker: ReAlignGitTracker instance
+        commit_hash: Commit hash to restore from
+        session_rel_path: Relative path in git (e.g., "sessions/user_claude_hash.jsonl")
+        dest_path: Destination path to restore to
+
+    Returns:
+        True if successful, False otherwise
+    """
+    import json
+    from datetime import datetime
+
+    try:
+        # Extract session content from commit
+        result = subprocess.run(
+            ["git", "show", f"{commit_hash}:{session_rel_path}"],
+            cwd=tracker.realign_dir,
+            capture_output=True,
+            check=False
+        )
+
+        if result.returncode != 0:
+            return False
+
+        content = result.stdout.decode('utf-8', errors='replace')
+
+        # Validate JSONL format (basic check)
+        try:
+            for line in content.splitlines():
+                line = line.strip()
+                if line:  # Skip empty lines
+                    json.loads(line)  # Will raise if invalid JSON
+        except json.JSONDecodeError:
+            # Invalid JSONL, create .corrupted file
+            corrupted_path = dest_path.with_suffix('.jsonl.corrupted')
+            corrupted_path.write_text(content, encoding='utf-8')
+            return False
+
+        # If destination exists, create backup
+        if dest_path.exists():
+            timestamp = datetime.now().strftime("%Y%m%d-%H%M%S")
+            backup_name = dest_path.stem + f".backup-{timestamp}" + dest_path.suffix
+            backup_path = dest_path.parent / backup_name
+            dest_path.rename(backup_path)
+
+        # Create parent directory if needed
+        dest_path.parent.mkdir(parents=True, exist_ok=True)
+
+        # Write session content
+        dest_path.write_text(content, encoding='utf-8')
+
+        return True
+
+    except Exception:
+        return False