loki-mode 7.28.2 → 7.30.0

package/mcp/__init__.py

@@ -57,4 +57,4 @@ try:
 except ImportError:
     __all__ = ['mcp']
 
-__version__ = '7.28.2'
+__version__ = '7.30.0'

package/mcp/server.py

@@ -467,39 +467,156 @@ def _emit_context_relevance_signal(
     thread.start()
 
 
-# BUG #3 FIX: The local mcp/ package shadows the pip-installed mcp SDK.
-# Load FastMCP directly from site-packages using importlib.util to bypass
-# Python's package name resolution entirely (avoids infinite recursion).
-import importlib.util
+# ============================================================
+# Loading the pip MCP SDK's FastMCP under a NAMESPACE COLLISION
+# ============================================================
+#
+# Root cause (task 562): this repo ships a local package named `mcp/`
+# (this very file is mcp/server.py). That local package SHADOWS the
+# pip-installed MCP SDK, which is also named `mcp`. The two cannot both
+# own the top-level `mcp` name in one interpreter.
+#
+# The pre-task code tried to sidestep this by loading mcp/server/fastmcp.py
+# directly from site-packages via importlib. That worked for the SDK's old
+# single-FILE layout, but MCP SDK 1.x ships FastMCP as a PACKAGE DIRECTORY
+# (mcp/server/fastmcp/__init__.py) whose own code does absolute imports like
+# `from mcp.types import Icon` and `from mcp.server.lowlevel import Server`.
+# Under shadowing those resolve to the LOCAL package and raise
+# `ModuleNotFoundError: No module named 'mcp.types'`, so FastMCP never loads
+# and the server exits. (lsp_proxy.py has the same latent failure but
+# silently degrades to a no-op shim.)
+#
+# So the real fix is NOT file-vs-directory detection: it is resolving the
+# namespace collision so the genuine SDK can import its own `mcp.*` subtree.
+# We do this by temporarily letting the REAL SDK own the `mcp` name:
+#   1. snapshot + evict the local `mcp` / `mcp.*` modules from sys.modules,
+#   2. drop the repo root (and "" / ".") from sys.path so the next import of
+#      `mcp` resolves to site-packages, not the local package,
+#   3. import the real `mcp.server.fastmcp` (and eagerly `mcp.types`), which
+#      transitively caches the real `mcp.*` subtree in sys.modules,
+#   4. restore the LOCAL `mcp` and `mcp.server` entries so the rest of this
+#      codebase keeps using the local package for its own relative imports,
+#      while the real SDK submodules (mcp.types, mcp.shared.*,
+#      mcp.server.fastmcp.*, mcp.server.lowlevel.*) stay cached for the SDK's
+#      runtime use. FastMCP holds direct references to its dependencies once
+#      imported, so it does not re-resolve `mcp.server` by name at runtime.
+#
+# This is the least-invasive fix (it does not rename the local package, which
+# mcp/__init__.py documents as intended behavior). It is inherently a bit
+# fragile because it juggles sys.modules; the regression test for this code
+# path is an END-TO-END one (start the server, complete an MCP stdio
+# handshake, list tools), not a file-exists check, because only a real
+# handshake proves FastMCP actually loaded and the subtree resolved.
+import importlib
 import site
 
-_fastmcp_found = False
-_search_paths = []
-try:
-    _search_paths.extend(site.getsitepackages())
-except AttributeError:
-    pass
-try:
-    _search_paths.append(site.getusersitepackages())
-except AttributeError:
-    pass
 
-for _site_dir in _search_paths:
-    _fastmcp_path = os.path.join(_site_dir, "mcp", "server", "fastmcp.py")
-    if os.path.isfile(_fastmcp_path):
-        _spec = importlib.util.spec_from_file_location(
-            "mcp_pip_sdk.server.fastmcp", _fastmcp_path,
-            submodule_search_locations=[]
+def _real_mcp_search_dirs():
+    """Ordered site directories to search for the pip MCP SDK."""
+    dirs = []
+    try:
+        dirs.extend(site.getsitepackages())
+    except AttributeError:
+        pass
+    try:
+        dirs.append(site.getusersitepackages())
+    except AttributeError:
+        pass
+    return dirs
+
+
+def _mcp_sdk_present(search_dirs=None):
+    """True if the pip MCP SDK appears installed in any site dir, accepting
+    both the legacy single-file layout and the 1.x package-directory layout.
+
+    Pure filesystem probe (no import side effects), kept standalone so the
+    both-layouts behaviour can be unit-tested against mktemp fixture dirs.
+    """
+    if search_dirs is None:
+        search_dirs = _real_mcp_search_dirs()
+    for _site_dir in search_dirs:
+        if not _site_dir:
+            continue
+        _file_layout = os.path.join(_site_dir, "mcp", "server", "fastmcp.py")
+        _pkg_layout = os.path.join(
+            _site_dir, "mcp", "server", "fastmcp", "__init__.py"
         )
-        if _spec and _spec.loader:
-            _fastmcp_mod = importlib.util.module_from_spec(_spec)
-            _spec.loader.exec_module(_fastmcp_mod)
-            FastMCP = _fastmcp_mod.FastMCP
-            _fastmcp_found = True
-            break
-
-if not _fastmcp_found:
-    logger.error("MCP SDK (pip package 'mcp') not found in site-packages. Install with: pip install mcp")
+        if os.path.isfile(_file_layout) or os.path.isfile(_pkg_layout):
+            return True
+    return False
+
+
+def _load_real_fastmcp():
+    """Import the genuine pip MCP SDK's FastMCP class, resolving the local-vs-
+    SDK `mcp` namespace collision. Returns the FastMCP class, or None if the
+    SDK cannot be loaded. Restores the local `mcp`/`mcp.server` modules before
+    returning so the rest of this module keeps working unchanged.
+    """
+    if not _mcp_sdk_present():
+        return None
+
+    # 1. Snapshot every currently-loaded local `mcp`/`mcp.*` module so we can
+    #    restore the ones this codebase depends on afterwards.
+    _saved_local = {
+        _k: _v for _k, _v in list(sys.modules.items())
+        if _k == "mcp" or _k.startswith("mcp.")
+    }
+    # 2. Evict them so the real SDK can claim the `mcp` name on import.
+    for _k in list(_saved_local):
+        del sys.modules[_k]
+
+    # 3. Drop repo-root / cwd entries from sys.path for the SDK import so
+    #    `mcp` resolves to site-packages rather than the local package.
+    _repo_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+    _saved_path = sys.path[:]
+    sys.path[:] = [
+        _p for _p in sys.path
+        if _p not in ("", ".")
+        and os.path.abspath(_p) != os.path.abspath(_repo_root)
+    ]
+
+    _fastmcp_cls = None
+    try:
+        _real_fastmcp = importlib.import_module("mcp.server.fastmcp")
+        # Eagerly import the subtree FastMCP touches at runtime so the real
+        # modules are cached before we restore the local `mcp` over the name.
+        importlib.import_module("mcp.types")
+        importlib.import_module("mcp.server.lowlevel")
+        _fastmcp_cls = getattr(_real_fastmcp, "FastMCP", None)
+    except Exception as _exc:  # pragma: no cover - defensive
+        logger.error("Failed to import the pip MCP SDK FastMCP: %s", _exc)
+        _fastmcp_cls = None
+    finally:
+        # 4. Restore sys.path and re-pin the LOCAL `mcp` + `mcp.server` modules
+        #    so this codebase's own relative/absolute imports keep resolving
+        #    locally. We intentionally leave the real `mcp.types`,
+        #    `mcp.shared.*`, `mcp.server.fastmcp.*`, and `mcp.server.lowlevel.*`
+        #    cached for the SDK's runtime use; the local package never defined
+        #    those submodules, so there is nothing to clobber.
+        sys.path[:] = _saved_path
+        for _k in ("mcp", "mcp.server"):
+            if _k in _saved_local:
+                sys.modules[_k] = _saved_local[_k]
+        for _k, _v in _saved_local.items():
+            # Restore any other purely-local submodules that the SDK import did
+            # not legitimately replace (e.g. mcp.magic_tools, mcp.tools).
+            _real = sys.modules.get(_k)
+            if _real is None:
+                sys.modules[_k] = _v
+
+    return _fastmcp_cls
+
+
+FastMCP = _load_real_fastmcp()
+
+if FastMCP is None:
+    logger.error(
+        "MCP SDK (pip package 'mcp') not found or not importable. "
+        "Install it, then re-run. The simplest path is: 'loki mcp', which "
+        "creates a managed virtualenv at .loki/mcp-venv and installs "
+        "mcp/requirements.txt for you. To install manually: "
+        "pip install -r mcp/requirements.txt (or: pip install mcp)."
+    )
     sys.exit(1)
 
 # Read version from VERSION file instead of hardcoding
@@ -509,12 +626,31 @@ try:
 except Exception:
     _version = "unknown"
 
-# Initialize FastMCP server
-mcp = FastMCP(
-    "loki-mode",
-    version=_version,
-    description="Loki Mode autonomous agent orchestration"
-)
+# Initialize FastMCP server.
+#
+# Task 562: pass only kwargs the installed SDK actually accepts. MCP SDK 1.x
+# FastMCP.__init__ has no `version=`/`description=` parameters (it uses
+# `instructions=`), so passing them raises TypeError and the server never
+# starts. We introspect the signature and forward only supported optional
+# kwargs, keeping forward/backward compatibility across SDK versions.
+def _build_fastmcp():
+    import inspect
+    _kwargs = {}
+    try:
+        _params = inspect.signature(FastMCP.__init__).parameters
+    except (TypeError, ValueError):  # pragma: no cover - defensive
+        _params = {}
+    _desc = "Loki Mode autonomous agent orchestration"
+    if "instructions" in _params:
+        _kwargs["instructions"] = _desc
+    elif "description" in _params:
+        _kwargs["description"] = _desc
+    if "version" in _params:
+        _kwargs["version"] = _version
+    return FastMCP("loki-mode", **_kwargs)
+
+
+mcp = _build_fastmcp()
 
 # ============================================================
 # TOOLS - Functions Claude can call
@@ -2462,8 +2598,23 @@ def main():
                        help='Transport mechanism (default: stdio)')
     parser.add_argument('--port', type=int, default=8421,
                        help='Port for HTTP transport (default: 8421)')
+    parser.add_argument('--check-sdk', action='store_true',
+                       help=('Probe only: exit 0 if the MCP SDK loaded and the '
+                             'server object built, non-zero otherwise. Used by '
+                             '`loki mcp` to verify a venv before launching. '
+                             'Does not start a server.'))
     args = parser.parse_args()
 
+    # --check-sdk: if we reached here, the module-level loader already imported
+    # FastMCP and built `mcp` (otherwise the module would have sys.exit(1)'d at
+    # import). So reaching main() with a live `mcp` object means the SDK is
+    # genuinely importable. Report success and exit without starting a server.
+    if args.check_sdk:
+        if mcp is not None:
+            print("MCP SDK OK", file=sys.stderr)
+            sys.exit(0)
+        sys.exit(1)
+
     # Register cleanup to prevent file handle leaks on shutdown/restart
     atexit.register(cleanup_mcp_singletons)
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "loki-mode",
   "mcpName": "io.github.asklokesh/loki-mode",
-  "version": "7.28.2",
+  "version": "7.30.0",
   "description": "Loki Mode by Autonomi. Autonomous spec-to-product system: takes a PRD, GitHub issue, OpenAPI/JSON/YAML, or one-line brief to a deployed app via the RARV-C closure loop with 11 quality gates. Provider-agnostic (Claude Code, OpenAI Codex, Cline, Aider).",
   "keywords": [
     "agent",

package/templates/simple-todo-app.md

@@ -15,3 +15,6 @@ index.html in a browser runs the whole app.
 
 Keep the whole thing minimal and readable. The goal is a quick end-to-end
 build that finishes fast, not a production system.
+
+A basic automated check or verification step confirms that add, list, toggle,
+and delete behave as described before the build is called done.