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

{aline_ai-0.2.0.dist-info → aline_ai-0.2.2.dist-info}/METADATA

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

{aline_ai-0.2.0.dist-info → aline_ai-0.2.2.dist-info}/RECORD

@@ -1,25 +1,25 @@
-aline_ai-0.2.0.dist-info/licenses/LICENSE,sha256=H8wTqV5IF1oHw_HbBtS1PSDU8G_q81yblEIL_JfV8Vo,1077
-realign/__init__.py,sha256=BQbPK4WDn_XTLzhYq5k0CThranUR0W-UN21_yU9w-D4,68
+aline_ai-0.2.2.dist-info/licenses/LICENSE,sha256=H8wTqV5IF1oHw_HbBtS1PSDU8G_q81yblEIL_JfV8Vo,1077
+realign/__init__.py,sha256=f1FalM6Y9iEIqHcRYlPxgxYsNHpJAHkmJtFz4WPRUeU,68
 realign/claude_detector.py,sha256=NLxI0zJWcqNxNha9jAy9AslTMwHKakCc9yPGdkrbiFE,3028
 realign/cli.py,sha256=bkwS329jMDEkrUEihXRN2DDyeTKE6HbAysoDxxskZ8g,941
 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=l4RclCoUaj4w84r3kLSPTh3c9IVqYE5_pv_JKXMp1f8,45076
+realign/hooks.py,sha256=80x7kF7t_D2D0TWM4whCU2Id3ItgkPXeREKkz1jfL_c,48751
 realign/logging_config.py,sha256=KvkKktF-bkUu031y9vgUoHpsbnOw7ud25jhpzliNZwA,4929
 realign/mcp_server.py,sha256=dntFatMpozI80K5hHrIiQ9sviC6ARKTP89goULhi1T4,16477
-realign/mcp_watcher.py,sha256=D6qVM0yD2hQPxrD_HnHkDob78_dqK96klHIogh48cw4,23971
+realign/mcp_watcher.py,sha256=ffYOXDLuf9T6Kab3CdGNAOY3DBlAbjZrVrSjM5RdYGU,26828
 realign/redactor.py,sha256=uZvLKKGrRGJm-qM8S4XJyJK6i0CSSby_wbKiay7VGJw,8148
 realign/commands/__init__.py,sha256=GG6IMw6fUBQAXGJDFJvOOQgv6pkiRSfMh8z3AYXTyRM,31
 realign/commands/auto_commit.py,sha256=jgjAYZHqN34NmQkncZg3Vtwsl3MyAlsvucxEBwUj7ko,7450
 realign/commands/commit.py,sha256=mlwrv5nfTRY17WlcAdiJKKGh5uM7dGvT7sMxhdbsfkw,12605
 realign/commands/config.py,sha256=iiu7usqw00djKZja5bx0iDH8DB0vU2maUPMkXLdgXwI,6609
-realign/commands/init.py,sha256=_w5_ZzNpdiHO5EJ6KHKwJf3_ne54EXhwuq4sT-XSZ0U,13246
+realign/commands/init.py,sha256=52WkcgdTdsvYXYOuTQ0zR1QF6QOWsjWOuu0f8vLhbL4,13452
 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.0.dist-info/METADATA,sha256=vBklfx2KSYMZbpmnjY9h1A3AhwlCQDdHMr4xEVX2iuM,1398
-aline_ai-0.2.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-aline_ai-0.2.0.dist-info/entry_points.txt,sha256=h-NocHDzSueXfsepHTIdRPNQzhNZQPAztJfldd-mQTE,202
-aline_ai-0.2.0.dist-info/top_level.txt,sha256=yIL3s2xv9nf1GwD5n71Aq_JEIV4AfzCIDNKBzewuRm4,8
-aline_ai-0.2.0.dist-info/RECORD,,
+aline_ai-0.2.2.dist-info/METADATA,sha256=Eck_4ZFdzNnAcomzVJ5aoK4XgwPKpBmh8NiAzJfN2RE,1398
+aline_ai-0.2.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+aline_ai-0.2.2.dist-info/entry_points.txt,sha256=h-NocHDzSueXfsepHTIdRPNQzhNZQPAztJfldd-mQTE,202
+aline_ai-0.2.2.dist-info/top_level.txt,sha256=yIL3s2xv9nf1GwD5n71Aq_JEIV4AfzCIDNKBzewuRm4,8
+aline_ai-0.2.2.dist-info/RECORD,,

realign/__init__.py

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

realign/commands/init.py

@@ -119,10 +119,16 @@ def init_repository(
             hook_path.chmod(0o755)
             result["hooks_created"].append(f"prepare-commit-msg ({action})")
 
-        # Create .gitignore for sessions (optional - commented out for MVP)
+        # Create .gitignore for sessions and metadata
         gitignore_path = realign_dir / ".gitignore"
         if not gitignore_path.exists():
-            gitignore_path.write_text("# Uncomment to ignore session files\n# sessions/\n", encoding="utf-8")
+            gitignore_content = (
+                "# Uncomment to ignore session files\n"
+                "# sessions/\n\n"
+                "# Ignore metadata files (used internally to prevent duplicate processing)\n"
+                ".metadata/\n"
+            )
+            gitignore_path.write_text(gitignore_content, encoding="utf-8")
 
         # Backup and set core.hooksPath
         backup_file = realign_dir / "backup_hook_config.yaml"

realign/hooks.py

@@ -311,6 +311,10 @@ def find_latest_session(history_path: Path, explicit_path: Optional[str] = None)
     """
     Find the most recent session file.
 
+    Filters out Claude Code agent sessions (agent-*.jsonl) since they are
+    sub-tasks of main sessions and their results are already incorporated
+    into the main session files.
+
     Args:
         history_path: Path to history directory or a specific session file (for Codex)
         explicit_path: Explicit path to a session file (overrides history_path)
@@ -337,7 +341,13 @@ def find_latest_session(history_path: Path, explicit_path: Optional[str] = None)
     # Otherwise, search directory for session files
     session_files = []
     for pattern in ["*.json", "*.jsonl"]:
-        session_files.extend(history_path.glob(pattern))
+        for file in history_path.glob(pattern):
+            # Filter out Claude Code agent sessions (agent-*.jsonl)
+            # These are sub-tasks whose results are already in main sessions
+            if file.name.startswith("agent-"):
+                logger.debug(f"Skipping agent session: {file.name}")
+                continue
+            session_files.append(file)
 
     if not session_files:
         return None
@@ -689,12 +699,12 @@ def copy_session_to_repo(
     repo_root: Path,
     user: str,
     config: Optional[ReAlignConfig] = None
-) -> Tuple[Path, str, bool]:
+) -> Tuple[Path, str, bool, int]:
     """
     Copy session file to repository .realign/sessions/ directory.
     Optionally redacts sensitive information if configured.
     If the source filename is in UUID format, renames it to include username for better identification.
-    Returns (absolute_path, relative_path, was_redacted).
+    Returns (absolute_path, relative_path, was_redacted, content_size).
     """
     logger.info(f"Copying session to repo: {session_file.name}")
     logger.debug(f"Source: {session_file}, Repo root: {repo_root}, User: {user}")
@@ -746,7 +756,12 @@ def copy_session_to_repo(
         temp_path.rename(dest_path)
         rel_path = dest_path.relative_to(repo_root)
         logger.warning(f"Copied session with fallback (no agent detection): {rel_path}")
-        return dest_path, str(rel_path), False
+        # Get file size for the fallback case
+        try:
+            fallback_size = dest_path.stat().st_size
+        except Exception:
+            fallback_size = 0
+        return dest_path, str(rel_path), False, fallback_size
 
     # Detect agent type from session content
     agent_type = "unknown"
@@ -843,9 +858,68 @@ def copy_session_to_repo(
         shutil.copy2(session_file, dest_path)
         logger.warning("Fallback to simple copy")
 
-    # Return both absolute and relative paths, plus redaction status
+    # Return both absolute and relative paths, plus redaction status and content size
     rel_path = dest_path.relative_to(repo_root)
-    return dest_path, str(rel_path), was_redacted
+    content_size = len(content)
+    return dest_path, str(rel_path), was_redacted, content_size
+
+
+def save_session_metadata(repo_root: Path, session_relpath: str, content_size: int):
+    """
+    Save metadata about a processed session to avoid reprocessing.
+
+    Args:
+        repo_root: Path to repository root
+        session_relpath: Relative path to session file
+        content_size: Size of session content when processed
+    """
+    metadata_dir = repo_root / ".realign" / ".metadata"
+    metadata_dir.mkdir(parents=True, exist_ok=True)
+
+    # Use session filename as metadata key
+    session_name = Path(session_relpath).name
+    metadata_file = metadata_dir / f"{session_name}.meta"
+
+    metadata = {
+        "processed_at": time.time(),
+        "content_size": content_size,
+        "session_relpath": session_relpath,
+    }
+
+    try:
+        with open(metadata_file, 'w', encoding='utf-8') as f:
+            json.dump(metadata, f)
+        logger.debug(f"Saved metadata for {session_relpath}: {content_size} bytes")
+    except Exception as e:
+        logger.warning(f"Failed to save metadata for {session_relpath}: {e}")
+
+
+def get_session_metadata(repo_root: Path, session_relpath: str) -> Optional[Dict[str, Any]]:
+    """
+    Get metadata about a previously processed session.
+
+    Args:
+        repo_root: Path to repository root
+        session_relpath: Relative path to session file
+
+    Returns:
+        Metadata dictionary or None if not found
+    """
+    metadata_dir = repo_root / ".realign" / ".metadata"
+    session_name = Path(session_relpath).name
+    metadata_file = metadata_dir / f"{session_name}.meta"
+
+    if not metadata_file.exists():
+        return None
+
+    try:
+        with open(metadata_file, 'r', encoding='utf-8') as f:
+            metadata = json.load(f)
+        logger.debug(f"Loaded metadata for {session_relpath}: {metadata.get('content_size')} bytes")
+        return metadata
+    except Exception as e:
+        logger.warning(f"Failed to load metadata for {session_relpath}: {e}")
+        return None
 
 
 def process_sessions(
@@ -915,13 +989,15 @@ def process_sessions(
 
     # Copy all sessions to repo (with optional redaction)
     session_relpaths = []
+    session_metadata_map = {}  # Map session_relpath -> content_size
     any_redacted = False
     for session_file in session_files:
         try:
-            _, session_relpath, was_redacted = copy_session_to_repo(
+            _, session_relpath, was_redacted, content_size = copy_session_to_repo(
                 session_file, repo_root, user, config
             )
             session_relpaths.append(session_relpath)
+            session_metadata_map[session_relpath] = content_size
             if was_redacted:
                 any_redacted = True
         except Exception as e:
@@ -941,8 +1017,13 @@ def process_sessions(
 
     logger.info(f"Copied {len(session_relpaths)} session(s): {session_relpaths}")
 
-    # If pre-commit mode, just return session paths (summary will be generated later)
+    # If pre-commit mode, save metadata and return session paths (summary will be generated later)
     if pre_commit_mode:
+        # Save metadata for each session to prevent reprocessing
+        for session_relpath, content_size in session_metadata_map.items():
+            save_session_metadata(repo_root, session_relpath, content_size)
+            logger.debug(f"Saved metadata for {session_relpath} in pre-commit")
+
         elapsed = time.time() - start_time
         logger.info(f"======== Hook completed: {hook_type} in {elapsed:.2f}s ========")
         return {
@@ -974,7 +1055,10 @@ def process_sessions(
     summary_model_label: Optional[str] = None
 
     for session_relpath in session_relpaths:
-        # Extract NEW content using git diff
+        # Extract NEW content using git diff (compares staged content with HEAD)
+        # This correctly detects new content even if the file hasn't grown since pre-commit
+        # (which happens in auto-commit scenarios where the AI has finished responding)
+        current_size = session_metadata_map.get(session_relpath, 0)
         new_content = get_new_content_from_git_diff(repo_root, session_relpath)
 
         if not new_content or not new_content.strip():
@@ -1020,6 +1104,10 @@ def process_sessions(
         })
         legacy_summary_chunks.append(f"[{agent_name}] {summary_text}")
 
+        # Update metadata after successfully generating summary
+        save_session_metadata(repo_root, session_relpath, current_size)
+        logger.debug(f"Updated metadata for {session_relpath} in prepare-commit-msg")
+
     # Combine all summaries
     if summary_entries:
         if summary_model_label is None:

realign/mcp_watcher.py

@@ -14,6 +14,10 @@ from datetime import datetime
 
 from .config import ReAlignConfig
 from .hooks import find_all_active_sessions
+from .logging_config import setup_logger
+
+# Initialize logger for watcher
+logger = setup_logger('realign.mcp_watcher', 'mcp_watcher.log')
 
 
 # Session type detection
@@ -38,17 +42,24 @@ class DialogueWatcher:
     async def start(self):
         """Start watching session files."""
         if not self.config.mcp_auto_commit:
+            logger.info("Auto-commit disabled in config")
             print("[MCP Watcher] Auto-commit disabled in config", file=sys.stderr)
             return
 
         self.running = True
+        logger.info("Started watching for dialogue completion")
+        logger.info(f"Mode: Per-request (triggers at end of each AI response)")
+        logger.info(f"Supports: Claude Code & Codex (auto-detected)")
+        logger.info(f"Debounce: {self.debounce_delay}s, Cooldown: {self.min_commit_interval}s")
         print("[MCP Watcher] Started watching for dialogue completion", file=sys.stderr)
         print(f"[MCP Watcher] Mode: Per-request (triggers at end of each AI response)", file=sys.stderr)
         print(f"[MCP Watcher] Supports: Claude Code & Codex (auto-detected)", file=sys.stderr)
         print(f"[MCP Watcher] Debounce: {self.debounce_delay}s, Cooldown: {self.min_commit_interval}s", file=sys.stderr)
         if self.project_path:
+            logger.info(f"Monitoring project: {self.project_path}")
             print(f"[MCP Watcher] Monitoring project: {self.project_path}", file=sys.stderr)
         else:
+            logger.info("Project path unknown, falling back to multi-project scan")
             print("[MCP Watcher] Project path unknown, falling back to multi-project scan", file=sys.stderr)
 
         # Initialize baseline sizes and stop_reason counts
@@ -61,6 +72,7 @@ class DialogueWatcher:
                 await self.check_for_changes()
                 await asyncio.sleep(0.5)  # Check every 0.5 seconds for responsiveness
             except Exception as e:
+                logger.error(f"Error in check loop: {e}", exc_info=True)
                 print(f"[MCP Watcher] Error: {e}", file=sys.stderr)
                 await asyncio.sleep(1.0)
 
@@ -69,6 +81,7 @@ class DialogueWatcher:
         self.running = False
         if self.pending_commit_task:
             self.pending_commit_task.cancel()
+        logger.info("Watcher stopped")
         print("[MCP Watcher] Stopped", file=sys.stderr)
 
     def _get_session_sizes(self) -> Dict[str, int]:
@@ -82,7 +95,9 @@ class DialogueWatcher:
             for session_file in session_files:
                 if session_file.exists():
                     sizes[str(session_file)] = session_file.stat().st_size
+            logger.debug(f"Tracked {len(sizes)} session file(s)")
         except Exception as e:
+            logger.error(f"Error getting session sizes: {e}", exc_info=True)
             print(f"[MCP Watcher] Error getting session sizes: {e}", file=sys.stderr)
         return sizes
 
@@ -239,8 +254,11 @@ class DialogueWatcher:
         """
         Count complete dialogue turns for Claude Code sessions.
 
-        Uses stop_reason='end_turn' as the marker, with message ID deduplication
+        Uses stop_reason in ('end_turn', 'tool_use') as the marker, with message ID deduplication
         to handle Claude Code's incremental writes (thinking first, then full content).
+
+        Note: In Claude Code, most responses have stop_reason='tool_use' because the AI
+        frequently uses tools. We count both 'end_turn' and 'tool_use' as complete turns.
         """
         unique_message_ids = set()
         try:
@@ -252,8 +270,11 @@ class DialogueWatcher:
                     try:
                         data = json.loads(line)
                         message = data.get("message", {})
-                        # Only count end_turn stop reasons (ignore tool_use, etc.)
-                        if message.get("stop_reason") == "end_turn":
+                        stop_reason = message.get("stop_reason")
+                        # Count both end_turn and tool_use as complete turns
+                        # tool_use indicates the AI used tools (most common in Claude Code)
+                        # end_turn indicates a simple response without tools
+                        if stop_reason in ("end_turn", "tool_use"):
                             # Deduplicate by message ID to handle incremental writes
                             msg_id = message.get("id")
                             if msg_id:
@@ -264,6 +285,7 @@ class DialogueWatcher:
                     except json.JSONDecodeError:
                         continue
         except Exception as e:
+            logger.error(f"Error counting Claude turns in {session_file}: {e}", exc_info=True)
             print(f"[MCP Watcher] Error counting Claude turns in {session_file}: {e}", file=sys.stderr)
         return len(unique_message_ids)
 
@@ -308,10 +330,13 @@ class DialogueWatcher:
                 old_size = self.last_session_sizes.get(path, 0)
                 if size > old_size:
                     changed_files.append(Path(path))
+                    logger.debug(f"Session file changed: {Path(path).name} ({old_size} -> {size} bytes)")
 
             if changed_files:
+                logger.info(f"Detected changes in {len(changed_files)} session file(s), scheduling commit check")
                 # File changed - cancel any pending commit and schedule a new one
                 if self.pending_commit_task:
+                    logger.debug("Cancelling pending commit task")
                     self.pending_commit_task.cancel()
 
                 # Wait for debounce period to ensure the turn is complete
@@ -323,6 +348,7 @@ class DialogueWatcher:
             self.last_session_sizes = current_sizes
 
         except Exception as e:
+            logger.error(f"Error checking for changes: {e}", exc_info=True)
             print(f"[MCP Watcher] Error checking for changes: {e}", file=sys.stderr)
 
     async def _debounced_commit(self, changed_files: list):
@@ -337,6 +363,7 @@ class DialogueWatcher:
             for session_file in changed_files:
                 if await self._check_if_turn_complete(session_file):
                     session_to_commit = session_file
+                    logger.info(f"Complete turn detected in {session_file.name}")
                     print(f"[MCP Watcher] Complete turn detected in {session_file.name}", file=sys.stderr)
                     break
 
@@ -344,6 +371,7 @@ class DialogueWatcher:
                 # Extract project path from the session file
                 project_path = self._extract_project_path(session_to_commit)
                 if not project_path:
+                    logger.warning(f"Could not determine project path for {session_to_commit.name}, skipping commit")
                     print(f"[MCP Watcher] Could not determine project path for {session_to_commit.name}, skipping commit", file=sys.stderr)
                     return
 
@@ -354,10 +382,12 @@ class DialogueWatcher:
                 if last_commit_time:
                     time_since_last = current_time - last_commit_time
                     if time_since_last < self.min_commit_interval:
+                        logger.info(f"Skipping commit for {project_path.name} (cooldown: {time_since_last:.1f}s < {self.min_commit_interval}s)")
                         print(f"[MCP Watcher] Skipping commit for {project_path.name} (cooldown: {time_since_last:.1f}s < {self.min_commit_interval}s)", file=sys.stderr)
                         return
 
                 # Perform commit for this project
+                logger.info(f"Triggering commit for {project_path.name}")
                 await self._do_commit(project_path, session_to_commit)
 
         except asyncio.CancelledError:
@@ -390,6 +420,7 @@ class DialogueWatcher:
 
             # Commit after each complete assistant response (1 new turn)
             if new_turns >= 1:
+                logger.info(f"Detected {new_turns} new turn(s) in {session_file.name} ({session_type})")
                 print(f"[MCP Watcher] Detected {new_turns} new turn(s) in {session_file.name} ({session_type})", file=sys.stderr)
                 # Update baseline immediately to avoid double-counting
                 self.last_stop_reason_counts[session_path] = current_count
@@ -398,6 +429,7 @@ class DialogueWatcher:
             return False
 
         except Exception as e:
+            logger.error(f"Error checking turn completion: {e}", exc_info=True)
             print(f"[MCP Watcher] Error checking turn completion: {e}", file=sys.stderr)
             return False
 
@@ -423,12 +455,16 @@ 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)
                 # 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()
+            else:
+                logger.warning(f"Commit failed for {project_path.name}")
 
         except Exception as e:
+            logger.error(f"Error during commit for {project_path}: {e}", exc_info=True)
             print(f"[MCP Watcher] Error during commit for {project_path}: {e}", file=sys.stderr)
 
     def _run_realign_commit(self, project_path: Path, message: str) -> bool:
@@ -562,11 +598,15 @@ async def start_watcher():
     global _watcher
 
     if _watcher and _watcher.running:
+        logger.info("Watcher already running, skipping start")
         print("[MCP Watcher] Already running", file=sys.stderr)
         return
 
+    logger.info("Initializing global watcher instance")
     _watcher = DialogueWatcher()
+    logger.info("Starting watcher task")
     asyncio.create_task(_watcher.start())
+    logger.info("Watcher task created")
 
 
 async def stop_watcher():