libcontext 0.7.0__tar.gz → 0.7.1__tar.gz

{libcontext-0.7.0 → libcontext-0.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: libcontext
-Version: 0.7.0
+Version: 0.7.1
 Summary: Generate optimized LLM context from Python library APIs — CLI, skill, and MCP server
 Project-URL: Homepage, https://github.com/Syclaw/libcontext
 Project-URL: Repository, https://github.com/Syclaw/libcontext

{libcontext-0.7.0 → libcontext-0.7.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "libcontext"
-version = "0.7.0"
+version = "0.7.1"
 description = "Generate optimized LLM context from Python library APIs — CLI, skill, and MCP server"
 readme = "README.md"
 license = "MIT"

{libcontext-0.7.0 → libcontext-0.7.1}/src/libcontext/_envsetup.py

@@ -262,22 +262,44 @@ def resolve_python_executable(python_arg: str) -> Path:
 
 
 def get_target_sys_path(python_exe: Path) -> list[str]:
-    """Query a Python interpreter for its ``sys.path``.
+    """Query a Python interpreter for its non-stdlib ``sys.path`` entries.
 
     Runs the interpreter in a subprocess with a short timeout to
-    extract the full search path, including ``.pth`` expansions and
-    site-packages.
+    extract site-packages and user-added paths.  Stdlib paths are
+    excluded to prevent cross-version import contamination when the
+    tool interpreter differs from the target (e.g. tool on 3.13,
+    target venv on 3.11).
 
     Args:
         python_exe: Absolute path to the target Python executable.
 
     Returns:
-        List of path strings from the target interpreter's ``sys.path``.
+        List of non-stdlib path strings from the target interpreter.
 
     Raises:
         EnvironmentSetupError: If the subprocess fails or times out.
     """
-    script = "import sys, json; print(json.dumps(sys.path))"
+    # Filter out stdlib paths from the target interpreter's sys.path.
+    # When the target runs a different Python version from the tool,
+    # injecting stdlib paths causes C-extension mismatches (e.g.
+    # Python 3.13 loading csv.py from 3.11 stdlib → _csv ImportError).
+    script = (
+        "import json, os, sys\n"
+        "base = os.path.realpath(sys.base_prefix)\n"
+        "prefix = os.path.realpath(sys.prefix)\n"
+        "in_venv = prefix != base\n"
+        "def _under(p, root):\n"
+        "    return p == root or p.startswith(root + os.sep)\n"
+        "paths = [\n"
+        "    p for p in sys.path\n"
+        "    if p and not (\n"
+        "        in_venv\n"
+        "        and _under(os.path.realpath(p), base)\n"
+        "        and not _under(os.path.realpath(p), prefix)\n"
+        "    )\n"
+        "]\n"
+        "print(json.dumps(paths))\n"
+    )
     try:
         result = subprocess.run(
             [str(python_exe), "-c", script],

{libcontext-0.7.0 → libcontext-0.7.1}/src/libcontext/mcp_server.py

@@ -32,7 +32,12 @@ from ._security import truncate_output
 from .collector import collect_package
 from .diff import diff_packages
 from .exceptions import PackageNotFoundError
-from .models import PackageInfo, _deserialize_envelope, _serialize_envelope
+from .models import (
+    ModuleInfo,
+    PackageInfo,
+    _deserialize_envelope,
+    _serialize_envelope,
+)
 from .renderer import (
     render_diff,
     render_module,
@@ -79,6 +84,30 @@ def _invalidate_cache() -> None:
     _collect_cached.cache_clear()
 
 
+def _is_module_snapshot(data: dict[str, object]) -> bool:
+    """Return True if *data* looks like a ModuleInfo dict, not PackageInfo."""
+    return "modules" not in data and (
+        "functions" in data or "classes" in data or "variables" in data
+    )
+
+
+def _coerce_to_package(data: dict[str, object]) -> PackageInfo:
+    """Build a PackageInfo from either a package or module snapshot dict.
+
+    When ``get_api_json`` is called with a ``module_name``, the envelope
+    contains a single ModuleInfo dict.  This helper wraps it in a
+    synthetic PackageInfo so that ``diff_packages`` can compare them.
+    """
+    if _is_module_snapshot(data):
+        module_name: str = data.get("name", "unknown")  # type: ignore[assignment]
+        pkg_name = module_name.split(".")[0] if "." in module_name else module_name
+        return PackageInfo(
+            name=pkg_name,
+            modules=[ModuleInfo.from_dict(data)],  # type: ignore[arg-type]
+        )
+    return PackageInfo.from_dict(data)
+
+
 # ---------------------------------------------------------------------------
 # MCP Tools
 # ---------------------------------------------------------------------------
@@ -237,8 +266,8 @@ def diff_api(old_json: str, new_json: str, output_format: str = "markdown") -> s
     except ValueError as exc:
         return f"Error: {exc}"
 
-    old_pkg = PackageInfo.from_dict(old_data)
-    new_pkg = PackageInfo.from_dict(new_data)
+    old_pkg = _coerce_to_package(old_data)
+    new_pkg = _coerce_to_package(new_data)
     result = diff_packages(old_pkg, new_pkg)
 
     if output_format == "json":

{libcontext-0.7.0 → libcontext-0.7.1}/tests/test_envsetup.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import os
 import sys
 from pathlib import Path
 
@@ -81,6 +82,26 @@ def test_get_target_sys_path_bad_executable(tmp_path):
         get_target_sys_path(fake)
 
 
+def test_get_target_sys_path_excludes_base_stdlib_in_venv():
+    """Stdlib paths from the base interpreter are excluded when in a venv."""
+    paths = get_target_sys_path(Path(sys.executable))
+
+    base = os.path.realpath(sys.base_prefix)
+    prefix = os.path.realpath(sys.prefix)
+    if prefix == base:
+        pytest.skip("not running inside a venv")
+
+    # Paths under the base Python installation (stdlib, lib-dynload, etc.)
+    # must be excluded to prevent cross-version contamination.
+    # Paths under the venv prefix itself (e.g. site-packages) are kept.
+    for p in paths:
+        rp = os.path.realpath(p)
+        is_under_base = rp.startswith(base + os.sep) or rp == base
+        is_under_venv = rp.startswith(prefix + os.sep) or rp == prefix
+        if is_under_base and not is_under_venv:
+            pytest.fail(f"base-interpreter stdlib path leaked: {p}")
+
+
 # ---------------------------------------------------------------------------
 # inject_target_environment
 # ---------------------------------------------------------------------------

{libcontext-0.7.0 → libcontext-0.7.1}/tests/test_mcp_server.py

@@ -362,6 +362,60 @@ class TestDiffApi:
         result = mcp_server.diff_api("{}", "{}")
         assert "Error:" in result
 
+    def test_module_level_snapshots(self):
+        """diff_api accepts module-level JSON produced by get_api_json."""
+        import dataclasses
+
+        from libcontext.models import _serialize_envelope
+
+        old_mod = ModuleInfo(
+            name="fakepkg.utils",
+            functions=[
+                FunctionInfo(
+                    name="parse",
+                    parameters=[ParameterInfo(name="text", annotation="str")],
+                    return_annotation="dict",
+                ),
+            ],
+        )
+        new_mod = ModuleInfo(
+            name="fakepkg.utils",
+            functions=[
+                FunctionInfo(
+                    name="parse",
+                    parameters=[
+                        ParameterInfo(name="text", annotation="str"),
+                        ParameterInfo(name="strict", annotation="bool"),
+                    ],
+                    return_annotation="dict",
+                ),
+            ],
+        )
+
+        old_json = json.dumps(_serialize_envelope(dataclasses.asdict(old_mod)))
+        new_json = json.dumps(_serialize_envelope(dataclasses.asdict(new_mod)))
+        result = mcp_server.diff_api(old_json, new_json)
+
+        assert "strict" in result
+        assert "Breaking" in result
+
+    def test_module_level_no_changes(self):
+        """Identical module snapshots produce 'No changes'."""
+        import dataclasses
+
+        from libcontext.models import _serialize_envelope
+
+        mod = ModuleInfo(
+            name="fakepkg.utils",
+            functions=[
+                FunctionInfo(name="parse", parameters=[], return_annotation="dict"),
+            ],
+        )
+        mod_json = json.dumps(_serialize_envelope(dataclasses.asdict(mod)))
+        result = mcp_server.diff_api(mod_json, mod_json)
+
+        assert "No changes" in result
+
 
 # ---------------------------------------------------------------------------
 # refresh_cache