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

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

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

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

@@ -1,13 +1,13 @@
-aline_ai-0.1.6.dist-info/licenses/LICENSE,sha256=H8wTqV5IF1oHw_HbBtS1PSDU8G_q81yblEIL_JfV8Vo,1077
-realign/__init__.py,sha256=7fKH0C4lNvrYFiQ00kUEAH-H3RUUMLXG-69ehNncimI,68
+aline_ai-0.1.8.dist-info/licenses/LICENSE,sha256=H8wTqV5IF1oHw_HbBtS1PSDU8G_q81yblEIL_JfV8Vo,1077
+realign/__init__.py,sha256=SinCCjUdQJgIbiL3QFxgLcSeMMNgu-2OIZmOD-_yaHM,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=-LAJIsxN8U1VSzr-8TYhV9s2jC_t4_XdblnGAcbaKNk,17572
-realign/mcp_watcher.py,sha256=a_9R0r4DM8a9BiRIimJlY8_EhoHTQcTo55yCf4vVYOU,16163
+realign/mcp_server.py,sha256=HGg0nW9_cJnW-22bSBwBONpid3Lq8UICyWyzOAny4OM,18963
+realign/mcp_watcher.py,sha256=xL35Nz35YF6Mc9yu-nCbDzKzTFHQaYmtPNfyBzKKOhc,16038
 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.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,,
+aline_ai-0.1.8.dist-info/METADATA,sha256=_zzB8FOdgwI6cj1Ja6alPVifXEHVm4A8vN0G6P5_Joc,1398
+aline_ai-0.1.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+aline_ai-0.1.8.dist-info/entry_points.txt,sha256=h-NocHDzSueXfsepHTIdRPNQzhNZQPAztJfldd-mQTE,202
+aline_ai-0.1.8.dist-info/top_level.txt,sha256=yIL3s2xv9nf1GwD5n71Aq_JEIV4AfzCIDNKBzewuRm4,8
+aline_ai-0.1.8.dist-info/RECORD,,

realign/__init__.py

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

realign/mcp_server.py

@@ -395,10 +395,42 @@ async def handle_version(args: dict) -> list[TextContent]:
     )]
 
 
+def _server_log(msg: str):
+    """Log MCP server messages to both stderr and file."""
+    from datetime import datetime
+    timestamp = datetime.now().strftime("%H:%M:%S")
+    print(f"[MCP Server] {msg}", file=sys.stderr)
+
+    # Also write to the watcher log file for consistency
+    log_path = Path.home() / ".aline_watcher.log"
+    try:
+        with open(log_path, "a") as f:
+            f.write(f"[{timestamp}] [MCP Server] {msg}\n")
+    except Exception:
+        pass
+
+
+# Log immediately when module is imported
+_early_log_path = Path.home() / ".aline_mcp_startup.log"
+try:
+    with open(_early_log_path, "a") as f:
+        from datetime import datetime
+        f.write(f"\n{'='*60}\n")
+        f.write(f"[{datetime.now()}] MCP SERVER MODULE LOADED\n")
+        f.write(f"Python: {sys.executable}\n")
+        f.write(f"CWD: {Path.cwd()}\n")
+        f.write(f"HOME: {Path.home()}\n")
+        f.write(f"Version: {__version__}\n")
+        f.write(f"{'='*60}\n")
+except Exception as e:
+    print(f"[MCP Server] Early log failed: {e}", file=sys.stderr)
+
+
 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)
+    _server_log("Starting Aline MCP server...")
+    _server_log(f"Current working directory: {Path.cwd()}")
+    _server_log(f"Home directory: {Path.home()}")
 
     # Detect workspace path and start the watcher
     # Try multiple methods since MCP server may run in different context
@@ -414,52 +446,52 @@ 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)
+            _server_log(f"Detected workspace from git: {repo_path}")
         else:
-            print(f"[MCP Server] Not in git repo (cwd: {Path.cwd()})", file=sys.stderr)
+            _server_log(f"Not in git repo (cwd: {Path.cwd()})")
 
         # 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)
+            _server_log(f"Checking Claude projects at: {claude_projects}")
             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)
+                _server_log(f"Found {len(session_files)} Claude session files")
                 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)
+                    _server_log(f"Most recent session: {session_files[0]}")
                     # 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)
+                    _server_log(f"Project dir name: {project_dir_name}")
                     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)
+                        _server_log(f"Candidate path: {candidate_path}, exists: {candidate_path.exists()}")
                         if candidate_path.exists():
                             repo_path = candidate_path
-                            print(f"[MCP Server] Detected workspace from Claude session: {repo_path}", file=sys.stderr)
+                            _server_log(f"Detected workspace from Claude session: {repo_path}")
 
         # Method 3: Fallback to current directory
         if not repo_path:
             repo_path = Path.cwd()
-            print(f"[MCP Server] Using current directory: {repo_path}", file=sys.stderr)
+            _server_log(f"Using current directory: {repo_path}")
 
         # Start the watcher
-        print(f"[MCP Server] Starting watcher for: {repo_path}", file=sys.stderr)
+        _server_log(f"Starting watcher for: {repo_path}")
         await start_watcher(repo_path)
 
     except Exception as e:
-        print(f"[MCP Server] Warning: Could not start watcher: {e}", file=sys.stderr)
+        _server_log(f"Warning: Could not start watcher: {e}")
         import traceback
         traceback.print_exc(file=sys.stderr)
 
-    print("[MCP Server] MCP server ready", file=sys.stderr)
+    _server_log("MCP server ready")
 
     async with stdio_server() as (read_stream, write_stream):
         await app.run(
@@ -471,7 +503,27 @@ async def async_main():
 
 def main():
     """Entry point for the MCP server command."""
-    asyncio.run(async_main())
+    # Log entry point
+    try:
+        with open(_early_log_path, "a") as f:
+            from datetime import datetime
+            f.write(f"[{datetime.now()}] main() called, starting asyncio.run\n")
+    except Exception:
+        pass
+
+    try:
+        asyncio.run(async_main())
+    except Exception as e:
+        # Log any exceptions
+        try:
+            with open(_early_log_path, "a") as f:
+                from datetime import datetime
+                import traceback
+                f.write(f"[{datetime.now()}] EXCEPTION in main: {e}\n")
+                f.write(traceback.format_exc())
+        except Exception:
+            pass
+        raise
 
 
 if __name__ == "__main__":

realign/mcp_watcher.py

@@ -13,6 +13,35 @@ from .config import ReAlignConfig
 from .hooks import find_all_active_sessions
 
 
+# File-based logger for debugging when stderr is not visible
+_log_file = None
+
+def _log(msg: str):
+    """Log to both stderr and a debug file."""
+    global _log_file
+    timestamp = datetime.now().strftime("%H:%M:%S")
+    full_msg = f"[{timestamp}] {msg}"
+    print(f"[MCP Watcher] {msg}", file=sys.stderr)
+
+    # Also write to file for debugging
+    if _log_file is None:
+        log_path = Path.home() / ".aline_watcher.log"
+        try:
+            _log_file = open(log_path, "a", buffering=1)  # Line buffered
+            _log_file.write(f"\n{'='*60}\n")
+            _log_file.write(f"[{timestamp}] MCP Watcher Started\n")
+            _log_file.write(f"{'='*60}\n")
+        except Exception:
+            _log_file = False  # Mark as failed so we don't retry
+
+    if _log_file and _log_file is not False:
+        try:
+            _log_file.write(full_msg + "\n")
+            _log_file.flush()
+        except Exception:
+            pass
+
+
 class DialogueWatcher:
     """Watch session files and auto-commit immediately after each user request completes."""
 
@@ -30,14 +59,15 @@ class DialogueWatcher:
     async def start(self):
         """Start watching session files."""
         if not self.config.mcp_auto_commit:
-            print("[MCP Watcher] Auto-commit disabled in config", file=sys.stderr)
+            _log("Auto-commit disabled in config")
             return
 
         self.running = True
-        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)
+        _log("Started watching for dialogue completion")
+        _log(f"Mode: Per-request (triggers at end of each Claude response)")
+        _log(f"Debounce: {self.debounce_delay}s, Cooldown: {self.min_commit_interval}s")
+        _log(f"Home directory: {Path.home()}")
+        _log(f"Current working directory: {Path.cwd()}")
 
         # Initialize baseline sizes and stop_reason counts
         self.last_session_sizes = self._get_session_sizes()
@@ -45,14 +75,14 @@ class DialogueWatcher:
 
         # 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)
+            _log(f"Monitoring {len(self.last_session_sizes)} session file(s):")
             for session_path in list(self.last_session_sizes.keys())[:5]:  # Show first 5
-                print(f"  - {session_path}", file=sys.stderr)
+                _log(f"  - {session_path}")
             if len(self.last_session_sizes) > 5:
-                print(f"  ... and {len(self.last_session_sizes) - 5} more", file=sys.stderr)
+                _log(f"  ... and {len(self.last_session_sizes) - 5} more")
         else:
             claude_projects = Path.home() / ".claude" / "projects"
-            print(f"[MCP Watcher] WARNING: No session files found in {claude_projects}", file=sys.stderr)
+            _log(f"WARNING: No session files found in {claude_projects}")
 
         # Poll for file changes more frequently
         while self.running:
@@ -60,7 +90,7 @@ class DialogueWatcher:
                 await self.check_for_changes()
                 await asyncio.sleep(0.5)  # Check every 0.5 seconds for responsiveness
             except Exception as e:
-                print(f"[MCP Watcher] Error: {e}", file=sys.stderr)
+                _log(f"Error: {e}")
                 await asyncio.sleep(1.0)
 
     async def stop(self):
@@ -68,7 +98,7 @@ class DialogueWatcher:
         self.running = False
         if self.pending_commit_task:
             self.pending_commit_task.cancel()
-        print("[MCP Watcher] Stopped", file=sys.stderr)
+        _log("Stopped")
 
     def _get_session_sizes(self) -> Dict[str, int]:
         """Get current sizes of all active session files (from all Claude projects)."""
@@ -81,7 +111,7 @@ class DialogueWatcher:
                     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)
+            _log(f"Error getting session sizes: {e}")
         return sizes
 
     def _get_stop_reason_counts(self) -> Dict[str, int]:
@@ -95,7 +125,7 @@ class DialogueWatcher:
                     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)
+            _log(f"Error getting stop_reason counts: {e}")
         return counts
 
     def _count_stop_reasons(self, session_file: Path) -> int:
@@ -127,7 +157,7 @@ class DialogueWatcher:
                     except json.JSONDecodeError:
                         continue
         except Exception as e:
-            print(f"[MCP Watcher] Error counting stop_reasons in {session_file}: {e}", file=sys.stderr)
+            _log(f"Error counting stop_reasons in {session_file}: {e}")
         return len(unique_message_ids)
 
     async def check_for_changes(self):
@@ -146,7 +176,7 @@ class DialogueWatcher:
                 old_size = self.last_session_sizes.get(path, 0)
                 if size > old_size:
                     changed_files.append(Path(path))
-                    print(f"[MCP Watcher] Session file changed: {Path(path).name} ({old_size} -> {size} bytes)", file=sys.stderr)
+                    _log(f"Session file changed: {Path(path).name} ({old_size} -> {size} bytes)")
 
             if changed_files:
                 # File changed - cancel any pending commit and schedule a new one
@@ -162,7 +192,7 @@ class DialogueWatcher:
             self.last_session_sizes = current_sizes
 
         except Exception as e:
-            print(f"[MCP Watcher] Error checking for changes: {e}", file=sys.stderr)
+            _log(f"Error checking for changes: {e}")
 
     async def _debounced_commit(self, changed_files: list):
         """Wait for debounce period, then check if dialogue is complete and commit."""
@@ -173,7 +203,7 @@ class DialogueWatcher:
             # Check if any of the changed files contains a complete dialogue turn
             for session_file in changed_files:
                 if await self._check_if_turn_complete(session_file):
-                    print(f"[MCP Watcher] Complete turn detected in {session_file.name}", file=sys.stderr)
+                    _log(f"Complete turn detected in {session_file.name}")
 
                     # Extract project path from session file's parent directory
                     project_path = self._get_project_path_from_session(session_file)
@@ -182,18 +212,18 @@ class DialogueWatcher:
                         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)
+                            _log(f"Skipping commit for {project_path} (cooldown)")
                             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)
+                        _log(f"WARNING: Could not extract project path from {session_file}, skipping commit")
 
         except asyncio.CancelledError:
             # Task was cancelled because a newer change was detected
             pass
         except Exception as e:
-            print(f"[MCP Watcher] Error in debounced commit: {e}", file=sys.stderr)
+            _log(f"Error in debounced commit: {e}")
 
     async def _check_if_turn_complete(self, session_file: Path) -> bool:
         """
@@ -215,7 +245,7 @@ class DialogueWatcher:
 
             # Commit after each complete assistant response (1 new end_turn)
             if new_stop_reasons >= 1:
-                print(f"[MCP Watcher] Detected {new_stop_reasons} new end_turn entry(ies) in {session_file.name}", file=sys.stderr)
+                _log(f"Detected {new_stop_reasons} new end_turn entry(ies) in {session_file.name}")
                 # Update baseline immediately to avoid double-counting
                 self.last_stop_reason_counts[session_path] = current_count
                 return True
@@ -223,7 +253,7 @@ class DialogueWatcher:
             return False
 
         except Exception as e:
-            print(f"[MCP Watcher] Error checking turn completion: {e}", file=sys.stderr)
+            _log(f"Error checking turn completion: {e}")
             return False
 
     def _get_project_path_from_session(self, session_file: Path) -> Optional[Path]:
@@ -235,23 +265,23 @@ class DialogueWatcher:
         """
         try:
             project_dir_name = session_file.parent.name
-            print(f"[MCP Watcher] Extracting project path from: {project_dir_name}", file=sys.stderr)
+            _log(f"Extracting project path from: {project_dir_name}")
 
             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)
+                _log(f"Candidate project path: {candidate_path}")
 
                 if candidate_path.exists():
-                    print(f"[MCP Watcher] Project path exists: {candidate_path}", file=sys.stderr)
+                    _log(f"Project path exists: {candidate_path}")
                     return candidate_path
                 else:
-                    print(f"[MCP Watcher] WARNING: Project path does not exist: {candidate_path}", file=sys.stderr)
+                    _log(f"WARNING: Project path does not exist: {candidate_path}")
             else:
-                print(f"[MCP Watcher] WARNING: Directory name doesn't start with '-': {project_dir_name}", file=sys.stderr)
+                _log(f"WARNING: Directory name doesn't start with '-': {project_dir_name}")
         except Exception as e:
-            print(f"[MCP Watcher] Error extracting project path: {e}", file=sys.stderr)
+            _log(f"Error extracting project path: {e}")
         return None
 
     async def _do_commit(self, project_path: Path):
@@ -261,7 +291,7 @@ class DialogueWatcher:
             timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
             message = f"chore: Auto-commit MCP session ({timestamp})"
 
-            print(f"[MCP Watcher] Attempting commit in {project_path} with message: {message}", file=sys.stderr)
+            _log(f"Attempting commit in {project_path} with message: {message}")
 
             # Use realign commit command with the specific project path
             result = await asyncio.get_event_loop().run_in_executor(
@@ -272,12 +302,12 @@ class DialogueWatcher:
             )
 
             if result:
-                print(f"[MCP Watcher] ✓ Committed in {project_path}: {message}", file=sys.stderr)
+                _log(f"✓ Committed in {project_path}: {message}")
                 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)
+            _log(f"Error during commit: {e}")
 
     def _run_realign_commit(self, message: str, project_path: Path) -> bool:
         """
@@ -297,7 +327,7 @@ class DialogueWatcher:
             realign_dir = project_path / ".realign"
 
             if not realign_dir.exists():
-                print(f"[MCP Watcher] Aline not initialized in {project_path}, initializing...", file=sys.stderr)
+                _log(f"Aline not initialized in {project_path}, initializing...")
 
                 # Auto-initialize Aline (which also inits git if needed)
                 init_result = init_repository(
@@ -307,10 +337,10 @@ class DialogueWatcher:
                 )
 
                 if not init_result.get("success"):
-                    print(f"[MCP Watcher] Failed to initialize Aline: {init_result.get('message', 'Unknown error')}", file=sys.stderr)
+                    _log(f"Failed to initialize Aline: {init_result.get('message', 'Unknown error')}")
                     return False
 
-                print("[MCP Watcher] ✓ Aline initialized successfully", file=sys.stderr)
+                _log("✓ Aline initialized successfully")
 
             # Now run the commit with stage_all=True
             result = smart_commit(
@@ -330,11 +360,11 @@ class DialogueWatcher:
             else:
                 # Log the error for debugging
                 error_msg = result.get("message", "Unknown error")
-                print(f"[MCP Watcher] Commit failed: {error_msg}", file=sys.stderr)
+                _log(f"Commit failed: {error_msg}")
                 return False
 
         except Exception as e:
-            print(f"[MCP Watcher] Commit error: {e}", file=sys.stderr)
+            _log(f"Commit error: {e}")
             return False