aline-ai 0.1.9__py3-none-any.whl → 0.2.0__py3-none-any.whl

realign/file_lock.py

@@ -0,0 +1,120 @@
+"""File-based locking mechanism for cross-process synchronization."""
+
+import fcntl
+import os
+import time
+from pathlib import Path
+from typing import Optional
+from contextlib import contextmanager
+
+
+class FileLock:
+    """Simple file-based lock using fcntl (Unix/macOS only)."""
+
+    def __init__(self, lock_file: Path, timeout: float = 10.0):
+        """
+        Initialize a file lock.
+
+        Args:
+            lock_file: Path to the lock file
+            timeout: Maximum time to wait for lock acquisition (seconds)
+        """
+        self.lock_file = lock_file
+        self.timeout = timeout
+        self.fd: Optional[int] = None
+
+    def acquire(self, blocking: bool = True) -> bool:
+        """
+        Acquire the lock.
+
+        Args:
+            blocking: If True, wait for lock; if False, return immediately
+
+        Returns:
+            True if lock was acquired, False otherwise
+        """
+        # Create lock file directory if needed
+        self.lock_file.parent.mkdir(parents=True, exist_ok=True)
+
+        # Open lock file
+        self.fd = os.open(str(self.lock_file), os.O_CREAT | os.O_RDWR)
+
+        if blocking:
+            # Try to acquire with timeout
+            start_time = time.time()
+            while True:
+                try:
+                    fcntl.flock(self.fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
+                    return True
+                except BlockingIOError:
+                    if time.time() - start_time > self.timeout:
+                        os.close(self.fd)
+                        self.fd = None
+                        return False
+                    time.sleep(0.1)
+        else:
+            # Non-blocking attempt
+            try:
+                fcntl.flock(self.fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
+                return True
+            except BlockingIOError:
+                os.close(self.fd)
+                self.fd = None
+                return False
+
+    def release(self):
+        """Release the lock."""
+        if self.fd is not None:
+            try:
+                fcntl.flock(self.fd, fcntl.LOCK_UN)
+                os.close(self.fd)
+            except Exception:
+                pass
+            finally:
+                self.fd = None
+
+    def __enter__(self):
+        """Context manager entry."""
+        if not self.acquire():
+            raise TimeoutError(f"Could not acquire lock on {self.lock_file} within {self.timeout}s")
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Context manager exit."""
+        self.release()
+        return False
+
+    def __del__(self):
+        """Cleanup on deletion."""
+        self.release()
+
+
+@contextmanager
+def commit_lock(repo_path: Path, timeout: float = 10.0):
+    """
+    Context manager for acquiring a commit lock.
+
+    Prevents multiple watchers from committing simultaneously.
+
+    Usage:
+        with commit_lock(repo_path):
+            # Perform git commit
+            subprocess.run(["git", "commit", ...])
+
+    Args:
+        repo_path: Path to the repository
+        timeout: Maximum time to wait for lock (seconds)
+
+    Yields:
+        True if lock was acquired
+    """
+    lock_file = repo_path / ".realign" / ".commit.lock"
+    lock = FileLock(lock_file, timeout=timeout)
+
+    try:
+        if lock.acquire():
+            yield True
+        else:
+            yield False
+    finally:
+        lock.release()

realign/hooks.py

@@ -167,6 +167,41 @@ def find_codex_latest_session(project_path: Path, days_back: int = 7) -> Optiona
     return matching_sessions[0] if matching_sessions else None
 
 
+def find_all_claude_sessions() -> List[Path]:
+    """
+    Find all active Claude Code sessions from ALL projects.
+
+    Scans ~/.claude/projects/ and returns the latest session from each project.
+
+    Returns:
+        List of session file paths from all Claude projects
+    """
+    sessions = []
+    claude_base = Path.home() / ".claude" / "projects"
+
+    if not claude_base.exists():
+        logger.debug(f"Claude projects directory not found: {claude_base}")
+        return sessions
+
+    # Iterate through all project directories
+    for project_dir in claude_base.iterdir():
+        if not project_dir.is_dir():
+            continue
+
+        # Skip system directories
+        if project_dir.name.startswith('.'):
+            continue
+
+        # Find the latest session in this project directory
+        session = find_latest_session(project_dir)
+        if session:
+            sessions.append(session)
+            logger.debug(f"Found Claude session in {project_dir.name}: {session.name}")
+
+    logger.info(f"Found {len(sessions)} Claude session(s) across all projects")
+    return sessions
+
+
 def find_all_active_sessions(
     config: ReAlignConfig,
     project_path: Optional[Path] = None
@@ -181,13 +216,15 @@ def find_all_active_sessions(
 
     Args:
         config: Configuration object
-        project_path: Optional path to the current project (git repo root)
+        project_path: Optional path to the current project (git repo root).
+                     If None, will find sessions from ALL projects (multi-project mode).
 
     Returns:
         List of session file paths (may be empty if no sessions found)
     """
     logger.info("Searching for active AI sessions")
     logger.debug(f"Config: auto_detect_codex={config.auto_detect_codex}, auto_detect_claude={config.auto_detect_claude}")
+    logger.debug(f"Project path: {project_path}")
 
     sessions = []
 
@@ -203,15 +240,47 @@ def find_all_active_sessions(
             logger.warning(f"No session found at explicit path: {history_path}")
         return sessions
 
+    # Multi-project mode: find sessions from ALL projects
+    if project_path is None:
+        logger.info("Multi-project mode: scanning all projects")
+
+        # Find all Claude sessions if enabled
+        if config.auto_detect_claude:
+            logger.debug("Scanning all Claude projects")
+            claude_sessions = find_all_claude_sessions()
+            sessions.extend(claude_sessions)
+
+        # TODO: Add Codex multi-project support if needed
+        # For now, Codex sessions are only found when project_path is specified
+
+        if sessions:
+            logger.info(f"Multi-project scan complete: found {len(sessions)} session(s)")
+            return sessions
+
+        # Fallback: try local history path
+        logger.debug("No sessions found in multi-project scan, trying fallback path")
+        history_path = config.expanded_local_history_path
+        session = find_latest_session(history_path)
+        if session:
+            sessions.append(session)
+            logger.info(f"Found session at fallback path: {session}")
+        else:
+            logger.warning(f"No session found at fallback path: {history_path}")
+
+        return sessions
+
+    # Single-project mode: find sessions for specific project
+    logger.info(f"Single-project mode for: {project_path}")
+
     # Try Codex auto-detection if enabled
-    if config.auto_detect_codex and project_path:
+    if config.auto_detect_codex:
         logger.debug("Attempting Codex auto-detection")
         codex_session = find_codex_latest_session(project_path)
         if codex_session:
             sessions.append(codex_session)
 
     # Try Claude auto-detection if enabled
-    if config.auto_detect_claude and project_path:
+    if config.auto_detect_claude:
         logger.debug("Attempting Claude auto-detection")
         claude_dir = find_claude_sessions_dir(project_path)
         if claude_dir:
@@ -328,13 +397,48 @@ def simple_summarize(content: str, max_chars: int = 500) -> str:
         summary = " | ".join(summaries[:3])
         return summary[:max_chars]
 
+    # Fallback: surface the first few non-empty raw lines to give context
+    fallback_lines = []
+    for raw_line in lines:
+        stripped = raw_line.strip()
+        if not stripped:
+            continue
+        # Skip noisy JSON braces-only lines
+        if stripped in ("{", "}", "[", "]"):
+            continue
+        fallback_lines.append(stripped[:120])
+        if len(fallback_lines) == 3:
+            break
+
+    if fallback_lines:
+        summary = " | ".join(fallback_lines)
+        return summary[:max_chars]
+
     return f"Session updated with {len(lines)} new lines"
 
 
-def generate_summary_with_llm(content: str, max_chars: int = 500, provider: str = "auto") -> Optional[str]:
+def detect_agent_from_session_path(session_relpath: str) -> str:
+    """Infer agent type based on session filename."""
+    lower_path = session_relpath.lower()
+
+    if "codex" in lower_path or "rollout-" in lower_path:
+        return "Codex"
+    if "claude" in lower_path or "agent-" in lower_path:
+        return "Claude"
+    if lower_path.endswith(".jsonl"):
+        # Default to Unknown to avoid mislabeling generic files
+        return "Unknown"
+    return "Unknown"
+
+
+def generate_summary_with_llm(
+    content: str,
+    max_chars: int = 500,
+    provider: str = "auto"
+) -> Tuple[Optional[str], Optional[str]]:
     """
     Generate summary using LLM (Anthropic Claude or OpenAI) for NEW content only.
-    Returns None if LLM is not available or fails.
+    Returns (summary, model_name) tuple, or (None, None) if LLM is unavailable.
 
     Args:
         content: Raw text content of new session additions
@@ -345,7 +449,7 @@ def generate_summary_with_llm(content: str, max_chars: int = 500, provider: str
 
     if not content or not content.strip():
         logger.debug("No content provided for summarization")
-        return "No new content in this session"
+        return "No new content in this session", None
 
     # Truncate content for API (to avoid token limits)
     # Approximately 4000 chars = ~1000 tokens
@@ -395,13 +499,13 @@ def generate_summary_with_llm(content: str, max_chars: int = 500, provider: str
             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]
+            return summary[:max_chars], "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
+                return None, None
             else:
                 print("   ❌ Anthropic package not installed, trying OpenAI...", file=sys.stderr)
         except Exception as e:
@@ -417,7 +521,7 @@ def generate_summary_with_llm(content: str, max_chars: int = 500, provider: str
                     print(f"   ❌ Anthropic quota/credit issue", file=sys.stderr)
                 else:
                     print(f"   ❌ Anthropic API error: {e}", file=sys.stderr)
-                return None
+                return None, None
             else:
                 # Auto mode: try falling back to OpenAI
                 if "authentication" in error_msg.lower() or "invalid" in error_msg.lower():
@@ -433,7 +537,7 @@ def generate_summary_with_llm(content: str, max_chars: int = 500, provider: str
         logger.debug("ANTHROPIC_API_KEY not set")
         if provider == "claude":
             print("   ❌ ANTHROPIC_API_KEY not set", file=sys.stderr)
-            return None
+            return None, None
         else:
             print("   ⓘ ANTHROPIC_API_KEY not set, trying OpenAI...", file=sys.stderr)
 
@@ -471,12 +575,12 @@ def generate_summary_with_llm(content: str, max_chars: int = 500, provider: str
             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]
+            return summary[:max_chars], "gpt-3.5-turbo"
 
         except ImportError:
             logger.warning("OpenAI package not installed")
             print("   ❌ OpenAI package not installed", file=sys.stderr)
-            return None
+            return None, None
         except Exception as e:
             error_msg = str(e)
             logger.error(f"OpenAI API error: {error_msg}", exc_info=True)
@@ -488,17 +592,17 @@ def generate_summary_with_llm(content: str, max_chars: int = 500, provider: str
                 print(f"   ❌ OpenAI quota/billing issue", file=sys.stderr)
             else:
                 print(f"   ❌ OpenAI API error: {e}", file=sys.stderr)
-            return None
+            return None, None
     elif try_openai:
         logger.debug("OPENAI_API_KEY not set")
         print("   ❌ OPENAI_API_KEY not set", file=sys.stderr)
-        return None
+        return 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
+    return None, None
 
 
 def generate_session_filename(user: str, agent: str = "claude") -> str:
@@ -509,6 +613,63 @@ def generate_session_filename(user: str, agent: str = "claude") -> str:
     return f"{timestamp}_{user_short}_{agent}_{short_id}.jsonl"
 
 
+def extract_codex_rollout_hash(filename: str) -> Optional[str]:
+    """
+    Extract stable hash from Codex rollout filename.
+
+    Primary Codex rollout format:
+        rollout-YYYY-MM-DDTHH-MM-SS-<uuid>.jsonl
+        Example: rollout-2025-11-16T18-10-42-019a8ddc-b4b3-7942-9a4f-fac74d1580c9.jsonl
+                 -> 019a8ddc-b4b3-7942-9a4f-fac74d1580c9
+
+    Legacy format (still supported):
+        rollout-<timestamp>-<hash>.jsonl
+        Example: rollout-1763315655-abc123def.jsonl -> abc123def
+
+    Args:
+        filename: Original Codex rollout filename
+
+    Returns:
+        Hash string, or None if parsing fails
+    """
+    if not filename.startswith("rollout-"):
+        return None
+
+    # Normalize filename (strip extension) and remove prefix
+    stem = Path(filename).stem
+    if stem.startswith("rollout-"):
+        stem = stem[len("rollout-"):]
+
+    if not stem:
+        return None
+
+    def looks_like_uuid(value: str) -> bool:
+        """Return True if value matches canonical UUID format."""
+        parts = value.split("-")
+        expected_lengths = [8, 4, 4, 4, 12]
+        if len(parts) != 5:
+            return False
+        hex_digits = set("0123456789abcdefABCDEF")
+        for part, length in zip(parts, expected_lengths):
+            if len(part) != length or not set(part).issubset(hex_digits):
+                return False
+        return True
+
+    # Newer Codex exports append a full UUID after the human-readable timestamp.
+    uuid_candidate_parts = stem.rsplit("-", 5)
+    if len(uuid_candidate_parts) == 6:
+        candidate_uuid = "-".join(uuid_candidate_parts[1:])
+        if looks_like_uuid(candidate_uuid):
+            return candidate_uuid.lower()
+
+    # Fallback for legacy rollout names: everything after first '-' is the hash.
+    legacy_parts = stem.split("-", 1)
+    if len(legacy_parts) == 2 and legacy_parts[1]:
+        return legacy_parts[1]
+
+    return None
+
+
 def get_git_user() -> str:
     """Get git user name."""
     try:
@@ -551,6 +712,8 @@ def copy_session_to_repo(
         '_' not in stem and
         len(stem) == 36  # UUID is 36 chars including hyphens
     )
+    # Codex rollout exports always start with rollout-<timestamp>-
+    is_codex_rollout = original_filename.startswith("rollout-")
 
     # Read session content first to detect agent type
     try:
@@ -566,6 +729,16 @@ def copy_session_to_repo(
             user_short = user.split()[0].lower() if user else "unknown"
             new_filename = f"{user_short}_unknown_{short_id}.jsonl"
             dest_path = sessions_dir / new_filename
+        elif is_codex_rollout:
+            # Extract stable hash from rollout filename
+            rollout_hash = extract_codex_rollout_hash(original_filename)
+            user_short = user.split()[0].lower() if user else "unknown"
+            if rollout_hash:
+                new_filename = f"{user_short}_codex_{rollout_hash}.jsonl"
+            else:
+                # Fallback if hash extraction fails
+                new_filename = generate_session_filename(user, "codex")
+            dest_path = sessions_dir / new_filename
         else:
             dest_path = sessions_dir / original_filename
         temp_path = dest_path.with_suffix(".tmp")
@@ -611,6 +784,18 @@ def copy_session_to_repo(
         # Format: username_agent_shortid.jsonl (no timestamp for consistency)
         new_filename = f"{user_short}_{agent_type}_{short_id}.jsonl"
         dest_path = sessions_dir / new_filename
+    elif is_codex_rollout:
+        # Extract stable hash from rollout filename
+        codex_agent = agent_type if agent_type != "unknown" else "codex"
+        rollout_hash = extract_codex_rollout_hash(original_filename)
+        user_short = user.split()[0].lower() if user else "unknown"
+        if rollout_hash:
+            # Format: username_codex_hash.jsonl (stable naming)
+            new_filename = f"{user_short}_{codex_agent}_{rollout_hash}.jsonl"
+        else:
+            # Fallback if hash extraction fails
+            new_filename = generate_session_filename(user, codex_agent)
+        dest_path = sessions_dir / new_filename
     else:
         # Keep original filename (could be timestamp_user_agent_id format or other)
         dest_path = sessions_dir / original_filename
@@ -678,7 +863,7 @@ def process_sessions(
         user: User name override (optional)
 
     Returns:
-        Dictionary with keys: summary, session_relpaths, redacted
+        Dictionary with keys: summary, session_relpaths, redacted, summary_entries, summary_model
     """
     import time
     start_time = time.time()
@@ -746,7 +931,13 @@ def process_sessions(
 
     if not session_relpaths:
         logger.warning("No session files copied successfully")
-        return {"summary": "", "session_relpaths": [], "redacted": False}
+        return {
+            "summary": "",
+            "session_relpaths": [],
+            "redacted": False,
+            "summary_entries": [],
+            "summary_model": "",
+        }
 
     logger.info(f"Copied {len(session_relpaths)} session(s): {session_relpaths}")
 
@@ -758,6 +949,8 @@ def process_sessions(
             "summary": "",
             "session_relpaths": session_relpaths,
             "redacted": any_redacted,
+            "summary_entries": [],
+            "summary_model": "",
         }
 
     # For prepare-commit-msg mode, we need to stage files first to get accurate diff
@@ -776,7 +969,9 @@ def process_sessions(
 
     # For prepare-commit-msg mode, generate summary from all sessions
     logger.info("Generating summaries for sessions")
-    all_summaries = []
+    summary_entries: List[Dict[str, str]] = []
+    legacy_summary_chunks: List[str] = []
+    summary_model_label: Optional[str] = None
 
     for session_relpath in session_relpaths:
         # Extract NEW content using git diff
@@ -787,37 +982,50 @@ def process_sessions(
             continue
 
         # Generate summary for NEW content only
-        summary = None
+        summary_text: Optional[str] = None
+        is_llm_summary = False
+        llm_model_name: Optional[str] = None
         if config.use_LLM:
             print(f"🤖 Attempting to generate LLM summary (provider: {config.llm_provider})...", file=sys.stderr)
-            summary = generate_summary_with_llm(new_content, config.summary_max_chars, config.llm_provider)
+            summary_text, llm_model_name = generate_summary_with_llm(
+                new_content,
+                config.summary_max_chars,
+                config.llm_provider
+            )
 
-            if summary:
+            if summary_text:
                 print("✅ LLM summary generated successfully", file=sys.stderr)
+                is_llm_summary = True
+                if summary_model_label is None:
+                    summary_model_label = llm_model_name or config.llm_provider
             else:
                 print("⚠️  LLM summary failed - falling back to local summarization", file=sys.stderr)
                 print("   Check your API keys: ANTHROPIC_API_KEY or OPENAI_API_KEY", file=sys.stderr)
 
-        if not summary:
+        if not summary_text:
             # Fallback to simple summarize
             logger.info("Using local summarization (no LLM)")
             print("📝 Using local summarization (no LLM)", file=sys.stderr)
-            summary = simple_summarize(new_content, config.summary_max_chars)
+            summary_text = simple_summarize(new_content, config.summary_max_chars)
 
         # Identify agent type from filename
-        agent_name = "Unknown"
-        if "rollout-" in session_relpath:
-            agent_name = "Codex"
-        elif "agent-" in session_relpath or ".jsonl" in session_relpath:
-            agent_name = "Claude"
+        agent_name = detect_agent_from_session_path(session_relpath)
 
-        logger.debug(f"Summary for {session_relpath} ({agent_name}): {summary[:100]}...")
-        all_summaries.append(f"[{agent_name}] {summary}")
+        summary_text = summary_text.strip()
+        logger.debug(f"Summary for {session_relpath} ({agent_name}): {summary_text[:100]}...")
+        summary_entries.append({
+            "agent": agent_name,
+            "text": summary_text,
+            "source": "llm" if is_llm_summary else "local",
+        })
+        legacy_summary_chunks.append(f"[{agent_name}] {summary_text}")
 
     # Combine all summaries
-    if all_summaries:
-        combined_summary = " | ".join(all_summaries)
-        logger.info(f"Generated {len(all_summaries)} summary(ies)")
+    if summary_entries:
+        if summary_model_label is None:
+            summary_model_label = "Local summarizer"
+        combined_summary = " | ".join(legacy_summary_chunks)
+        logger.info(f"Generated {len(summary_entries)} summary(ies)")
     else:
         combined_summary = "No new content in sessions"
         logger.info("No summaries generated (no new content)")
@@ -829,6 +1037,8 @@ def process_sessions(
         "summary": combined_summary,
         "session_relpaths": session_relpaths,
         "redacted": any_redacted,
+        "summary_entries": summary_entries,
+        "summary_model": summary_model_label or "",
     }
 
 
@@ -875,22 +1085,37 @@ def prepare_commit_msg_hook():
     Generates session summary and appends to commit message.
     """
     # Get commit message file path from command line arguments
-    if len(sys.argv) < 2:
-        print("Error: Commit message file path not provided", file=sys.stderr)
-        sys.exit(1)
-
-    msg_file = sys.argv[1]
+    # When called via __main__ with --prepare-commit-msg flag, the file is at index 2
+    # When called directly as a hook entry point, the file is at index 1
+    if sys.argv[1] == "--prepare-commit-msg":
+        # Called via: python -m realign.hooks --prepare-commit-msg <msg-file> <source>
+        if len(sys.argv) < 3:
+            print("Error: Commit message file path not provided", file=sys.stderr)
+            sys.exit(1)
+        msg_file = sys.argv[2]
+    else:
+        # Called via: realign-hook-prepare-commit-msg <msg-file> <source>
+        msg_file = sys.argv[1]
 
     # Process sessions and generate summary
     result = process_sessions(pre_commit_mode=False)
 
     # Append summary to commit message
-    if result["summary"] and result["session_relpaths"]:
+    summary_entries = result.get("summary_entries") or []
+    if summary_entries:
         try:
             with open(msg_file, "a", encoding="utf-8") as f:
-                f.write(f"\n\nAgent-Summary: {result['summary']}\n")
-                f.write(f"Agent-Session-Paths: {', '.join(result['session_relpaths'])}\n")
-                if result["redacted"]:
+                summary_model = result.get("summary_model") or "Local summarizer"
+                f.write("\n\n")
+                f.write(f"--- LLM-Summary ({summary_model}) ---\n")
+                for entry in summary_entries:
+                    agent_label = entry.get("agent", "Agent")
+                    text = (entry.get("text") or "").strip()
+                    if not text:
+                        continue
+                    f.write(f"* [{agent_label}] {text}\n")
+                f.write("\n")
+                if result.get("redacted"):
                     f.write("Agent-Redacted: true\n")
         except Exception as e:
             print(f"Warning: Could not append to commit message: {e}", file=sys.stderr)