stata-code 0.6.0__tar.gz → 0.6.1__tar.gz

{stata_code-0.6.0 → stata_code-0.6.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stata-code
-Version: 0.6.0
+Version: 0.6.1
 Summary: Agent-native Stata bridge — one core, multiple frontends (MCP, Jupyter, VSCode)
 Project-URL: Homepage, https://github.com/brycewang-stanford/stata-code
 Project-URL: Repository, https://github.com/brycewang-stanford/stata-code

{stata_code-0.6.0 → stata_code-0.6.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "stata-code"
-version = "0.6.0"
+version = "0.6.1"
 description = "Agent-native Stata bridge — one core, multiple frontends (MCP, Jupyter, VSCode)"
 readme = "README.md"
 license = "MIT"

{stata_code-0.6.0 → stata_code-0.6.1}/stata_code/__init__.py

@@ -58,7 +58,7 @@ from stata_code.core.schema import (
 # Convenience alias: `run(...)` == `execute(...)`.
 run = execute
 
-__version__ = "0.6.0"
+__version__ = "0.6.1"
 
 __all__ = [
     # Primary entry points

{stata_code-0.6.0 → stata_code-0.6.1}/stata_code/core/notebook.py

@@ -777,6 +777,28 @@ def _ensure_native_id(cell: dict[str, Any], index: int, source: str) -> str:
     return new_id
 
 
+def _upgrade_all_pre_45_ids(cells: list[Any]) -> int:
+    """Assign a fresh UUID to every cell that lacks a native ``id``.
+
+    Synthesised ids are derived from the cell's array index; any structural
+    mutation (insert / delete) shifts indices, silently invalidating every
+    synth id the caller is holding. Upgrading the whole notebook to nbformat
+    4.5+ ids on first mutation makes every cell handle stable from then on.
+
+    Returns the number of cells that were upgraded.
+    """
+    upgraded = 0
+    for cell in cells:
+        if not isinstance(cell, dict):
+            continue
+        raw = cell.get("id")
+        if isinstance(raw, str) and raw:
+            continue
+        cell["id"] = _new_cell_id()
+        upgraded += 1
+    return upgraded
+
+
 def edit_cell(
     path: str | Path,
     *,
@@ -883,6 +905,8 @@ def insert_cell(
     nb = load_notebook(p)
     cells = nb["cells"]
 
+    # Resolve the anchor BEFORE upgrading other ids — the caller may have
+    # passed a synth id that depends on the current array indices.
     if at_start:
         target_index = 0
     elif at_end:
@@ -891,20 +915,19 @@ def insert_cell(
         anchor_index, anchor_cell = _resolve_cell(
             cells, cell_id=after_cell_id, cell_index=None
         )
-        # If the anchor was a pre-4.5 cell addressed by its synth id, upgrade
-        # to a real UUID. Otherwise the anchor's index-derived synth id would
-        # change after insertion (silent foot-gun for the caller).
-        anchor_source = _source_to_str(anchor_cell.get("source"))
-        _ensure_native_id(anchor_cell, anchor_index, anchor_source)
         target_index = anchor_index + 1
     else:
         anchor_index, anchor_cell = _resolve_cell(
             cells, cell_id=before_cell_id, cell_index=None
         )
-        anchor_source = _source_to_str(anchor_cell.get("source"))
-        _ensure_native_id(anchor_cell, anchor_index, anchor_source)
         target_index = anchor_index
 
+    # Insertion shifts every cell at >= target_index by one slot, which
+    # would silently invalidate every synth id the caller is holding.
+    # Upgrade the whole notebook to nbformat 4.5+ ids in one shot so every
+    # cell handle remains stable across this and future mutations.
+    _upgrade_all_pre_45_ids(cells)
+
     new_id = _new_cell_id()
     new_cell = _build_cell(cell_type=cell_type, source=source, cell_id=new_id)
     cells.insert(target_index, new_cell)
@@ -949,6 +972,10 @@ def delete_cell(
     actual_id, synthesized = _cell_id(cell, index, current_source)
     ctype = _cell_type(cell)
     cells.pop(index)
+    # The pop shifts every later cell's array index, invalidating any synth
+    # ids the caller might still be holding for those cells. Upgrade them
+    # all to fresh UUIDs in one shot.
+    _upgrade_all_pre_45_ids(cells)
     _atomic_write_notebook(p, nb)
 
     return {

{stata_code-0.6.0 → stata_code-0.6.1}/stata_code/mcp/server.py

@@ -82,7 +82,7 @@ from stata_code.core.runner import (
 )
 from stata_code.core.schema import RunResult
 
-__version__ = "0.6.0"
+__version__ = "0.6.1"
 
 SERVER_INSTRUCTIONS = (
     "Use stata-code for running and inspecting Stata code. Prefer structuredContent "
@@ -1661,11 +1661,29 @@ async def _dispatch(name: str, arguments: dict[str, Any]) -> Any:
         return _error_result(f"Error: {type(exc).__name__}: {exc}", kind="internal_error")
 
 
+_RUN_BOOL_KEYS: tuple[tuple[str, bool], ...] = (
+    ("include_full_log", False),
+    ("include_dataset_variables", True),
+    ("persist_log_files", False),
+    ("persist_generated_files", True),
+    ("use_origin_workdir", True),
+)
+
+
 def _run_tool(arguments: dict[str, Any]) -> Any:
     args = dict(arguments)
     code = args.pop("code", None)
     if not code:
         return _error_result("code is required", kind="missing_argument")
+    # Validate booleans up front rather than letting truthy strings ("false",
+    # "no", …) silently flip behaviour inside the runner.
+    for key, default in _RUN_BOOL_KEYS:
+        if key not in args:
+            continue
+        value, err = _bool_arg(args, key, default=default)
+        if err is not None:
+            return err
+        args[key] = value
     try:
         result = pool_execute(code, **args)
     except (ValueError, NotImplementedError) as exc:
@@ -1753,6 +1771,35 @@ def _require_str(arguments: dict[str, Any], key: str) -> tuple[str, Any]:
     return value, None
 
 
+_SENTINEL = object()
+
+
+def _bool_arg(
+    arguments: dict[str, Any], key: str, *, default: bool
+) -> tuple[bool, Any]:
+    """Read an optional boolean argument with strict JSON-bool typing.
+
+    JSON has a real boolean type, and the inputSchema declares these args
+    as ``"type": "boolean"``. Many MCP clients do not enforce the schema,
+    so we reject coerced values like ``"true"``, ``1``, or ``"yes"`` here
+    rather than silently truthy-coerce them (``bool("false") is True``).
+
+    ``isinstance(x, bool)`` happens to also gate against ``int`` even
+    though ``bool`` is a subclass of ``int`` — only ``True`` / ``False``
+    pass the check. Returns ``(value, None)`` on success, or
+    ``(default, error_result)`` when the type is wrong.
+    """
+    value = arguments.get(key, _SENTINEL)
+    if value is _SENTINEL or value is None:
+        return default, None
+    if not isinstance(value, bool):
+        return default, _error_result(
+            f"{key} must be a boolean (true/false), got {type(value).__name__}",
+            kind="invalid_request",
+        )
+    return value, None
+
+
 def _notebook_edit_cell_tool(arguments: dict[str, Any]) -> Any:
     path, err = _require_str(arguments, "path")
     if err is not None:
@@ -1795,8 +1842,12 @@ def _notebook_insert_cell_tool(arguments: dict[str, Any]) -> Any:
         return _error_result("cell_type must be a string", kind="invalid_request")
     after_cell_id = arguments.get("after_cell_id")
     before_cell_id = arguments.get("before_cell_id")
-    at_start = bool(arguments.get("at_start") or False)
-    at_end = bool(arguments.get("at_end") or False)
+    at_start, err = _bool_arg(arguments, "at_start", default=False)
+    if err is not None:
+        return err
+    at_end, err = _bool_arg(arguments, "at_end", default=False)
+    if err is not None:
+        return err
     for label, value in (
         ("after_cell_id", after_cell_id),
         ("before_cell_id", before_cell_id),

{stata_code-0.6.0 → stata_code-0.6.1}/tests/test_mcp.py

@@ -292,6 +292,95 @@ class TestDispatch:
         body = _json_body(out)
         assert "error" in body
 
+    def test_stata_run_rejects_non_boolean_argument(self):
+        """The schema declares ``include_full_log`` as boolean, but many MCP
+        clients do not validate. Server must reject coerced strings rather
+        than silently truthy-coerce them (``bool("false") is True``).
+        """
+        from stata_code.mcp.server import _dispatch
+
+        out = asyncio.run(
+            _dispatch(
+                "stata_run", {"code": "display 1", "include_full_log": "false"}
+            )
+        )
+        assert out.isError is True
+        body = _json_body(out)
+        assert "include_full_log" in body["error"]
+        assert "boolean" in body["error"].lower()
+
+    def test_notebook_insert_cell_rejects_string_at_start(self, tmp_path):
+        from stata_code.mcp.server import _dispatch
+
+        nb_path = tmp_path / "nb.ipynb"
+        nb_path.write_text(
+            json.dumps(
+                {
+                    "nbformat": 4,
+                    "nbformat_minor": 5,
+                    "metadata": {},
+                    "cells": [
+                        {
+                            "cell_type": "code",
+                            "id": "a",
+                            "source": "x=1",
+                            "metadata": {},
+                            "outputs": [],
+                        }
+                    ],
+                }
+            ),
+            encoding="utf-8",
+        )
+
+        out = asyncio.run(
+            _dispatch(
+                "notebook_insert_cell",
+                {"path": str(nb_path), "source": "x=2", "at_start": "true"},
+            )
+        )
+        assert out.isError is True
+        body = _json_body(out)
+        assert "at_start" in body["error"]
+        # No cell was appended despite the truthy-looking string.
+        cells = json.loads(nb_path.read_text(encoding="utf-8"))["cells"]
+        assert len(cells) == 1
+
+    def test_notebook_insert_cell_accepts_bool_at_start(self, tmp_path):
+        from stata_code.mcp.server import _dispatch
+
+        nb_path = tmp_path / "nb.ipynb"
+        nb_path.write_text(
+            json.dumps(
+                {
+                    "nbformat": 4,
+                    "nbformat_minor": 5,
+                    "metadata": {},
+                    "cells": [
+                        {
+                            "cell_type": "code",
+                            "id": "a",
+                            "source": "x=1",
+                            "metadata": {},
+                            "outputs": [],
+                        }
+                    ],
+                }
+            ),
+            encoding="utf-8",
+        )
+
+        out = asyncio.run(
+            _dispatch(
+                "notebook_insert_cell",
+                {"path": str(nb_path), "source": "x=2", "at_start": True},
+            )
+        )
+        assert out.isError is not True
+        cells = json.loads(nb_path.read_text(encoding="utf-8"))["cells"]
+        assert len(cells) == 2
+        assert cells[0]["source"] == "x=2"
+
     def test_stata_info_unavailable_shape(self, monkeypatch):
         from stata_code.mcp import server
 

{stata_code-0.6.0 → stata_code-0.6.1}/tests/test_notebook_phase2.py

@@ -477,3 +477,137 @@ def test_edit_cell_no_temp_files_left_behind(tmp_path: Path) -> None:
     # Only the notebook file should remain.
     leftover = [p.name for p in tmp_path.iterdir()]
     assert leftover == ["nb.ipynb"]
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Pre-4.5 id stability across structural mutations
+# ─────────────────────────────────────────────────────────────────────────────
+
+
+def test_insert_at_start_upgrades_all_synth_ids(tmp_path: Path) -> None:
+    """`at_start` shifts every existing cell down one slot, which silently
+    invalidates every index-derived synth id the caller is holding. Inserting
+    must upgrade every pre-4.5 cell to a fresh UUID so previously-cached
+    handles either still resolve (if the caller re-reads) or fail loudly.
+    """
+    path = _write_nb(
+        tmp_path,
+        [
+            {"cell_type": "code", "source": "x=1", "metadata": {}, "outputs": []},
+            {"cell_type": "code", "source": "x=2", "metadata": {}, "outputs": []},
+            {"cell_type": "markdown", "source": "# H", "metadata": {}},
+        ],
+    )
+    insert_cell(path, source="first", at_start=True)
+    cells = _read(path)["cells"]
+    assert len(cells) == 4
+    # Every cell now carries a real UUID — no synth ids survive on disk.
+    for cell in cells:
+        cid = cell["id"]
+        assert isinstance(cid, str)
+        assert not cid.startswith("synth-")
+        assert re.match(r"^[0-9a-f-]{36}$", cid)
+    # Ids are unique.
+    assert len({c["id"] for c in cells}) == 4
+
+
+def test_insert_at_end_upgrades_all_synth_ids(tmp_path: Path) -> None:
+    path = _write_nb(
+        tmp_path,
+        [
+            {"cell_type": "code", "source": "x=1", "metadata": {}, "outputs": []},
+            {"cell_type": "code", "source": "x=2", "metadata": {}, "outputs": []},
+        ],
+    )
+    insert_cell(path, source="last", at_end=True)
+    cells = _read(path)["cells"]
+    for cell in cells:
+        assert not cell["id"].startswith("synth-")
+
+
+def test_insert_after_upgrades_unrelated_synth_ids(tmp_path: Path) -> None:
+    """The anchor's synth id was already upgraded by prior versions, but
+    other synth-id cells past the insertion point would silently shift.
+    All cells must end up with stable native ids.
+    """
+    path = _write_nb(
+        tmp_path,
+        [
+            {"cell_type": "code", "source": "x=1", "metadata": {}, "outputs": []},
+            {"cell_type": "code", "source": "x=2", "metadata": {}, "outputs": []},
+            {"cell_type": "code", "source": "x=3", "metadata": {}, "outputs": []},
+        ],
+    )
+    out = outline_notebook(path)
+    anchor_synth = out["cells"][0]["cell_id"]
+    third_synth = out["cells"][2]["cell_id"]
+    assert anchor_synth.startswith("synth-")
+    assert third_synth.startswith("synth-")
+
+    insert_cell(path, source="x=99", after_cell_id=anchor_synth)
+
+    cells = _read(path)["cells"]
+    # Cell that was at index 2 ('x=3') is now at index 3 — its synth id
+    # would have changed silently. The upgrade made it stable.
+    assert cells[3]["source"] == "x=3"
+    assert not cells[3]["id"].startswith("synth-")
+    assert re.match(r"^[0-9a-f-]{36}$", cells[3]["id"])
+
+
+def test_delete_cell_upgrades_remaining_synth_ids(tmp_path: Path) -> None:
+    path = _write_nb(
+        tmp_path,
+        [
+            {"cell_type": "code", "source": "drop", "metadata": {}, "outputs": []},
+            {"cell_type": "code", "source": "keep1", "metadata": {}, "outputs": []},
+            {"cell_type": "code", "source": "keep2", "metadata": {}, "outputs": []},
+        ],
+    )
+    out = outline_notebook(path)
+    target = out["cells"][0]["cell_id"]
+
+    delete_cell(path, cell_id=target)
+    cells = _read(path)["cells"]
+    assert [c["source"] for c in cells] == ["keep1", "keep2"]
+    for cell in cells:
+        assert not cell["id"].startswith("synth-")
+
+
+def test_edit_cell_upgrades_target_synth_id_only(tmp_path: Path) -> None:
+    path = _write_nb(
+        tmp_path,
+        [
+            {"cell_type": "code", "source": "x=1", "metadata": {}, "outputs": []},
+            {"cell_type": "code", "source": "x=2", "metadata": {}, "outputs": []},
+        ],
+    )
+    out = outline_notebook(path)
+    target = out["cells"][0]["cell_id"]
+
+    edit_cell(path, cell_id=target, new_source="x=99")
+    cells = _read(path)["cells"]
+    assert not cells[0]["id"].startswith("synth-")
+    assert "id" not in cells[1]
+
+
+def test_edit_cell_keeps_other_synth_ids_usable_for_same_outline(
+    tmp_path: Path,
+) -> None:
+    path = _write_nb(
+        tmp_path,
+        [
+            {"cell_type": "code", "source": "x=1", "metadata": {}, "outputs": []},
+            {"cell_type": "code", "source": "x=2", "metadata": {}, "outputs": []},
+        ],
+    )
+    out = outline_notebook(path)
+    first_id = out["cells"][0]["cell_id"]
+    second_id = out["cells"][1]["cell_id"]
+
+    edit_cell(path, cell_id=first_id, new_source="x=10")
+    edit_cell(path, cell_id=second_id, new_source="x=20")
+
+    cells = _read(path)["cells"]
+    assert [c["source"] for c in cells] == ["x=10", "x=20"]
+    assert not cells[0]["id"].startswith("synth-")
+    assert not cells[1]["id"].startswith("synth-")