clikernel 0.1.2__tar.gz → 0.1.3__tar.gz

clikernel-0.1.3/CHANGELOG.md

@@ -0,0 +1,34 @@
+<!-- do not remove -->
+
+## 0.1.3
+
+### New Features
+
+- Add `exit` MCP tool for hard process reset, and add pyskill ([#7](https://github.com/AnswerDotAI/clikernel/issues/7))
+- Add asyncio lock and async wrappers to MCP tools to allow top-level await ([#6](https://github.com/AnswerDotAI/clikernel/issues/6))
+- Add %nbopen/%nbrun line magics for running notebook cells by id prefix ([#5](https://github.com/AnswerDotAI/clikernel/issues/5))
+- Add MCP server exposing persistent IPython session; suppress duplicate tracebacks and defer init to main() ([#3](https://github.com/AnswerDotAI/clikernel/issues/3))
+
+### Bugs Squashed
+
+- Set `structured_output`=False on MCP tool decorators ([#4](https://github.com/AnswerDotAI/clikernel/issues/4))
+
+
+## 0.1.2
+
+### New Features
+
+- Add ONLCR terminal flag control ([#2](https://github.com/AnswerDotAI/clikernel/issues/2))
+
+
+## 0.1.1
+
+### New Features
+
+- Use a fixed per-session delimiter and emit `.` ack before each response ([#1](https://github.com/AnswerDotAI/clikernel/issues/1))
+
+
+## 0.1.0
+
+- Initial release
+

{clikernel-0.1.2/clikernel.egg-info → clikernel-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clikernel
-Version: 0.1.2
+Version: 0.1.3
 Summary: A tiny stdin/stdout IPython worker
 Author: clikernel contributors
 License: Apache-2.0
@@ -10,7 +10,8 @@ Classifier: Programming Language :: Python :: 3 :: Only
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: execnb
+Requires-Dist: execnb>=0.2.3
+Requires-Dist: mcp
 Provides-Extra: dev
 Requires-Dist: fastship; extra == "dev"
 Requires-Dist: build; extra == "dev"
@@ -73,6 +74,20 @@ After execution, `clikernel` prints the acknowledgement, the rendered output, an
 
 Outputs are rendered with `fastcore.nbio.render_text`. A single non-empty output is printed directly. Multiple outputs use raw XML-ish tags, for example `<stdout>`, `<display_data mime="text/markdown">`, and `<execute_result>`.
 
+## Notebook magics
+
+`clikernel` registers two line magics wrapping `execnb`'s `nbopen`/`nbrun`, for running cells from a notebook by cell id prefix:
+
+```text
+%nbopen foo.ipynb
+%nbrun ab12
+%nbrun ab12 --above
+%nbrun --all --exported
+%nbrun ab12 --fname other.ipynb
+```
+
+`%nbopen` sets the default notebook for later `%nbrun` calls (as does passing `--fname`). `%nbrun` runs the cell whose id starts with the given prefix; `--above`/`--below` also run the cells before/after it, `--all` runs every code cell, and `--exported` filters to cells with an nbdev `#| export`/`#| exports` directive. The notebook is re-read from disk on each call, and each executed cell's rendered output is printed under a `--- {cell id} ---` header.
+
 `clikernel` sets quiet defaults for `IPYTHONDIR`, `MPLCONFIGDIR`, and `MPLBACKEND=Agg` before creating the shell. Existing `IPYTHONDIR` and `MPLCONFIGDIR` values are left alone. Loading messages and any startup warnings are printed before the first delimiter. Set `CLIKERNEL_STATE_DIR` to choose the default parent directory.
 
 ## Why The Protocol Is Odd

{clikernel-0.1.2 → clikernel-0.1.3}/README.md

@@ -53,6 +53,20 @@ After execution, `clikernel` prints the acknowledgement, the rendered output, an
 
 Outputs are rendered with `fastcore.nbio.render_text`. A single non-empty output is printed directly. Multiple outputs use raw XML-ish tags, for example `<stdout>`, `<display_data mime="text/markdown">`, and `<execute_result>`.
 
+## Notebook magics
+
+`clikernel` registers two line magics wrapping `execnb`'s `nbopen`/`nbrun`, for running cells from a notebook by cell id prefix:
+
+```text
+%nbopen foo.ipynb
+%nbrun ab12
+%nbrun ab12 --above
+%nbrun --all --exported
+%nbrun ab12 --fname other.ipynb
+```
+
+`%nbopen` sets the default notebook for later `%nbrun` calls (as does passing `--fname`). `%nbrun` runs the cell whose id starts with the given prefix; `--above`/`--below` also run the cells before/after it, `--all` runs every code cell, and `--exported` filters to cells with an nbdev `#| export`/`#| exports` directive. The notebook is re-read from disk on each call, and each executed cell's rendered output is printed under a `--- {cell id} ---` header.
+
 `clikernel` sets quiet defaults for `IPYTHONDIR`, `MPLCONFIGDIR`, and `MPLBACKEND=Agg` before creating the shell. Existing `IPYTHONDIR` and `MPLCONFIGDIR` values are left alone. Loading messages and any startup warnings are printed before the first delimiter. Set `CLIKERNEL_STATE_DIR` to choose the default parent directory.
 
 ## Why The Protocol Is Odd

clikernel-0.1.3/clikernel/__init__.py

@@ -0,0 +1,4 @@
+__version__ = "0.1.3"
+
+
+

{clikernel-0.1.2 → clikernel-0.1.3}/clikernel/cli.py

@@ -1,5 +1,4 @@
-print("please wait, loading...", flush=True)
-import os,secrets,string,sys,tempfile,termios,traceback
+import inspect,os,secrets,shlex,string,sys,tempfile,termios,traceback
 from pathlib import Path
 
 def _state_root():
@@ -16,9 +15,6 @@ def _set_default_dirs():
     os.environ.setdefault("MPLBACKEND", "Agg")
 
 
-_set_default_dirs()
-
-
 _ALPHANUM = string.ascii_letters + string.digits
 _MULTILINE = "--"
 
@@ -51,11 +47,31 @@ def _execute(shell, code):
 def _request_exit(shell): shell._clikernel_exit = True
 
 
+def _magic_wrap(fn):
+    "Make a line magic from `fn`: `--name` flags for bool params, `--name value` otherwise, else positional"
+    params = inspect.signature(fn).parameters
+    def magic(line):
+        args,kw = [],{}
+        toks = iter(shlex.split(line))
+        for t in toks:
+            if t.startswith('--'):
+                k = t[2:]
+                kw[k] = True if params[k].annotation in (bool,'bool') else next(toks)
+            else: args.append(t)
+        return fn(*args, **kw)
+    return magic
+
+
 def _make_shell():
     from execnb.shell import CaptureShell
     shell = CaptureShell(mpl_format=None, history=False)
+    for name in ('nbopen','nbrun'): shell.register_magic_function(_magic_wrap(getattr(shell, name)), 'line', name)
     shell._clikernel_exit = False
     shell.ask_exit = lambda: _request_exit(shell)
+    # execnb already captures the exception as a structured error output; suppress
+    # IPython's own traceback print so it isn't duplicated (in colour) via stdout.
+    shell.showtraceback = lambda *a, **k: None
+    shell.showsyntaxerror = lambda *a, **k: None
     return shell
 
 
@@ -90,6 +106,8 @@ def _restore_termios(state):
 
 
 def main():
+    print("please wait, loading...", flush=True)
+    _set_default_dirs()
     shell = _make_shell()
     output_state = _disable_output_newline_translation()
     echo_state = _disable_echo()

clikernel-0.1.3/clikernel/mcp.py

@@ -0,0 +1,37 @@
+"MCP server exposing a persistent IPython `CaptureShell` as an `execute` tool."
+import asyncio
+
+from clikernel.cli import _set_default_dirs, _make_shell
+
+
+def main():
+    _set_default_dirs()
+    from mcp.server.fastmcp import FastMCP
+    from fastcore.nbio import render_text
+    mcp = FastMCP("clikernel")
+    state = {"shell": _make_shell(), "lock": asyncio.Lock()}
+
+    @mcp.tool(structured_output=False)
+    async def execute(code:str  # IPython-compatible code to run in the persistent session
+                     )->str:   # Rendered outputs (stdout, display data, last-expression result, errors)
+        "Run `code` in the persistent IPython session, keeping state across calls (imports, variables, monkeypatches, cached objects)."
+        async with state["lock"]:
+            outputs = await asyncio.to_thread(state["shell"].run, code)
+            return render_text(outputs)
+
+    @mcp.tool(structured_output=False)
+    async def restart()->str:
+        "Discard all session state (imports, variables, monkeypatches, cached objects) and start a fresh IPython shell inside the same server process. Use this for the common case: a bad variable, a half-finished experiment to abandon, or a user-requested clean slate. Note: this does NOT touch `sys.modules` or anything already monkeypatched (e.g. via fastcore's `@patch`) -- those live at the process level, not the shell level, and survive `restart` untouched. If you need a genuinely fresh interpreter (e.g. after reloading a module that other already-imported modules had patched -- symptoms: a stale-class bug where `isinstance`/`is` checks mysteriously fail, or a class is missing a method you know it has), use `exit` instead. After restarting, redo any imports/setup the task still needs."
+        async with state["lock"]: state["shell"] = _make_shell()
+        return "restarted"
+
+    @mcp.tool(structured_output=False)
+    async def exit()->str:
+        "Terminate this MCP server process immediately, for when `restart` isn't enough (see its docstring). This call itself will error (\"Connection closed\") since the process dies before it can respond -- that's expected, not a failure. The next `execute` call transparently reconnects to a freshly-spawned process with `sys.modules` genuinely reset (confirmed via a new pid), no manual reconnect needed. After reconnecting, redo any imports/setup the task still needs."
+        import os
+        os._exit(0)
+
+    mcp.run()
+
+
+if __name__ == "__main__": main()

clikernel-0.1.3/clikernel/skill.py

@@ -0,0 +1,101 @@
+"""Use the persistent `clikernel` MCP session as the default workspace for any task advanced through live Python execution -- stateful inspection, file-editing workflows, debugging, experiments, API probes, data transforms, or notebook-style work. Read this before writing, running, or debugging Python code in a session with `clikernel` connected.
+
+# Core idea
+
+`clikernel` exposes one long-lived IPython process (wrapping `execnb.shell.CaptureShell`) that runs Python/IPython code and keeps state across the whole conversation: imports, live objects, monkeypatches, cached results, API clients, small experiments. Treat it as a notebook-style workbench, not a one-shot script runner.
+
+Prefer it over one-off Python scripts (`python -c`, shell heredocs) whenever you need to inspect runtime behavior, test an idea, call a Python API, examine package state, run a live probe, or iterate on an implementation detail. Shell commands are still the right tool for file search, git, project test/build commands, and non-Python tools.
+
+There are two ways to drive it, depending on what the host supports:
+
+- **MCP server** (`clikernel-mcp`): no delimiter protocol, stdin plumbing, or readiness polling to manage -- call one tool, get back the rendered outputs.
+- **CLI** (`clikernel`): a plain stdin/stdout process using a delimiter protocol, for hosts that drive background terminal sessions instead of MCP tools.
+
+# MCP tools
+
+`execute`, `restart`, and `exit` are self-documenting -- read each tool's own MCP description rather than looking for docs elsewhere.
+
+# CLI protocol
+
+When driven as a plain process, `clikernel` prints loading status followed by a random session delimiter -- always `--` plus 5 alphanumeric characters:
+
+    please wait, loading...
+    loading complete. first delimiter:
+    --aB3x9
+
+Any startup warnings print before the first delimiter. Treat that delimiter as the readiness signal, completion signal, and multiline terminator; it stays the same until the process exits.
+
+Send a single line to execute a single-line request. `clikernel` first prints an acknowledgement line (`.`) -- that means request *accepted*, not execution complete -- then the response body, then the session delimiter:
+
+    1+1
+    .
+    2
+    --aB3x9
+
+Use a bare `--` line to start multiline input, ending the block with the session delimiter exactly:
+
+    --
+    def f(x):
+        return x + 1
+
+    f(2)
+    --aB3x9
+
+Do not look for an IPython prompt, do not use `%cpaste`, and do not invent your own terminator. A blank line is a real (empty) request, so it makes a good idle-poll: an idle kernel answers with `.` and the delimiter; if that doesn't come back quickly, the previous request is still running or the process is wedged.
+
+Python exceptions render as normal notebook error output. Protocol/worker failures render with readable XML-ish error tags, then the session delimiter.
+
+To end the session, send `exit`. In CLI mode there is no `restart` tool -- starting a fresh process *is* the restart, and gives a genuinely fresh interpreter (the equivalent of the MCP `exit` tool).
+
+# Notebook magics
+
+Two line magics run cells from a `.ipynb` file by cell id prefix:
+
+    %nbopen foo.ipynb
+    %nbrun ab12
+    %nbrun ab12 --above
+    %nbrun --all --exported
+    %nbrun ab12 --fname other.ipynb
+
+`%nbopen` sets the default notebook for later `%nbrun` calls (passing `--fname` does too). `%nbrun` runs the cell whose id starts with the given prefix; `--above`/`--below` also run the cells before/after it, `--all` runs every code cell, and `--exported` filters to cells carrying an nbdev `#| export`/`#| exports` directive. The notebook is re-read from disk on each call, so file edits are picked up; each executed cell's output is printed under a `--- {cell id} ---` header. Cell execution shares the persistent session state, and `restart` clears the `%nbopen` default.
+
+Prefer these magics over copying cell source into `execute` by hand when working through a notebook -- e.g. after editing a cell, `%nbrun <id>` re-runs it in place, and `%nbrun <id> --above` rebuilds the state it depends on.
+
+# Output shape
+
+Outputs are rendered with `fastcore.nbio.render_text`. A single non-empty stream/display/result/error comes back as just its preferred text form, e.g. `42`. Multiple non-empty outputs use readable XML-ish tags with raw, unescaped body text, e.g.:
+
+    <stdout>
+    hello
+    </stdout>
+    <execute_result>
+    42
+    </execute_result>
+
+`display_data`/`execute_result` prefer a non-image, markdown-over-HTML representation; images are ignored. Exceptions come back as a single clean `<error>` traceback -- no color codes, not duplicated.
+
+# Interaction rules
+
+- Try the simple import or API call first, before mutating environment, monkeypatching, or adding setup. Only change session state after the ordinary path fails and the reason is understood.
+- For file-editing workflows, view the target slice first and make the smallest verified edit -- avoid whole-file rewrites when a line/range/string operation is enough.
+- Default to raw triple-quoted strings (`r'''...'''`) for generated markdown, code, regexes, commands, or other source-like text, since backslashes usually need to survive intact. Use normal triple-quoted strings only when Python's own escape processing is what you want. For risky multiline content, verify with `repr(...)` or a focused readback before writing broadly.
+- Lean on reprs: many objects returned by libraries in this ecosystem (pyskills results especially) have reprs designed for direct reading. End a cell with the bare expression instead of writing a loop to reformat fields by hand -- only drop to attribute access when the repr genuinely omits what you need.
+
+# Critical issues
+
+- Like Jupyter, only the *last* expression in a cell is printed/returned. `print(...)` any earlier value you need to see.
+- Don't re-run an `import` you've already run this session -- it's persistent, so it's already done. Use `importlib.reload` if you've changed a module and need the change picked up. If a previously-imported name raises `NameError`, the session restarted -- redo whatever imports/setup the task needs.
+- `importlib.reload`ing a module is not always enough to pick up a change: other already-imported modules that did `from x import *`, or that monkeypatched one of its classes (e.g. via fastcore's `@patch`), hold stale references that a targeted reload won't fix. If you hit a stale-class symptom (a class missing a method you know it has, `isinstance` mysteriously failing), you need a fresh interpreter process: the MCP `exit` tool (see the `restart`/`exit` tool descriptions for which does what), or in CLI mode, exit and start a new process.
+- Everything a cell outputs lands in the conversation and stays there. Be surgical: inspect only what's needed, and don't dump large values -- `print(len(v))` first, then decide whether to print in full or filter down.
+- The kernel is scoped to one client session and shared by any subagents within it. If the server restarts or exits, in-memory state is gone -- redo imports and setup.
+
+# Pyskills
+
+This kernel environment commonly has `pyskills` installed -- a plugin system for discovering additional Python capabilities registered by installed packages. When present, checking it is the first thing to do at the start of a session, and using a relevant pyskill is strongly preferred over ad hoc code. See `pyskills.skill`'s own docs for the full discovery/usage workflow:
+
+    from pyskills import list_pyskills, doc
+    import pyskills.skill
+    print(doc(pyskills.skill))
+"""
+
+__all__ = []

{clikernel-0.1.2 → clikernel-0.1.3/clikernel.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clikernel
-Version: 0.1.2
+Version: 0.1.3
 Summary: A tiny stdin/stdout IPython worker
 Author: clikernel contributors
 License: Apache-2.0
@@ -10,7 +10,8 @@ Classifier: Programming Language :: Python :: 3 :: Only
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: execnb
+Requires-Dist: execnb>=0.2.3
+Requires-Dist: mcp
 Provides-Extra: dev
 Requires-Dist: fastship; extra == "dev"
 Requires-Dist: build; extra == "dev"
@@ -73,6 +74,20 @@ After execution, `clikernel` prints the acknowledgement, the rendered output, an
 
 Outputs are rendered with `fastcore.nbio.render_text`. A single non-empty output is printed directly. Multiple outputs use raw XML-ish tags, for example `<stdout>`, `<display_data mime="text/markdown">`, and `<execute_result>`.
 
+## Notebook magics
+
+`clikernel` registers two line magics wrapping `execnb`'s `nbopen`/`nbrun`, for running cells from a notebook by cell id prefix:
+
+```text
+%nbopen foo.ipynb
+%nbrun ab12
+%nbrun ab12 --above
+%nbrun --all --exported
+%nbrun ab12 --fname other.ipynb
+```
+
+`%nbopen` sets the default notebook for later `%nbrun` calls (as does passing `--fname`). `%nbrun` runs the cell whose id starts with the given prefix; `--above`/`--below` also run the cells before/after it, `--all` runs every code cell, and `--exported` filters to cells with an nbdev `#| export`/`#| exports` directive. The notebook is re-read from disk on each call, and each executed cell's rendered output is printed under a `--- {cell id} ---` header.
+
 `clikernel` sets quiet defaults for `IPYTHONDIR`, `MPLCONFIGDIR`, and `MPLBACKEND=Agg` before creating the shell. Existing `IPYTHONDIR` and `MPLCONFIGDIR` values are left alone. Loading messages and any startup warnings are printed before the first delimiter. Set `CLIKERNEL_STATE_DIR` to choose the default parent directory.
 
 ## Why The Protocol Is Odd

{clikernel-0.1.2 → clikernel-0.1.3}/clikernel.egg-info/SOURCES.txt

@@ -5,10 +5,13 @@ README.md
 pyproject.toml
 clikernel/__init__.py
 clikernel/cli.py
+clikernel/mcp.py
+clikernel/skill.py
 clikernel.egg-info/PKG-INFO
 clikernel.egg-info/SOURCES.txt
 clikernel.egg-info/dependency_links.txt
 clikernel.egg-info/entry_points.txt
 clikernel.egg-info/requires.txt
 clikernel.egg-info/top_level.txt
-tests/test_cli.py
+tests/test_cli.py
+tests/test_mcp.py

clikernel-0.1.3/clikernel.egg-info/entry_points.txt

@@ -0,0 +1,6 @@
+[console_scripts]
+clikernel = clikernel.cli:main
+clikernel-mcp = clikernel.mcp:main
+
+[pyskills]
+clikernel = clikernel.skill

{clikernel-0.1.2 → clikernel-0.1.3}/clikernel.egg-info/requires.txt

@@ -1,4 +1,5 @@
-execnb
+execnb>=0.2.3
+mcp
 
 [dev]
 fastship

{clikernel-0.1.2 → clikernel-0.1.3}/pyproject.toml

@@ -16,7 +16,8 @@ classifiers = [
 ]
 
 dependencies = [
-  "execnb",
+  "execnb>=0.2.3",
+  "mcp",
 ]
 
 [project.optional-dependencies]
@@ -27,11 +28,15 @@ dev = [
   "pytest",
 ]
 
+[project.entry-points.pyskills]
+clikernel = "clikernel.skill"
+
 [project.urls]
 Homepage = "https://github.com/AnswerDotAI/clikernel"
 
 [project.scripts]
 clikernel = "clikernel.cli:main"
+clikernel-mcp = "clikernel.mcp:main"
 
 [tool.setuptools.dynamic]
 version = { attr = "clikernel.__version__" }

{clikernel-0.1.2 → clikernel-0.1.3}/tests/test_cli.py

@@ -1,4 +1,4 @@
-import os,pty,re,select,shutil,subprocess,tempfile,time
+import json,os,pty,re,select,shutil,subprocess,tempfile,time
 
 import pytest
 
@@ -243,6 +243,21 @@ def test_runtime_errors_return_error_text_and_same_delimiter(kernel):
     assert next_delim == delim
 
 
+def test_error_has_no_ansi_and_no_duplicate_traceback(kernel):
+    proc, _, _ = kernel
+    body, _ = send(proc, "1/0\n")
+    assert "\x1b[" not in body                    # no ANSI colour codes
+    assert body.count("ZeroDivisionError") == 1   # single traceback, not duplicated
+    assert "<stdout>" not in body                 # no captured stdout traceback copy
+
+
+def test_error_preserves_real_stdout(kernel):
+    proc, _, delim = kernel
+    body, _ = send(proc, f"--\nprint('before')\n1/0\n{delim}\n")
+    assert "<stdout>\nbefore\n</stdout>" in body   # genuine prints kept
+    assert body.count("ZeroDivisionError") == 1
+
+
 @pytest.mark.parametrize("cmd", ["exit()", "quit()"])
 def test_exit_request_returns_final_delimiter_and_stops_process(kernel, cmd):
     proc, _, start_delim = kernel
@@ -258,3 +273,37 @@ def test_history_is_disabled(kernel):
     proc, _, _ = kernel
     body, _ = send(proc, "get_ipython().history_manager.enabled\n")
     assert body == "False\n"
+
+
+NB_CELLS = [("aaa111", "x = 41\nprint('one')"),
+            ("bbb222", "#| export\nprint('two', x + 1)"),
+            ("ccc333", "print('three')")]
+
+def make_nb(path):
+    cells = [dict(cell_type="code", id=i, metadata={}, outputs=[], execution_count=None, source=src)
+             for i,src in NB_CELLS]
+    path.write_text(json.dumps(dict(cells=cells, metadata={}, nbformat=4, nbformat_minor=5)))
+    return path
+
+
+def test_nbopen_nbrun_magics(kernel, tmp_path):
+    proc, _, _ = kernel
+    nb = make_nb(tmp_path/"t.ipynb")
+    body, _ = send(proc, f"%nbopen {nb}\n")
+    assert "error" not in body.lower()
+    body, _ = send(proc, "%nbrun aaa\n")
+    assert "--- aaa111 ---" in body
+    assert "one" in body
+    body, _ = send(proc, "%nbrun bbb222 --above\n")
+    assert "one" in body and "two 42" in body
+    body, _ = send(proc, "%nbrun --all --exported\n")
+    assert "two 42" in body and "one" not in body and "three" not in body
+
+
+def test_nbrun_fname_arg_sets_default(kernel, tmp_path):
+    proc, _, _ = kernel
+    nb = make_nb(tmp_path/"t.ipynb")
+    body, _ = send(proc, f"%nbrun aaa --fname {nb}\n")
+    assert "one" in body
+    body, _ = send(proc, "%nbrun ccc\n")
+    assert "three" in body

clikernel-0.1.3/tests/test_mcp.py

@@ -0,0 +1,91 @@
+import os,shutil,sys,tempfile
+
+import pytest
+from mcp import ClientSession, StdioServerParameters
+from mcp.client.stdio import stdio_client
+
+
+def _server_params():
+    cmd = shutil.which("clikernel-mcp")
+    args = [] if cmd else ["-m", "clikernel.mcp"]
+    cmd = cmd or sys.executable
+    env = dict(os.environ, CLIKERNEL_STATE_DIR=tempfile.mkdtemp(prefix="clikernel-mcp-test-"))
+    return StdioServerParameters(command=cmd, args=args, env=env)
+
+
+async def _drive(codes):
+    "Run each code string through the execute tool in one session; return result texts."
+    async with stdio_client(_server_params()) as (r,w), ClientSession(r,w) as s:
+        await s.initialize()
+        out = []
+        for c in codes:
+            res = await s.call_tool("execute", {"code": c})
+            out.append(res.content[0].text if res.content else "")
+        return out
+
+
+async def _drive_ops(ops):
+    "Run a mix of ('execute', code) / ('restart',) ops in one session; return result texts."
+    async with stdio_client(_server_params()) as (r,w), ClientSession(r,w) as s:
+        await s.initialize()
+        out = []
+        for op in ops:
+            name, args = (op[0], {"code": op[1]}) if op[0] == "execute" else (op[0], {})
+            res = await s.call_tool(name, args)
+            out.append(res.content[0].text if res.content else "")
+        return out
+
+
+@pytest.mark.anyio
+async def test_execute_returns_result(): assert await _drive(["40+2"]) == ["42"]
+
+
+@pytest.mark.anyio
+async def test_execute_supports_top_level_await():
+    r = await _drive(["import asyncio\nawait asyncio.sleep(0)\n42"])
+    assert r == ["42"]
+
+
+@pytest.mark.anyio
+async def test_state_persists_across_calls(): assert (await _drive(["x = 41", "x + 1"]))[1] == "42"
+
+
+@pytest.mark.anyio
+async def test_multiple_outputs_use_xmlish_blocks():
+    r = (await _drive(["print('hi'); 99"]))[0]
+    assert "<stdout>\nhi\n</stdout>" in r
+    assert "<execute_result>\n99\n</execute_result>" in r
+
+
+@pytest.mark.anyio
+async def test_error_is_clean():
+    r = (await _drive(["1/0"]))[0]
+    assert "ZeroDivisionError" in r
+    assert "\x1b[" not in r
+    assert r.count("ZeroDivisionError") == 1
+
+
+@pytest.mark.anyio
+async def test_restart_clears_state():
+    r = await _drive_ops([("execute","x = 1"), ("restart",), ("execute","x")])
+    assert "NameError" in r[2]
+
+
+@pytest.mark.anyio
+async def test_restart_leaves_kernel_usable():
+    r = await _drive_ops([("execute","x = 1"), ("restart",), ("execute","40+2")])
+    assert r[2] == "42"
+
+
+@pytest.mark.anyio
+async def test_nb_magics(tmp_path):
+    import json
+    cells = [dict(cell_type="code", id="aaa111", metadata={}, outputs=[], execution_count=None, source="print('one')")]
+    nb = tmp_path/"t.ipynb"
+    nb.write_text(json.dumps(dict(cells=cells, metadata={}, nbformat=4, nbformat_minor=5)))
+    r = await _drive([f"%nbopen {nb}", "%nbrun aaa"])
+    assert "--- aaa111 ---" in r[1] and "one" in r[1]
+
+
+@pytest.fixture
+def anyio_backend(): return "asyncio"

clikernel-0.1.2/CHANGELOG.md

@@ -1,20 +0,0 @@
-<!-- do not remove -->
-
-## 0.1.2
-
-### New Features
-
-- Add ONLCR terminal flag control ([#2](https://github.com/AnswerDotAI/clikernel/issues/2))
-
-
-## 0.1.1
-
-### New Features
-
-- Use a fixed per-session delimiter and emit `.` ack before each response ([#1](https://github.com/AnswerDotAI/clikernel/issues/1))
-
-
-## 0.1.0
-
-- Initial release
-

clikernel-0.1.2/clikernel/__init__.py

@@ -1,3 +0,0 @@
-__version__ = "0.1.2"
-
-

clikernel-0.1.2/clikernel.egg-info/entry_points.txt

@@ -1,2 +0,0 @@
-[console_scripts]
-clikernel = clikernel.cli:main