codebind 0.6.7__tar.gz → 0.6.9__tar.gz

{codebind-0.6.7 → codebind-0.6.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codebind
-Version: 0.6.7
+Version: 0.6.9
 Summary: A frontend-neutral model loop for persistent IPython sessions.
 Keywords: ai,ipython,llm,repl,agents
 Author: Giovanni Gravili
@@ -75,7 +75,7 @@ Inspect this project and tell me what to implement first.
 ```
 
 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. 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.
+Model-executed cells appear with IPython's native input counter, syntax highlighting, output prompts, streams, and tracebacks. Assistant Markdown appears before the following tool cell, and tool output appears as it is written. 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.7 → codebind-0.6.9}/README.md

@@ -47,7 +47,7 @@ Inspect this project and tell me what to implement first.
 ```
 
 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. 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.
+Model-executed cells appear with IPython's native input counter, syntax highlighting, output prompts, streams, and tracebacks. Assistant Markdown appears before the following tool cell, and tool output appears as it is written. 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.7 → codebind-0.6.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "codebind"
-version = "0.6.7"
+version = "0.6.9"
 description = "A frontend-neutral model loop for persistent IPython sessions."
 readme = "README.md"
 requires-python = ">=3.13"

{codebind-0.6.7 → codebind-0.6.9}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "codebind"
-version = "0.6.7"
+version = "0.6.9"
 description = "A frontend-neutral model loop for persistent IPython sessions."
 readme = "README.md"
 authors = [

{codebind-0.6.7 → codebind-0.6.9}/src/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-0.6.7 → codebind-0.6.9}/src/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
 
@@ -20,6 +22,9 @@ _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()
@@ -89,6 +94,7 @@ def load_ipython_extension(ipython: InteractiveShell) -> None:
         "restore_terminal_display": None,
         "restore_terminal_question_mode": None,
         "terminal_history": None,
+        "restore_output_magic": None,
     }
 
     if manager is None:
@@ -104,6 +110,37 @@ def load_ipython_extension(ipython: InteractiveShell) -> 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:

{codebind-0.6.7 → codebind-0.6.9}/src/codebind/session.py

@@ -274,8 +274,24 @@ class Session:
         for identifier in self._pending_calls(turn_id):
             self._append_message_sync(self._interrupted_tool_message(identifier), turn_id)
 
-    def _update_assistant_stream(self, cell_id: str | None, text: str) -> str | None:
-        if self.bridge is None or not text:
+    def _update_assistant_stream(
+        self,
+        cell_id: str | None,
+        text: str,
+        shown: str,
+        terminal_displayed: list[str] | None = None,
+    ) -> str | None:
+        if not text:
+            return cell_id
+        if self.bridge is None:
+            previous = terminal_displayed[0] if terminal_displayed is not None else shown
+            if previous.startswith(text):
+                return cell_id
+            addition = text[len(previous) :] if text.startswith(previous) else text
+            if addition:
+                self._display_assistant(addition)
+            if terminal_displayed is not None:
+                terminal_displayed[0] = text
             return cell_id
         if cell_id is None:
             return self.bridge.start_markdown_cell(text)
@@ -284,7 +300,9 @@ class Session:
 
     def _finish_assistant_stream(self, cell_id: str | None, response: AIMessage) -> None:
         answer = _message_text(response)
-        if cell_id is not None and self.bridge is not None:
+        if self.bridge is None:
+            return
+        if cell_id is not None:
             self.bridge.finish_markdown_cell(cell_id, answer)
         elif answer:
             self._display_assistant(answer)
@@ -302,9 +320,10 @@ class Session:
         self,
         model: BaseChatModel,
     ) -> tuple[AIMessage, str | None]:
+        terminal_displayed = [""]
         for retry in range(len(_MODEL_RETRY_DELAYS) + 1):
             try:
-                return self._stream_model(self._bind(model), model)
+                return self._stream_model(self._bind(model), model, terminal_displayed)
             except TransientProviderError as error:
                 if retry == len(_MODEL_RETRY_DELAYS):
                     raise
@@ -316,9 +335,10 @@ class Session:
         self,
         model: BaseChatModel,
     ) -> tuple[AIMessage, str | None]:
+        terminal_displayed = [""]
         for retry in range(len(_MODEL_RETRY_DELAYS) + 1):
             try:
-                return await self._astream_model(self._bind(model), model)
+                return await self._astream_model(self._bind(model), model, terminal_displayed)
             except TransientProviderError as error:
                 if retry == len(_MODEL_RETRY_DELAYS):
                     raise
@@ -344,6 +364,7 @@ class Session:
         self,
         bound_model: Runnable[Any, BaseMessage],
         model: BaseChatModel,
+        terminal_displayed: list[str] | None = None,
     ) -> tuple[AIMessage, str | None]:
         aggregate: AIMessageChunk | None = None
         response: AIMessage | None = None
@@ -366,12 +387,14 @@ class Session:
                     raise TypeError("model stream must return AIMessage chunks")
                 text = _message_text(current)
                 if tool_call_started and text != shown:
-                    cell_id = self._update_assistant_stream(cell_id, text)
+                    cell_id = self._update_assistant_stream(
+                        cell_id, text, shown, terminal_displayed
+                    )
                     shown = text
             completed = self._completed_stream_message(aggregate, response)
             answer = _message_text(completed)
             if answer != shown:
-                cell_id = self._update_assistant_stream(cell_id, answer)
+                cell_id = self._update_assistant_stream(cell_id, answer, shown, terminal_displayed)
             return completed, cell_id
         except BaseException:
             self._cancel_assistant_stream(cell_id)
@@ -381,6 +404,7 @@ class Session:
         self,
         bound_model: Runnable[Any, BaseMessage],
         model: BaseChatModel,
+        terminal_displayed: list[str] | None = None,
     ) -> tuple[AIMessage, str | None]:
         aggregate: AIMessageChunk | None = None
         response: AIMessage | None = None
@@ -403,12 +427,14 @@ class Session:
                     raise TypeError("model stream must return AIMessage chunks")
                 text = _message_text(current)
                 if tool_call_started and text != shown:
-                    cell_id = self._update_assistant_stream(cell_id, text)
+                    cell_id = self._update_assistant_stream(
+                        cell_id, text, shown, terminal_displayed
+                    )
                     shown = text
             completed = self._completed_stream_message(aggregate, response)
             answer = _message_text(completed)
             if answer != shown:
-                cell_id = self._update_assistant_stream(cell_id, answer)
+                cell_id = self._update_assistant_stream(cell_id, answer, shown, terminal_displayed)
             return completed, cell_id
         except BaseException:
             self._cancel_assistant_stream(cell_id)

{codebind-0.6.7 → codebind-0.6.9}/src/codebind/terminal.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import ast
+import shutil
 import sys
 from collections.abc import Callable, Iterator
 from contextlib import contextmanager
@@ -13,7 +14,7 @@ from IPython.terminal.interactiveshell import IPythonPTLexer, TerminalInteractiv
 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
@@ -22,10 +23,29 @@ from rich.markdown import Markdown
 
 _MISSING = object()
 _IMAGE_FORMATS = ("image/png", "image/jpeg", "image/svg+xml")
+_MAXIMUM_VISIBLE_OUTPUT_LINES = 10
 
 
-def _question_text(transformed: str) -> str | None:
-    """Recover a Codebind question from IPython's own transformed history."""
+def _plain_ansi(value: str) -> str:
+    return "".join(text for _, text in to_formatted_text(ANSI(value)))
+
+
+def _split_incomplete_ansi(value: str) -> tuple[str, str]:
+    last_escape = value.rfind("\x1b")
+    if last_escape < 0:
+        return value, ""
+    tail = value[last_escape:]
+    if tail == "\x1b":
+        return value[:last_escape], tail
+    if tail.startswith("\x1b[") and not any("@" <= char <= "~" for char in tail[2:]):
+        return value[:last_escape], tail
+    if tail.startswith("\x1b]") and "\x07" not in tail and "\x1b\\" not in tail:
+        return value[:last_escape], tail
+    return 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:
@@ -42,14 +62,14 @@ def _question_text(transformed: str) -> str | None:
         and call.func.value.func.id == "get_ipython"
         and bool(call.args)
         and isinstance(call.args[0], ast.Constant)
-        and call.args[0].value == "question"
+        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 text.strip() if isinstance(text, str) else None
+    return (call.args[0].value, text.strip()) if isinstance(text, str) else None
 
 
 def _history_cell(
@@ -63,9 +83,11 @@ def _history_cell(
         return None
     history = shell.history_manager
     identifier = f"terminal-{number}"
-    question = _question_text(transformed)
-    if question is not None:
-        return {"id": identifier, "type": "markdown", "source": question}
+    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, ()):
@@ -139,10 +161,138 @@ class TerminalCellHistory:
     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 self.visible_characters and not self.visible_ends_line:
+            sys.stdout.write("\n")
+            self.visible_ends_line = True
+        if not self.hidden_characters:
+            return
+        if sys.stdout.isatty():
+            sys.stdout.write("\x1b[0m")
+        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:
+        complete, self.pending = _split_incomplete_ansi(self.pending + data)
+        if complete:
+            self.preview.write(self.stream, _plain_ansi(complete))
+        return len(data)
+
+    def flush(self) -> None:
+        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
@@ -245,6 +395,7 @@ def show_input(shell: TerminalInteractiveShell, cell: str) -> None:
             style=style,
             color_depth=shell.color_depth,
         )
+    sys.stdout.write("\n")
 
 
 def install_markdown_renderer(shell: TerminalInteractiveShell) -> Callable[[], None]:
@@ -256,6 +407,7 @@ def install_markdown_renderer(shell: TerminalInteractiveShell) -> Callable[[], N
     previous_renderer = shell.mime_renderers.get(mime, _MISSING)
 
     def render(text: str, _metadata: object) -> None:
+        sys.stdout.write("\n")
         Console(file=sys.stdout, soft_wrap=True, no_color=shell.colors.lower() == "nocolor").print(
             Markdown(text)
         )
@@ -305,6 +457,7 @@ __all__ = [
     "TerminalCellHistory",
     "install_markdown_renderer",
     "install_question_mode",
+    "preview_tool_output",
     "record_tool_output",
     "show_input",
 ]