codebind 0.6.6__py3-none-any.whl → 0.6.8__py3-none-any.whl

codebind/execution.py

@@ -16,7 +16,7 @@ from IPython.utils.capture import capture_output
 from .display import display_cell
 from .images import PreparedImage, prepare_mime_image
 from .jupyter import JupyterLabBridge
-from .terminal import record_tool_output, show_input
+from .terminal import preview_tool_output, record_tool_output, show_input
 
 
 _MAXIMUM_IMAGES_PER_REPORT = 32
@@ -219,9 +219,11 @@ class IPythonExecutor:
 
         if self.bridge is None and isinstance(self.shell, TerminalInteractiveShell):
             show_input(self.shell, cell)
-            with record_tool_output(self.shell):
+            with preview_tool_output() as preview, record_tool_output(self.shell):
                 result = self.shell.run_cell(cell, store_history=True)
-            return self._native_report(result)
+            report = self._native_report(result)
+            preview.show_notice(result.execution_count, report.error)
+            return report
 
         bridge = self.bridge
         cell_id = bridge.start_code_cell(cell) if bridge is not None else None
@@ -260,6 +262,7 @@ class IPythonExecutor:
             transformed = self.shell.transform_cell(cell)
             result = None
             with (
+                preview_tool_output() as preview,
                 record_tool_output(self.shell),
                 self.shell._tee(channel="stdout"),
                 self.shell._tee(channel="stderr"),
@@ -273,7 +276,9 @@ class IPythonExecutor:
                 finally:
                     self.shell.events.trigger("post_execute")
                     self.shell.events.trigger("post_run_cell", result)
-            return self._native_report(result)
+            report = self._native_report(result)
+            preview.show_notice(result.execution_count, report.error)
+            return report
 
         bridge = self.bridge
         cell_id = bridge.start_code_cell(cell) if bridge is not None else None

codebind/extension.py

@@ -3,9 +3,11 @@
 from __future__ import annotations
 
 import asyncio
+import sys
 from typing import Any
 
 from IPython.core.interactiveshell import InteractiveShell
+from IPython.core.page import page
 from IPython.terminal.interactiveshell import TerminalInteractiveShell
 from langchain_core.language_models import BaseChatModel
 
@@ -13,13 +15,22 @@ from .configuration import load_configuration, load_models
 from .conversation import MemoryConversationStore, NotebookConversationStore
 from .jupyter import JupyterLabBridge, TARGET_NAME
 from .session import Session
-from .terminal import install_markdown_renderer
+from .terminal import TerminalCellHistory, install_markdown_renderer, install_question_mode
 
 
 _STATE_ATTRIBUTE = "_codebind_extension_state"
 
 
 def _close_state(state: dict[str, Any]) -> None:
+    restore_output_magic = state.get("restore_output_magic")
+    if callable(restore_output_magic):
+        restore_output_magic()
+    terminal_history = state.get("terminal_history")
+    if isinstance(terminal_history, TerminalCellHistory):
+        terminal_history.close()
+    restore_terminal_question_mode = state.get("restore_terminal_question_mode")
+    if callable(restore_terminal_question_mode):
+        restore_terminal_question_mode()
     restore_terminal_display = state.get("restore_terminal_display")
     if callable(restore_terminal_display):
         restore_terminal_display()
@@ -44,6 +55,9 @@ def _close_state(state: dict[str, Any]) -> None:
 def load_ipython_extension(ipython: InteractiveShell) -> None:
     """Load Codebind into the active IPython session."""
     previous = getattr(ipython, _STATE_ATTRIBUTE, None)
+    previous_terminal_history = (
+        previous.get("terminal_history") if isinstance(previous, dict) else None
+    )
     if isinstance(previous, dict):
         _close_state(previous)
 
@@ -78,12 +92,55 @@ def load_ipython_extension(ipython: InteractiveShell) -> None:
         "comm_manager": manager,
         "comm_target": None,
         "restore_terminal_display": None,
+        "restore_terminal_question_mode": None,
+        "terminal_history": None,
+        "restore_output_magic": None,
     }
 
     if manager is None:
         state["session"] = Session(shell=ipython, store=MemoryConversationStore())
         if isinstance(ipython, TerminalInteractiveShell):
+            state["terminal_history"] = TerminalCellHistory(
+                ipython,
+                previous=(
+                    previous_terminal_history
+                    if isinstance(previous_terminal_history, TerminalCellHistory)
+                    else None
+                ),
+            )
             state["restore_terminal_display"] = install_markdown_renderer(ipython)
+            state["restore_terminal_question_mode"] = install_question_mode(ipython)
+
+            line_magics = ipython.magics_manager.magics["line"]
+            previous_output_magic = line_magics.get("output")
+
+            def output_magic(line: str) -> None:
+                number_text = line.strip()
+                if not number_text.isdecimal() or int(number_text) < 1:
+                    raise ValueError("Usage: %output <cell number>")
+                terminal_history = state["terminal_history"]
+                if not isinstance(terminal_history, TerminalCellHistory):
+                    raise RuntimeError("Terminal history is unavailable")
+                number = int(number_text)
+                try:
+                    full_output = terminal_history.output_text(number)
+                except KeyError as error:
+                    raise ValueError(f"No recorded cell In [{number}]") from error
+                if full_output:
+                    page(f"\x1b[90m{full_output}\x1b[0m" if sys.stdout.isatty() else full_output)
+                else:
+                    print(f"In [{number}] has no text output.")
+
+            ipython.register_magic_function(output_magic, "line", "output")
+
+            def restore_output_magic() -> None:
+                if line_magics.get("output") is output_magic:
+                    if previous_output_magic is None:
+                        line_magics.pop("output", None)
+                    else:
+                        line_magics["output"] = previous_output_magic
+
+            state["restore_output_magic"] = restore_output_magic
     else:
 
         def accept_comm(comm: Any, message: dict[str, Any]) -> None:
@@ -142,8 +199,14 @@ def load_ipython_extension(ipython: InteractiveShell) -> None:
             session = Session(shell=ipython, store=MemoryConversationStore())
             state["session"] = session
         selected = get_model()
+        terminal_history = state.get("terminal_history")
+        history = (
+            terminal_history.snapshot()
+            if isinstance(terminal_history, TerminalCellHistory)
+            else None
+        )
         try:
-            session.send(cell if cell is not None else line, selected)
+            session.send(cell if cell is not None else line, selected, notebook=history)
         except BaseException:
             asyncio.run(discard_model())
             raise

codebind/instructions.md

@@ -11,7 +11,7 @@ You are a facts-rooted coding agent, operating through the user’s live IPython
 - Ground factual claims and reported results in direct observations or valid, identifiable sources that actually support them; give the user enough detail to verify the source. Never invent or simulate factual data, sources, citations, quotes, tool output, actions, or observations, or present guesses as facts. If evidence is missing, say so rather than fabricate it. Create synthetic or fictional material only when explicitly requested, label it clearly, and never present it as real; treat fabricated evidence presented as real as fraud.
 - Keep the user oriented while working. Before meaningful tool work, emit one brief Markdown update saying what you are about to do. Between tool calls, emit another update only for a new phase, an important finding, or a change of plan. Do not perform several meaningful steps silently, but do not narrate trivial operations.
 - Keep responses brief and direct, free of jargon and human-written with a clear intent.
-- Treat notebook-context messages as the authoritative notebook document state; later deltas override earlier cell versions.
-- Notebook cells and supported images displayed in them, including images from your IPython tool, enter your context automatically. Inspect those images directly before claiming you cannot see them; mention any reported image omission.
+- Treat notebook-context messages as the authoritative cell history for the active notebook or terminal; later deltas override earlier cell versions. Terminal context includes completed IPython inputs and outputs.
+- Notebook and terminal cells, plus supported images displayed in them, including images from your IPython tool, enter your context automatically. Inspect those images directly before claiming you cannot see them; mention any reported image omission.
 - Before importing or using a non-standard library, check whether it is available in the active IPython interpreter. If it is missing, determine a working installer for that environment (such as `uv` or `pip`), install it into that interpreter, and verify the import before proceeding; do not assume installation succeeded.
 - Be very proactive, instead of giving up. You can ask questions to the user to clarify.

codebind/terminal.py

@@ -2,21 +2,369 @@
 
 from __future__ import annotations
 
+import ast
+import shutil
 import sys
 from collections.abc import Callable, Iterator
 from contextlib import contextmanager
+from copy import deepcopy
 from unittest.mock import patch
 
 from IPython.terminal.interactiveshell import IPythonPTLexer, TerminalInteractiveShell
+from prompt_toolkit.enums import DEFAULT_BUFFER
+from prompt_toolkit.filters import Condition, has_focus
 from prompt_toolkit.document import Document
-from prompt_toolkit.formatted_text import FormattedText, PygmentsTokens
+from prompt_toolkit.formatted_text import ANSI, FormattedText, PygmentsTokens, to_formatted_text
 from prompt_toolkit.shortcuts import print_formatted_text
+from prompt_toolkit.styles import DynamicStyle, Style, merge_styles
 from rich.console import Console
 from rich.markdown import Markdown
 
 
 _MISSING = object()
 _IMAGE_FORMATS = ("image/png", "image/jpeg", "image/svg+xml")
+_MAXIMUM_VISIBLE_OUTPUT_LINES = 10
+
+
+def _plain_ansi(value: str) -> str:
+    return "".join(text for _, text in to_formatted_text(ANSI(value)))
+
+
+def _magic_input(transformed: str) -> tuple[str, str] | None:
+    """Recognize a complete IPython magic call in transformed history."""
+    try:
+        statements = ast.parse(transformed).body
+    except SyntaxError:
+        return None
+    if len(statements) != 1 or not isinstance(statements[0], ast.Expr):
+        return None
+    call = statements[0].value
+    if not (
+        isinstance(call, ast.Call)
+        and isinstance(call.func, ast.Attribute)
+        and call.func.attr in {"run_cell_magic", "run_line_magic"}
+        and isinstance(call.func.value, ast.Call)
+        and isinstance(call.func.value.func, ast.Name)
+        and call.func.value.func.id == "get_ipython"
+        and bool(call.args)
+        and isinstance(call.args[0], ast.Constant)
+        and isinstance(call.args[0].value, str)
+    ):
+        return None
+    text_index = 2 if call.func.attr == "run_cell_magic" else 1
+    if len(call.args) <= text_index or not isinstance(call.args[text_index], ast.Constant):
+        return None
+    text = call.args[text_index].value
+    return (call.args[0].value, text.strip()) if isinstance(text, str) else None
+
+
+def _history_cell(
+    shell: TerminalInteractiveShell,
+    number: int,
+    source: str,
+    transformed: str,
+) -> dict[str, object] | None:
+    """Capture one finished IPython cell before later displays can alter its history."""
+    if not source.strip():
+        return None
+    history = shell.history_manager
+    identifier = f"terminal-{number}"
+    magic = _magic_input(transformed)
+    if magic is not None and magic[0] == "question":
+        return {"id": identifier, "type": "markdown", "source": magic[1]}
+    if magic is not None and magic[0] == "output":
+        return {"id": identifier, "type": "raw", "source": source}
+
+    outputs: list[dict[str, object]] = []
+    for record in history.outputs.get(number, ()):
+        if record.output_type in {"out_stream", "err_stream"}:
+            stream = record.bundle.get("stream", [])
+            outputs.append(
+                {
+                    "output_type": "stream",
+                    "name": "stdout" if record.output_type == "out_stream" else "stderr",
+                    "text": "".join(stream),
+                }
+            )
+        elif record.output_type in {"display_data", "execute_result"}:
+            output: dict[str, object] = {
+                "output_type": record.output_type,
+                "data": deepcopy(record.bundle),
+                "metadata": {},
+            }
+            if record.output_type == "execute_result":
+                output["execution_count"] = number
+            outputs.append(output)
+    error = history.exceptions.get(number)
+    if error is not None:
+        outputs.append({"output_type": "error", **deepcopy(error)})
+    return {
+        "id": identifier,
+        "type": "code",
+        "source": source,
+        "execution_count": number,
+        "outputs": outputs,
+    }
+
+
+class TerminalCellHistory:
+    """Track completed IPython cells, without reinterpreting mutable output history."""
+
+    def __init__(
+        self,
+        shell: TerminalInteractiveShell,
+        previous: TerminalCellHistory | None = None,
+    ) -> None:
+        self.shell = shell
+        self._cells = deepcopy(previous._cells) if previous is not None else {}
+        history = shell.history_manager
+        for number in range(1, shell.execution_count):
+            if number in self._cells or number >= len(history.input_hist_raw):
+                continue
+            cell = _history_cell(
+                shell,
+                number,
+                history.input_hist_raw[number],
+                history.input_hist_parsed[number],
+            )
+            if cell is not None:
+                self._cells[number] = cell
+        self._callback = self._record
+        shell.events.register("post_run_cell", self._callback)
+
+    def _record(self, result) -> None:
+        if result is None or result.execution_count is None or not result.info.store_history:
+            return
+        cell = _history_cell(
+            self.shell,
+            result.execution_count,
+            result.info.raw_cell,
+            result.info.transformed_cell,
+        )
+        if cell is not None:
+            self._cells[result.execution_count] = cell
+
+    def snapshot(self) -> list[dict[str, object]]:
+        return [deepcopy(self._cells[number]) for number in sorted(self._cells)]
+
+    def output_text(self, number: int) -> str:
+        """Format one completed cell's recorded output for IPython's pager."""
+        cell = self._cells.get(number)
+        if cell is None:
+            raise KeyError(number)
+        parts: list[str] = []
+        for output in cell.get("outputs", []):
+            kind = output["output_type"]
+            if kind == "stream":
+                parts.append(output["text"])
+            elif kind in {"execute_result", "display_data"}:
+                data = output["data"]
+                text = data.get("text/plain", data.get("text/markdown"))
+                if text is None:
+                    continue
+                prefix = f"Out[{number}]: " if kind == "execute_result" else ""
+                parts.append(prefix + str(text) + "\n")
+            elif kind == "error":
+                traceback = output.get("traceback") or [
+                    f"{output.get('ename', 'Error')}: {output.get('evalue', '')}"
+                ]
+                parts.append("\n".join(traceback) + "\n")
+        return _plain_ansi("".join(parts))
+
+    def close(self) -> None:
+        self.shell.events.unregister("post_run_cell", self._callback)
+
+
+class _OutputPreview:
+    """Limit only terminal painting; IPython still records every written byte."""
+
+    def __init__(self, maximum_lines: int, maximum_characters: int) -> None:
+        self.maximum_lines = maximum_lines
+        self.maximum_characters = maximum_characters
+        self.visible_lines = 0
+        self.visible_characters = 0
+        self.hidden_line_breaks = 0
+        self.hidden_has_tail = False
+        self.hidden_characters = 0
+        self.truncated = False
+        self.visible_ends_line = True
+
+    def _hide(self, data: str) -> None:
+        self.truncated = True
+        self.hidden_characters += len(data)
+        self.hidden_line_breaks += data.count("\n") + data.count("\r") - data.count("\r\n")
+        self.hidden_has_tail = not data.endswith(("\n", "\r"))
+
+    def write(self, stream, data: str) -> int:
+        for piece in data.splitlines(keepends=True):
+            remaining = self.maximum_characters - self.visible_characters
+            if self.truncated or self.visible_lines >= self.maximum_lines or remaining <= 0:
+                self._hide(piece)
+                continue
+            visible = piece[:remaining]
+            if len(visible) < len(piece) and "\x1b" in visible:
+                # Never leave a partially printed ANSI escape sequence on screen.
+                visible = ""
+            if visible:
+                if stream.isatty():
+                    stream.write("\x1b[90m")
+                stream.write(visible)
+                if stream.isatty():
+                    stream.write("\x1b[0m")
+                self.visible_characters += len(visible)
+                self.visible_ends_line = visible.endswith(("\n", "\r"))
+                if self.visible_ends_line:
+                    self.visible_lines += 1
+            if len(visible) < len(piece):
+                self._hide(piece[len(visible) :])
+        return len(data)
+
+    def show_notice(self, number: int, error: dict[str, str] | None = None) -> None:
+        if not self.hidden_characters:
+            return
+        if sys.stdout.isatty():
+            sys.stdout.write("\x1b[0m")
+        if not self.visible_ends_line:
+            sys.stdout.write("\n")
+        hidden_lines = self.hidden_line_breaks + int(self.hidden_has_tail)
+        label = "line" if hidden_lines == 1 else "lines"
+        sys.stdout.write(
+            f"… {hidden_lines:,} more output {label}. Run %output {number} to view all.\n"
+        )
+        if error is not None:
+            if sys.stdout.isatty():
+                sys.stdout.write("\x1b[90m")
+            sys.stdout.write(f"{error['type']}: {error['message']}\n")
+            if sys.stdout.isatty():
+                sys.stdout.write("\x1b[0m")
+
+
+class _PreviewStream:
+    def __init__(self, stream, preview: _OutputPreview) -> None:
+        self.stream = stream
+        self.preview = preview
+        self.pending = ""
+
+    def write(self, data: str) -> int:
+        self.pending += data
+        lines = self.pending.splitlines(keepends=True)
+        if lines and not lines[-1].endswith(("\n", "\r")):
+            self.pending = lines.pop()
+        else:
+            self.pending = ""
+        for line in lines:
+            self.preview.write(self.stream, _plain_ansi(line))
+        return len(data)
+
+    def flush(self) -> None:
+        if self.pending:
+            self.preview.write(self.stream, _plain_ansi(self.pending))
+            self.pending = ""
+        self.stream.flush()
+
+    def __getattr__(self, name: str):
+        return getattr(self.stream, name)
+
+
+@contextmanager
+def preview_tool_output(
+    maximum_lines: int = _MAXIMUM_VISIBLE_OUTPUT_LINES,
+) -> Iterator[_OutputPreview]:
+    """Show a compact preview while keeping the tool cell's complete native output."""
+    columns = shutil.get_terminal_size(fallback=(80, 24)).columns
+    preview = _OutputPreview(maximum_lines, maximum_lines * max(20, columns))
+    stdout, stderr = sys.stdout, sys.stderr
+    preview_stdout = _PreviewStream(stdout, preview)
+    preview_stderr = _PreviewStream(stderr, preview)
+    sys.stdout = preview_stdout
+    sys.stderr = preview_stderr
+    try:
+        yield preview
+    finally:
+        preview_stdout.flush()
+        preview_stderr.flush()
+        sys.stdout, sys.stderr = stdout, stderr
+
+
+def install_question_mode(shell: TerminalInteractiveShell) -> Callable[[], None]:
+    """Let Shift+Tab switch the terminal prompt between Python and questions."""
+    prompt_session = shell.pt_app
+    if prompt_session is None:
+        return lambda: None
+
+    original_style = prompt_session.style
+    original_prompt_for_code = shell.prompt_for_code
+    had_prompt_override = "prompt_for_code" in vars(shell)
+    bindings = prompt_session.key_bindings
+    transforms = shell.input_transformer_manager.cleanup_transforms
+    question_mode = False
+    active_prompt = False
+    pending_question = False
+
+    def prompt_for_code() -> str:
+        nonlocal active_prompt, pending_question
+        active_prompt = True
+        try:
+            text = original_prompt_for_code()
+        finally:
+            active_prompt = False
+        pending_question = question_mode and bool(text.strip())
+        return text
+
+    def transform_question(lines: list[str]) -> list[str]:
+        nonlocal pending_question
+        if not pending_question:
+            return lines
+        pending_question = False
+        return ["%%question\n", *lines]
+
+    def toggle_question(event) -> None:
+        nonlocal question_mode
+        question_mode = not question_mode
+        event.app.invalidate()
+
+    def submit_question(event) -> None:
+        event.current_buffer.validate_and_handle()
+
+    question_active = Condition(lambda: active_prompt and question_mode)
+    bindings.add("s-tab", filter=has_focus(DEFAULT_BUFFER))(toggle_question)
+    bindings.add("enter", filter=has_focus(DEFAULT_BUFFER) & question_active)(submit_question)
+    shell.prompt_for_code = prompt_for_code
+    question_style = merge_styles(
+        [
+            original_style,
+            Style.from_dict(
+                {
+                    key: "#a855f7"
+                    for key in (
+                        "pygments.prompt",
+                        "pygments.promptnum",
+                        "pygments.prompt.mode",
+                        "pygments.prompt.linenumber",
+                        "pygments.prompt.continuation",
+                        "pygments.prompt.padding",
+                        "pygments.prompt.wrap",
+                    )
+                }
+            ),
+        ]
+    )
+    prompt_session.style = DynamicStyle(
+        lambda: question_style if active_prompt and question_mode else original_style
+    )
+    transforms.insert(0, transform_question)
+
+    def restore() -> None:
+        bindings.remove(toggle_question)
+        bindings.remove(submit_question)
+        transforms.remove(transform_question)
+        if had_prompt_override:
+            shell.prompt_for_code = original_prompt_for_code
+        else:
+            del shell.prompt_for_code
+        prompt_session.style = original_style
+
+    return restore
 
 
 def show_input(shell: TerminalInteractiveShell, cell: str) -> None:
@@ -96,4 +444,11 @@ def record_tool_output(shell: TerminalInteractiveShell) -> Iterator[None]:
             shell.mime_renderers["image/png"] = previous_png_renderer
 
 
-__all__ = ["install_markdown_renderer", "record_tool_output", "show_input"]
+__all__ = [
+    "TerminalCellHistory",
+    "install_markdown_renderer",
+    "install_question_mode",
+    "preview_tool_output",
+    "record_tool_output",
+    "show_input",
+]

{codebind-0.6.6.dist-info → codebind-0.6.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codebind
-Version: 0.6.6
+Version: 0.6.8
 Summary: A frontend-neutral model loop for persistent IPython sessions.
 Keywords: ai,ipython,llm,repl,agents
 Author: Giovanni Gravili
@@ -65,15 +65,17 @@ Start a new conversation:
 uvx codebind
 ```
 
-Ask through ordinary IPython magic syntax:
+Press `Shift+Tab` to switch the prompt into Question mode; the prompt turns purple. Type a question and press `Enter` to send it. Press `Shift+Tab` again to return to Python mode. Ordinary `Tab` completion is unchanged.
+
+The `%question` and `%%question` magics remain available:
 
 ```python
 %%question
 Inspect this project and tell me what to implement first.
 ```
 
-Terminal conversations remain live for the current IPython process. Durable automatic resumption belongs to notebooks, where the notebook file provides an unambiguous conversation identity.
-Model-executed cells appear with IPython's native input counter, syntax highlighting, output prompts, streams, and tracebacks. Assistant Markdown is rendered through IPython's terminal MIME renderer. A terminal is a stream rather than a notebook document, so these displays are not editable notebook cells.
+Terminal conversations remain live for the current IPython process. Previous terminal inputs and outputs, including Python cells you ran yourself, enter the model's context when you ask a question. Durable automatic resumption belongs to notebooks, where the notebook file provides an unambiguous conversation identity.
+Model-executed cells appear with IPython's native input counter, syntax highlighting, output prompts, streams, and tracebacks. To keep terminal scrollback usable, Codebind shows at most 10 gray lines of each model-executed cell's output, then displays a notice such as `… 990 more output lines. Run %output 8 to view all.` The complete output remains available to the model and in IPython history; `%output 8` opens its full text in IPython's pager. User-entered Python cells keep IPython's normal display behavior. Assistant Markdown is rendered through IPython's terminal MIME renderer. A terminal is a stream rather than a notebook document, so these displays are not editable notebook cells.
 
 ## JupyterLab
 

{codebind-0.6.6.dist-info → codebind-0.6.8.dist-info}/RECORD

@@ -3,22 +3,22 @@ codebind/cli.py,sha256=9LOR1L3P8sPsOOgsnpbOsA1PNUZdAj1Z9ROFKeo3EV8,423
 codebind/configuration.py,sha256=b9ux-MiepzAFfRhorZp4w2pdLLs44necescIGg_IKfo,1828
 codebind/conversation.py,sha256=nFMe2QgFkFOA2GYInN-cO_jhA9010LpM6_Ij2g4Q2BA,17500
 codebind/display.py,sha256=IpxcElyNcr5olRIatEduN_d-sRwpsMlaq1UtrOXocQA,494
-codebind/execution.py,sha256=gqpZP2BFlSnGkdjLXCsouU6Zim9oETz7dmAiHlIybj8,16261
-codebind/extension.py,sha256=kLlpPZxW5OrQSAA0Oh5tXTHqTsSat7B_HjG8qsG5F_o,6050
+codebind/execution.py,sha256=0G3WZ5HkXCdr-PavhRcvjKOjW70-iHGM2Xp9KkZ6WIc,16562
+codebind/extension.py,sha256=DRT0-Syn8yQ4ib46Mb-Yvxhw1fXz9OINr2bCS7oR-uE,8953
 codebind/images.py,sha256=9bJHjXc75_YRBFTAqAWiknRTCjs8ApyGVVSxC_S5lio,4342
-codebind/instructions.md,sha256=WQ42UB5mmGcRqj_hQBzYLpcyUh1EuKDFU5dZ3GpB6JM,3664
+codebind/instructions.md,sha256=_8CVGEuKgPRLmxfPnJMP0sNGg_Nh_o6z5iuKHKj57RM,3768
 codebind/jupyter.py,sha256=07H_S9G3iyyUtWRzlvFr5-5X6CuLBXVficu5Fz8jpVw,8652
 codebind/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 codebind/session.py,sha256=b8fEFOFdZn4h1wIr9RE2K5SPWmoVyro5pRhGUr4rI6c,23722
-codebind/terminal.py,sha256=zSnVSHSxVqKg6wyjZm6KtxUTmuyCM46PQoXwVIVxmNw,3819
-codebind-0.6.6.dist-info/licenses/LICENSE,sha256=ujX46e0LFBIBTnCDY0u3Q7LV363B7CiI7QJZxIkEXlk,1073
-codebind-0.6.6.data/data/share/jupyter/labextensions/codebind-jupyterlab/install.json,sha256=78rEThkfrk1pXtekX5WrG9_Y0lJYi5XBEm8n9athpFE,164
-codebind-0.6.6.data/data/share/jupyter/labextensions/codebind-jupyterlab/package.json,sha256=hawl8ZytgxN-WbUjgbzdIVemPPczzmSFoc2HwDxtgIc,1192
-codebind-0.6.6.data/data/share/jupyter/labextensions/codebind-jupyterlab/static/590.dae4561c5427a855.js,sha256=lMbXilytbQEc_kzyVkgzhKZxU_zgdNLTz4uLJfC7APY,16141
-codebind-0.6.6.data/data/share/jupyter/labextensions/codebind-jupyterlab/static/remoteEntry.c10098fb6e87897c.js,sha256=U0JBoOwkRkzPct8MzcUO1pc2XeVGvxgztXBMtJMg2b4,11794
-codebind-0.6.6.data/data/share/jupyter/labextensions/codebind-jupyterlab/static/style.js,sha256=Opy15wyuR_ABqsrk-cOcOj2yZtvtq0r36aDkErnloD0,113
-codebind-0.6.6.data/data/share/jupyter/labextensions/codebind-jupyterlab/static/third-party-licenses.json,sha256=MNToQfru1YnHAie-2Virp23yWsc5co3qG0IzrO6SEfw,20
-codebind-0.6.6.dist-info/WHEEL,sha256=7hzKWg-J8I3Buqyw5tBii5z_MmAVsDYXXijd_QAtNZ8,81
-codebind-0.6.6.dist-info/entry_points.txt,sha256=GiPcU63sULDlywJSKigAS4M3vaziYIrubXOb3fAg2_c,48
-codebind-0.6.6.dist-info/METADATA,sha256=2M2ZoO3gCWYhx_BSEFhhECMyXh4prs8mo2V3nF4wMlY,6959
-codebind-0.6.6.dist-info/RECORD,,
+codebind/terminal.py,sha256=YcaHvl8L9P0vNfsS7YEhhkXXJJOTZ1QUeprzEE6pabg,16979
+codebind-0.6.8.dist-info/licenses/LICENSE,sha256=ujX46e0LFBIBTnCDY0u3Q7LV363B7CiI7QJZxIkEXlk,1073
+codebind-0.6.8.data/data/share/jupyter/labextensions/codebind-jupyterlab/install.json,sha256=78rEThkfrk1pXtekX5WrG9_Y0lJYi5XBEm8n9athpFE,164
+codebind-0.6.8.data/data/share/jupyter/labextensions/codebind-jupyterlab/package.json,sha256=hawl8ZytgxN-WbUjgbzdIVemPPczzmSFoc2HwDxtgIc,1192
+codebind-0.6.8.data/data/share/jupyter/labextensions/codebind-jupyterlab/static/590.dae4561c5427a855.js,sha256=lMbXilytbQEc_kzyVkgzhKZxU_zgdNLTz4uLJfC7APY,16141
+codebind-0.6.8.data/data/share/jupyter/labextensions/codebind-jupyterlab/static/remoteEntry.c10098fb6e87897c.js,sha256=U0JBoOwkRkzPct8MzcUO1pc2XeVGvxgztXBMtJMg2b4,11794
+codebind-0.6.8.data/data/share/jupyter/labextensions/codebind-jupyterlab/static/style.js,sha256=Opy15wyuR_ABqsrk-cOcOj2yZtvtq0r36aDkErnloD0,113
+codebind-0.6.8.data/data/share/jupyter/labextensions/codebind-jupyterlab/static/third-party-licenses.json,sha256=MNToQfru1YnHAie-2Virp23yWsc5co3qG0IzrO6SEfw,20
+codebind-0.6.8.dist-info/WHEEL,sha256=7hzKWg-J8I3Buqyw5tBii5z_MmAVsDYXXijd_QAtNZ8,81
+codebind-0.6.8.dist-info/entry_points.txt,sha256=GiPcU63sULDlywJSKigAS4M3vaziYIrubXOb3fAg2_c,48
+codebind-0.6.8.dist-info/METADATA,sha256=BqNK8lXq6yyfeisTOEM6B2q2p8kMweQs5cOKYs0hIVQ,7716
+codebind-0.6.8.dist-info/RECORD,,