fix: make per-file parse timeout thread-safe so analyze_repo works off the main thread

Running analyze_repo via asyncio.to_thread exposed a latent bug in the
SIGALRM-based timeout() helper: signal.signal() can only be called from
the main thread, so from a worker thread it raised (ValueError, then
UnboundLocalError in the finally block), which the per-file
`except Exception` swallowed at DEBUG level.  Every file was skipped and
analyze_repo returned 0 components on macOS/Linux.  Windows was
unaffected because it already fell back through the AttributeError path.

- timeout(): skip SIGALRM when it is unavailable or when not on the main
  thread; run the body without a timeout instead of failing
- server.py: reword the lock comment and satisfy ruff format (blank line)

Author: anhnh2002

codewiki/mcp/server.py

@@ -374,6 +374,7 @@ async def list_tools() -> list[Tool]:
 
 _analyze_lock = asyncio.Lock()
 
+
 @server.call_tool()
 async def call_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]:
     """Route tool calls to the appropriate handler."""
@@ -384,9 +385,11 @@ async def call_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]:
         if name == "analyze_repo":
             from codewiki.mcp.tools.analysis import handle_analyze_repo
 
-            # NOTE: Tree-sitter C extensions are not thread-safe, so we use
-            # a lock to ensure only one analyze_repo runs at a time, but
-            # offload to a thread to avoid blocking the stdio pump.
+            # Offloaded to a thread so the long-running analysis does not
+            # block the stdio pump.  The lock serialises concurrent
+            # analyze_repo calls: each analyzer owns its own Tree-sitter
+            # Parser, but parsers are not safe to drive from several
+            # threads at once and the job is heavy anyway.
             async with _analyze_lock:
                 return [_text(await asyncio.to_thread(handle_analyze_repo, arguments, _store))]
 

codewiki/src/be/dependency_analyzer/analysis/call_graph_analyzer.py

@@ -9,6 +9,7 @@
 import logging
 import re
 import signal
+import threading
 import time
 import traceback
 from collections import defaultdict
@@ -33,25 +34,28 @@ class TimeoutError(Exception):
 
 @contextmanager
 def timeout(seconds):
-    """Context manager for timeout on file parsing."""
+    """Context manager for timeout on file parsing.
+
+    SIGALRM only exists on Unix and can only be installed from the main
+    thread.  Anywhere else (Windows, worker threads such as the MCP server's
+    ``asyncio.to_thread`` pool) the body runs without a timeout instead of
+    failing -- previously ``signal.signal`` raised from a worker thread and
+    the per-file ``except Exception`` silently skipped every file.
+    """
+    if not hasattr(signal, "SIGALRM") or threading.current_thread() is not threading.main_thread():
+        yield
+        return
 
     def signal_handler(signum, frame):
         raise TimeoutError(f"File parsing exceeded {seconds}s timeout")
 
-    # Only use signal on Unix systems (not Windows)
+    old_handler = signal.signal(signal.SIGALRM, signal_handler)
+    signal.alarm(seconds)
     try:
-        old_handler = signal.signal(signal.SIGALRM, signal_handler)
-        signal.alarm(seconds)
-        yield
-    except AttributeError:
-        # Windows doesn't support SIGALRM, skip timeout
         yield
     finally:
-        try:
-            signal.alarm(0)
-            signal.signal(signal.SIGALRM, old_handler)
-        except (AttributeError, ValueError):
-            pass
+        signal.alarm(0)
+        signal.signal(signal.SIGALRM, old_handler)
 
 
 class CallGraphAnalyzer: