stata-code 0.7.0__tar.gz → 0.7.1__tar.gz

{stata_code-0.7.0 → stata_code-0.7.1}/.gitignore

@@ -223,6 +223,8 @@ log-files/
 *.smcl
 *.dta
 !tests/fixtures/*.dta
+# Graph-export artifact written by the runner graph-capture tests
+stata_code_test_export.png
 
 # macOS
 .DS_Store

{stata_code-0.7.0 → stata_code-0.7.1}/CHANGELOG.md

@@ -6,6 +6,39 @@ to semver-major.minor for the result schema (see `SCHEMA.md` §6).
 
 ## Unreleased
 
+## 0.7.1 — 2026-06-19
+
+### Fixed
+
+- **Jupyter kernel: graphs after the first cell now display.** Graph capture
+  detected new graphs by diffing in-memory graph names before/after a run.
+  Because Stata keeps only one graph per name and every unnamed graph command
+  overwrites the default `Graph` in place, the second and later cells of a
+  persistent session produced no name delta and their graphs were silently
+  dropped — only the first cell's graph ever rendered. Capture now also
+  re-exports any graph the cell's own source shows it (re)drew (every
+  `name(...)` target, plus the default `Graph` for any unnamed graph command),
+  so in-place redraws surface every time. The same fix covers repeated MCP
+  `stata_run` calls in one session. The graph-command detector was tightened
+  to distinguish drawing commands from `graph` utility subcommands (`export`,
+  `display`, `dir`, `drop`, …) so a utility-only cell no longer re-surfaces a
+  stale graph.
+- **Jupyter kernel: no more duplicated code echo in cell output.** pystata
+  runs a multi-line cell as a temporary do-file, and Stata echoes every
+  submitted command (`. cmd` / `> continuation`) regardless of `echo=False`
+  (which only suppresses echo for a single inline command). For a cell with no
+  textual output (e.g. a graph) that echo was the *only* thing shown — a
+  useless repeat of the source already visible in the input cell. The kernel
+  now strips command-echo lines before streaming, keeping genuine command
+  output. The full log (with echo) is unchanged in `RunResult.log` for MCP /
+  agent consumers.
+
+### Changed
+
+- **VS Code extension now ships a Marketplace icon** (coef-plot mark, Anthropic
+  palette on white) so the listing and Extensions sidebar render branded
+  artwork instead of the default placeholder.
+
 ## 0.7.0 — 2026-05-30
 
 ### Added

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stata-code
-Version: 0.7.0
+Version: 0.7.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
@@ -84,9 +84,9 @@ Description-Content-Type: text/markdown
               └─────────────┘  └────────────┘  └─────────────────┘
 ```
 
-**Status: v0.6 (May 2026)** — the core, MCP server, Jupyter kernel, and VS Code extension work end-to-end against Stata 18 MP. The test suite covers schema, runner, MCP, kernel, notebook, run-index, subprocess-pool, and VS Code modules; CI also checks linting, type safety, schema generation, package metadata, and VSIX packaging. License: **MIT**.
+**Status: v0.7 (May 2026)** — the core, MCP server, Jupyter kernel, and VS Code extension work end-to-end against Stata 18 MP. The test suite covers schema, runner, MCP, kernel, notebook, run-index, subprocess-pool, and VS Code modules; CI also checks linting, type safety, schema generation, package metadata, and VSIX packaging. License: **MIT**.
 
-Two workflows v0.6 explicitly supports for end users:
+Two workflows the current release explicitly supports for end users:
 
 - **Run Stata code from a Jupyter notebook.** `pip install "stata-code[kernel]"` + `stata-code-kernel install --user` registers a **Stata** kernel that the Jupyter Notebook UI, JupyterLab, and the VS Code Jupyter extension all pick up by name. Cells render Stata logs, graphs, and warnings inline (the kernel logo bundled since v0.5 makes it appear in VS Code's kernel picker too). See [As a Jupyter Kernel](#as-a-jupyter-kernel).
 - **Optional agent "fix and rerun" loop.** `stata_run` returns typed `error.kind/line/context` plus `suggestions` on every failure. By default Claude Code only reports diagnostics — but if you explicitly say "fix this and rerun until it passes", the agent uses the same fields to edit your `.do` file and re-call `stata_run` until the run is green. The repair loop is **opt-in**: failed runs are diagnostics first, not automatic rewrite permission. See [Error Recovery in Agent Workflows](#error-recovery-in-agent-workflows).
@@ -444,7 +444,7 @@ stata_code/
 
 ## Roadmap
 
-### Done (through v0.6 — May 2026)
+### Done (through v0.7 — May 2026)
 
 - v1.0 result schema ([SCHEMA.md](SCHEMA.md))
 - `pystata`-based runner with native-typed `r()`, `e()`, and matrices

{stata_code-0.7.0 → stata_code-0.7.1}/README.md

@@ -45,9 +45,9 @@
               └─────────────┘  └────────────┘  └─────────────────┘
 ```
 
-**Status: v0.6 (May 2026)** — the core, MCP server, Jupyter kernel, and VS Code extension work end-to-end against Stata 18 MP. The test suite covers schema, runner, MCP, kernel, notebook, run-index, subprocess-pool, and VS Code modules; CI also checks linting, type safety, schema generation, package metadata, and VSIX packaging. License: **MIT**.
+**Status: v0.7 (May 2026)** — the core, MCP server, Jupyter kernel, and VS Code extension work end-to-end against Stata 18 MP. The test suite covers schema, runner, MCP, kernel, notebook, run-index, subprocess-pool, and VS Code modules; CI also checks linting, type safety, schema generation, package metadata, and VSIX packaging. License: **MIT**.
 
-Two workflows v0.6 explicitly supports for end users:
+Two workflows the current release explicitly supports for end users:
 
 - **Run Stata code from a Jupyter notebook.** `pip install "stata-code[kernel]"` + `stata-code-kernel install --user` registers a **Stata** kernel that the Jupyter Notebook UI, JupyterLab, and the VS Code Jupyter extension all pick up by name. Cells render Stata logs, graphs, and warnings inline (the kernel logo bundled since v0.5 makes it appear in VS Code's kernel picker too). See [As a Jupyter Kernel](#as-a-jupyter-kernel).
 - **Optional agent "fix and rerun" loop.** `stata_run` returns typed `error.kind/line/context` plus `suggestions` on every failure. By default Claude Code only reports diagnostics — but if you explicitly say "fix this and rerun until it passes", the agent uses the same fields to edit your `.do` file and re-call `stata_run` until the run is green. The repair loop is **opt-in**: failed runs are diagnostics first, not automatic rewrite permission. See [Error Recovery in Agent Workflows](#error-recovery-in-agent-workflows).
@@ -405,7 +405,7 @@ stata_code/
 
 ## Roadmap
 
-### Done (through v0.6 — May 2026)
+### Done (through v0.7 — May 2026)
 
 - v1.0 result schema ([SCHEMA.md](SCHEMA.md))
 - `pystata`-based runner with native-typed `r()`, `e()`, and matrices

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

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

{stata_code-0.7.0 → stata_code-0.7.1}/stata_code/__init__.py

@@ -174,7 +174,7 @@ def is_available() -> bool:
     return True
 
 
-__version__ = "0.7.0"
+__version__ = "0.7.1"
 
 __all__ = [
     # Primary entry points

{stata_code-0.7.0 → stata_code-0.7.1}/stata_code/core/runner.py

@@ -1195,11 +1195,20 @@ def _extract_warnings(log: str) -> list:  # list[StataWarning]
 
 
 _GRAPH_NAME_RE = re.compile(r"\bname\(\s*([A-Za-z_][A-Za-z0-9_]*)", re.IGNORECASE)
+# Stata's default in-memory graph name, (re)used by any graph command that
+# omits an explicit `name(...)` option. Capture/redraw detection keys off this.
+_DEFAULT_GRAPH_NAME = "Graph"
+# Commands that actually *draw* a graph (and thus create/overwrite an
+# in-memory graph). Deliberately excludes the `graph` utility subcommands
+# (export, display, dir, drop, describe, save, use, rename, set, copy, query,
+# replay) — those operate on existing graphs and must not be mistaken for a
+# redraw, or a bare `graph export` cell would spuriously re-surface a stale
+# graph.
 _GRAPH_COMMAND_RE = re.compile(
     r"^\s*(?:"
-    r"graph\s+\w+|"
-    r"twoway|scatter|line|connected|histogram|kdensity|lowess|lfit|qfit|"
-    r"coefplot|binscatter"
+    r"graph\s+(?:bar|hbar|box|hbox|dot|pie|twoway|matrix|combine)\b|"
+    r"twoway|scatter|line|connected|histogram|hist|kdensity|lpoly|lowess|"
+    r"lfit|qfit|coefplot|binscatter|marginsplot"
     r")\b",
     re.IGNORECASE,
 )
@@ -1262,19 +1271,40 @@ def _collect_graphs(
     source_hints: dict[str, tuple[str, int]] | None = None,
     unnamed_source_hints: list[tuple[str, int]] | None = None,
 ) -> list[GraphInfo]:
-    """Capture graphs that user code newly created.
+    """Capture graphs that user code newly created or redrew.
 
     Strategy: snapshot graph names before user code (`pre_existing`), call
-    after to find the post-existing list, take the set difference. For each
-    new graph: `graph display <name>` (makes it active), `graph export` to a
-    tmpfile, read bytes, store under a ref. Tmpfile is deleted after.
+    after to find the post-existing list. Capture a graph when its name is
+    genuinely new *or* when this cell's source shows it (re)drew that name.
+
+    The redraw case matters because Stata keeps only one in-memory graph per
+    name, so a command that overwrites an existing name (most commonly the
+    default ``Graph``, produced by any unnamed graph command) leaves the
+    ``graph dir`` name set unchanged. A pure set-difference against
+    `pre_existing` therefore misses it — which is why, in a persistent session
+    (Jupyter cell 2+, repeated MCP runs), only the first graph ever surfaced.
+
+    For each captured graph: `graph display <name>` (makes it active),
+    `graph export` to a tmpfile, read bytes, store under a ref. Tmpfile is
+    deleted after.
     """
     after_names = _list_graph_names(rt)
-    new_names = [n for n in after_names if n not in pre_existing]
-    if not new_names:
-        return []
     source_hints = source_hints or {}
     unnamed_source_hints = unnamed_source_hints or []
+
+    # Names this cell explicitly drew, inferred from its source: every
+    # `name(...)` option, plus the default graph when any unnamed graph
+    # command ran. These are re-captured even if they already existed, so an
+    # in-place redraw is not dropped.
+    redrawn = set(source_hints)
+    if unnamed_source_hints:
+        redrawn.add(_DEFAULT_GRAPH_NAME)
+
+    new_names = [
+        n for n in after_names if n not in pre_existing or n in redrawn
+    ]
+    if not new_names:
+        return []
     unattributed_names = [n for n in new_names if n not in source_hints]
     unnamed_by_graph: dict[str, tuple[str, int]] = {}
     if len(unattributed_names) == len(unnamed_source_hints):

{stata_code-0.7.0 → stata_code-0.7.1}/stata_code/kernel/kernel.py

@@ -102,6 +102,35 @@ def _word_at_cursor(code: str, cursor_pos: int) -> tuple[str, int, int]:
     return code[start:end], start, end
 
 
+def _strip_command_echo(log_text: str) -> str:
+    """Drop Stata's do-file command echo from a captured cell log.
+
+    pystata runs a multi-line cell as a temporary do-file, and Stata echoes
+    every submitted command — ``. cmd`` for the first line of each command and
+    ``> ...`` for wrapped/continued lines — regardless of the ``echo=False``
+    flag (which only suppresses echo for a single inline command). In a
+    notebook the input cell already shows the source, so the echo is pure
+    duplication; for a cell with no textual output (e.g. a graph) the echo is
+    the *only* thing shown, which reads as a useless repeat of the code.
+
+    Strip the echoed command/continuation lines, keep genuine command output,
+    and collapse the blank-line runs the removal leaves behind. Echoed lines
+    always start at column 0 with ``. `` (dot-space) or ``> `` (continuation);
+    real Stata output never begins that way, so this is safe.
+    """
+    kept: list[str] = []
+    for line in log_text.split("\n"):
+        if line.startswith(". ") or line.startswith("> "):
+            continue
+        # Collapse leading and consecutive blank lines left by removed echoes.
+        if not line.strip() and (not kept or not kept[-1].strip()):
+            continue
+        kept.append(line)
+    while kept and not kept[-1].strip():
+        kept.pop()
+    return "\n".join(kept)
+
+
 # ─────────────────────────────────────────────────────────────────────────────
 # Kernel
 # ─────────────────────────────────────────────────────────────────────────────
@@ -155,8 +184,9 @@ class StataKernel(_KernelBase):
         self._last_result = result
 
         if not silent:
-            if result.log.head:
-                self._stream("stdout", result.log.head + "\n")
+            log_text = _strip_command_echo(result.log.head) if result.log.head else ""
+            if log_text:
+                self._stream("stdout", log_text + "\n")
             if result.warnings:
                 for w in result.warnings:
                     self._stream("stderr", f"[{w.kind}] {w.message}\n")

{stata_code-0.7.0 → stata_code-0.7.1}/stata_code/mcp/server.py

@@ -95,7 +95,7 @@ from stata_code.core.runner import (
 )
 from stata_code.core.schema import RunResult
 
-__version__ = "0.7.0"
+__version__ = "0.7.1"
 
 SERVER_INSTRUCTIONS = (
     "Use stata-code for running and inspecting Stata code. Prefer structuredContent "

{stata_code-0.7.0 → stata_code-0.7.1}/tests/test_kernel.py

@@ -130,6 +130,73 @@ class TestStataKernelClass:
         finally:
             kernel_module._HAS_IPYKERNEL = original
 
+    def test_do_execute_suppresses_pure_command_echo(self):
+        """A cell with no textual output (e.g. a graph) must not stream the
+        echoed source back — that read as a useless repeat of the code."""
+        from stata_code.kernel import kernel as kernel_module
+
+        original = kernel_module._HAS_IPYKERNEL
+        kernel_module._HAS_IPYKERNEL = True
+        echo_only = LogInfo(
+            head='\n. * 3) fit\n. twoway (scatter price mpg) (lfit price mpg)\n\n. \n',
+            tail="",
+            lines_total=5,
+            bytes_total=60,
+        )
+        mock_result = _make_run_result(ok=True, log=echo_only)
+        try:
+            from stata_code.kernel import StataKernel
+
+            kb = StataKernel()
+            streamed: list[tuple[str, str]] = []
+            with patch.object(
+                kb, "_stream", side_effect=lambda n, t: streamed.append((n, t))
+            ):
+                with patch(
+                    "stata_code.kernel.kernel.execute", return_value=mock_result
+                ):
+                    reply = kb.do_execute(
+                        "* 3) fit\ntwoway (scatter price mpg) (lfit price mpg)",
+                        silent=False,
+                    )
+            assert reply["status"] == "ok"
+            assert not any(name == "stdout" for name, _ in streamed)
+        finally:
+            kernel_module._HAS_IPYKERNEL = original
+
+    def test_do_execute_streams_output_without_echo(self):
+        """Genuine command output is streamed, but the leading `. cmd` echo is
+        stripped from it."""
+        from stata_code.kernel import kernel as kernel_module
+
+        original = kernel_module._HAS_IPYKERNEL
+        kernel_module._HAS_IPYKERNEL = True
+        mixed = LogInfo(
+            head="\n. summarize price\n\n    price |   74\n\n. \n",
+            tail="",
+            lines_total=6,
+            bytes_total=40,
+        )
+        mock_result = _make_run_result(ok=True, log=mixed)
+        try:
+            from stata_code.kernel import StataKernel
+
+            kb = StataKernel()
+            streamed: list[tuple[str, str]] = []
+            with patch.object(
+                kb, "_stream", side_effect=lambda n, t: streamed.append((n, t))
+            ):
+                with patch(
+                    "stata_code.kernel.kernel.execute", return_value=mock_result
+                ):
+                    kb.do_execute("summarize price", silent=False)
+            stdout = [t for n, t in streamed if n == "stdout"]
+            assert len(stdout) == 1
+            assert ". summarize price" not in stdout[0]
+            assert "price |   74" in stdout[0]
+        finally:
+            kernel_module._HAS_IPYKERNEL = original
+
     def test_do_complete_returns_stata_keywords(self):
         """do_complete should return Stata keyword matches."""
         from stata_code.kernel import StataKernel
@@ -332,6 +399,52 @@ class TestInstallKernel:
         assert flags == [False]
 
 
+class TestCommandEchoStripping:
+    """Unit tests for `_strip_command_echo` (pure, no Stata required)."""
+
+    def test_pure_echo_graph_cell_becomes_empty(self):
+        from stata_code.kernel.kernel import _strip_command_echo
+
+        log = "\n. * 3) fit\n. twoway (scatter price mpg) (lfit price mpg)\n\n. \n"
+        assert _strip_command_echo(log) == ""
+
+    def test_wrapped_continuation_lines_stripped(self):
+        from stata_code.kernel.kernel import _strip_command_echo
+
+        # Stata wraps a long command onto a `> ` continuation line.
+        log = (
+            '\n. twoway scatter price mpg, title("A long title that wraps\n'
+            '> onto another line")\n\n. \n'
+        )
+        assert _strip_command_echo(log) == ""
+
+    def test_real_output_preserved_echo_removed(self):
+        from stata_code.kernel.kernel import _strip_command_echo
+
+        log = "\n. summarize price\n\n    price |   74\n\n. \n"
+        out = _strip_command_echo(log)
+        assert ". summarize" not in out
+        assert out == "    price |   74"
+
+    def test_consecutive_blank_lines_collapsed(self):
+        from stata_code.kernel.kernel import _strip_command_echo
+
+        assert _strip_command_echo("line1\n\n\n\nline2") == "line1\n\nline2"
+
+    def test_log_without_echo_unchanged(self):
+        from stata_code.kernel.kernel import _strip_command_echo
+
+        log = "    Variable |  Obs\n       price |   74"
+        assert _strip_command_echo(log) == log
+
+    def test_missing_value_dot_output_not_stripped(self):
+        from stata_code.kernel.kernel import _strip_command_echo
+
+        # A bare "." (e.g. `display .`) is real output, not an echoed prompt
+        # (which is always ". " — dot-space). It must survive.
+        assert _strip_command_echo(".") == "."
+
+
 # NOTE: TestStataGraphDataUri was removed in v0.2. The legacy `StataGraph`
 # dataclass (with .to_base64() / .to_data_uri()) is gone; the v1.0 `GraphInfo`
 # schema returns refs by default and inline base64 only when explicitly

{stata_code-0.7.0 → stata_code-0.7.1}/tests/test_runner.py

@@ -265,6 +265,67 @@ class TestGraphCapture:
         # refs are unique per index
         assert len({g.ref for g in r.graphs}) == 2
 
+    def test_redrawn_default_graph_recaptured_each_cell(self, loaded_auto):
+        """Regression: in a persistent session every unnamed graph command
+        overwrites the default "Graph" in place, so a pure name set-diff sees
+        no new name on the 2nd+ run and captured nothing — only the first
+        Jupyter cell's graph displayed. Each redraw must now surface its own
+        graph. NOTE: deliberately no _clean_graphs between runs."""
+        from stata_code.core.runner import execute
+
+        self._clean_graphs(execute)
+        r1 = execute("scatter price mpg")
+        assert len(r1.graphs) == 1
+        r2 = execute("scatter weight mpg")
+        assert len(r2.graphs) == 1  # was 0 before the fix
+        r3 = execute("histogram price")
+        assert len(r3.graphs) == 1
+
+    def test_redrawn_named_graph_recaptured(self, loaded_auto):
+        """A named graph redrawn under the same name across runs is captured
+        every time, not just the first."""
+        from stata_code.core.runner import execute
+
+        self._clean_graphs(execute)
+        r1 = execute("scatter price mpg, name(g_redraw, replace)")
+        assert len(r1.graphs) == 1
+        r2 = execute("scatter weight mpg, name(g_redraw, replace)")
+        assert len(r2.graphs) == 1  # was 0 before the fix
+        assert r2.graphs[0].name == "g_redraw"
+
+    def test_no_graph_cell_after_graph_no_recapture(self, loaded_auto):
+        """A cell that draws nothing must not re-surface an existing graph
+        left over from an earlier cell."""
+        from stata_code.core.runner import execute
+
+        self._clean_graphs(execute)
+        first = execute("scatter price mpg")
+        assert len(first.graphs) == 1
+        r = execute('display "just text, no graph"')
+        assert r.graphs == []
+
+    def test_graph_export_cell_does_not_recapture(self, loaded_auto, tmp_path):
+        """A utility-only cell (graph export of a prior graph) must not be
+        treated as a redraw — `graph export` is not a drawing command."""
+        from stata_code.core.runner import execute
+
+        self._clean_graphs(execute)
+        execute("scatter price mpg")  # default Graph now exists
+        out = (tmp_path / "export.png").as_posix()
+        r = execute(f'graph export "{out}", replace')
+        assert r.graphs == []
+
+    def test_new_graph_with_untouched_graph_persisting(self, loaded_auto):
+        """When a cell draws one new named graph while an older, untouched
+        named graph still lives in memory, only the new one is captured."""
+        from stata_code.core.runner import execute
+
+        self._clean_graphs(execute)
+        execute("scatter price mpg, name(g_keep)")
+        r = execute("histogram weight, name(g_fresh)")
+        assert len(r.graphs) == 1
+        assert r.graphs[0].name == "g_fresh"
+
     def test_get_graph_returns_bytes(self, loaded_auto):
         from stata_code.core.runner import execute, get_graph