aline-ai 0.1.4__py3-none-any.whl → 0.1.6__py3-none-any.whl

{aline_ai-0.1.4.dist-info → aline_ai-0.1.6.dist-info}/METADATA

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

{aline_ai-0.1.4.dist-info → aline_ai-0.1.6.dist-info}/RECORD

@@ -1,13 +1,13 @@
-aline_ai-0.1.4.dist-info/licenses/LICENSE,sha256=H8wTqV5IF1oHw_HbBtS1PSDU8G_q81yblEIL_JfV8Vo,1077
-realign/__init__.py,sha256=PFVJVPatfhf1vGJIGnMKgKkPLWTkGXI6NKq_PQMW7Bc,68
+aline_ai-0.1.6.dist-info/licenses/LICENSE,sha256=H8wTqV5IF1oHw_HbBtS1PSDU8G_q81yblEIL_JfV8Vo,1077
+realign/__init__.py,sha256=7fKH0C4lNvrYFiQ00kUEAH-H3RUUMLXG-69ehNncimI,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/hooks.py,sha256=qhAeuln_62OgTq0vboZcUAuP2apOrNn58vSZqKwNmWQ,36456
 realign/logging_config.py,sha256=KvkKktF-bkUu031y9vgUoHpsbnOw7ud25jhpzliNZwA,4929
-realign/mcp_server.py,sha256=oe2RQZ7_en_6vDMqXgVaSHCSqc_aQejc8wM2vkF0rj4,16702
-realign/mcp_watcher.py,sha256=jxr4em27hw79N9d-lYCbu4dGclzG7OyPuPFtPeeadMM,13122
+realign/mcp_server.py,sha256=-LAJIsxN8U1VSzr-8TYhV9s2jC_t4_XdblnGAcbaKNk,17572
+realign/mcp_watcher.py,sha256=a_9R0r4DM8a9BiRIimJlY8_EhoHTQcTo55yCf4vVYOU,16163
 realign/redactor.py,sha256=uZvLKKGrRGJm-qM8S4XJyJK6i0CSSby_wbKiay7VGJw,8148
 realign/commands/__init__.py,sha256=GG6IMw6fUBQAXGJDFJvOOQgv6pkiRSfMh8z3AYXTyRM,31
 realign/commands/auto_commit.py,sha256=_DOw7nt9q3tD_Y3qDL9IFKAUG1hM4qH_xZ-9nyBc2Bc,7451
@@ -16,8 +16,8 @@ realign/commands/config.py,sha256=oarvn6UuGT8svd2h5_8M_ueV5QWOCUOn8SYoa4XYjs8,65
 realign/commands/init.py,sha256=EpSzh2Dd2EmEQ_wo3vAsg6Uq7_YOlQWIpzIkZa_2y0A,11863
 realign/commands/search.py,sha256=0CZaXll99wtd01MRiZk5NAblxgogc4RUAzMyJunvckE,18044
 realign/commands/show.py,sha256=P1waa94-AKJr9XjagkE40OHMXzE6IwC74DpeDKqwsqw,16693
-aline_ai-0.1.4.dist-info/METADATA,sha256=fGfNH8tf8zKsOhpi7vfAkDkRDF0zFzpWHNaFtCtrnIM,1398
-aline_ai-0.1.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-aline_ai-0.1.4.dist-info/entry_points.txt,sha256=h-NocHDzSueXfsepHTIdRPNQzhNZQPAztJfldd-mQTE,202
-aline_ai-0.1.4.dist-info/top_level.txt,sha256=yIL3s2xv9nf1GwD5n71Aq_JEIV4AfzCIDNKBzewuRm4,8
-aline_ai-0.1.4.dist-info/RECORD,,
+aline_ai-0.1.6.dist-info/METADATA,sha256=GK1pSW1EFmnNV2ojpzEBhoBDlQrYKr9OAf4c_VELcww,1398
+aline_ai-0.1.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+aline_ai-0.1.6.dist-info/entry_points.txt,sha256=h-NocHDzSueXfsepHTIdRPNQzhNZQPAztJfldd-mQTE,202
+aline_ai-0.1.6.dist-info/top_level.txt,sha256=yIL3s2xv9nf1GwD5n71Aq_JEIV4AfzCIDNKBzewuRm4,8
+aline_ai-0.1.6.dist-info/RECORD,,

realign/__init__.py

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

realign/mcp_server.py

@@ -398,6 +398,7 @@ async def handle_version(args: dict) -> list[TextContent]:
 async def async_main():
     """Run the MCP server (async)."""
     print("[MCP Server] Starting Aline MCP server...", file=sys.stderr)
+    print(f"[MCP Server] Current working directory: {Path.cwd()}", file=sys.stderr)
 
     # Detect workspace path and start the watcher
     # Try multiple methods since MCP server may run in different context
@@ -414,25 +415,32 @@ async def async_main():
         if result.returncode == 0:
             repo_path = Path(result.stdout.strip())
             print(f"[MCP Server] Detected workspace from git: {repo_path}", file=sys.stderr)
+        else:
+            print(f"[MCP Server] Not in git repo (cwd: {Path.cwd()})", file=sys.stderr)
 
         # Method 2: If not in git repo, try to find from Claude session files
         if not repo_path:
             claude_projects = Path.home() / ".claude" / "projects"
+            print(f"[MCP Server] Checking Claude projects at: {claude_projects}", file=sys.stderr)
             if claude_projects.exists():
                 # Find most recently modified session file
                 session_files = list(claude_projects.glob("*/*.jsonl"))
+                print(f"[MCP Server] Found {len(session_files)} Claude session files", file=sys.stderr)
                 if session_files:
                     # Sort by modification time, newest first
                     session_files.sort(key=lambda p: p.stat().st_mtime, reverse=True)
+                    print(f"[MCP Server] Most recent session: {session_files[0]}", file=sys.stderr)
                     # Extract project path from directory name
                     # Format: -Users-jundewu-Downloads-code-noclue -> /Users/jundewu/Downloads/code/noclue
                     project_dir_name = session_files[0].parent.name
+                    print(f"[MCP Server] Project dir name: {project_dir_name}", file=sys.stderr)
                     if project_dir_name.startswith('-'):
                         # Convert back to path: -Users-foo-bar -> /Users/foo/bar
                         # Note: underscores were also replaced with dashes, but we can't distinguish
                         # So we just replace dashes with slashes
                         path_str = '/' + project_dir_name[1:].replace('-', '/')
                         candidate_path = Path(path_str)
+                        print(f"[MCP Server] Candidate path: {candidate_path}, exists: {candidate_path.exists()}", file=sys.stderr)
                         if candidate_path.exists():
                             repo_path = candidate_path
                             print(f"[MCP Server] Detected workspace from Claude session: {repo_path}", file=sys.stderr)
@@ -443,10 +451,13 @@ async def async_main():
             print(f"[MCP Server] Using current directory: {repo_path}", file=sys.stderr)
 
         # Start the watcher
+        print(f"[MCP Server] Starting watcher for: {repo_path}", file=sys.stderr)
         await start_watcher(repo_path)
 
     except Exception as e:
         print(f"[MCP Server] Warning: Could not start watcher: {e}", file=sys.stderr)
+        import traceback
+        traceback.print_exc(file=sys.stderr)
 
     print("[MCP Server] MCP server ready", file=sys.stderr)
 

realign/mcp_watcher.py

@@ -17,9 +17,9 @@ class DialogueWatcher:
     """Watch session files and auto-commit immediately after each user request completes."""
 
     def __init__(self, repo_path: Path):
-        self.repo_path = repo_path
+        self.repo_path = repo_path  # Default repo path (may be overridden per-session)
         self.config = ReAlignConfig.load()
-        self.last_commit_time: Optional[float] = None
+        self.last_commit_time: Dict[str, float] = {}  # Track commit time per project
         self.last_session_sizes: Dict[str, int] = {}  # Track file sizes
         self.last_stop_reason_counts: Dict[str, int] = {}  # Track stop_reason counts per session
         self.min_commit_interval = 5.0  # Minimum 5 seconds between commits (cooldown)
@@ -37,11 +37,23 @@ class DialogueWatcher:
         print("[MCP Watcher] Started watching for dialogue completion", file=sys.stderr)
         print(f"[MCP Watcher] Mode: Per-request (triggers at end of each Claude response)", file=sys.stderr)
         print(f"[MCP Watcher] Debounce: {self.debounce_delay}s, Cooldown: {self.min_commit_interval}s", file=sys.stderr)
+        print(f"[MCP Watcher] Home directory: {Path.home()}", file=sys.stderr)
 
         # Initialize baseline sizes and stop_reason counts
         self.last_session_sizes = self._get_session_sizes()
         self.last_stop_reason_counts = self._get_stop_reason_counts()
 
+        # Log initial session files being monitored
+        if self.last_session_sizes:
+            print(f"[MCP Watcher] Monitoring {len(self.last_session_sizes)} session file(s):", file=sys.stderr)
+            for session_path in list(self.last_session_sizes.keys())[:5]:  # Show first 5
+                print(f"  - {session_path}", file=sys.stderr)
+            if len(self.last_session_sizes) > 5:
+                print(f"  ... and {len(self.last_session_sizes) - 5} more", file=sys.stderr)
+        else:
+            claude_projects = Path.home() / ".claude" / "projects"
+            print(f"[MCP Watcher] WARNING: No session files found in {claude_projects}", file=sys.stderr)
+
         # Poll for file changes more frequently
         while self.running:
             try:
@@ -59,13 +71,15 @@ class DialogueWatcher:
         print("[MCP Watcher] Stopped", file=sys.stderr)
 
     def _get_session_sizes(self) -> Dict[str, int]:
-        """Get current sizes of all active session files."""
+        """Get current sizes of all active session files (from all Claude projects)."""
         sizes = {}
         try:
-            session_files = find_all_active_sessions(self.config, self.repo_path)
-            for session_file in session_files:
-                if session_file.exists():
-                    sizes[str(session_file)] = session_file.stat().st_size
+            # Watch ALL Claude session files, not just one project
+            claude_projects = Path.home() / ".claude" / "projects"
+            if claude_projects.exists():
+                for session_file in claude_projects.glob("*/*.jsonl"):
+                    if session_file.exists():
+                        sizes[str(session_file)] = session_file.stat().st_size
         except Exception as e:
             print(f"[MCP Watcher] Error getting session sizes: {e}", file=sys.stderr)
         return sizes
@@ -74,10 +88,12 @@ class DialogueWatcher:
         """Get current count of stop_reason entries in all active session files."""
         counts = {}
         try:
-            session_files = find_all_active_sessions(self.config, self.repo_path)
-            for session_file in session_files:
-                if session_file.exists():
-                    counts[str(session_file)] = self._count_stop_reasons(session_file)
+            # Watch ALL Claude session files
+            claude_projects = Path.home() / ".claude" / "projects"
+            if claude_projects.exists():
+                for session_file in claude_projects.glob("*/*.jsonl"):
+                    if session_file.exists():
+                        counts[str(session_file)] = self._count_stop_reasons(session_file)
         except Exception as e:
             print(f"[MCP Watcher] Error getting stop_reason counts: {e}", file=sys.stderr)
         return counts
@@ -154,24 +170,24 @@ class DialogueWatcher:
             # Wait for debounce period
             await asyncio.sleep(self.debounce_delay)
 
-            # Check cooldown period
-            current_time = time.time()
-            if self.last_commit_time:
-                time_since_last = current_time - self.last_commit_time
-                if time_since_last < self.min_commit_interval:
-                    print(f"[MCP Watcher] Skipping commit (cooldown: {time_since_last:.1f}s < {self.min_commit_interval}s)", file=sys.stderr)
-                    return
-
             # Check if any of the changed files contains a complete dialogue turn
-            has_complete_turn = False
             for session_file in changed_files:
                 if await self._check_if_turn_complete(session_file):
-                    has_complete_turn = True
                     print(f"[MCP Watcher] Complete turn detected in {session_file.name}", file=sys.stderr)
-                    break
 
-            if has_complete_turn:
-                await self._do_commit()
+                    # Extract project path from session file's parent directory
+                    project_path = self._get_project_path_from_session(session_file)
+                    if project_path:
+                        # Check cooldown for this specific project
+                        current_time = time.time()
+                        last_time = self.last_commit_time.get(str(project_path), 0)
+                        if current_time - last_time < self.min_commit_interval:
+                            print(f"[MCP Watcher] Skipping commit for {project_path} (cooldown)", file=sys.stderr)
+                            continue
+
+                        await self._do_commit(project_path)
+                    else:
+                        print(f"[MCP Watcher] WARNING: Could not extract project path from {session_file}, skipping commit", file=sys.stderr)
 
         except asyncio.CancelledError:
             # Task was cancelled because a newer change was detected
@@ -210,31 +226,60 @@ class DialogueWatcher:
             print(f"[MCP Watcher] Error checking turn completion: {e}", file=sys.stderr)
             return False
 
-    async def _do_commit(self):
-        """Perform the actual commit."""
+    def _get_project_path_from_session(self, session_file: Path) -> Optional[Path]:
+        """
+        Extract the actual project path from a Claude session file's location.
+
+        Claude Code stores sessions in: ~/.claude/projects/-Users-username-path/session.jsonl
+        The directory name encodes the project path with dashes replacing slashes.
+        """
+        try:
+            project_dir_name = session_file.parent.name
+            print(f"[MCP Watcher] Extracting project path from: {project_dir_name}", file=sys.stderr)
+
+            if project_dir_name.startswith('-'):
+                # Convert back to path: -Users-foo-bar -> /Users/foo/bar
+                path_str = '/' + project_dir_name[1:].replace('-', '/')
+                candidate_path = Path(path_str)
+                print(f"[MCP Watcher] Candidate project path: {candidate_path}", file=sys.stderr)
+
+                if candidate_path.exists():
+                    print(f"[MCP Watcher] Project path exists: {candidate_path}", file=sys.stderr)
+                    return candidate_path
+                else:
+                    print(f"[MCP Watcher] WARNING: Project path does not exist: {candidate_path}", file=sys.stderr)
+            else:
+                print(f"[MCP Watcher] WARNING: Directory name doesn't start with '-': {project_dir_name}", file=sys.stderr)
+        except Exception as e:
+            print(f"[MCP Watcher] Error extracting project path: {e}", file=sys.stderr)
+        return None
+
+    async def _do_commit(self, project_path: Path):
+        """Perform the actual commit for a specific project."""
         try:
             # Generate commit message
             timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
             message = f"chore: Auto-commit MCP session ({timestamp})"
 
-            print(f"[MCP Watcher] Attempting commit with message: {message}", file=sys.stderr)
+            print(f"[MCP Watcher] Attempting commit in {project_path} with message: {message}", file=sys.stderr)
 
-            # Use realign commit command
+            # Use realign commit command with the specific project path
             result = await asyncio.get_event_loop().run_in_executor(
                 None,
                 self._run_realign_commit,
-                message
+                message,
+                project_path
             )
 
             if result:
-                print(f"[MCP Watcher] ✓ Committed: {message}", file=sys.stderr)
-                self.last_commit_time = time.time()
+                print(f"[MCP Watcher] ✓ Committed in {project_path}: {message}", file=sys.stderr)
+                self.last_commit_time[str(project_path)] = time.time()
                 # Baseline counts already updated in _check_if_turn_complete()
 
         except Exception as e:
             print(f"[MCP Watcher] Error during commit: {e}", file=sys.stderr)
 
-    def _run_realign_commit(self, message: str) -> bool:
+    def _run_realign_commit(self, message: str, project_path: Path) -> bool:
         """
         Run aline commit command using Python functions directly.
 
@@ -249,14 +294,14 @@ class DialogueWatcher:
             from .commands.commit import smart_commit
 
             # Check if Aline is initialized
-            realign_dir = self.repo_path / ".realign"
+            realign_dir = project_path / ".realign"
 
             if not realign_dir.exists():
-                print("[MCP Watcher] Aline not initialized, initializing...", file=sys.stderr)
+                print(f"[MCP Watcher] Aline not initialized in {project_path}, initializing...", file=sys.stderr)
 
                 # Auto-initialize Aline (which also inits git if needed)
                 init_result = init_repository(
-                    repo_path=str(self.repo_path),
+                    repo_path=str(project_path),
                     auto_init_git=True,
                     skip_commit=False,
                 )
@@ -270,7 +315,7 @@ class DialogueWatcher:
             # Now run the commit with stage_all=True
             result = smart_commit(
                 message=message,
-                repo_path=str(self.repo_path),
+                repo_path=str(project_path),
                 stage_all=True,
                 amend=False,
                 no_edit=False,