modern-python-guidance 0.3.7__tar.gz → 0.3.8__tar.gz

{modern_python_guidance-0.3.7 → modern_python_guidance-0.3.8}/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 All notable changes to this project will be documented in this file.
 
+## [0.3.8] — 2026-06-02
+
+### Added
+
+- Fuzzy suggestions on retrieve miss: when a guide ID is not found, `difflib.get_close_matches` suggests up to 3 similar IDs (cutoff=0.5, case-insensitive). CLI shows "Did you mean:" in human format; JSON format and MCP tool return an envelope `{"results": [...], "not_found": [{"id": ..., "suggestions": [...]}]}`. Bare list preserved on all-found for backward compatibility. Exit code 1 when any ID is not found. (closes #14)
+
+### Fixed
+
+- `_handle_request` crash on non-dict JSON input (list, string, number, bool): now returns JSON-RPC -32600 "Invalid Request" error instead of `AttributeError`. Server continues processing subsequent requests. (closes #82)
+
 ## [0.3.7] — 2026-06-02
 
 ### Fixed

{modern_python_guidance-0.3.7 → modern_python_guidance-0.3.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modern-python-guidance
-Version: 0.3.7
+Version: 0.3.8
 Summary: Version-aware BAD/GOOD pattern guides that help AI coding agents generate modern Python
 Project-URL: Homepage, https://github.com/yottayoshida/modern-python-guidance
 Project-URL: Repository, https://github.com/yottayoshida/modern-python-guidance

{modern_python_guidance-0.3.7 → modern_python_guidance-0.3.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "modern-python-guidance"
-version = "0.3.7"
+version = "0.3.8"
 description = "Version-aware BAD/GOOD pattern guides that help AI coding agents generate modern Python"
 readme = "README.md"
 license = "Apache-2.0 OR MIT"

{modern_python_guidance-0.3.7 → modern_python_guidance-0.3.8}/src/modern_python_guidance/__init__.py

@@ -1,3 +1,3 @@
 """Modern Python Guidance — version-aware BAD/GOOD pattern guides for AI coding agents."""
 
-__version__ = "0.3.7"
+__version__ = "0.3.8"

{modern_python_guidance-0.3.7 → modern_python_guidance-0.3.8}/src/modern_python_guidance/cli.py

@@ -12,7 +12,7 @@ from pathlib import Path
 from modern_python_guidance import __version__
 from modern_python_guidance.compat import VERSION_RE, version_compatible
 from modern_python_guidance.guide_index import build_index
-from modern_python_guidance.retrieve import retrieve
+from modern_python_guidance.retrieve import retrieve, suggest_ids
 from modern_python_guidance.search import search as do_search
 from modern_python_guidance.version_detect import detect_version
 
@@ -191,26 +191,42 @@ def _cmd_search(args: argparse.Namespace) -> None:
 
 def _cmd_retrieve(args: argparse.Namespace) -> None:
     index = build_index()
-    guide_ids = [gid.strip() for gid in args.ids.split(",")]
+    guide_ids = [gid.strip() for gid in args.ids.split(",") if gid.strip()]
+    if not guide_ids:
+        print("No guide IDs provided.")
+        sys.exit(1)
     results = retrieve(index, guide_ids, python_version=args.python_version)
 
-    fmt = _resolve_format(args)
+    found_ids = {r["id"] for r in results}
+    missing = [gid for gid in guide_ids if gid not in found_ids]
 
-    if not results:
-        if fmt == "human":
-            print("No guides found.")
-        else:
-            print("[]")
-        sys.exit(1)
+    fmt = _resolve_format(args)
 
     if fmt == "json":
-        print(json.dumps(results, indent=2, ensure_ascii=False))
+        if missing:
+            not_found = [{"id": gid, "suggestions": suggest_ids(index, gid)} for gid in missing]
+            envelope = {"results": results, "not_found": not_found}
+            print(json.dumps(envelope, indent=2, ensure_ascii=False))
+        else:
+            print(json.dumps(results, indent=2, ensure_ascii=False))
     else:
         for r in results:
             match_str = "YES" if r["version_match"] else "NO"
             print(f"--- {r['id']} (version match: {match_str}) ---")
             print(r["content"])
             print()
+        for gid in missing:
+            suggestions = suggest_ids(index, gid)
+            if suggestions:
+                print(f"No guide found for '{gid}'. Did you mean:")
+                for s in suggestions:
+                    print(f"  {s}")
+            else:
+                print(f"No guide found for '{gid}'.")
+                print("Run 'mpg list' to see available guides.")
+
+    if missing:
+        sys.exit(1)
 
 
 def _cmd_list(args: argparse.Namespace) -> None:

{modern_python_guidance-0.3.7 → modern_python_guidance-0.3.8}/src/modern_python_guidance/mcp_server.py

@@ -10,7 +10,7 @@ from pathlib import Path
 from modern_python_guidance import __version__
 from modern_python_guidance.compat import VERSION_RE
 from modern_python_guidance.guide_index import GuideIndex, build_index
-from modern_python_guidance.retrieve import retrieve
+from modern_python_guidance.retrieve import retrieve, suggest_ids
 from modern_python_guidance.search import search
 from modern_python_guidance.version_detect import detect_version
 
@@ -280,6 +280,14 @@ def _tool_retrieve(arguments: dict) -> dict:
 
     index = _get_index()
     results = retrieve(index, guide_ids, python_version=pv)
+
+    found_ids = {r["id"] for r in results}
+    missing = [gid for gid in guide_ids if gid not in found_ids]
+    if missing:
+        not_found = [{"id": gid, "suggestions": suggest_ids(index, gid)} for gid in missing]
+        envelope = {"results": results, "not_found": not_found}
+        return _tool_result(json.dumps(envelope, indent=2, ensure_ascii=False))
+
     return _tool_result(json.dumps(results, indent=2, ensure_ascii=False))
 
 
@@ -332,6 +340,8 @@ PROTOCOL_VERSION = "2024-11-05"
 
 
 def _handle_request(msg: dict) -> dict | None:
+    if not isinstance(msg, dict):
+        return _error_response(None, -32600, "Invalid Request: expected JSON object")
     method = msg.get("method", "")
     req_id = msg.get("id")
     params = msg.get("params", {})

{modern_python_guidance-0.3.7 → modern_python_guidance-0.3.8}/src/modern_python_guidance/retrieve.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import difflib
 import json
 from typing import Any
 
@@ -9,6 +10,18 @@ from modern_python_guidance import __version__
 from modern_python_guidance.compat import token_estimate, version_compatible
 from modern_python_guidance.guide_index import Guide, GuideIndex
 
+MAX_ID_LEN = 200
+_SUGGEST_CUTOFF = 0.5
+_SUGGEST_MAX = 3
+
+
+def suggest_ids(index: GuideIndex, missing_id: str) -> list[str]:
+    if not isinstance(missing_id, str):
+        return []
+    truncated = missing_id[:MAX_ID_LEN].lower()
+    all_ids = list(index.guides.keys())
+    return difflib.get_close_matches(truncated, all_ids, n=_SUGGEST_MAX, cutoff=_SUGGEST_CUTOFF)
+
 
 def retrieve(
     index: GuideIndex,

{modern_python_guidance-0.3.7 → modern_python_guidance-0.3.8}/tests/test_cli_unit.py

@@ -115,14 +115,56 @@ class TestCmdRetrieve:
         assert "use-builtin-generics" in ids
         assert "union-syntax" in ids
 
-    def test_no_match_exits_1(self, capsys):
+    def test_no_match_exits_1_json_envelope(self, capsys):
         with pytest.raises(SystemExit, match="1"):
             main(argv=["retrieve", "nonexistent-guide-id", "--format", "json"])
+        data = json.loads(capsys.readouterr().out)
+        assert "not_found" in data
+        assert data["results"] == []
+        assert data["not_found"][0]["id"] == "nonexistent-guide-id"
 
     def test_no_match_human_exits_1(self, capsys):
         with pytest.raises(SystemExit, match="1"):
             main(argv=["retrieve", "nonexistent-guide-id", "--format", "human"])
-        assert "No guides found" in capsys.readouterr().out
+        assert "No guide found for" in capsys.readouterr().out
+
+    def test_suggestion_human(self, capsys):
+        with pytest.raises(SystemExit, match="1"):
+            main(argv=["retrieve", "builtin-generics", "--format", "human"])
+        out = capsys.readouterr().out
+        assert "Did you mean" in out
+        assert "use-builtin-generics" in out
+
+    def test_suggestion_json(self, capsys):
+        with pytest.raises(SystemExit, match="1"):
+            main(argv=["retrieve", "builtin-generics", "--format", "json"])
+        data = json.loads(capsys.readouterr().out)
+        assert "use-builtin-generics" in data["not_found"][0]["suggestions"]
+
+    def test_mixed_valid_and_invalid(self, capsys):
+        with pytest.raises(SystemExit, match="1"):
+            main(argv=["retrieve", "use-builtin-generics,zzz-fake", "--format", "json"])
+        data = json.loads(capsys.readouterr().out)
+        assert len(data["results"]) == 1
+        assert data["results"][0]["id"] == "use-builtin-generics"
+        assert data["not_found"][0]["id"] == "zzz-fake"
+
+    def test_all_found_bare_list(self, capsys):
+        main(argv=["retrieve", "use-builtin-generics", "--format", "json"])
+        data = json.loads(capsys.readouterr().out)
+        assert isinstance(data, list)
+        assert data[0]["id"] == "use-builtin-generics"
+
+    def test_trailing_comma_ignored(self, capsys):
+        main(argv=["retrieve", "use-builtin-generics,", "--format", "json"])
+        data = json.loads(capsys.readouterr().out)
+        assert isinstance(data, list)
+        assert data[0]["id"] == "use-builtin-generics"
+
+    def test_all_commas_exits_1(self, capsys):
+        with pytest.raises(SystemExit, match="1"):
+            main(argv=["retrieve", ",,,", "--format", "human"])
+        assert "No guide IDs provided" in capsys.readouterr().out
 
     def test_version_match_yes(self, capsys):
         main(

modern_python_guidance-0.3.8/tests/test_compat.py

@@ -0,0 +1,82 @@
+from __future__ import annotations
+
+import pytest
+
+from modern_python_guidance.compat import VERSION_RE, token_estimate, version_compatible
+
+
+class TestVersionCompatible:
+    def test_compatible(self):
+        assert version_compatible(">=3.9", "3.12") is True
+
+    def test_incompatible(self):
+        assert version_compatible(">=3.11", "3.9") is False
+
+    def test_boundary_exact(self):
+        assert version_compatible(">=3.11", "3.11") is True
+
+    def test_compound_specifier_pass(self):
+        assert version_compatible(">=3.9,<3.13", "3.12") is True
+
+    def test_compound_specifier_fail(self):
+        assert version_compatible(">=3.9,<3.13", "3.13") is False
+
+    def test_empty_specifier_matches_all(self):
+        assert version_compatible("", "3.12") is True
+
+    def test_invalid_specifier_fail_open(self):
+        assert version_compatible("not-valid", "3.12") is True
+
+    def test_invalid_target_fail_open(self):
+        assert version_compatible(">=3.9", "abc") is True
+
+    def test_patch_level_target(self):
+        assert version_compatible(">=3.9", "3.11.1") is True
+
+
+class TestTokenEstimate:
+    def test_empty_string(self):
+        assert token_estimate("") == 0
+
+    def test_one_char(self):
+        assert token_estimate("x") == 0
+
+    def test_three_chars(self):
+        assert token_estimate("xxx") == 0
+
+    def test_four_chars(self):
+        assert token_estimate("abcd") == 1
+
+    def test_five_chars(self):
+        assert token_estimate("xxxxx") == 1
+
+    def test_hundred_chars(self):
+        assert token_estimate("x" * 100) == 25
+
+
+class TestVersionRe:
+    @pytest.mark.parametrize(
+        ("value", "expected"),
+        [
+            ("3.12", True),
+            ("3.12.1", False),
+            ("abc", False),
+            ("", False),
+            ("v3.12", False),
+            ("3.", False),
+            (".11", False),
+            ("03.011", True),
+        ],
+        ids=[
+            "major_minor",
+            "patch_no_match",
+            "alpha_no_match",
+            "empty_no_match",
+            "v_prefix_no_match",
+            "trailing_dot_no_match",
+            "leading_dot_no_match",
+            "leading_zeros_match",
+        ],
+    )
+    def test_pattern(self, value: str, expected: bool):
+        assert (VERSION_RE.match(value) is not None) is expected

modern_python_guidance-0.3.8/tests/test_guide_index.py

@@ -0,0 +1,280 @@
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+from unittest.mock import patch
+
+from modern_python_guidance.frontmatter import GuideMeta
+from modern_python_guidance.guide_index import (
+    Guide,
+    GuideIndex,
+    _code_lines,
+    _find_guides_dir,
+    build_index,
+)
+
+
+def _raise_type_error(_pkg):
+    raise TypeError("mocked")
+
+
+def _make_guide_md(
+    *,
+    guide_id: str = "test-guide",
+    title: str = "Test Guide",
+    category: str = "testing",
+    layer: int = 1,
+    python: str = ">=3.9",
+    frequency: str = "high",
+    bad_code: str = "old_code()",
+    good_code: str = "new_code()",
+) -> str:
+    return (
+        f"---\n"
+        f"id: {guide_id}\n"
+        f"title: {title}\n"
+        f"category: {category}\n"
+        f"layer: {layer}\n"
+        f"tags:\n"
+        f"  - test\n"
+        f'python: "{python}"\n'
+        f"frequency: {frequency}\n"
+        f"---\n"
+        f"\n"
+        f"## BAD\n"
+        f"```python\n"
+        f"{bad_code}\n"
+        f"```\n"
+        f"\n"
+        f"## GOOD\n"
+        f"```python\n"
+        f"{good_code}\n"
+        f"```\n"
+    )
+
+
+# ---------------------------------------------------------------------------
+# GuideIndex dataclass methods
+# ---------------------------------------------------------------------------
+
+
+class TestGuideIndex:
+    def test_len_empty(self):
+        idx = GuideIndex()
+        assert len(idx) == 0
+
+    def test_len_with_entries(self):
+        meta = GuideMeta(
+            id="a",
+            title="A",
+            category="c",
+            layer=1,
+            tags=["t"],
+            python=">=3.9",
+            frequency="high",
+        )
+        idx = GuideIndex(guides={"a": Guide(meta=meta, body="", source_path="a.md")})
+        assert len(idx) == 1
+
+    def test_get_existing(self):
+        meta = GuideMeta(
+            id="a",
+            title="A",
+            category="c",
+            layer=1,
+            tags=["t"],
+            python=">=3.9",
+            frequency="high",
+        )
+        guide = Guide(meta=meta, body="body", source_path="a.md")
+        idx = GuideIndex(guides={"a": guide})
+        assert idx.get("a") is guide
+
+    def test_get_missing(self):
+        idx = GuideIndex()
+        assert idx.get("nonexistent") is None
+
+    def test_all_meta(self):
+        meta = GuideMeta(
+            id="a",
+            title="A",
+            category="c",
+            layer=1,
+            tags=["t"],
+            python=">=3.9",
+            frequency="high",
+        )
+        idx = GuideIndex(guides={"a": Guide(meta=meta, body="", source_path="a.md")})
+        result = idx.all_meta()
+        assert len(result) == 1
+        assert result[0] is meta
+
+    def test_categories_sorted_unique(self):
+        def _meta(guide_id: str, cat: str) -> GuideMeta:
+            return GuideMeta(
+                id=guide_id,
+                title=guide_id,
+                category=cat,
+                layer=1,
+                tags=["t"],
+                python=">=3.9",
+                frequency="high",
+            )
+
+        idx = GuideIndex(
+            guides={
+                "b": Guide(meta=_meta("b", "zeta"), body="", source_path="b.md"),
+                "a": Guide(meta=_meta("a", "alpha"), body="", source_path="a.md"),
+                "c": Guide(meta=_meta("c", "alpha"), body="", source_path="c.md"),
+            }
+        )
+        assert idx.categories() == ["alpha", "zeta"]
+
+
+# ---------------------------------------------------------------------------
+# build_index
+# ---------------------------------------------------------------------------
+
+
+class TestBuildIndex:
+    def test_happy_path(self, tmp_path: Path):
+        (tmp_path / "guide-a.md").write_text(_make_guide_md(guide_id="guide-a"))
+        (tmp_path / "guide-b.md").write_text(_make_guide_md(guide_id="guide-b", category="async"))
+        idx = build_index(tmp_path)
+        assert len(idx) == 2
+        assert idx.get("guide-a") is not None
+        assert idx.get("guide-b") is not None
+
+    def test_nonexistent_directory(self, tmp_path: Path, caplog):
+        missing = tmp_path / "does-not-exist"
+        with caplog.at_level(logging.WARNING):
+            idx = build_index(missing)
+        assert len(idx) == 0
+        assert "not found" in caplog.text
+
+    def test_empty_directory(self, tmp_path: Path):
+        idx = build_index(tmp_path)
+        assert len(idx) == 0
+
+    def test_duplicate_id_first_wins(self, tmp_path: Path, caplog):
+        (tmp_path / "aaa.md").write_text(_make_guide_md(guide_id="dup", title="First"))
+        (tmp_path / "bbb.md").write_text(_make_guide_md(guide_id="dup", title="Second"))
+        (tmp_path / "ccc.md").write_text(_make_guide_md(guide_id="survivor", title="Survivor"))
+        with caplog.at_level(logging.WARNING):
+            idx = build_index(tmp_path)
+        assert len(idx) == 2
+        assert idx.get("dup").meta.title == "First"
+        assert idx.get("survivor") is not None
+        assert "Duplicate" in caplog.text
+
+    def test_frontmatter_error_skipped(self, tmp_path: Path, caplog):
+        (tmp_path / "bad.md").write_text("no frontmatter here")
+        (tmp_path / "good.md").write_text(_make_guide_md(guide_id="good"))
+        with caplog.at_level(logging.WARNING):
+            idx = build_index(tmp_path)
+        assert len(idx) == 1
+        assert idx.get("good") is not None
+        assert "Skipping" in caplog.text
+
+    def test_generic_exception_skipped(self, tmp_path: Path, caplog):
+        (tmp_path / "err.md").write_text("placeholder")
+        (tmp_path / "ok.md").write_text(_make_guide_md(guide_id="ok"))
+
+        original_read_text = Path.read_text
+
+        def _patched_read_text(self, *args, **kwargs):
+            if self.name == "err.md":
+                raise RuntimeError("simulated read failure")
+            return original_read_text(self, *args, **kwargs)
+
+        with patch.object(Path, "read_text", _patched_read_text), caplog.at_level(logging.WARNING):
+            idx = build_index(tmp_path)
+        assert len(idx) == 1
+        assert idx.get("ok") is not None
+        assert "Unexpected error" in caplog.text
+
+    def test_id_filename_mismatch(self, tmp_path: Path, caplog):
+        (tmp_path / "wrong-name.md").write_text(_make_guide_md(guide_id="real-id"))
+        with caplog.at_level(logging.WARNING):
+            idx = build_index(tmp_path)
+        assert len(idx) == 1
+        assert idx.get("real-id") is not None
+        assert idx.get("wrong-name") is None
+        assert "mismatch" in caplog.text
+
+    def test_nested_subdirectories(self, tmp_path: Path):
+        sub = tmp_path / "subdir"
+        sub.mkdir()
+        (sub / "nested.md").write_text(_make_guide_md(guide_id="nested"))
+        idx = build_index(tmp_path)
+        assert len(idx) == 1
+        assert idx.get("nested") is not None
+
+
+# ---------------------------------------------------------------------------
+# _code_lines (boundary cases only — _extract_snippet covered by test_search.py)
+# ---------------------------------------------------------------------------
+
+
+class TestCodeLines:
+    def test_basic_extraction(self):
+        body = "## BAD\n```python\nold()\nnew()\n```\n"
+        assert _code_lines(body, "## BAD") == ["old()", "new()"]
+
+    def test_tilde_fence_unsupported(self):
+        body = "## BAD\n~~~python\nold()\n~~~\n"
+        assert _code_lines(body, "## BAD") == []
+
+    def test_heading_trailing_space_no_match(self):
+        body = "## BAD \n```python\nold()\n```\n"
+        assert _code_lines(body, "## BAD") == []
+
+    def test_unclosed_fence_returns_all_lines(self):
+        body = "## BAD\n```python\nline1\nline2\n"
+        assert _code_lines(body, "## BAD") == ["line1", "line2"]
+
+    def test_empty_code_block(self):
+        body = "## BAD\n```python\n```\n"
+        assert _code_lines(body, "## BAD") == []
+
+    def test_multiple_fences_first_only(self):
+        body = "## BAD\n```python\nfirst()\n```\n```python\nsecond()\n```\n"
+        assert _code_lines(body, "## BAD") == ["first()"]
+
+
+# ---------------------------------------------------------------------------
+# _find_guides_dir fallbacks
+# ---------------------------------------------------------------------------
+
+
+class TestFindGuidesDir:
+    def test_dev_fallback(self, monkeypatch):
+        monkeypatch.setattr(
+            "modern_python_guidance.guide_index.importlib.resources.files",
+            _raise_type_error,
+        )
+        import modern_python_guidance.guide_index as gi_module
+
+        repo_root = Path(__file__).resolve().parent.parent
+        monkeypatch.setattr(
+            gi_module,
+            "__file__",
+            str(repo_root / "src" / "modern_python_guidance" / "guide_index.py"),
+        )
+        result = _find_guides_dir()
+        expected = repo_root / "skills" / "modern-python-guidance" / "guides"
+        assert result == expected
+
+    def test_relative_fallback(self, monkeypatch, tmp_path):
+        monkeypatch.setattr(
+            "modern_python_guidance.guide_index.importlib.resources.files",
+            _raise_type_error,
+        )
+        fake_file = tmp_path / "pkg" / "sub" / "guide_index.py"
+        fake_file.parent.mkdir(parents=True)
+        fake_file.touch()
+        import modern_python_guidance.guide_index as gi_module
+
+        monkeypatch.setattr(gi_module, "__file__", str(fake_file))
+        result = _find_guides_dir()
+        assert result == Path("skills") / "modern-python-guidance" / "guides"

{modern_python_guidance-0.3.7 → modern_python_guidance-0.3.8}/tests/test_mcp_server.py

@@ -262,7 +262,9 @@ class TestRetrieveGuides:
         result = responses[1]["result"]
         assert "isError" not in result
         data = json.loads(result["content"][0]["text"])
-        assert data == []
+        assert "not_found" in data
+        assert data["results"] == []
+        assert data["not_found"][0]["id"] == "nonexistent-guide-xyz"
 
 
 class TestListGuides:

{modern_python_guidance-0.3.7 → modern_python_guidance-0.3.8}/tests/test_mcp_unit.py

@@ -197,10 +197,25 @@ class TestToolFunctions:
         r = mcp._tool_retrieve({"guide_ids": []})
         assert r["isError"] is True
 
-    def test_retrieve_valid(self):
+    def test_retrieve_valid_bare_list(self):
         r = mcp._tool_retrieve({"guide_ids": ["use-builtin-generics"]})
         data = json.loads(r["content"][0]["text"])
         assert isinstance(data, list)
+        assert data[0]["id"] == "use-builtin-generics"
+
+    def test_retrieve_nonexistent_envelope(self):
+        r = mcp._tool_retrieve({"guide_ids": ["builtin-generics"]})
+        data = json.loads(r["content"][0]["text"])
+        assert "not_found" in data
+        assert data["not_found"][0]["id"] == "builtin-generics"
+        assert "use-builtin-generics" in data["not_found"][0]["suggestions"]
+
+    def test_retrieve_mixed_envelope(self):
+        r = mcp._tool_retrieve({"guide_ids": ["use-builtin-generics", "zzz-fake"]})
+        data = json.loads(r["content"][0]["text"])
+        assert len(data["results"]) == 1
+        assert data["results"][0]["id"] == "use-builtin-generics"
+        assert data["not_found"][0]["id"] == "zzz-fake"
 
     def test_retrieve_exactly_41_allowed(self):
         ids = [f"fake-{i}" for i in range(41)]
@@ -335,6 +350,18 @@ class TestHandleRequest:
         resp = mcp._handle_request(msg)
         assert resp is None
 
+    @pytest.mark.parametrize(
+        "msg",
+        [[1, 2, 3], "hello", 42, True],
+        ids=["list", "string", "number", "bool"],
+    )
+    def test_non_dict_returns_invalid_request(self, msg):
+        resp = mcp._handle_request(msg)
+        assert resp["jsonrpc"] == "2.0"
+        assert resp["id"] is None
+        assert resp["error"]["code"] == -32600
+        assert "expected JSON object" in resp["error"]["message"]
+
 
 # --- serve ---
 
@@ -377,3 +404,20 @@ class TestServe:
         assert len(responses) == 2
         assert responses[0]["id"] == 1
         assert responses[1]["id"] == 2
+
+    def test_non_dict_json_recovery(self):
+        lines = (
+            json.dumps([1, 2, 3])
+            + "\n"
+            + json.dumps({"jsonrpc": "2.0", "id": 1, "method": "initialize", "params": {}})
+            + "\n"
+        )
+        sin = io.StringIO(lines)
+        sout = io.StringIO()
+        mcp.serve(stdin=sin, stdout=sout)
+        responses = [json.loads(line) for line in sout.getvalue().strip().split("\n")]
+        assert len(responses) == 2
+        assert responses[0]["error"]["code"] == -32600
+        assert responses[0]["id"] is None
+        assert responses[1]["id"] == 1
+        assert "protocolVersion" in responses[1]["result"]

{modern_python_guidance-0.3.7 → modern_python_guidance-0.3.8}/tests/test_retrieve.py

@@ -6,7 +6,7 @@ from pathlib import Path
 import pytest
 
 from modern_python_guidance.guide_index import build_index
-from modern_python_guidance.retrieve import retrieve, retrieve_json
+from modern_python_guidance.retrieve import retrieve, retrieve_json, suggest_ids
 
 GUIDES_DIR = Path(__file__).parent.parent / "skills" / "modern-python-guidance" / "guides"
 
@@ -84,3 +84,36 @@ class TestRetrieveJSON:
             "source",
         }
         assert set(parsed[0].keys()) == expected_keys
+
+
+class TestSuggestIds:
+    def test_close_match(self, index):
+        suggestions = suggest_ids(index, "builtin-generics")
+        assert "use-builtin-generics" in suggestions
+
+    def test_no_match(self, index):
+        suggestions = suggest_ids(index, "zzz-totally-unknown")
+        assert suggestions == []
+
+    def test_max_three(self, index):
+        suggestions = suggest_ids(index, "pydantic")
+        assert len(suggestions) <= 3
+
+    def test_case_insensitive(self, index):
+        suggestions = suggest_ids(index, "USE-BUILTIN-GENERICS")
+        assert "use-builtin-generics" in suggestions
+
+    def test_long_id_truncated(self, index):
+        long_id = "use-builtin-generics" + "-x" * 200
+        suggestions = suggest_ids(index, long_id)
+        assert isinstance(suggestions, list)
+
+    def test_non_string_returns_empty(self, index):
+        assert suggest_ids(index, 123) == []
+
+    def test_empty_index(self):
+        from modern_python_guidance.guide_index import GuideIndex
+
+        empty = GuideIndex()
+        suggestions = suggest_ids(empty, "anything")
+        assert suggestions == []