clikernel 0.2.9__tar.gz → 0.2.10__tar.gz

{clikernel-0.2.9 → clikernel-0.2.10}/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 <!-- do not remove -->
 
+## 0.2.10
+
+### New Features
+
+- Add Luau kernel support: lua tool and create(language=...), Python-only startup/inspectors ([#48](https://github.com/AnswerDotAI/clikernel/issues/48))
+
+
 ## 0.2.9
 
 ### Breaking Changes

clikernel-0.2.10/PKG-INFO

@@ -0,0 +1,94 @@
+Metadata-Version: 2.4
+Name: clikernel
+Version: 0.2.10
+Summary: Serve persistent Jupyter kernels to LLMs as concise text, over MCP or a plain stream protocol
+Author: clikernel contributors
+License: Apache-2.0
+Project-URL: Repository, https://github.com/AnswerDotAI/clikernel
+Project-URL: Documentation, https://AnswerDotAI.github.io/clikernel/
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: fastcore>=2.2.2
+Requires-Dist: jupyasyncclient>=0.2.10
+Requires-Dist: jupywire>=0.1.9
+Requires-Dist: mcpmini>=0.0.4
+Requires-Dist: rustygate>=0.1.11
+Requires-Dist: httpx
+Provides-Extra: dev
+Requires-Dist: fastship; extra == "dev"
+Dynamic: license-file
+
+# clikernel
+
+
+<!-- WARNING: THIS FILE WAS AUTOGENERATED! DO NOT EDIT! -->
+
+`clikernel` gives an LLM agent a persistent Python or Luau session. Imports, variables, and results remain available between tool calls. An agent can create a kernel or attach to an existing one, including a user’s live solveit kernel, on a local or named remote gateway.
+
+[rustygate](https://github.com/AnswerDotAI/rustygate) hosts the Jupyter kernels and provides their MCP tools. `clikernel` is the conversation-side router: the MCP host launches it over stdio, and it forwards requests to gateways over HTTP. It selects gateways from `gateways.toml`, supplies `startup.py` and `inspectors.py` to Python kernels it creates, and starts a private local gateway when needed. The default kernel is [ipymini](https://github.com/AnswerDotAI/ipymini).
+
+Kernel ownership determines what happens when the conversation ends:
+
+- A session closes kernels it created with `autoclose`, including the automatic kernel used by bare `py` or `lua` and kernels created with `create`’s default settings.
+- Attaching with `use_kernel` does not make that session responsible for closing the kernel.
+- A kernel created with `autoclose=false` on a resident gateway can outlive the conversation. A later conversation can attach and continue using its state.
+- A private child gateway ends with its conversation. Use a resident gateway for kernels that need to survive across conversations.
+
+## Install
+
+``` sh
+pip install clikernel
+```
+
+This installs rustygate and ipymini. No service setup is required for a conversation-local kernel: clikernel starts a private gateway if it cannot find one. To retain kernels across conversations, run a resident gateway, for example through launchd or systemd:
+
+``` sh
+rustygate --port 8787
+```
+
+## Use with an MCP host
+
+Register the stdio server with your MCP host. For Claude Code:
+
+``` sh
+claude mcp add clikernel -- clikernel-mcp
+```
+
+Use `py(code=...)` for Python/IPython or `lua(code=...)` for bundled Luau. Either starts its language’s kernel when none is current. There is one current kernel: a language mismatch errors without switching or running the code. IPython magics, including `%%bash`, are Python-only.
+
+For a named kernel, use `create(dlgname="work", language="luau")`. Omit `language` to reuse an existing binding unchanged, or default a new kernel to Python. An explicit language must match an existing binding. The other tools are `list_kernels`, `use_kernel`, `delete_kernel`, `restart`, and `interrupt`; creation, selection, and listing report the language.
+
+These tools forward to rustygate. `list_kernels`, `use_kernel`, and `create` also accept a `host` naming a gateway from `gateways.toml`. One MCP registration can therefore reach multiple machines. Replies retain the gateway’s text and image blocks. Python startup and inspectors run only in Python, never Luau, including after restart.
+
+`$CLIKERNEL_HOST` overrides the default gateway URL, `http://127.0.0.1:8787`. If no gateway answers, clikernel uses a private child gateway for the conversation. The ownership rules above determine which kernels close at session end.
+
+Pass `--quiet`, as in `clikernel-mcp --quiet`, to omit startup output from replies. Python startup code still runs.
+
+## Configuration
+
+Three optional files in `$XDG_CONFIG_HOME/clikernel/` configure the router, usually under `~/.config/clikernel/`:
+
+- `startup.py` runs in each Python kernel clikernel creates, with `__file__` set to its path. Its output appears in the reply announcing the kernel unless `--quiet` is set.
+- `inspectors.py` installs Python cell inspectors after startup. Define `inspect`, a list named `inspectors`, or both. Each inspector runs once before a cell: a one-argument inspector takes the cell’s AST, and a two-argument inspector takes the AST and raw source. Return a string to print a note before the output. Raise the provided `RuleBlock` to block execution. Other exceptions produce a warning and allow the cell to run. See [examples/inspectors.py](examples/inspectors.py).
+- `gateways.toml` names remote gateways and configures authentication without putting tokens in tool arguments:
+
+``` toml
+[gateways.solveit]
+url = "https://solveit.example.com/gate"
+token_env = "SOLVEIT_TOKEN"
+verify = false   # optional: accept a self-signed certificate
+```
+
+## The stream protocol
+
+Run `clikernel` as a plain CLI process for clients that read a text stream rather than MCP messages. It uses a delimiter-framed stdin/stdout protocol:
+
+- Input is not echoed.
+- Each request gets a `.` acknowledgement.
+- A per-process random delimiter marks the end of each response.
+- Multiline cells are framed by `--` and the delimiter.
+
+The startup banner supplies the protocol instructions and delimiter. Running `clikernel` without arguments creates a kernel and stops it on exit. `--kernel <id>` attaches to an existing kernel and leaves it running on exit.

clikernel-0.2.10/README.md

@@ -0,0 +1,71 @@
+# clikernel
+
+
+<!-- WARNING: THIS FILE WAS AUTOGENERATED! DO NOT EDIT! -->
+
+`clikernel` gives an LLM agent a persistent Python or Luau session. Imports, variables, and results remain available between tool calls. An agent can create a kernel or attach to an existing one, including a user’s live solveit kernel, on a local or named remote gateway.
+
+[rustygate](https://github.com/AnswerDotAI/rustygate) hosts the Jupyter kernels and provides their MCP tools. `clikernel` is the conversation-side router: the MCP host launches it over stdio, and it forwards requests to gateways over HTTP. It selects gateways from `gateways.toml`, supplies `startup.py` and `inspectors.py` to Python kernels it creates, and starts a private local gateway when needed. The default kernel is [ipymini](https://github.com/AnswerDotAI/ipymini).
+
+Kernel ownership determines what happens when the conversation ends:
+
+- A session closes kernels it created with `autoclose`, including the automatic kernel used by bare `py` or `lua` and kernels created with `create`’s default settings.
+- Attaching with `use_kernel` does not make that session responsible for closing the kernel.
+- A kernel created with `autoclose=false` on a resident gateway can outlive the conversation. A later conversation can attach and continue using its state.
+- A private child gateway ends with its conversation. Use a resident gateway for kernels that need to survive across conversations.
+
+## Install
+
+``` sh
+pip install clikernel
+```
+
+This installs rustygate and ipymini. No service setup is required for a conversation-local kernel: clikernel starts a private gateway if it cannot find one. To retain kernels across conversations, run a resident gateway, for example through launchd or systemd:
+
+``` sh
+rustygate --port 8787
+```
+
+## Use with an MCP host
+
+Register the stdio server with your MCP host. For Claude Code:
+
+``` sh
+claude mcp add clikernel -- clikernel-mcp
+```
+
+Use `py(code=...)` for Python/IPython or `lua(code=...)` for bundled Luau. Either starts its language’s kernel when none is current. There is one current kernel: a language mismatch errors without switching or running the code. IPython magics, including `%%bash`, are Python-only.
+
+For a named kernel, use `create(dlgname="work", language="luau")`. Omit `language` to reuse an existing binding unchanged, or default a new kernel to Python. An explicit language must match an existing binding. The other tools are `list_kernels`, `use_kernel`, `delete_kernel`, `restart`, and `interrupt`; creation, selection, and listing report the language.
+
+These tools forward to rustygate. `list_kernels`, `use_kernel`, and `create` also accept a `host` naming a gateway from `gateways.toml`. One MCP registration can therefore reach multiple machines. Replies retain the gateway’s text and image blocks. Python startup and inspectors run only in Python, never Luau, including after restart.
+
+`$CLIKERNEL_HOST` overrides the default gateway URL, `http://127.0.0.1:8787`. If no gateway answers, clikernel uses a private child gateway for the conversation. The ownership rules above determine which kernels close at session end.
+
+Pass `--quiet`, as in `clikernel-mcp --quiet`, to omit startup output from replies. Python startup code still runs.
+
+## Configuration
+
+Three optional files in `$XDG_CONFIG_HOME/clikernel/` configure the router, usually under `~/.config/clikernel/`:
+
+- `startup.py` runs in each Python kernel clikernel creates, with `__file__` set to its path. Its output appears in the reply announcing the kernel unless `--quiet` is set.
+- `inspectors.py` installs Python cell inspectors after startup. Define `inspect`, a list named `inspectors`, or both. Each inspector runs once before a cell: a one-argument inspector takes the cell’s AST, and a two-argument inspector takes the AST and raw source. Return a string to print a note before the output. Raise the provided `RuleBlock` to block execution. Other exceptions produce a warning and allow the cell to run. See [examples/inspectors.py](examples/inspectors.py).
+- `gateways.toml` names remote gateways and configures authentication without putting tokens in tool arguments:
+
+``` toml
+[gateways.solveit]
+url = "https://solveit.example.com/gate"
+token_env = "SOLVEIT_TOKEN"
+verify = false   # optional: accept a self-signed certificate
+```
+
+## The stream protocol
+
+Run `clikernel` as a plain CLI process for clients that read a text stream rather than MCP messages. It uses a delimiter-framed stdin/stdout protocol:
+
+- Input is not echoed.
+- Each request gets a `.` acknowledgement.
+- A per-process random delimiter marks the end of each response.
+- Multiline cells are framed by `--` and the delimiter.
+
+The startup banner supplies the protocol instructions and delimiter. Running `clikernel` without arguments creates a kernel and stops it on exit. `--kernel <id>` attaches to an existing kernel and leaves it running on exit.

{clikernel-0.2.9 → clikernel-0.2.10}/clikernel/__init__.py

@@ -8,4 +8,4 @@ Modules:
 - `clikernel.skill`: Use the `clikernel` MCP session as the default workspace for Python work: reading and changing files, notebook work, trying things out, checking how a library behaves, and reshaping data. One session stays open, so imports and variables carry between calls. Read this before writing, running, or debugging Python code in a session with `clikernel` connected.
 - `clikernel.stream`: Streaming JSON-lines worker protocol: nbformat-shaped output events, and a supervisor for select-based UIs."""
 
-__version__ = "0.2.9"
+__version__ = "0.2.10"

{clikernel-0.2.9 → clikernel-0.2.10}/clikernel/core.py

@@ -33,8 +33,9 @@ def resolve(host='', cfgdir=None):
     "`(url, token, verify)` for `host`: empty = the default local gateway, a URL = itself, else a `gateways.toml` name"
     if not host: return os.environ.get('CLIKERNEL_HOST', DEFAULT_URL), os.environ.get('CLIKERNEL_TOKEN'), True
     if '://' in host: return host, os.environ.get('CLIKERNEL_TOKEN'), True
+    cfgdir = Path(cfgdir) if cfgdir else cfg_dir()
     g = gateways(cfgdir).get(host)
-    if g is None: raise ValueError(f"unknown gateway {host!r}: not a URL, and not in {cfg_dir()/'gateways.toml'}")
+    if g is None: raise ValueError(f"unknown gateway {host!r}: not a URL, and not in {cfgdir/'gateways.toml'}")
     return g['url'], g.get('token') or os.environ.get(g.get('token_env','')) or None, g.get('verify', True)
 
 

{clikernel-0.2.9 → clikernel-0.2.10}/clikernel/skill.py

@@ -14,6 +14,12 @@ Remote gateways are the same tools with a `host` argument on `list_kernels`, `us
 
 # Working in it
 
+For native Luau work use `lua(code=...)`, or `create(dlgname, language="luau")` for a named kernel. The first `lua` auto-starts Luau when no kernel is selected, with the same autoclose rules as Python. There is one current kernel: `py` requires Python and `lua` requires Luau, so a mismatch errors rather than switching. Use `use_kernel` or `create` to select deliberately. Omit `language` to reuse an existing binding unchanged or default a new one to Python; an explicit language must match an existing binding. A `dlgname` execution override changes only that call. These rules also apply on named remote gateways.
+
+Start native work with `lua(code="help()")` for the bundled guide and examples, or `lua(code='help("ex.edit_file")')` for function details.
+
+Luau has persistent globals, cell-local `local` variables, and native `rg.search`, `rg.find`, `fs.read_text`, `ex.edit_text`, `ex.view_file`/`ex.edit_file`, `ex.view_cell`/`ex.edit_cell`, `os.execute`, and `io.popen` APIs. File edits use arrays of command fields (like Python exhash tuples); `{inplace=false}` previews. Shell commands use `/bin/sh -c`; pipes support read/lines/write/flush/close and persist until closed. Interrupts terminate subprocess groups and close outstanding pipes. Python startup/inspectors and IPython magics do not apply to Luau. The following guidance is for Python:
+
 - Magics work as written, including `%%bash` for shell work. `%cd` expands `~` and is the way to change directory: prefer it over `os.chdir`.
 - Only the last expression in a cell displays. `print(...)` any earlier value you need to see.
 - Everything a cell outputs lands in the conversation. Be selective: `len(v)` first, then decide what to show.

clikernel-0.2.10/clikernel.egg-info/PKG-INFO

@@ -0,0 +1,94 @@
+Metadata-Version: 2.4
+Name: clikernel
+Version: 0.2.10
+Summary: Serve persistent Jupyter kernels to LLMs as concise text, over MCP or a plain stream protocol
+Author: clikernel contributors
+License: Apache-2.0
+Project-URL: Repository, https://github.com/AnswerDotAI/clikernel
+Project-URL: Documentation, https://AnswerDotAI.github.io/clikernel/
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: fastcore>=2.2.2
+Requires-Dist: jupyasyncclient>=0.2.10
+Requires-Dist: jupywire>=0.1.9
+Requires-Dist: mcpmini>=0.0.4
+Requires-Dist: rustygate>=0.1.11
+Requires-Dist: httpx
+Provides-Extra: dev
+Requires-Dist: fastship; extra == "dev"
+Dynamic: license-file
+
+# clikernel
+
+
+<!-- WARNING: THIS FILE WAS AUTOGENERATED! DO NOT EDIT! -->
+
+`clikernel` gives an LLM agent a persistent Python or Luau session. Imports, variables, and results remain available between tool calls. An agent can create a kernel or attach to an existing one, including a user’s live solveit kernel, on a local or named remote gateway.
+
+[rustygate](https://github.com/AnswerDotAI/rustygate) hosts the Jupyter kernels and provides their MCP tools. `clikernel` is the conversation-side router: the MCP host launches it over stdio, and it forwards requests to gateways over HTTP. It selects gateways from `gateways.toml`, supplies `startup.py` and `inspectors.py` to Python kernels it creates, and starts a private local gateway when needed. The default kernel is [ipymini](https://github.com/AnswerDotAI/ipymini).
+
+Kernel ownership determines what happens when the conversation ends:
+
+- A session closes kernels it created with `autoclose`, including the automatic kernel used by bare `py` or `lua` and kernels created with `create`’s default settings.
+- Attaching with `use_kernel` does not make that session responsible for closing the kernel.
+- A kernel created with `autoclose=false` on a resident gateway can outlive the conversation. A later conversation can attach and continue using its state.
+- A private child gateway ends with its conversation. Use a resident gateway for kernels that need to survive across conversations.
+
+## Install
+
+``` sh
+pip install clikernel
+```
+
+This installs rustygate and ipymini. No service setup is required for a conversation-local kernel: clikernel starts a private gateway if it cannot find one. To retain kernels across conversations, run a resident gateway, for example through launchd or systemd:
+
+``` sh
+rustygate --port 8787
+```
+
+## Use with an MCP host
+
+Register the stdio server with your MCP host. For Claude Code:
+
+``` sh
+claude mcp add clikernel -- clikernel-mcp
+```
+
+Use `py(code=...)` for Python/IPython or `lua(code=...)` for bundled Luau. Either starts its language’s kernel when none is current. There is one current kernel: a language mismatch errors without switching or running the code. IPython magics, including `%%bash`, are Python-only.
+
+For a named kernel, use `create(dlgname="work", language="luau")`. Omit `language` to reuse an existing binding unchanged, or default a new kernel to Python. An explicit language must match an existing binding. The other tools are `list_kernels`, `use_kernel`, `delete_kernel`, `restart`, and `interrupt`; creation, selection, and listing report the language.
+
+These tools forward to rustygate. `list_kernels`, `use_kernel`, and `create` also accept a `host` naming a gateway from `gateways.toml`. One MCP registration can therefore reach multiple machines. Replies retain the gateway’s text and image blocks. Python startup and inspectors run only in Python, never Luau, including after restart.
+
+`$CLIKERNEL_HOST` overrides the default gateway URL, `http://127.0.0.1:8787`. If no gateway answers, clikernel uses a private child gateway for the conversation. The ownership rules above determine which kernels close at session end.
+
+Pass `--quiet`, as in `clikernel-mcp --quiet`, to omit startup output from replies. Python startup code still runs.
+
+## Configuration
+
+Three optional files in `$XDG_CONFIG_HOME/clikernel/` configure the router, usually under `~/.config/clikernel/`:
+
+- `startup.py` runs in each Python kernel clikernel creates, with `__file__` set to its path. Its output appears in the reply announcing the kernel unless `--quiet` is set.
+- `inspectors.py` installs Python cell inspectors after startup. Define `inspect`, a list named `inspectors`, or both. Each inspector runs once before a cell: a one-argument inspector takes the cell’s AST, and a two-argument inspector takes the AST and raw source. Return a string to print a note before the output. Raise the provided `RuleBlock` to block execution. Other exceptions produce a warning and allow the cell to run. See [examples/inspectors.py](examples/inspectors.py).
+- `gateways.toml` names remote gateways and configures authentication without putting tokens in tool arguments:
+
+``` toml
+[gateways.solveit]
+url = "https://solveit.example.com/gate"
+token_env = "SOLVEIT_TOKEN"
+verify = false   # optional: accept a self-signed certificate
+```
+
+## The stream protocol
+
+Run `clikernel` as a plain CLI process for clients that read a text stream rather than MCP messages. It uses a delimiter-framed stdin/stdout protocol:
+
+- Input is not echoed.
+- Each request gets a `.` acknowledgement.
+- A per-process random delimiter marks the end of each response.
+- Multiline cells are framed by `--` and the delimiter.
+
+The startup banner supplies the protocol instructions and delimiter. Running `clikernel` without arguments creates a kernel and stops it on exit. `--kernel <id>` attaches to an existing kernel and leaves it running on exit.

{clikernel-0.2.9 → clikernel-0.2.10}/clikernel.egg-info/requires.txt

@@ -2,7 +2,7 @@ fastcore>=2.2.2
 jupyasyncclient>=0.2.10
 jupywire>=0.1.9
 mcpmini>=0.0.4
-rustygate>=0.1.7
+rustygate>=0.1.11
 httpx
 
 [dev]

{clikernel-0.2.9 → clikernel-0.2.10}/pyproject.toml

@@ -20,7 +20,7 @@ dependencies = [
   "jupyasyncclient>=0.2.10",
   "jupywire>=0.1.9",
   "mcpmini>=0.0.4",
-  "rustygate>=0.1.7",
+  "rustygate>=0.1.11",
   "httpx",
 ]
 

clikernel-0.2.9/PKG-INFO

@@ -1,76 +0,0 @@
-Metadata-Version: 2.4
-Name: clikernel
-Version: 0.2.9
-Summary: Serve persistent Jupyter kernels to LLMs as concise text, over MCP or a plain stream protocol
-Author: clikernel contributors
-License: Apache-2.0
-Project-URL: Repository, https://github.com/AnswerDotAI/clikernel
-Project-URL: Documentation, https://AnswerDotAI.github.io/clikernel/
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3 :: Only
-Requires-Python: >=3.11
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: fastcore>=2.2.2
-Requires-Dist: jupyasyncclient>=0.2.10
-Requires-Dist: jupywire>=0.1.9
-Requires-Dist: mcpmini>=0.0.4
-Requires-Dist: rustygate>=0.1.7
-Requires-Dist: httpx
-Provides-Extra: dev
-Requires-Dist: fastship; extra == "dev"
-Dynamic: license-file
-
-# clikernel
-
-
-<!-- WARNING: THIS FILE WAS AUTOGENERATED! DO NOT EDIT! -->
-
-`clikernel` gives an LLM agent a persistent Python workbench built from two processes. A gateway ([rustygate](https://github.com/AnswerDotAI/rustygate)) hosts real Jupyter kernels ([ipymini](https://github.com/AnswerDotAI/ipymini) by default) and serves the MCP tool surface itself; kernels live there and persist until explicitly stopped. `clikernel` starts and stops with each conversation: a router the MCP host launches, speaking stdio MCP to the model and forwarding to gateways over HTTP. It adds what a single fixed endpoint cannot: gateway naming from `gateways.toml` (a `host` argument on the kernel-selection tools reaches any machine you’ve named), delivery of your `startup.py` and `inspectors.py` into every kernel a conversation creates, and a local gateway that always exists — found running, or started as a child that lives exactly as long as the conversation.
-
-Kernel scope is the gateway’s rule, one rule everywhere: a session’s end stops the kernels it created with autoclose (the bare-`py` auto kernel, and `create`’s default) and nothing else. A kernel created with `autoclose=false` on a persistent gateway outlives the conversation, and a later conversation reattaches with `use_kernel` and finds its state intact — including the user’s live solveit kernel.
-
-## Install
-
-``` sh
-pip install clikernel
-```
-
-This brings [rustygate](https://github.com/AnswerDotAI/rustygate) and a kernel ([ipymini](https://github.com/AnswerDotAI/ipymini)) with it, and no service setup is needed: a conversation that finds no gateway starts its own. Run a resident gateway when kernels should outlive conversations (e.g. via launchd/systemd):
-
-``` sh
-rustygate --port 8787
-```
-
-## Use with an MCP host
-
-Register the stdio server with your MCP host, e.g. for Claude Code:
-
-``` sh
-claude mcp add clikernel -- clikernel-mcp
-```
-
-The tools are rustygate’s, forwarded: `py` (the normal tool — it auto-starts a kernel when none is current, and magics like a `%%bash` first line run as written), `list_kernels`, `create`, `use_kernel`, `delete_kernel`, `restart`, and `interrupt`. The router adds one thing to them: `list_kernels`, `use_kernel`, and `create` take a `host` naming a gateway from `gateways.toml`, so one MCP entry reaches every machine you’ve named. Replies carry text and image blocks exactly as the gateway rendered them.
-
-A conversation cleans up after itself: its end stops the auto kernel and every `create` it made, unless `autoclose=false` asked for a keeper. Kernels reached with `use_kernel` are never touched. `$CLIKERNEL_HOST` overrides the default gateway (`http://127.0.0.1:8787`), and when nothing answers there, the conversation runs on a private child gateway that ends with it.
-
-Pass `--quiet` (`clikernel-mcp --quiet`) for a host whose sessions should not see banner noise: startup still runs, but its output stays out of every reply.
-
-## Configuration
-
-Three optional files in `$XDG_CONFIG_HOME/clikernel/` (usually `~/.config/clikernel/`):
-
-- `startup.py` — run in every kernel clikernel creates, with `__file__` bound to its path; its output returns in the reply that announces the kernel.
-- `inspectors.py` — cell inspectors installed after startup. The file may define `inspect` and/or a list `inspectors`; each is called once per cell before it runs (1-arg: the cell’s AST; 2-arg: AST and raw source). Return a string to print a note before the cell’s output, raise `RuleBlock` (provided in the namespace) to block the cell; any other exception warns and the cell runs. See `examples/inspectors.py`.
-- `gateways.toml` — named remote gateways, so tokens never appear in tool arguments:
-
-``` toml
-[gateways.solveit]
-url = "https://solveit.example.com/gate"
-token_env = "SOLVEIT_TOKEN"
-verify = false   # optional: accept a self-signed certificate
-```
-
-## The stream protocol
-
-Run `clikernel` as a plain CLI process and the same client speaks a delimiter-framed stdin/stdout protocol for token-reading clients: no echo, a cheap `.` acknowledgement per request, responses ended by a per-process random delimiter, multiline cells framed by `--` and the delimiter. The full recipe is announced in the process’s own startup banner. Run bare it creates a kernel and stops it on exit; `--kernel <id>` attaches to an existing kernel and leaves it as found.

clikernel-0.2.9/README.md

@@ -1,53 +0,0 @@
-# clikernel
-
-
-<!-- WARNING: THIS FILE WAS AUTOGENERATED! DO NOT EDIT! -->
-
-`clikernel` gives an LLM agent a persistent Python workbench built from two processes. A gateway ([rustygate](https://github.com/AnswerDotAI/rustygate)) hosts real Jupyter kernels ([ipymini](https://github.com/AnswerDotAI/ipymini) by default) and serves the MCP tool surface itself; kernels live there and persist until explicitly stopped. `clikernel` starts and stops with each conversation: a router the MCP host launches, speaking stdio MCP to the model and forwarding to gateways over HTTP. It adds what a single fixed endpoint cannot: gateway naming from `gateways.toml` (a `host` argument on the kernel-selection tools reaches any machine you’ve named), delivery of your `startup.py` and `inspectors.py` into every kernel a conversation creates, and a local gateway that always exists — found running, or started as a child that lives exactly as long as the conversation.
-
-Kernel scope is the gateway’s rule, one rule everywhere: a session’s end stops the kernels it created with autoclose (the bare-`py` auto kernel, and `create`’s default) and nothing else. A kernel created with `autoclose=false` on a persistent gateway outlives the conversation, and a later conversation reattaches with `use_kernel` and finds its state intact — including the user’s live solveit kernel.
-
-## Install
-
-``` sh
-pip install clikernel
-```
-
-This brings [rustygate](https://github.com/AnswerDotAI/rustygate) and a kernel ([ipymini](https://github.com/AnswerDotAI/ipymini)) with it, and no service setup is needed: a conversation that finds no gateway starts its own. Run a resident gateway when kernels should outlive conversations (e.g. via launchd/systemd):
-
-``` sh
-rustygate --port 8787
-```
-
-## Use with an MCP host
-
-Register the stdio server with your MCP host, e.g. for Claude Code:
-
-``` sh
-claude mcp add clikernel -- clikernel-mcp
-```
-
-The tools are rustygate’s, forwarded: `py` (the normal tool — it auto-starts a kernel when none is current, and magics like a `%%bash` first line run as written), `list_kernels`, `create`, `use_kernel`, `delete_kernel`, `restart`, and `interrupt`. The router adds one thing to them: `list_kernels`, `use_kernel`, and `create` take a `host` naming a gateway from `gateways.toml`, so one MCP entry reaches every machine you’ve named. Replies carry text and image blocks exactly as the gateway rendered them.
-
-A conversation cleans up after itself: its end stops the auto kernel and every `create` it made, unless `autoclose=false` asked for a keeper. Kernels reached with `use_kernel` are never touched. `$CLIKERNEL_HOST` overrides the default gateway (`http://127.0.0.1:8787`), and when nothing answers there, the conversation runs on a private child gateway that ends with it.
-
-Pass `--quiet` (`clikernel-mcp --quiet`) for a host whose sessions should not see banner noise: startup still runs, but its output stays out of every reply.
-
-## Configuration
-
-Three optional files in `$XDG_CONFIG_HOME/clikernel/` (usually `~/.config/clikernel/`):
-
-- `startup.py` — run in every kernel clikernel creates, with `__file__` bound to its path; its output returns in the reply that announces the kernel.
-- `inspectors.py` — cell inspectors installed after startup. The file may define `inspect` and/or a list `inspectors`; each is called once per cell before it runs (1-arg: the cell’s AST; 2-arg: AST and raw source). Return a string to print a note before the cell’s output, raise `RuleBlock` (provided in the namespace) to block the cell; any other exception warns and the cell runs. See `examples/inspectors.py`.
-- `gateways.toml` — named remote gateways, so tokens never appear in tool arguments:
-
-``` toml
-[gateways.solveit]
-url = "https://solveit.example.com/gate"
-token_env = "SOLVEIT_TOKEN"
-verify = false   # optional: accept a self-signed certificate
-```
-
-## The stream protocol
-
-Run `clikernel` as a plain CLI process and the same client speaks a delimiter-framed stdin/stdout protocol for token-reading clients: no echo, a cheap `.` acknowledgement per request, responses ended by a per-process random delimiter, multiline cells framed by `--` and the delimiter. The full recipe is announced in the process’s own startup banner. Run bare it creates a kernel and stops it on exit; `--kernel <id>` attaches to an existing kernel and leaves it as found.

clikernel-0.2.9/clikernel.egg-info/PKG-INFO

@@ -1,76 +0,0 @@
-Metadata-Version: 2.4
-Name: clikernel
-Version: 0.2.9
-Summary: Serve persistent Jupyter kernels to LLMs as concise text, over MCP or a plain stream protocol
-Author: clikernel contributors
-License: Apache-2.0
-Project-URL: Repository, https://github.com/AnswerDotAI/clikernel
-Project-URL: Documentation, https://AnswerDotAI.github.io/clikernel/
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3 :: Only
-Requires-Python: >=3.11
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: fastcore>=2.2.2
-Requires-Dist: jupyasyncclient>=0.2.10
-Requires-Dist: jupywire>=0.1.9
-Requires-Dist: mcpmini>=0.0.4
-Requires-Dist: rustygate>=0.1.7
-Requires-Dist: httpx
-Provides-Extra: dev
-Requires-Dist: fastship; extra == "dev"
-Dynamic: license-file
-
-# clikernel
-
-
-<!-- WARNING: THIS FILE WAS AUTOGENERATED! DO NOT EDIT! -->
-
-`clikernel` gives an LLM agent a persistent Python workbench built from two processes. A gateway ([rustygate](https://github.com/AnswerDotAI/rustygate)) hosts real Jupyter kernels ([ipymini](https://github.com/AnswerDotAI/ipymini) by default) and serves the MCP tool surface itself; kernels live there and persist until explicitly stopped. `clikernel` starts and stops with each conversation: a router the MCP host launches, speaking stdio MCP to the model and forwarding to gateways over HTTP. It adds what a single fixed endpoint cannot: gateway naming from `gateways.toml` (a `host` argument on the kernel-selection tools reaches any machine you’ve named), delivery of your `startup.py` and `inspectors.py` into every kernel a conversation creates, and a local gateway that always exists — found running, or started as a child that lives exactly as long as the conversation.
-
-Kernel scope is the gateway’s rule, one rule everywhere: a session’s end stops the kernels it created with autoclose (the bare-`py` auto kernel, and `create`’s default) and nothing else. A kernel created with `autoclose=false` on a persistent gateway outlives the conversation, and a later conversation reattaches with `use_kernel` and finds its state intact — including the user’s live solveit kernel.
-
-## Install
-
-``` sh
-pip install clikernel
-```
-
-This brings [rustygate](https://github.com/AnswerDotAI/rustygate) and a kernel ([ipymini](https://github.com/AnswerDotAI/ipymini)) with it, and no service setup is needed: a conversation that finds no gateway starts its own. Run a resident gateway when kernels should outlive conversations (e.g. via launchd/systemd):
-
-``` sh
-rustygate --port 8787
-```
-
-## Use with an MCP host
-
-Register the stdio server with your MCP host, e.g. for Claude Code:
-
-``` sh
-claude mcp add clikernel -- clikernel-mcp
-```
-
-The tools are rustygate’s, forwarded: `py` (the normal tool — it auto-starts a kernel when none is current, and magics like a `%%bash` first line run as written), `list_kernels`, `create`, `use_kernel`, `delete_kernel`, `restart`, and `interrupt`. The router adds one thing to them: `list_kernels`, `use_kernel`, and `create` take a `host` naming a gateway from `gateways.toml`, so one MCP entry reaches every machine you’ve named. Replies carry text and image blocks exactly as the gateway rendered them.
-
-A conversation cleans up after itself: its end stops the auto kernel and every `create` it made, unless `autoclose=false` asked for a keeper. Kernels reached with `use_kernel` are never touched. `$CLIKERNEL_HOST` overrides the default gateway (`http://127.0.0.1:8787`), and when nothing answers there, the conversation runs on a private child gateway that ends with it.
-
-Pass `--quiet` (`clikernel-mcp --quiet`) for a host whose sessions should not see banner noise: startup still runs, but its output stays out of every reply.
-
-## Configuration
-
-Three optional files in `$XDG_CONFIG_HOME/clikernel/` (usually `~/.config/clikernel/`):
-
-- `startup.py` — run in every kernel clikernel creates, with `__file__` bound to its path; its output returns in the reply that announces the kernel.
-- `inspectors.py` — cell inspectors installed after startup. The file may define `inspect` and/or a list `inspectors`; each is called once per cell before it runs (1-arg: the cell’s AST; 2-arg: AST and raw source). Return a string to print a note before the cell’s output, raise `RuleBlock` (provided in the namespace) to block the cell; any other exception warns and the cell runs. See `examples/inspectors.py`.
-- `gateways.toml` — named remote gateways, so tokens never appear in tool arguments:
-
-``` toml
-[gateways.solveit]
-url = "https://solveit.example.com/gate"
-token_env = "SOLVEIT_TOKEN"
-verify = false   # optional: accept a self-signed certificate
-```
-
-## The stream protocol
-
-Run `clikernel` as a plain CLI process and the same client speaks a delimiter-framed stdin/stdout protocol for token-reading clients: no echo, a cheap `.` acknowledgement per request, responses ended by a per-process random delimiter, multiline cells framed by `--` and the delimiter. The full recipe is announced in the process’s own startup banner. Run bare it creates a kernel and stops it on exit; `--kernel <id>` attaches to an existing kernel and leaves it as found.