codebind 0.6.8__tar.gz → 0.6.10__tar.gz

{codebind-0.6.8 → codebind-0.6.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codebind
-Version: 0.6.8
+Version: 0.6.10
 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. 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.
+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 previews at most three gray output lines, shortening each line after 60 characters with `...`. Further lines appear as `… N more output lines.` The complete output remains available to the model and in IPython history; `%output 8` opens the full text of cell 8 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.8 → codebind-0.6.10}/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. 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.
+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 previews at most three gray output lines, shortening each line after 60 characters with `...`. Further lines appear as `… N more output lines.` The complete output remains available to the model and in IPython history; `%output 8` opens the full text of cell 8 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.8 → codebind-0.6.10}/pyproject.toml

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

{codebind-0.6.8 → codebind-0.6.10}/pyproject.toml.orig

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

{codebind-0.6.8 → codebind-0.6.10}/src/codebind/execution.py

@@ -222,7 +222,7 @@ class IPythonExecutor:
             with preview_tool_output() as preview, record_tool_output(self.shell):
                 result = self.shell.run_cell(cell, store_history=True)
             report = self._native_report(result)
-            preview.show_notice(result.execution_count, report.error)
+            preview.show_notice(report.error)
             return report
 
         bridge = self.bridge
@@ -277,7 +277,7 @@ class IPythonExecutor:
                     self.shell.events.trigger("post_execute")
                     self.shell.events.trigger("post_run_cell", result)
             report = self._native_report(result)
-            preview.show_notice(result.execution_count, report.error)
+            preview.show_notice(report.error)
             return report
 
         bridge = self.bridge

{codebind-0.6.8 → codebind-0.6.10}/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.8 → codebind-0.6.10}/src/codebind/terminal.py

@@ -3,7 +3,6 @@
 from __future__ import annotations
 
 import ast
-import shutil
 import sys
 from collections.abc import Callable, Iterator
 from contextlib import contextmanager
@@ -23,13 +22,28 @@ from rich.markdown import Markdown
 
 _MISSING = object()
 _IMAGE_FORMATS = ("image/png", "image/jpeg", "image/svg+xml")
-_MAXIMUM_VISIBLE_OUTPUT_LINES = 10
+_MAXIMUM_VISIBLE_OUTPUT_LINES = 3
+_MAXIMUM_VISIBLE_OUTPUT_CHARACTERS_PER_LINE = 80
 
 
 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:
@@ -178,65 +192,80 @@ class TerminalCellHistory:
 class _OutputPreview:
     """Limit only terminal painting; IPython still records every written byte."""
 
-    def __init__(self, maximum_lines: int, maximum_characters: int) -> None:
+    def __init__(self, maximum_lines: int, maximum_characters_per_line: int) -> None:
         self.maximum_lines = maximum_lines
-        self.maximum_characters = maximum_characters
+        self.maximum_characters_per_line = maximum_characters_per_line
         self.visible_lines = 0
+        self.characters_on_line = 0
+        self.line_truncated = False
         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 _paint(self, stream, text: str) -> None:
+        if not text:
+            return
+        if stream.isatty():
+            stream.write("\x1b[90m")
+        stream.write(text)
+        if stream.isatty():
+            stream.write("\x1b[0m")
+        self.visible_characters += len(text)
+
     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:
+            if self.visible_lines >= self.maximum_lines:
                 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 piece.endswith("\r\n"):
+                body, ending = piece[:-2], "\r\n"
+            elif piece.endswith(("\n", "\r")):
+                body, ending = piece[:-1], piece[-1]
+            else:
+                body, ending = piece, ""
+
+            visible = ""
+            if not self.line_truncated:
+                remaining = self.maximum_characters_per_line - self.characters_on_line
+                visible = body[:remaining]
+                self.characters_on_line += len(visible)
+                if len(body) > remaining:
+                    visible += "…"
+                    self.line_truncated = True
+            if ending:
+                visible += ending
+                self.visible_lines += 1
+                self.characters_on_line = 0
+                self.line_truncated = False
             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) :])
+                self._paint(stream, visible)
+                self.visible_ends_line = bool(ending)
         return len(data)
 
-    def show_notice(self, number: int, error: dict[str, str] | None = None) -> None:
+    def show_notice(self, 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")
-        if not self.visible_ends_line:
-            sys.stdout.write("\n")
+        terminal = sys.stdout.isatty()
+        if terminal:
+            sys.stdout.write("\x1b[90m")
         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"
-        )
+        sys.stdout.write(f"… {hidden_lines:,} more output {label}\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")
+        if terminal:
+            sys.stdout.write("\x1b[0m")
 
 
 class _PreviewStream:
@@ -246,20 +275,12 @@ class _PreviewStream:
         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))
+        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:
-        if self.pending:
-            self.preview.write(self.stream, _plain_ansi(self.pending))
-            self.pending = ""
         self.stream.flush()
 
     def __getattr__(self, name: str):
@@ -269,10 +290,10 @@ class _PreviewStream:
 @contextmanager
 def preview_tool_output(
     maximum_lines: int = _MAXIMUM_VISIBLE_OUTPUT_LINES,
+    maximum_characters_per_line: int = _MAXIMUM_VISIBLE_OUTPUT_CHARACTERS_PER_LINE,
 ) -> 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))
+    preview = _OutputPreview(maximum_lines, maximum_characters_per_line)
     stdout, stderr = sys.stdout, sys.stderr
     preview_stdout = _PreviewStream(stdout, preview)
     preview_stderr = _PreviewStream(stderr, preview)
@@ -399,6 +420,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)
         )