libcontext 0.7.0__tar.gz → 0.7.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: libcontext
-Version: 0.7.0
+Version: 0.7.2
 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.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "libcontext"
-version = "0.7.0"
+version = "0.7.2"
 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.2}/src/libcontext/_envsetup.py

@@ -46,6 +46,50 @@ _INTERPRETER_CANDIDATES = (
     Path("bin") / "python3",  # Unix alternative
 )
 
+# Script executed in the *target* interpreter to collect site-packages
+# directories.  Kept as a module constant so it can be tested directly.
+# Uses only stdlib modules guaranteed present in Python 3.9+.
+_SITE_PACKAGES_SCRIPT = """\
+import json, site, sys, os
+
+paths = []
+
+# site-packages directories (includes system site-packages when the
+# venv was created with --system-site-packages)
+try:
+    paths.extend(site.getsitepackages())
+except AttributeError:
+    pass
+
+# User site-packages (e.g. ~/.local/lib/python3.x/site-packages),
+# honoured only when ENABLE_USER_SITE is not explicitly disabled.
+if site.ENABLE_USER_SITE:
+    try:
+        user = site.getusersitepackages()
+        if isinstance(user, str):
+            paths.append(user)
+    except AttributeError:
+        pass
+
+# .pth files in site-packages can inject arbitrary paths into sys.path
+# (editable installs, namespace packages, etc.).  Collect them by
+# diffing sys.path against site-packages — any path that is not a
+# site-packages dir and not under sys.base_prefix is .pth-injected.
+site_set = set(os.path.realpath(p) for p in paths)
+base = os.path.realpath(sys.base_prefix)
+for p in sys.path:
+    if not p:
+        continue
+    rp = os.path.realpath(p)
+    if rp in site_set:
+        continue
+    if rp == base or rp.startswith(base + os.sep):
+        continue
+    paths.append(p)
+
+print(json.dumps(paths))
+"""
+
 
 def _has_python_interpreter(venv_dir: Path) -> bool:
     """Check whether a directory contains a recognisable Python interpreter."""
@@ -262,22 +306,26 @@ 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 target interpreter for its package-discovery paths.
 
-    Runs the interpreter in a subprocess with a short timeout to
-    extract the full search path, including ``.pth`` expansions and
-    site-packages.
+    Collects site-packages directories (including system site-packages
+    for ``--system-site-packages`` venvs), user site-packages, and
+    any paths injected by ``.pth`` files (editable installs, namespace
+    packages).  Stdlib paths are **excluded** to prevent cross-version
+    import contamination when tool and target run different Python
+    versions.
 
     Args:
         python_exe: Absolute path to the target Python executable.
 
     Returns:
-        List of path strings from the target interpreter's ``sys.path``.
+        List of path strings suitable for prepending to ``sys.path``
+        in the tool process.
 
     Raises:
         EnvironmentSetupError: If the subprocess fails or times out.
     """
-    script = "import sys, json; print(json.dumps(sys.path))"
+    script = _SITE_PACKAGES_SCRIPT
     try:
         result = subprocess.run(
             [str(python_exe), "-c", script],

{libcontext-0.7.0 → libcontext-0.7.2}/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.2}/tests/test_envsetup.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import os
 import sys
 from pathlib import Path
 
@@ -81,6 +82,32 @@ def test_get_target_sys_path_bad_executable(tmp_path):
         get_target_sys_path(fake)
 
 
+def test_get_target_sys_path_returns_site_packages_not_stdlib():
+    """Returns site-packages paths and excludes base-interpreter stdlib."""
+    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")
+
+    # At least one site-packages directory must be present.
+    assert any("site-packages" in p for p in paths), (
+        f"no site-packages found in returned paths: {paths}"
+    )
+
+    # No path should resolve under the base Python installation
+    # (stdlib, lib-dynload, zip archives) unless it is also under
+    # the venv prefix.
+    def _under(child: str, root: str) -> bool:
+        return child == root or child.startswith(root + os.sep)
+
+    for p in paths:
+        rp = os.path.realpath(p)
+        if _under(rp, base) and not _under(rp, prefix):
+            pytest.fail(f"base-interpreter stdlib path leaked: {p}")
+
+
 # ---------------------------------------------------------------------------
 # inject_target_environment
 # ---------------------------------------------------------------------------

{libcontext-0.7.0 → libcontext-0.7.2}/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